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

main
ts 329 lines 10.9 KB
Raw
1 import * as resourcemanager from "@distilled.cloud/gcp/cloudresourcemanager_v3";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { createPhysicalName } from "alchemy/PhysicalName";
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 type { Providers } from "../Providers.ts";
10 import {
11 FOLDER_DISPLAY_MAX,
12 collectPages,
13 isDeleteRequested,
14 resolveParent,
15 resourceNameFromOperation,
16 sameHierarchyParent,
17 waitForOperation,
18 waitForCreate,
19 } from "./internal.ts";
20
21 export type FolderProps = {
22 /**
23 * User-visible display name. Unique among sibling folders. 1-30
24 * characters, starting and ending with a letter or digit. If omitted,
25 * a unique name is generated from the stack, stage, and logical id.
26 */
27 displayName?: string;
28 /**
29 * Parent `organizations/{org}` or `folders/{folder}`. Defaults to the
30 * current project's parent. Changing parent moves the folder.
31 */
32 parent?: string;
33 };
34
35 export type Folder = Resource<
36 "GCP.ResourceManager.Folder",
37 FolderProps,
38 {
39 /** Resource name `folders/{folder_id}`. */
40 name: string;
41 /** User-visible display name as stored in Cloud Resource Manager. */
42 displayName: string;
43 /** Parent `organizations/{org}` or `folders/{folder}`. */
44 parent: string;
45 /** Lifecycle state (`ACTIVE` or `DELETE_REQUESTED`). */
46 state: string | undefined;
47 /** Server etag for optimistic concurrency. */
48 etag: string | undefined;
49 /** RFC3339 creation timestamp. */
50 createTime: string | undefined;
51 /** RFC3339 last-update timestamp. */
52 updateTime: string | undefined;
53 /** RFC3339 time a delete was requested, if any. */
54 deleteTime: string | undefined;
55 /** Configured folder capabilities, if any. */
56 configuredCapabilities: string[];
57 /** Management project when app-management is enabled. */
58 managementProject: string | undefined;
59 },
60 never,
61 Providers
62 >;
63
64 /**
65 * A Cloud Resource Manager folder — a node in an organization's resource
66 * hierarchy used to group projects and other folders.
67 *
68 * Folders have no labels, so a folder found without prior state is
69 * reported as unowned and only taken over with `--adopt`. `displayName`
70 * updates in place; changing `parent` moves the folder. Delete is a 30-day
71 * soft-delete (`DELETE_REQUESTED`).
72 *
73 * ### Creating a Folder
74 * **Example:** Generated display name under the current project's parent
75 * ```typescript
76 * const folder = yield* GCP.ResourceManager.Folder("Team", {});
77 * ```
78 *
79 * **Example:** Explicit display name and parent
80 * ```typescript
81 * const folder = yield* GCP.ResourceManager.Folder("Team", {
82 * displayName: "platform",
83 * parent: "organizations/123456789",
84 * });
85 * ```
86 *
87 * ### Updating a Folder
88 * **Example:** Rename
89 * ```typescript
90 * const folder = yield* GCP.ResourceManager.Folder("Team", {
91 * displayName: "platform-prod",
92 * });
93 * ```
94 *
95 * @resource
96 * @category ResourceManager
97 */
98 export const Folder = Resource<Folder>("GCP.ResourceManager.Folder");
99
100 export class FolderNotResolved extends Data.TaggedError("GCP.ResourceManager.FolderNotResolved")<{
101 resourceName: string;
102 }> {}
103
104 export class FolderStillExists extends Data.TaggedError("GCP.ResourceManager.FolderStillExists")<{
105 resourceName: string;
106 }> {}
107
108 const sanitizeDisplayName = (value: string) => {
109 let next = value
110 .replace(/[^a-zA-Z0-9_ -]/g, "-")
111 .replace(/\s+/g, " ")
112 .trim();
113 if (next.length > FOLDER_DISPLAY_MAX) {
114 next = next.slice(0, FOLDER_DISPLAY_MAX);
115 }
116 if (!/^[a-zA-Z0-9]/.test(next)) next = `a${next}`.slice(0, FOLDER_DISPLAY_MAX);
117 next = next.replace(/[^a-zA-Z0-9]+$/g, "");
118 if (next.length === 0) next = "az0";
119 return next;
120 };
121
122 const toDisplayName = (id: string, displayName: string | undefined, existing?: string) =>
123 Effect.gen(function* () {
124 if (displayName !== undefined) return sanitizeDisplayName(displayName);
125 if (existing !== undefined) return existing;
126 const generated = yield* createPhysicalName({
127 id,
128 maxLength: FOLDER_DISPLAY_MAX,
129 lowercase: true,
130 suffixLength: 8,
131 });
132 return sanitizeDisplayName(generated);
133 });
134
135 const toAttrs = (folder: resourcemanager.Folder) => ({
136 name: folder.name ?? "",
137 displayName: folder.displayName ?? "",
138 parent: folder.parent ?? "",
139 state: folder.state,
140 etag: folder.etag,
141 createTime: folder.createTime,
142 updateTime: folder.updateTime,
143 deleteTime: folder.deleteTime,
144 configuredCapabilities: folder.configuredCapabilities ?? [],
145 managementProject: folder.managementProject,
146 });
147
148 const getByName = (name: string) =>
149 resourcemanager
150 .getFolders({ name })
151 .pipe(Effect.catchTag(["NotFound", "FolderNotFound"], () => Effect.undefined));
152
153 const listChildren = (parent: string, showDeleted = true) =>
154 collectPages(
155 resourcemanager.listFolders.pages({
156 parent,
157 pageSize: 300,
158 showDeleted,
159 }),
160 (page) => page.folders,
161 ).pipe(Effect.catchTag("NotFound", () => Effect.succeed([] as resourcemanager.Folder[])));
162
163 const findByDisplayName = (parent: string, displayName: string, resourceName?: string) =>
164 Effect.gen(function* () {
165 if (resourceName !== undefined && resourceName.length > 0) {
166 const byName = yield* getByName(resourceName);
167 if (byName !== undefined) return byName;
168 }
169 const children = yield* listChildren(parent, true);
170 return children.find((folder) => folder.displayName === displayName);
171 });
172
173 const observe = (resourceName: string | undefined, parent: string, displayName: string) =>
174 Effect.gen(function* () {
175 if (resourceName !== undefined && resourceName.length > 0) {
176 const byName = yield* getByName(resourceName);
177 if (byName !== undefined) return byName;
178 }
179 return yield* findByDisplayName(parent, displayName, resourceName);
180 });
181
182 const waitUntilExists = (resourceName: string | undefined, parent: string, displayName: string) =>
183 observe(resourceName, parent, displayName).pipe(
184 Effect.filterOrFail(
185 (folder): folder is resourcemanager.Folder => folder !== undefined,
186 () =>
187 new FolderNotResolved({
188 resourceName: resourceName ?? `${parent}/${displayName}`,
189 }),
190 ),
191 Effect.retry({
192 while: (error) => error._tag === "GCP.ResourceManager.FolderNotResolved",
193 times: 8,
194 schedule: Schedule.spaced("1 second"),
195 }),
196 );
197
198 const waitUntilGone = (name: string) =>
199 getByName(name).pipe(
200 Effect.flatMap((folder) =>
201 folder === undefined || isDeleteRequested(folder.state)
202 ? Effect.void
203 : Effect.fail(new FolderStillExists({ resourceName: name })),
204 ),
205 Effect.retry({
206 while: (error) => error._tag === "GCP.ResourceManager.FolderStillExists",
207 times: 10,
208 schedule: Schedule.spaced("1 second"),
209 }),
210 );
211
212 const ensureActive = (folder: resourcemanager.Folder) =>
213 Effect.gen(function* () {
214 if (!isDeleteRequested(folder.state) || folder.name === undefined) {
215 return folder;
216 }
217 const operation = yield* resourcemanager.undeleteFolders({
218 name: folder.name,
219 body: {},
220 });
221 yield* waitForOperation(operation);
222 return (
223 (yield* waitUntilExists(folder.name, folder.parent ?? "", folder.displayName ?? "")) ?? folder
224 );
225 });
226
227 export const FolderProvider = () =>
228 Provider.succeed(Folder, {
229 stables: ["name", "createTime"],
230
231 read: Effect.fn(function* ({ id, olds, output }) {
232 const displayName = yield* toDisplayName(id, olds?.displayName, output?.displayName);
233 const parent = yield* resolveParent(olds?.parent, output?.parent).pipe(
234 Effect.catchTag("GCP.ResourceManager.ParentRequired", () =>
235 Effect.succeed(output?.parent ?? ""),
236 ),
237 );
238 if (parent.length === 0 && output?.name === undefined) return undefined;
239 const existing = yield* observe(output?.name, parent || (output?.parent ?? ""), displayName);
240 if (existing === undefined) return undefined;
241 const attrs = toAttrs(existing);
242 // No labels field: without prior state it may not be ours.
243 return output !== undefined ? attrs : Unowned(attrs);
244 }),
245
246 reconcile: Effect.fn(function* ({ id, news, output }) {
247 const displayName = yield* toDisplayName(id, news.displayName, output?.displayName);
248 const parent = yield* resolveParent(news.parent, output?.parent);
249
250 let current = yield* observe(output?.name, parent, displayName);
251
252 if (current === undefined) {
253 const created = yield* resourcemanager
254 .createFolders({
255 body: {
256 parent,
257 displayName,
258 },
259 })
260 .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
261 if (created !== undefined) {
262 const settled = yield* waitForCreate(created);
263 current = yield* waitUntilExists(
264 resourceNameFromOperation(settled, "folders/") ??
265 resourceNameFromOperation(created, "folders/"),
266 parent,
267 displayName,
268 );
269 } else {
270 current = yield* waitUntilExists(undefined, parent, displayName);
271 }
272 }
273
274 if (current === undefined || current.name === undefined) {
275 return yield* new FolderNotResolved({
276 resourceName: output?.name ?? `${parent}/${displayName}`,
277 });
278 }
279
280 const name = current.name;
281 current = yield* ensureActive(current);
282
283 if ((current.displayName ?? "") !== displayName) {
284 const operation = yield* resourcemanager.patchFolders({
285 name: current.name ?? name,
286 updateMask: "displayName",
287 body: {
288 name: current.name ?? name,
289 displayName,
290 etag: current.etag,
291 },
292 });
293 yield* waitForOperation(operation);
294 current = yield* waitUntilExists(current.name ?? name, parent, displayName);
295 }
296
297 if (current.parent !== undefined && !sameHierarchyParent(current.parent, parent)) {
298 const operation = yield* resourcemanager.moveFolders({
299 name: current.name ?? name,
300 body: { destinationParent: parent },
301 });
302 yield* waitForOperation(operation);
303 current = yield* waitUntilExists(current.name ?? name, parent, displayName);
304 }
305
306 if (current === undefined) {
307 return yield* new FolderNotResolved({
308 resourceName: output?.name ?? `${parent}/${displayName}`,
309 });
310 }
311
312 return toAttrs(current);
313 }),
314
315 delete: Effect.fn(function* ({ output }) {
316 const operation = yield* resourcemanager.deleteFolders({ name: output.name }).pipe(
317 Effect.retry({
318 while: (error) => error._tag === "Conflict",
319 times: 8,
320 schedule: Schedule.spaced("2 seconds"),
321 }),
322 Effect.catchTag(["NotFound", "FolderNotFound"], () => Effect.undefined),
323 );
324 if (operation !== undefined) {
325 yield* waitForOperation(operation, { notFoundOk: true });
326 }
327 yield* waitUntilGone(output.name);
328 }),
329 });