The best way to control Claude Code, Codex and more from any computer or phone

main
ts 241 lines 7.72 KB
Raw
1 import * as marketplace from "@distilled.cloud/gcp/authorizedbuyersmarketplace_v1";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { isResolved } from "alchemy/Diff";
4 import * as Provider from "alchemy/Provider";
5 import { Resource } from "alchemy/Resource";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import { GcpEnvironment } from "../Environment.ts";
9 import type { Providers } from "../Providers.ts";
10 import {
11 expandParent,
12 findUserByEmail,
13 listUsers,
14 parentOfName,
15 replaceOnIdentity,
16 resourceName,
17 sameText,
18 toAttrs,
19 toEmail,
20 type ClientUserState,
21 } from "./internal.ts";
22
23 export type BuyersClientsUserProps = {
24 /**
25 * Parent client, as `buyers/{buyer}/clients/{client}` or
26 * `{buyer}/clients/{client}`. Immutable — changing it replaces the
27 * client user.
28 */
29 parent: string;
30 /**
31 * Invitee email. Unique per client. Immutable — changing it replaces
32 * the user. If omitted, a unique `example.com` address is generated.
33 * The invite goes to this exact address; client users have no labels,
34 * so Alchemy tracks the user by its resource name.
35 */
36 email?: string;
37 /**
38 * Server-assigned user id (last path segment). Omit on create; pass
39 * the observed id to keep the same user. Immutable — changing it
40 * replaces the user.
41 */
42 userId?: string;
43 /**
44 * Desired serving state after the invite is accepted. Create always
45 * yields `INVITED`. `ACTIVE` / `INACTIVE` are applied only once the
46 * user has left `INVITED` (`activate` / `deactivate`).
47 */
48 state?: ClientUserState | (string & {});
49 };
50
51 export type BuyersClientsUser = Resource<
52 "GCP.AuthorizedBuyersMarketplace.BuyersClientsUser",
53 BuyersClientsUserProps,
54 {
55 /** Full resource name `buyers/{buyer}/clients/{client}/users/{user}`. */
56 name: string;
57 /** Server-assigned user id (last path segment). */
58 userId: string;
59 /** Parent client resource name. */
60 parent: string;
61 /** Project id used when the client user was reconciled. */
62 project: string;
63 /** Invitee email with the Alchemy plus-tag stripped. */
64 email: string;
65 /** Server-reported user state (`INVITED`, `ACTIVE`, `INACTIVE`). */
66 state: string | undefined;
67 },
68 never,
69 Providers
70 >;
71
72 /**
73 * An Authorized Buyers Marketplace client user
74 * (`buyers/{buyer}/clients/{client}/users/{user}`).
75 *
76 * Client users have no labels or description — Alchemy stamps ownership
77 * into the email plus-tag so `list` / nuke can find them. Parent and
78 * email are identity; changing either replaces the user. Create sends an
79 * invitation (`INVITED`). Activate and deactivate only apply after the
80 * invitee accepts.
81 *
82 * ### Creating a Client User
83 * **Example:** Generated email
84 * ```typescript
85 * const user = yield* GCP.AuthorizedBuyersMarketplace.BuyersClientsUser(
86 * "Analyst",
87 * { parent: "buyers/123/clients/456" },
88 * );
89 * ```
90 *
91 * **Example:** Invite a known mailbox
92 * ```typescript
93 * const user = yield* GCP.AuthorizedBuyersMarketplace.BuyersClientsUser(
94 * "Analyst",
95 * {
96 * parent: "buyers/123/clients/456",
97 * email: "analyst@example.com",
98 * },
99 * );
100 * ```
101 *
102 * ### Updating a Client User
103 * **Example:** Deactivate after the invite is accepted
104 * ```typescript
105 * // Same logical id, changed state: the engine keeps the same user.
106 * const user = yield* GCP.AuthorizedBuyersMarketplace.BuyersClientsUser(
107 * "Analyst",
108 * {
109 * parent: "buyers/123/clients/456",
110 * email: "analyst@example.com",
111 * state: "INACTIVE",
112 * },
113 * );
114 * ```
115 *
116 * @resource
117 * @category AuthorizedBuyersMarketplace
118 */
119 export const BuyersClientsUser = Resource<BuyersClientsUser>(
120 "GCP.AuthorizedBuyersMarketplace.BuyersClientsUser",
121 );
122
123 export class BuyersClientsUserNotResolved extends Data.TaggedError(
124 "GCP.AuthorizedBuyersMarketplace.BuyersClientsUserNotResolved",
125 )<{
126 parent: string;
127 resourceName: string;
128 }> {}
129
130 const getByName = (name: string) =>
131 !name
132 ? Effect.undefined
133 : marketplace
134 .getBuyersClientsUsers({ name })
135 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
136
137 const lookupName = (
138 parent: string,
139 userId: string | undefined,
140 existingName: string | undefined,
141 ) => {
142 if (existingName && existingName.length > 0) return existingName;
143 if (userId && userId.length > 0 && parent.length > 0) {
144 return resourceName(parent, userId);
145 }
146 return "";
147 };
148
149 const syncState = (current: marketplace.ClientUser, desired: string | undefined) =>
150 Effect.gen(function* () {
151 if (!desired || !current.name) return current;
152 const observed = current.state ?? "";
153 if (sameText(observed, desired)) return current;
154 if (observed === "INVITED") return current;
155 if (desired === "ACTIVE" && observed === "INACTIVE") {
156 return yield* marketplace.activateBuyersClientsUsers({
157 name: current.name,
158 });
159 }
160 if (desired === "INACTIVE" && observed === "ACTIVE") {
161 return yield* marketplace.deactivateBuyersClientsUsers({
162 name: current.name,
163 });
164 }
165 return current;
166 });
167
168 export const BuyersClientsUserProvider = () =>
169 Provider.succeed(BuyersClientsUser, {
170 stables: ["name", "userId", "parent", "project", "email"],
171
172 diff: Effect.fn(function* ({ news, olds, output }) {
173 if (!isResolved(news)) return undefined;
174 return replaceOnIdentity({
175 previousParent: expandParent(olds?.parent ?? output?.parent ?? ""),
176 nextParent: expandParent(news.parent),
177 previousEmail: olds?.email ?? output?.email,
178 nextEmail: news.email,
179 previousUserId: olds?.userId ?? output?.userId,
180 nextUserId: news.userId,
181 });
182 }),
183
184 read: Effect.fn(function* ({ olds, output }) {
185 const env = yield* GcpEnvironment.current;
186 const parent = expandParent(olds?.parent ?? output?.parent ?? "");
187 const name = lookupName(parent, olds?.userId ?? output?.userId, output?.name);
188 const existing = yield* getByName(name);
189 if (existing !== undefined) {
190 return toAttrs(existing, parentOfName(existing.name ?? "") || parent, env.project);
191 }
192 // Without a known name, a user with the same email may be someone
193 // else's invite: surface it as unowned.
194 const email = olds?.email ?? output?.email;
195 if (!parent || !email) return undefined;
196 const users = yield* listUsers(parent);
197 const found = findUserByEmail(users, email);
198 return found === undefined ? undefined : Unowned(toAttrs(found, parent, env.project));
199 }),
200
201 reconcile: Effect.fn(function* ({ id, news, output }) {
202 const env = yield* GcpEnvironment.current;
203 const parent = expandParent(news.parent);
204 const email = yield* toEmail(id, news.email, output?.email);
205 const name = lookupName(parent, news.userId ?? output?.userId, output?.name);
206
207 let current = yield* getByName(name);
208 if (current === undefined) {
209 const users = yield* listUsers(parent);
210 current = findUserByEmail(users, email);
211 }
212
213 if (current === undefined) {
214 current = yield* marketplace
215 .createBuyersClientsUsers({ parent, body: { email } })
216 .pipe(
217 Effect.catchTag("Conflict", () =>
218 listUsers(parent).pipe(Effect.map((users) => findUserByEmail(users, email))),
219 ),
220 );
221 }
222
223 if (current === undefined) {
224 return yield* new BuyersClientsUserNotResolved({
225 parent,
226 resourceName: name || email,
227 });
228 }
229
230 current = yield* syncState(current, news.state);
231
232 return toAttrs(current, parent, env.project);
233 }),
234
235 delete: Effect.fn(function* ({ output }) {
236 if (!output.name) return;
237 yield* marketplace
238 .deleteBuyersClientsUsers({ name: output.name })
239 .pipe(Effect.catchTag("NotFound", () => Effect.void));
240 }),
241 });