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

main
ts 415 lines 13.1 KB
Raw
1 import * as firebasedataconnect from "@distilled.cloud/gcp/firebasedataconnect_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 { tagRecord } from "alchemy/Tags";
7 import * as Effect from "effect/Effect";
8 import * as Schedule from "effect/Schedule";
9 import { GcpEnvironment } from "../Environment.ts";
10 import { createInternalLabels, diffLabels, hasAlchemyLabels, toLabels } from "../Labels.ts";
11 import type { Providers } from "../Providers.ts";
12 import {
13 expandParent,
14 fieldMask,
15 fingerprint,
16 listAtNested,
17 listLabeledPages,
18 MAX_CONNECTOR_ID_LENGTH,
19 normalizeLocation,
20 parseName,
21 replaceOnIdentity,
22 ResourceNotResolved,
23 retryStaleEtag,
24 sameText,
25 stringMap,
26 toPhysicalId,
27 userLabels,
28 waitForDeleteOperation,
29 waitForOperation,
30 waitUntilExists,
31 waitUntilGone,
32 waitUntilReady,
33 } from "./internal.ts";
34 import type { Source } from "./ServicesSchema.ts";
35
36 export type ClientCache = {
37 /**
38 * When true, connector source is validated for client-side caching
39 * (stricter aliases, etc.).
40 */
41 strictValidationEnabled?: boolean;
42 /**
43 * When true, responses include entityIds in GraphQL extensions for
44 * normalized client caching. Only enable when primary keys are not
45 * sensitive.
46 */
47 entityIdIncluded?: boolean;
48 };
49
50 export type ServicesConnectorProps = {
51 /**
52 * Parent Data Connect service. Full name
53 * `projects/{project}/locations/{location}/services/{service}` or the
54 * service id (combined with `location`). Immutable — changing it
55 * replaces the connector. The service must already have an active
56 * schema compatible with `source`.
57 */
58 service: string;
59 /**
60 * Region used when `service` is a bare id.
61 * @default the stack's GCP region (`GCP.Region`, else the profile region, else `us-central1`)
62 */
63 location?: string;
64 /**
65 * Connector id (the `{connector}` segment). If omitted, a unique
66 * RFC1035 name is generated from the stack, stage, and logical id.
67 * Immutable — changing it replaces the connector.
68 */
69 connectorId?: string;
70 /**
71 * GraphQL operations (queries and mutations) that make up the
72 * connector. Must be compatible with the active schema.
73 */
74 source: Source;
75 /**
76 * Client-side cache settings.
77 */
78 clientCache?: ClientCache;
79 /**
80 * Human-readable name. 63 character limit.
81 */
82 displayName?: string;
83 /**
84 * User annotations (preserved by external tools).
85 */
86 annotations?: Record<string, string>;
87 /**
88 * User labels. Alchemy ownership labels are merged in automatically.
89 */
90 labels?: Record<string, string>;
91 };
92
93 export type ServicesConnector = Resource<
94 "GCP.FirebaseDataConnect.ServicesConnector",
95 ServicesConnectorProps,
96 {
97 /** Full resource name. */
98 name: string;
99 /** Connector id (last path segment). */
100 connectorId: string;
101 /** Parent service name. */
102 service: string;
103 /** Project id. */
104 project: string;
105 /** Location id. */
106 location: string;
107 /** GraphQL operation source files. */
108 source: Source | undefined;
109 /** Client-side cache settings. */
110 clientCache: ClientCache | undefined;
111 /** Human-readable name. */
112 displayName: string | undefined;
113 /** True while Data Connect is compiling or deploying the connector. */
114 reconciling: boolean;
115 /** User annotations. */
116 annotations: Record<string, string>;
117 /** User labels (Alchemy ownership labels stripped). */
118 labels: Record<string, string>;
119 /** Server-generated resource uid. */
120 uid: string | undefined;
121 /** RFC3339 creation timestamp. */
122 createTime: string | undefined;
123 /** RFC3339 last-update timestamp. */
124 updateTime: string | undefined;
125 /** Server-computed etag. */
126 etag: string | undefined;
127 },
128 never,
129 Providers
130 >;
131
132 /**
133 * A Firebase Data Connect connector — a set of GraphQL queries and
134 * mutations compiled against the service's active schema.
135 *
136 * Changing `connectorId`, `service`, or `location` replaces the
137 * connector. Source, client cache, display name, labels, and
138 * annotations update in place. Create fails if the service has no
139 * schema or the operations are incompatible with it.
140 *
141 * ### Creating a Connector
142 * **Example:** Public query
143 * ```typescript
144 * const schema = yield* GCP.FirebaseDataConnect.ServicesSchema("Main", {
145 * service: service.name,
146 * source: {
147 * files: [{
148 * path: "schema.gql",
149 * content: "type Note @table { title: String! }",
150 * }],
151 * },
152 * datasources: [{ postgresql: { unlinked: true } }],
153 * });
154 * const connector = yield* GCP.FirebaseDataConnect.ServicesConnector(
155 * "Queries",
156 * {
157 * service: schema.service,
158 * source: {
159 * files: [{
160 * path: "queries.gql",
161 * content:
162 * "query ListNotes @auth(level: PUBLIC) { notes { id title } }",
163 * }],
164 * },
165 * labels: { env: "test" },
166 * },
167 * );
168 * ```
169 *
170 * ### Updating a Connector
171 * **Example:** Display name and labels
172 * ```typescript
173 * const connector = yield* GCP.FirebaseDataConnect.ServicesConnector(
174 * "Queries",
175 * {
176 * service: schema.service,
177 * source: {
178 * files: [{
179 * path: "queries.gql",
180 * content:
181 * "query ListNotes @auth(level: PUBLIC) { notes { id title } }",
182 * }],
183 * },
184 * displayName: "notes queries v2",
185 * labels: { env: "prod" },
186 * },
187 * );
188 * ```
189 *
190 * @resource
191 * @category FirebaseDataConnect
192 */
193 export const ServicesConnector = Resource<ServicesConnector>(
194 "GCP.FirebaseDataConnect.ServicesConnector",
195 );
196
197 const resourceName = (service: string, connectorId: string) =>
198 `${service}/connectors/${connectorId}`;
199
200 const toFile = (value: firebasedataconnect.File) => ({
201 content: value.content,
202 path: value.path,
203 });
204
205 const toSource = (value: firebasedataconnect.Source | undefined): Source | undefined =>
206 value === undefined ? undefined : { files: value.files?.map(toFile) };
207
208 const toClientCache = (
209 value: firebasedataconnect.ClientCache | undefined,
210 ): ClientCache | undefined =>
211 value === undefined
212 ? undefined
213 : {
214 strictValidationEnabled: value.strictValidationEnabled,
215 entityIdIncluded: value.entityIdIncluded,
216 };
217
218 const toAttrs = (
219 item: firebasedataconnect.Connector,
220 project: string,
221 region: string,
222 ): ServicesConnector["Attributes"] => {
223 const name = item.name ?? "";
224 const parsed = parseName(name, "connectors", region);
225 return {
226 name,
227 connectorId: parsed.id,
228 service: parsed.parent,
229 project: parsed.project || project,
230 location: parsed.location,
231 source: toSource(item.source),
232 clientCache: toClientCache(item.clientCache),
233 displayName: item.displayName,
234 reconciling: item.reconciling === true,
235 annotations: stringMap(item.annotations),
236 labels: userLabels(item.labels),
237 uid: item.uid,
238 createTime: item.createTime,
239 updateTime: item.updateTime,
240 etag: item.etag,
241 };
242 };
243
244 const getByName = (name: string) =>
245 firebasedataconnect
246 .getProjectsLocationsServicesConnectors({ name })
247 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
248
249 const listOwned = (project: string) =>
250 listAtNested(project, "services/-", (parent) =>
251 listLabeledPages(
252 firebasedataconnect.listProjectsLocationsServicesConnectors.pages({
253 parent,
254 pageSize: 1000,
255 }),
256 (page) => page.connectors,
257 (item) => item.labels,
258 ),
259 );
260
261 export const ServicesConnectorProvider = () =>
262 Provider.succeed(ServicesConnector, {
263 stables: ["name", "connectorId", "service", "project", "location", "uid", "createTime"],
264
265 diff: Effect.fn(function* ({ news, olds, output }) {
266 if (!isResolved(news)) return undefined;
267 const env = yield* GcpEnvironment.current;
268 const location = normalizeLocation(
269 news.location ?? olds?.location ?? output?.location,
270 env.region,
271 );
272 const previousLocation = normalizeLocation(olds?.location ?? output?.location, env.region);
273 const previousParent =
274 (olds?.service ?? output?.service)
275 ? expandParent(
276 olds?.service ?? output?.service ?? "",
277 env.project,
278 previousLocation,
279 "services",
280 )
281 : undefined;
282 const nextParent = expandParent(news.service, env.project, location, "services");
283 return replaceOnIdentity({
284 previousId: olds?.connectorId ?? output?.connectorId,
285 nextId: news.connectorId ?? olds?.connectorId ?? output?.connectorId,
286 previousLocation,
287 nextLocation: location,
288 previousParent,
289 nextParent,
290 });
291 }),
292
293 read: Effect.fn(function* ({ id, olds, output }) {
294 const env = yield* GcpEnvironment.current;
295 const connectorId = yield* toPhysicalId(
296 id,
297 olds?.connectorId,
298 output?.connectorId,
299 "connector",
300 MAX_CONNECTOR_ID_LENGTH,
301 );
302 const location = normalizeLocation(olds?.location ?? output?.location, env.region);
303 const service =
304 output?.service ??
305 (olds?.service ? expandParent(olds.service, env.project, location, "services") : undefined);
306 const name = output?.name ?? (service ? resourceName(service, connectorId) : undefined);
307 if (name === undefined) return undefined;
308 const existing = yield* getByName(name);
309 if (existing === undefined) return undefined;
310 const attrs = toAttrs(existing, env.project, env.region);
311 return (yield* hasAlchemyLabels(id, tagRecord(existing.labels))) ? attrs : Unowned(attrs);
312 }),
313
314 list: () =>
315 Effect.gen(function* () {
316 const env = yield* GcpEnvironment.current;
317 const items = yield* listOwned(env.project);
318 return items.map((item) => toAttrs(item, env.project, env.region));
319 }),
320
321 reconcile: Effect.fn(function* ({ id, news, output }) {
322 const env = yield* GcpEnvironment.current;
323 const connectorId = yield* toPhysicalId(
324 id,
325 news.connectorId,
326 output?.connectorId,
327 "connector",
328 MAX_CONNECTOR_ID_LENGTH,
329 );
330 const location = normalizeLocation(news.location ?? output?.location, env.region);
331 const service = expandParent(news.service, env.project, location, "services");
332 const name = resourceName(service, connectorId);
333 const desiredLabels = {
334 ...toLabels(news.labels),
335 ...(yield* createInternalLabels(id)),
336 };
337 const desiredAnnotations = news.annotations ?? {};
338 const body: firebasedataconnect.Connector = {
339 source: news.source,
340 clientCache: news.clientCache,
341 displayName: news.displayName,
342 annotations: desiredAnnotations,
343 labels: desiredLabels,
344 };
345
346 let current = yield* getByName(output?.name ?? name);
347
348 if (current === undefined) {
349 const created = yield* firebasedataconnect
350 .createProjectsLocationsServicesConnectors({
351 parent: service,
352 connectorId,
353 body,
354 })
355 .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
356 if (created !== undefined) {
357 yield* waitForOperation(created);
358 }
359 current = yield* waitUntilExists(getByName(name), name);
360 }
361
362 if (current === undefined) {
363 return yield* new ResourceNotResolved({ resourceName: name });
364 }
365
366 const observedLabels = tagRecord(current.labels);
367 const { upsert, removed } = diffLabels(observedLabels, desiredLabels);
368 const mask = fieldMask([
369 (upsert.length > 0 || removed.length > 0) && "labels",
370 fingerprint(stringMap(current.annotations)) !== fingerprint(desiredAnnotations) &&
371 "annotations",
372 !sameText(current.displayName, news.displayName) && "displayName",
373 fingerprint(toSource(current.source)) !== fingerprint(news.source) && "source",
374 fingerprint(toClientCache(current.clientCache)) !== fingerprint(news.clientCache) &&
375 "clientCache",
376 ]);
377
378 if (mask.length > 0) {
379 const patchName = current.name ?? name;
380 yield* retryStaleEtag(
381 firebasedataconnect
382 .patchProjectsLocationsServicesConnectors({
383 name: patchName,
384 updateMask: mask,
385 body,
386 })
387 .pipe(Effect.flatMap((operation) => waitForOperation(operation))),
388 );
389 current = yield* waitUntilExists(getByName(current.name ?? name), current.name ?? name);
390 }
391
392 current = yield* waitUntilReady(getByName(current.name ?? name), current.name ?? name);
393 return toAttrs(current, env.project, env.region);
394 }),
395
396 delete: Effect.fn(function* ({ output }) {
397 const operation = yield* firebasedataconnect
398 .deleteProjectsLocationsServicesConnectors({
399 name: output.name,
400 force: true,
401 })
402 .pipe(
403 Effect.retry({
404 while: (error) => error._tag === "Conflict",
405 times: 8,
406 schedule: Schedule.spaced("2 seconds"),
407 }),
408 Effect.catchTag("NotFound", () => Effect.undefined),
409 );
410 if (operation !== undefined) {
411 yield* waitForDeleteOperation(operation);
412 }
413 yield* waitUntilGone(getByName(output.name), output.name);
414 }),
415 });