@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 512 lines 17.1 KB
Raw
1 import * as spanner from "@distilled.cloud/gcp/spanner_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 * as Schedule from "effect/Schedule";
9 import * as Stream from "effect/Stream";
10 import { GcpEnvironment } from "../Environment.ts";
11 import type { Providers } from "../Providers.ts";
12 import {
13 configIdOf,
14 configNameOf,
15 DEFAULT_PARTITION_PROCESSING_UNITS,
16 displayNameOf,
17 instanceIdOf,
18 instanceName,
19 instancePartitionName,
20 listAlchemyInstances,
21 MAX_PARTITION_ID_LENGTH,
22 parentOwned,
23 parseResourceName,
24 retryConcurrentChanges,
25 toPhysicalId,
26 waitForOperation,
27 } from "./operations.ts";
28
29 export type PartitionAutoscalingLimits = {
30 /** Minimum nodes. Mutually exclusive with processing-unit limits. */
31 minNodes?: number;
32 /** Minimum processing units (multiples of 1000). */
33 minProcessingUnits?: number;
34 /** Maximum nodes. */
35 maxNodes?: number;
36 /** Maximum processing units (multiples of 1000). */
37 maxProcessingUnits?: number;
38 };
39
40 export type PartitionAutoscalingTargets = {
41 /** Target high-priority CPU percent (`10`–`90`). */
42 highPriorityCpuUtilizationPercent?: number;
43 /** Target total CPU percent (`10`–`90`). */
44 totalCpuUtilizationPercent?: number;
45 /** Target storage percent (`10`–`99`). */
46 storageUtilizationPercent?: number;
47 };
48
49 export type PartitionAutoscalingConfig = {
50 /** Min/max compute capacity. */
51 autoscalingLimits?: PartitionAutoscalingLimits;
52 /** CPU and storage targets. */
53 autoscalingTargets?: PartitionAutoscalingTargets;
54 };
55
56 export type InstancesInstancePartitionProps = {
57 /**
58 * Parent instance id or full name
59 * (`projects/{project}/instances/{instance}`). Immutable — changing
60 * it replaces the partition.
61 */
62 instance: string;
63 /**
64 * Instance partition id (the `{partition}` segment of
65 * `.../instancePartitions/{partition}`). If omitted, a unique name is
66 * generated. Must match `^[a-z][-a-z0-9]*[a-z0-9]$` (2–64
67 * characters). Immutable — changing it replaces the partition.
68 */
69 instancePartitionId?: string;
70 /**
71 * Instance configuration id (`regional-us-west1`) or full name.
72 * Typically a different config than the parent instance. Immutable —
73 * changing it replaces the partition.
74 */
75 config: string;
76 /**
77 * User-facing display name. Must be unique per project and 4–30
78 * characters. Defaults to a truncated partition id.
79 */
80 displayName?: string;
81 /**
82 * Processing units. Mutually exclusive with `nodeCount`. Ignored when
83 * autoscaling is enabled. Minimum is 1000 (1 node).
84 * @default 1000
85 */
86 processingUnits?: number;
87 /**
88 * Node count. Mutually exclusive with `processingUnits`. Ignored when
89 * autoscaling is enabled.
90 */
91 nodeCount?: number;
92 /**
93 * Autoscaling configuration. When set, `nodeCount` and
94 * `processingUnits` become output-only.
95 */
96 autoscalingConfig?: PartitionAutoscalingConfig;
97 };
98
99 export type InstancesInstancePartition = Resource<
100 "GCP.Spanner.InstancesInstancePartition",
101 InstancesInstancePartitionProps,
102 {
103 /** Full resource name `.../instancePartitions/{partition}`. */
104 name: string;
105 /** Instance partition id (last path segment). */
106 instancePartitionId: string;
107 /** Parent instance id. */
108 instanceId: string;
109 /** Project id. */
110 project: string;
111 /** Full instance config name. */
112 config: string;
113 /** User-facing display name. */
114 displayName: string | undefined;
115 /** Processing units currently allocated. */
116 processingUnits: number | undefined;
117 /** Nodes currently allocated. */
118 nodeCount: number | undefined;
119 /** Autoscaling configuration, if enabled. */
120 autoscalingConfig: PartitionAutoscalingConfig | undefined;
121 /** Current state (`CREATING`, `READY`). */
122 state: string | undefined;
123 /** RFC3339 creation timestamp. */
124 createTime: string | undefined;
125 /** RFC3339 last-update timestamp. */
126 updateTime: string | undefined;
127 /** Databases that reference this partition. */
128 referencingDatabases: string[];
129 /** Backups that reference this partition. */
130 referencingBackups: string[];
131 },
132 never,
133 Providers
134 >;
135
136 /**
137 * A Cloud Spanner instance partition for geo-partitioned data placement.
138 *
139 * Instance partitions have no labels field. Alchemy treats a partition
140 * as owned when its parent instance carries Alchemy labels, so `list` /
141 * `pnpm nuke:gcp` can find it. Geo-partitioning requires Enterprise Plus
142 * and typically a dual-region or multi-region parent instance. Changing
143 * `instancePartitionId`, `instance`, or `config` replaces the partition.
144 * Display name, compute capacity, and autoscaling update in place.
145 *
146 * ### Creating an Instance Partition
147 * **Example:** 1000 processing units in a second region
148 * ```typescript
149 * const partition = yield* GCP.Spanner.InstancesInstancePartition(
150 * "West",
151 * {
152 * instance: instance.instanceId,
153 * config: "regional-us-west1",
154 * processingUnits: 1000,
155 * },
156 * );
157 * ```
158 *
159 * **Example:** Explicit id and node count
160 * ```typescript
161 * const partition = yield* GCP.Spanner.InstancesInstancePartition(
162 * "West",
163 * {
164 * instance: instance.name,
165 * instancePartitionId: "west",
166 * config: "regional-us-west1",
167 * displayName: "west-partition",
168 * nodeCount: 1,
169 * },
170 * );
171 * ```
172 *
173 * @resource
174 * @category Spanner
175 */
176 export const InstancesInstancePartition = Resource<InstancesInstancePartition>(
177 "GCP.Spanner.InstancesInstancePartition",
178 );
179
180 export class InstancePartitionNotResolved extends Data.TaggedError(
181 "GCP.Spanner.InstancePartitionNotResolved",
182 )<{
183 resourceName: string;
184 }> {}
185
186 export class InstancePartitionNotReady extends Data.TaggedError(
187 "GCP.Spanner.InstancePartitionNotReady",
188 )<{
189 resourceName: string;
190 state: string;
191 }> {}
192
193 export class InstancePartitionStillExists extends Data.TaggedError(
194 "GCP.Spanner.InstancePartitionStillExists",
195 )<{
196 resourceName: string;
197 }> {}
198
199 const toId = (id: string, instancePartitionId: string | undefined, existing?: string) =>
200 toPhysicalId(id, instancePartitionId, existing, MAX_PARTITION_ID_LENGTH);
201
202 const autoscalingOf = (
203 config: spanner.AutoscalingConfig | undefined,
204 ): PartitionAutoscalingConfig | undefined => {
205 if (config === undefined) return undefined;
206 return {
207 autoscalingLimits: config.autoscalingLimits
208 ? {
209 minNodes: config.autoscalingLimits.minNodes,
210 minProcessingUnits: config.autoscalingLimits.minProcessingUnits,
211 maxNodes: config.autoscalingLimits.maxNodes,
212 maxProcessingUnits: config.autoscalingLimits.maxProcessingUnits,
213 }
214 : undefined,
215 autoscalingTargets: config.autoscalingTargets
216 ? {
217 highPriorityCpuUtilizationPercent:
218 config.autoscalingTargets.highPriorityCpuUtilizationPercent,
219 totalCpuUtilizationPercent: config.autoscalingTargets.totalCpuUtilizationPercent,
220 storageUtilizationPercent: config.autoscalingTargets.storageUtilizationPercent,
221 }
222 : undefined,
223 };
224 };
225
226 const autoscalingKey = (config: PartitionAutoscalingConfig | undefined) =>
227 JSON.stringify(config ?? null);
228
229 const toAttrs = (
230 partition: spanner.InstancePartition,
231 project: string,
232 ): InstancesInstancePartition["Attributes"] => {
233 const name = partition.name ?? "";
234 const parsed = parseResourceName(name);
235 return {
236 name,
237 instancePartitionId: parsed.instancePartitionId,
238 instanceId: parsed.instanceId,
239 project: parsed.project || project,
240 config: partition.config ?? "",
241 displayName: partition.displayName,
242 processingUnits: partition.processingUnits,
243 nodeCount: partition.nodeCount,
244 autoscalingConfig: autoscalingOf(partition.autoscalingConfig),
245 state: partition.state,
246 createTime: partition.createTime,
247 updateTime: partition.updateTime,
248 referencingDatabases: partition.referencingDatabases ?? [],
249 referencingBackups: partition.referencingBackups ?? [],
250 };
251 };
252
253 const getByName = (name: string) =>
254 spanner
255 .getProjectsInstancesInstancePartitions({ name })
256 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
257
258 const waitUntilExists = (name: string) =>
259 getByName(name).pipe(
260 Effect.flatMap((partition) =>
261 partition
262 ? Effect.succeed(partition)
263 : Effect.fail(new InstancePartitionNotResolved({ resourceName: name })),
264 ),
265 Effect.retry({
266 while: (error) => error._tag === "GCP.Spanner.InstancePartitionNotResolved",
267 times: 8,
268 schedule: Schedule.spaced("2 seconds"),
269 }),
270 );
271
272 const waitUntilReady = (name: string) =>
273 getByName(name).pipe(
274 Effect.filterOrFail(
275 (partition): partition is spanner.InstancePartition => partition !== undefined,
276 () => new InstancePartitionNotResolved({ resourceName: name }),
277 ),
278 Effect.filterOrFail(
279 (partition) => (partition.state ?? "STATE_UNSPECIFIED") === "READY",
280 (partition) =>
281 new InstancePartitionNotReady({
282 resourceName: name,
283 state: partition.state ?? "STATE_UNSPECIFIED",
284 }),
285 ),
286 Effect.retry({
287 while: (error) =>
288 error._tag === "GCP.Spanner.InstancePartitionNotReady" ||
289 error._tag === "GCP.Spanner.InstancePartitionNotResolved",
290 times: 10,
291 schedule: Schedule.spaced("8 seconds"),
292 }),
293 );
294
295 const waitUntilGone = (name: string) =>
296 getByName(name).pipe(
297 Effect.flatMap((partition) =>
298 partition === undefined
299 ? Effect.void
300 : Effect.fail(new InstancePartitionStillExists({ resourceName: name })),
301 ),
302 Effect.retry({
303 while: (error) => error._tag === "GCP.Spanner.InstancePartitionStillExists",
304 times: 10,
305 schedule: Schedule.spaced("8 seconds"),
306 }),
307 );
308
309 const toCreatePartition = (
310 name: string,
311 news: InstancesInstancePartitionProps,
312 project: string,
313 region: string,
314 displayName: string,
315 ): spanner.InstancePartition => {
316 const body: spanner.InstancePartition = {
317 name,
318 config: configNameOf(project, news.config, region),
319 displayName,
320 };
321 if (news.autoscalingConfig !== undefined) {
322 body.autoscalingConfig = news.autoscalingConfig;
323 } else if (news.nodeCount !== undefined) {
324 body.nodeCount = news.nodeCount;
325 } else {
326 body.processingUnits = news.processingUnits ?? DEFAULT_PARTITION_PROCESSING_UNITS;
327 }
328 return body;
329 };
330
331 export const InstancesInstancePartitionProvider = () =>
332 Provider.succeed(InstancesInstancePartition, {
333 stables: ["name", "instancePartitionId", "instanceId", "project", "config", "createTime"],
334
335 diff: Effect.fn(function* ({ news, olds, output }) {
336 if (!isResolved(news)) return undefined;
337 const env = yield* GcpEnvironment.current;
338
339 const previousId = olds?.instancePartitionId ?? output?.instancePartitionId;
340 const nextId = news.instancePartitionId ?? previousId;
341 const previousInstance = instanceIdOf(olds?.instance ?? output?.instanceId ?? "");
342 const nextInstance = instanceIdOf(news.instance);
343 const previousConfig = configIdOf(olds?.config ?? output?.config, env.region);
344 const nextConfig = configIdOf(news.config ?? olds?.config ?? output?.config, env.region);
345
346 const replace =
347 (previousId !== undefined && nextId !== undefined && previousId !== nextId) ||
348 (previousInstance.length > 0 && previousInstance !== nextInstance) ||
349 previousConfig !== nextConfig;
350
351 if (!replace) return undefined;
352 return {
353 action: "replace" as const,
354 deleteFirst:
355 previousConfig !== nextConfig || (previousId !== undefined && nextId === previousId),
356 };
357 }),
358
359 read: Effect.fn(function* ({ id, olds, output }) {
360 const env = yield* GcpEnvironment.current;
361 const instancePartitionId = yield* toId(
362 id,
363 olds?.instancePartitionId,
364 output?.instancePartitionId,
365 );
366 const instanceId = instanceIdOf(olds?.instance ?? output?.instanceId ?? "");
367 if (instanceId.length === 0) return undefined;
368 const name =
369 output?.name ?? instancePartitionName(env.project, instanceId, instancePartitionId);
370 const existing = yield* getByName(name);
371 if (existing === undefined) return undefined;
372 const attrs = toAttrs(existing, env.project);
373 return (yield* parentOwned(instanceName(attrs.project, attrs.instanceId)))
374 ? attrs
375 : Unowned(attrs);
376 }),
377
378 list: () =>
379 Effect.gen(function* () {
380 const env = yield* GcpEnvironment.current;
381 const instances = yield* listAlchemyInstances(env.project);
382 const pages = yield* Effect.forEach(
383 instances,
384 (instance) => {
385 const parent = instance.name;
386 if (parent === undefined || parent.length === 0) {
387 return Effect.succeed([] as InstancesInstancePartition["Attributes"][]);
388 }
389 return spanner.listProjectsInstancesInstancePartitions
390 .pages({
391 parent,
392 pageSize: 1000,
393 })
394 .pipe(
395 Stream.flatMap((page) => Stream.fromIterable(page.instancePartitions ?? [])),
396 Stream.map((partition) => toAttrs(partition, env.project)),
397 Stream.runCollect,
398 Effect.map((chunk) => Array.from(chunk)),
399 Effect.catchTag("NotFound", () =>
400 Effect.succeed([] as InstancesInstancePartition["Attributes"][]),
401 ),
402 );
403 },
404 { concurrency: 4 },
405 );
406 return pages.flat();
407 }),
408
409 reconcile: Effect.fn(function* ({ id, news, output }) {
410 const env = yield* GcpEnvironment.current;
411 const instanceId = instanceIdOf(news.instance);
412 const instancePartitionId = yield* toId(
413 id,
414 news.instancePartitionId,
415 output?.instancePartitionId,
416 );
417 const name = instancePartitionName(env.project, instanceId, instancePartitionId);
418 const displayName = displayNameOf(instancePartitionId, news.displayName);
419
420 let current = yield* getByName(output?.name ?? name);
421
422 if (current === undefined) {
423 const created = yield* spanner
424 .createProjectsInstancesInstancePartitions({
425 parent: instanceName(env.project, instanceId),
426 body: {
427 instancePartitionId,
428 instancePartition: toCreatePartition(
429 name,
430 news,
431 env.project,
432 env.region,
433 displayName,
434 ),
435 },
436 })
437 .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
438 if (created !== undefined) {
439 yield* waitForOperation(created, { alreadyExistsOk: true });
440 }
441 current = yield* waitUntilExists(name);
442 }
443
444 if ((current.state ?? "") !== "READY") {
445 current = yield* waitUntilReady(name);
446 }
447
448 const displayNameChanged = (current.displayName ?? "") !== displayName;
449 const autoscalingChanged =
450 news.autoscalingConfig !== undefined &&
451 autoscalingKey(autoscalingOf(current.autoscalingConfig)) !==
452 autoscalingKey(news.autoscalingConfig);
453 const processingUnitsChanged =
454 news.autoscalingConfig === undefined &&
455 news.nodeCount === undefined &&
456 news.processingUnits !== undefined &&
457 (current.processingUnits ?? 0) !== news.processingUnits;
458 const nodeCountChanged =
459 news.autoscalingConfig === undefined &&
460 news.nodeCount !== undefined &&
461 (current.nodeCount ?? 0) !== news.nodeCount;
462
463 if (displayNameChanged || autoscalingChanged || processingUnitsChanged || nodeCountChanged) {
464 const fieldMask = [
465 displayNameChanged ? "display_name" : undefined,
466 autoscalingChanged ? "autoscaling_config" : undefined,
467 processingUnitsChanged ? "processing_units" : undefined,
468 nodeCountChanged ? "node_count" : undefined,
469 ].filter((field): field is string => field !== undefined);
470
471 const patchBody: spanner.InstancePartition = {
472 name,
473 displayName,
474 };
475 if (autoscalingChanged) {
476 patchBody.autoscalingConfig = news.autoscalingConfig;
477 }
478 if (processingUnitsChanged) {
479 patchBody.processingUnits = news.processingUnits;
480 }
481 if (nodeCountChanged) {
482 patchBody.nodeCount = news.nodeCount;
483 }
484
485 const patched = yield* retryConcurrentChanges(
486 spanner.patchProjectsInstancesInstancePartitions({
487 name,
488 body: {
489 instancePartition: patchBody,
490 fieldMask: fieldMask.join(","),
491 },
492 }),
493 );
494 yield* waitForOperation(patched);
495 current = yield* waitUntilReady(name);
496 }
497
498 return toAttrs(current, env.project);
499 }),
500
501 delete: Effect.fn(function* ({ output }) {
502 yield* spanner.deleteProjectsInstancesInstancePartitions({ name: output.name }).pipe(
503 Effect.catchTag("NotFound", () => Effect.void),
504 Effect.retry({
505 while: (error) => error._tag === "Conflict",
506 times: 8,
507 schedule: Schedule.spaced("5 seconds"),
508 }),
509 );
510 yield* waitUntilGone(output.name);
511 }),
512 });