@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, 04:45 UTC

main
ts 370 lines 12.2 KB
Raw
1 import * as parametermanager from "@distilled.cloud/gcp/parametermanager_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 * as Schedule from "effect/Schedule";
8 import { GcpEnvironment } from "../Environment.ts";
9 import type { Providers } from "../Providers.ts";
10 import {
11 DEFAULT_LOCATION,
12 ParameterNotResolved,
13 ParameterVersionNotResolved,
14 ParameterVersionPayloadRequired,
15 desiredPayloadData,
16 expandParameter,
17 getParameter,
18 getVersion,
19 hasAlchemyLabelMap,
20 lastSegment,
21 listAlchemyParameters,
22 listVersions,
23 locationFromParameter,
24 normalizeLocation,
25 parseVersionName,
26 samePayload,
27 toPhysicalId,
28 versionResourceName,
29 waitUntilVersionGone,
30 } from "./internal.ts";
31
32 export type ParametersVersionProps = {
33 /**
34 * Parent parameter. Full name
35 * `projects/{project}/locations/{location}/parameters/{parameter}`
36 * or the parameter id (combined with `location`). Immutable —
37 * changing it replaces the version.
38 */
39 parameter: string;
40 /**
41 * Parameter Manager location used when `parameter` is a bare id.
42 * Immutable — changing it replaces the version. `GLOBAL` is accepted
43 * and normalized to `global`.
44 * @default "global"
45 */
46 location?: string;
47 /**
48 * Version id (the `{version}` segment of
49 * `.../parameters/{parameter}/versions/{version}`). If omitted, a
50 * unique name is generated from the stack, stage, and logical id.
51 * Must be 1-63 characters, start with a letter, and match
52 * `[a-zA-Z][a-zA-Z0-9_-]*`. Immutable — changing it replaces the
53 * version.
54 */
55 parameterVersionId?: string;
56 /**
57 * UTF-8 payload. Alchemy base64-encodes this for the API. Ignored
58 * when `payload.data` is set. Immutable — changing it replaces the
59 * version.
60 */
61 data?: string;
62 /**
63 * Payload as stored by the API. `data` is standard base64. Takes
64 * precedence over `data`. Immutable — changing it replaces the
65 * version.
66 */
67 payload?: {
68 data?: string;
69 };
70 /**
71 * When true, the version is metadata-only: get always returns the
72 * BASIC view and render fails. Mutable.
73 * @default false
74 */
75 disabled?: boolean;
76 };
77
78 export type ParametersVersion = Resource<
79 "GCP.ParameterManager.ParametersVersion",
80 ParametersVersionProps,
81 {
82 /** Full resource name `projects/{project}/locations/{location}/parameters/{parameter}/versions/{version}`. */
83 name: string;
84 /** Version id (last path segment). */
85 parameterVersionId: string;
86 /** Parent parameter resource name. */
87 parameter: string;
88 /** Parent parameter id. */
89 parameterId: string;
90 /** Project id. */
91 project: string;
92 /** Location id (`us-central1`, `global`, …). */
93 location: string;
94 /** Standard-base64 payload, when the FULL view returned it. */
95 payloadData: string | undefined;
96 /** Whether the version is disabled. */
97 disabled: boolean;
98 /** CMEK key version used to encrypt this payload, if the parent uses CMEK. */
99 kmsKeyVersion: string | undefined;
100 /** RFC3339 creation timestamp. */
101 createTime: string | undefined;
102 /** RFC3339 last-update timestamp. */
103 updateTime: string | undefined;
104 },
105 never,
106 Providers
107 >;
108
109 /**
110 * A Parameter Manager parameter version — an immutable payload attached
111 * to a {@link Parameter}. Versions have no labels field; `list` / nuke
112 * find versions whose parent parameter carries Alchemy labels.
113 *
114 * Changing `parameterVersionId`, `parameter`, `location`, or the payload
115 * replaces the version. `disabled` updates in place.
116 *
117 * ### Creating a ParametersVersion
118 * **Example:** UTF-8 payload
119 * ```typescript
120 * const parameter = yield* GCP.ParameterManager.Parameter("AppConfig", {});
121 * const version = yield* GCP.ParameterManager.ParametersVersion("V1", {
122 * parameter: parameter.name,
123 * data: "host=api.example.com",
124 * });
125 * ```
126 *
127 * **Example:** JSON payload on a JSON parameter
128 * ```typescript
129 * const parameter = yield* GCP.ParameterManager.Parameter("AppConfig", {
130 * format: "JSON",
131 * });
132 * const version = yield* GCP.ParameterManager.ParametersVersion("V1", {
133 * parameter: parameter.name,
134 * data: JSON.stringify({ host: "api.example.com" }),
135 * });
136 * ```
137 *
138 * ### Disabling a Version
139 * **Example:** Keep metadata, hide payload
140 * ```typescript
141 * const version = yield* GCP.ParameterManager.ParametersVersion("V1", {
142 * parameter: parameter.name,
143 * parameterVersionId: "v1",
144 * data: "host=api.example.com",
145 * disabled: true,
146 * });
147 * ```
148 *
149 * @resource
150 * @category ParameterManager
151 */
152 export const ParametersVersion = Resource<ParametersVersion>(
153 "GCP.ParameterManager.ParametersVersion",
154 );
155
156 export { ParameterVersionNotResolved, ParameterVersionPayloadRequired };
157
158 const toAttrs = (version: parametermanager.ParameterVersion, project: string) => {
159 const name = version.name ?? "";
160 const parsed = parseVersionName(name);
161 return {
162 name,
163 parameterVersionId: parsed.parameterVersionId,
164 parameter: parsed.parameter,
165 parameterId: lastSegment(parsed.parameter),
166 project: parsed.project || project,
167 location: parsed.location,
168 payloadData: version.payload?.data,
169 disabled: version.disabled === true,
170 kmsKeyVersion: version.kmsKeyVersion,
171 createTime: version.createTime,
172 updateTime: version.updateTime,
173 };
174 };
175
176 const createBody = (payloadData: string, disabled: boolean): parametermanager.ParameterVersion => ({
177 payload: { data: payloadData },
178 disabled,
179 });
180
181 export const ParametersVersionProvider = () =>
182 Provider.succeed(ParametersVersion, {
183 stables: [
184 "name",
185 "parameterVersionId",
186 "parameter",
187 "parameterId",
188 "project",
189 "location",
190 "createTime",
191 ],
192
193 diff: Effect.fn(function* ({ news, olds, output }) {
194 if (!isResolved(news)) return undefined;
195 const previousId = olds?.parameterVersionId ?? output?.parameterVersionId;
196 const nextId = news.parameterVersionId ?? previousId;
197 const previousParameter = lastSegment(olds?.parameter ?? output?.parameter ?? "");
198 const nextParameter = lastSegment(news.parameter);
199 const previousLocation = normalizeLocation(
200 olds?.location ??
201 output?.location ??
202 locationFromParameter(olds?.parameter ?? output?.parameter, DEFAULT_LOCATION),
203 );
204 const nextLocation = normalizeLocation(
205 news.location ?? locationFromParameter(news.parameter, previousLocation),
206 );
207 const previousPayload =
208 olds?.payload?.data ??
209 (olds?.data !== undefined ? yield* desiredPayloadData(olds) : output?.payloadData);
210 const nextPayload = yield* desiredPayloadData(news);
211 const idChanged = previousId !== undefined && nextId !== undefined && previousId !== nextId;
212 const parentChanged = previousParameter.length > 0 && previousParameter !== nextParameter;
213 const locationChanged = previousLocation !== nextLocation;
214 const payloadChanged =
215 nextPayload !== undefined &&
216 previousPayload !== undefined &&
217 !samePayload(previousPayload, nextPayload);
218 if (!idChanged && !parentChanged && !locationChanged && !payloadChanged) {
219 return undefined;
220 }
221 return {
222 action: "replace" as const,
223 deleteFirst:
224 !idChanged &&
225 !parentChanged &&
226 !locationChanged &&
227 payloadChanged &&
228 previousId !== undefined &&
229 nextId === previousId,
230 };
231 }),
232
233 read: Effect.fn(function* ({ id, olds, output }) {
234 const env = yield* GcpEnvironment.current;
235 const location = normalizeLocation(
236 olds?.location ??
237 output?.location ??
238 locationFromParameter(olds?.parameter ?? output?.parameter, DEFAULT_LOCATION),
239 );
240 const parameter = expandParameter(
241 olds?.parameter ?? output?.parameter ?? "",
242 env.project,
243 location,
244 );
245 const parameterVersionId = yield* toPhysicalId(
246 id,
247 olds?.parameterVersionId,
248 output?.parameterVersionId,
249 "version",
250 );
251 const name = output?.name ?? versionResourceName(parameter, parameterVersionId);
252 const existing = yield* getVersion(name);
253 if (existing === undefined) return undefined;
254 const attrs = toAttrs(existing, env.project);
255 const parent = yield* getParameter(attrs.parameter);
256 return hasAlchemyLabelMap(parent?.labels) ? attrs : Unowned(attrs);
257 }),
258
259 list: () =>
260 Effect.gen(function* () {
261 const env = yield* GcpEnvironment.current;
262 const parameters = yield* listAlchemyParameters(env.project);
263 const versions = yield* Effect.forEach(
264 parameters,
265 (parameter) => listVersions(parameter.name ?? ""),
266 { concurrency: 4 },
267 );
268 return versions.flat().map((version) => toAttrs(version, env.project));
269 }),
270
271 reconcile: Effect.fn(function* ({ id, news, output }) {
272 const env = yield* GcpEnvironment.current;
273 const location = normalizeLocation(
274 news.location ??
275 output?.location ??
276 locationFromParameter(news.parameter, DEFAULT_LOCATION),
277 );
278 const parameter = expandParameter(news.parameter, env.project, location);
279 const parameterVersionId = yield* toPhysicalId(
280 id,
281 news.parameterVersionId,
282 output?.parameterVersionId,
283 "version",
284 );
285 const name = versionResourceName(parameter, parameterVersionId);
286 const desiredDisabled = news.disabled === true;
287 const desiredPayload = yield* desiredPayloadData(news);
288
289 yield* getParameter(parameter).pipe(
290 Effect.flatMap((parent) =>
291 parent === undefined
292 ? Effect.fail(new ParameterNotResolved({ resourceName: parameter }))
293 : Effect.succeed(parent),
294 ),
295 Effect.retry({
296 while: (error) => error._tag === "GCP.ParameterManager.ParameterNotResolved",
297 times: 8,
298 schedule: Schedule.spaced("1 second"),
299 }),
300 );
301
302 let current = yield* getVersion(name);
303
304 if (
305 current !== undefined &&
306 desiredPayload !== undefined &&
307 !samePayload(current.payload?.data, desiredPayload)
308 ) {
309 yield* parametermanager
310 .deleteProjectsLocationsParametersVersions({
311 name: current.name ?? name,
312 })
313 .pipe(Effect.catchTag("NotFound", () => Effect.void));
314 yield* waitUntilVersionGone(name);
315 current = undefined;
316 }
317
318 if (current === undefined) {
319 if (desiredPayload === undefined) {
320 return yield* new ParameterVersionPayloadRequired({ resourceName: name });
321 }
322 const created = yield* parametermanager
323 .createProjectsLocationsParametersVersions({
324 parent: parameter,
325 parameterVersionId,
326 body: createBody(desiredPayload, desiredDisabled),
327 })
328 .pipe(
329 Effect.retry({
330 // The parent parameter may not be readable yet.
331 while: (error): boolean => error._tag === "NotFound",
332 times: 8,
333 schedule: Schedule.spaced("1 second"),
334 }),
335 Effect.catchTag("Conflict", () => getVersion(name)),
336 );
337 current = (yield* getVersion(name)) ?? created ?? undefined;
338 }
339
340 if (current === undefined) {
341 return yield* new ParameterVersionNotResolved({ resourceName: name });
342 }
343
344 if ((current.disabled === true) !== desiredDisabled) {
345 yield* parametermanager.patchProjectsLocationsParametersVersions({
346 name,
347 updateMask: "disabled",
348 body: {
349 name,
350 disabled: desiredDisabled,
351 },
352 });
353 current = (yield* getVersion(name)) ?? current;
354 }
355
356 return toAttrs(current, env.project);
357 }),
358
359 delete: Effect.fn(function* ({ output }) {
360 yield* parametermanager.deleteProjectsLocationsParametersVersions({ name: output.name }).pipe(
361 Effect.retry({
362 while: (error) => error._tag === "Conflict",
363 times: 8,
364 schedule: Schedule.spaced("1 second"),
365 }),
366 Effect.catchTag(["NotFound", "BadRequest"], () => Effect.void),
367 );
368 yield* waitUntilVersionGone(output.name);
369 }),
370 });