@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 225 lines 7.52 KB
Raw
1 import * as pubsublite from "@distilled.cloud/gcp/pubsublite_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 Effect from "effect/Effect";
7 import { GcpEnvironment } from "../Environment.ts";
8 import type { Providers } from "../Providers.ts";
9 import {
10 DEFAULT_THROUGHPUT_CAPACITY,
11 ResourceNotResolved,
12 fieldMask,
13 getReservation,
14 hasOwnershipMarker,
15 ignoreMissing,
16 listOwnedReservations,
17 normalizeLocation,
18 ownedByAlchemy,
19 parentOf,
20 parseName,
21 replaceOnIdentity,
22 resourceName,
23 retryInUse,
24 sameText,
25 toResourceId,
26 waitUntilGone,
27 } from "./internal.ts";
28
29 export type AdminReservationProps = {
30 /**
31 * Reservation id (the `{reservation}` segment of
32 * `projects/{project}/locations/{location}/reservations/{reservation}`).
33 * If omitted, a unique name is generated from the stack, stage, and
34 * logical id. Pub/Sub Lite has no labels field, so Alchemy stamps
35 * ownership into a `+alc.{stack}.{stage}.{id}` suffix. Immutable —
36 * changing it replaces the reservation.
37 */
38 reservationId?: string;
39 /**
40 * Region (`us-central1`, `us-east1`, …). Reservations are regional.
41 * Immutable — changing it replaces the reservation. `US-CENTRAL1` is
42 * accepted and normalized to `us-central1`.
43 * @default the stack's GCP region (`GCP.Region`, else the profile region, else `us-central1`)
44 */
45 location?: string;
46 /**
47 * Reserved throughput capacity. Each unit is 1 MiB/s of published
48 * messages or 2 MiB/s of subscribed messages.
49 * @default "4"
50 */
51 throughputCapacity?: string | number;
52 };
53
54 export type AdminReservation = Resource<
55 "GCP.PubSubLite.AdminReservation",
56 AdminReservationProps,
57 {
58 /** Full resource name `projects/{project}/locations/{location}/reservations/{reservation}`. */
59 name: string;
60 /** Reservation id (last path segment, including the Alchemy ownership suffix). */
61 reservationId: string;
62 /** Project id. */
63 project: string;
64 /** Region id (`us-central1`, …). */
65 location: string;
66 /** Reserved throughput capacity. */
67 throughputCapacity: string | undefined;
68 },
69 never,
70 Providers
71 >;
72
73 /**
74 * A Pub/Sub Lite throughput reservation — a regional pool of publish
75 * and subscribe capacity that topics can consume.
76 *
77 * Pub/Sub Lite reservations have no labels. Alchemy stamps
78 * `alchemy-stack` / `alchemy-stage` / `alchemy-id` into the reservation
79 * id so `list` / `pnpm nuke:gcp` can find them. `reservationId` and
80 * `location` replace the reservation; `throughputCapacity` updates in
81 * place.
82 *
83 * ### Creating a Reservation
84 * **Example:** Generated name
85 * ```typescript
86 * const reservation = yield* GCP.PubSubLite.AdminReservation("Capacity", {
87 * throughputCapacity: "4",
88 * });
89 * ```
90 *
91 * **Example:** Explicit id and region
92 * ```typescript
93 * const reservation = yield* GCP.PubSubLite.AdminReservation("Capacity", {
94 * reservationId: "analytics",
95 * location: "us-central1",
96 * throughputCapacity: "8",
97 * });
98 * ```
99 *
100 * ### Updating a Reservation
101 * Re-declare the same logical id with changed props; the engine keeps the
102 * physical resource and updates it in place.
103 *
104 * **Example:** Scale throughput
105 * ```typescript
106 * const reservation = yield* GCP.PubSubLite.AdminReservation("Capacity", {
107 * location: "us-central1",
108 * throughputCapacity: "16",
109 * });
110 * ```
111 *
112 * @resource
113 * @category PubSubLite
114 */
115 export const AdminReservation = Resource<AdminReservation>("GCP.PubSubLite.AdminReservation");
116
117 const COLLECTION = "reservations";
118
119 const capacityOf = (value: string | number | undefined) =>
120 value === undefined || value === "" ? DEFAULT_THROUGHPUT_CAPACITY : String(value);
121
122 const toAttrs = (
123 reservation: pubsublite.Reservation,
124 project: string,
125 ): AdminReservation["Attributes"] => {
126 const name = reservation.name ?? "";
127 const parsed = parseName(name, COLLECTION);
128 return {
129 name,
130 reservationId: parsed.id,
131 project: parsed.project || project,
132 location: parsed.location,
133 throughputCapacity: reservation.throughputCapacity,
134 };
135 };
136
137 export const AdminReservationProvider = () =>
138 Provider.succeed(AdminReservation, {
139 stables: ["name", "reservationId", "project", "location"],
140
141 diff: Effect.fn(function* ({ news, olds, output }) {
142 if (!isResolved(news)) return undefined;
143 const env = yield* GcpEnvironment.current;
144 return replaceOnIdentity({
145 previousId: olds?.reservationId ?? output?.reservationId,
146 nextId: news.reservationId ?? olds?.reservationId ?? output?.reservationId,
147 previousLocation: normalizeLocation(olds?.location ?? output?.location, env.region),
148 nextLocation: normalizeLocation(
149 news.location ?? olds?.location ?? output?.location,
150 env.region,
151 ),
152 });
153 }),
154
155 read: Effect.fn(function* ({ id, olds, output }) {
156 const env = yield* GcpEnvironment.current;
157 const reservationId = yield* toResourceId(id, olds?.reservationId, output?.reservationId);
158 const location = normalizeLocation(olds?.location ?? output?.location, env.region);
159 const name = output?.name ?? resourceName(env.project, location, COLLECTION, reservationId);
160 const existing = yield* getReservation(name);
161 if (existing === undefined) return undefined;
162 const attrs = toAttrs(existing, env.project);
163 const owned = yield* ownedByAlchemy(id, attrs.reservationId);
164 if (owned) return attrs;
165 return hasOwnershipMarker(attrs.reservationId) ? undefined : Unowned(attrs);
166 }),
167
168 list: () =>
169 Effect.gen(function* () {
170 const env = yield* GcpEnvironment.current;
171 const items = yield* listOwnedReservations();
172 return items.map((item) => toAttrs(item, env.project));
173 }),
174
175 reconcile: Effect.fn(function* ({ id, news, output }) {
176 const env = yield* GcpEnvironment.current;
177 const reservationId = yield* toResourceId(id, news.reservationId, output?.reservationId);
178 const location = normalizeLocation(news.location ?? output?.location, env.region);
179 const name = resourceName(env.project, location, COLLECTION, reservationId);
180 const throughputCapacity = capacityOf(news.throughputCapacity);
181
182 let current = yield* getReservation(output?.name ?? name);
183
184 if (current === undefined) {
185 const created = yield* pubsublite
186 .createAdminProjectsLocationsReservations({
187 parent: parentOf(env.project, location),
188 reservationId,
189 body: { throughputCapacity },
190 })
191 .pipe(Effect.catchTag("Conflict", () => getReservation(name)));
192 current = created ?? undefined;
193 }
194
195 if (current === undefined) {
196 return yield* new ResourceNotResolved({ resourceName: name });
197 }
198
199 const observedName = current.name ?? name;
200 const mask = fieldMask([
201 !sameText(current.throughputCapacity, throughputCapacity) && "throughputCapacity",
202 ]);
203 if (mask.length > 0) {
204 current = yield* pubsublite.patchAdminProjectsLocationsReservations({
205 name: observedName,
206 updateMask: mask,
207 body: {
208 name: observedName,
209 throughputCapacity,
210 },
211 });
212 }
213
214 return toAttrs(current, env.project);
215 }),
216
217 delete: Effect.fn(function* ({ output }) {
218 yield* pubsublite
219 .deleteAdminProjectsLocationsReservations({
220 name: output.name,
221 })
222 .pipe(ignoreMissing, retryInUse);
223 yield* waitUntilGone(getReservation(output.name));
224 }),
225 });