@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 231 lines 7.49 KB
Raw
1 import * as storage from "@distilled.cloud/gcp/storage_v1";
2 import { isResolved } from "alchemy/Diff";
3 import * as Provider from "alchemy/Provider";
4 import { Resource } from "alchemy/Resource";
5 import * as Data from "effect/Data";
6 import * as Effect from "effect/Effect";
7 import * as Schedule from "effect/Schedule";
8 import * as Stream from "effect/Stream";
9 import { DeleteNotConfirmed } from "../Errors.ts";
10 import type { Providers } from "../Providers.ts";
11 import { listAlchemyBuckets, toFolderName, withTrailingSlash } from "./internal.ts";
12
13 export type ManagedProps = {
14 /**
15 * Name of the uniform-access bucket that contains this managed folder.
16 * Immutable — changing it replaces the folder.
17 */
18 bucketName: string;
19 /**
20 * Managed folder path. A trailing slash is added if omitted. If
21 * omitted entirely, a unique name is generated from the stack, stage,
22 * and logical id. Immutable — changing it replaces the folder.
23 */
24 managedFolderName?: string;
25 };
26
27 export type Managed = Resource<
28 "GCP.Storage.Managed",
29 ManagedProps,
30 {
31 /** Parent bucket name. */
32 bucketName: string;
33 /** Managed folder path, including the trailing slash. */
34 managedFolderName: string;
35 /** Server-assigned id (`{bucket}/{folder}`). */
36 id: string | undefined;
37 /** Metadata generation. */
38 metageneration: string | undefined;
39 /** RFC3339 creation timestamp. */
40 createTime: string | undefined;
41 /** RFC3339 last-update timestamp. */
42 updateTime: string | undefined;
43 /** GCS self-link. */
44 selfLink: string | undefined;
45 },
46 never,
47 Providers
48 >;
49
50 /**
51 * A Cloud Storage managed folder.
52 *
53 * Managed folders provide IAM on an object-name prefix in a bucket with
54 * uniform bucket-level access. Identity is `(bucket, folder name)`.
55 * Managed folders have no mutable fields and no labels, so `list` /
56 * `pnpm nuke:gcp` discover them by enumerating alchemy-labeled buckets.
57 *
58 * ### Creating a Managed Folder
59 * **Example:** Generated name
60 * ```typescript
61 * const bucket = yield* GCP.Storage.Bucket("assets", {
62 * uniformBucketLevelAccess: true,
63 * forceDestroy: true,
64 * });
65 * const folder = yield* GCP.Storage.Managed("team", {
66 * bucketName: bucket.bucketName,
67 * });
68 * ```
69 *
70 * **Example:** Explicit path
71 * ```typescript
72 * const folder = yield* GCP.Storage.Managed("team", {
73 * bucketName: bucket.bucketName,
74 * managedFolderName: "teams/payments/",
75 * });
76 * ```
77 *
78 * @resource
79 * @category Storage
80 */
81 export const Managed = Resource<Managed>("GCP.Storage.Managed");
82
83 export class ManagedNotResolved extends Data.TaggedError("GCP.Storage.ManagedNotResolved")<{
84 bucketName: string;
85 managedFolderName: string;
86 }> {}
87
88 const toAttrs = (folder: storage.ManagedFolder, bucketName: string) => ({
89 bucketName: folder.bucket ?? bucketName,
90 managedFolderName: withTrailingSlash(folder.name ?? ""),
91 id: folder.id,
92 metageneration: folder.metageneration,
93 createTime: folder.createTime,
94 updateTime: folder.updateTime,
95 selfLink: folder.selfLink,
96 });
97
98 const getByName = (bucketName: string, managedFolderName: string) =>
99 storage
100 .getManagedFolders({
101 bucket: bucketName,
102 managedFolder: managedFolderName,
103 })
104 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
105
106 const listOnBucket = (bucketName: string) =>
107 storage.listManagedFolders.items({ bucket: bucketName, pageSize: 1000 }).pipe(
108 Stream.runCollect,
109 Effect.map((chunk) => Array.from(chunk)),
110 Effect.catchTag("NotFound", () => Effect.succeed([] as storage.ManagedFolder[])),
111 );
112
113 const waitUntilGone = (bucketName: string, managedFolderName: string) =>
114 getByName(bucketName, managedFolderName).pipe(
115 Effect.map((existing) => (existing === undefined ? ("gone" as const) : ("found" as const))),
116 Effect.repeat({
117 schedule: Schedule.spaced("1 second"),
118 until: (status) => status === "gone",
119 times: 30,
120 }),
121 Effect.flatMap((status): Effect.Effect<void, DeleteNotConfirmed> =>
122 status === "gone"
123 ? Effect.void
124 : Effect.fail(
125 new DeleteNotConfirmed({
126 resource: `${bucketName}/managedFolders/${managedFolderName}`,
127 }),
128 ),
129 ),
130 );
131
132 export const ManagedProvider = () =>
133 Provider.succeed(Managed, {
134 stables: ["bucketName", "managedFolderName", "id", "selfLink", "createTime"],
135
136 diff: Effect.fn(function* ({ news, olds, output }) {
137 if (!isResolved(news)) return undefined;
138 const previousBucket = olds?.bucketName ?? output?.bucketName;
139 if (previousBucket !== undefined && news.bucketName !== previousBucket) {
140 return { action: "replace" as const, deleteFirst: false };
141 }
142 const previousName = olds?.managedFolderName ?? output?.managedFolderName;
143 if (
144 news.managedFolderName !== undefined &&
145 previousName !== undefined &&
146 withTrailingSlash(news.managedFolderName) !== withTrailingSlash(previousName)
147 ) {
148 return { action: "replace" as const, deleteFirst: false };
149 }
150 return undefined;
151 }),
152
153 read: Effect.fn(function* ({ id, olds, output }) {
154 const bucketName = olds?.bucketName ?? output?.bucketName;
155 if (!bucketName) return undefined;
156 const managedFolderName = yield* toFolderName(
157 id,
158 olds?.managedFolderName,
159 output?.managedFolderName,
160 );
161 const existing = yield* getByName(bucketName, managedFolderName);
162 if (existing === undefined) return undefined;
163 return toAttrs(existing, bucketName);
164 }),
165
166 list: () =>
167 Effect.gen(function* () {
168 const buckets = yield* listAlchemyBuckets();
169 const pages = yield* Effect.forEach(
170 buckets,
171 (bucket) => {
172 const bucketName = bucket.name;
173 if (
174 !bucketName ||
175 bucket.iamConfiguration?.uniformBucketLevelAccess?.enabled !== true
176 ) {
177 return Effect.succeed([] as Array<Managed["Attributes"]>);
178 }
179 return listOnBucket(bucketName).pipe(
180 Effect.map((items) => items.map((item) => toAttrs(item, bucketName))),
181 );
182 },
183 { concurrency: 8 },
184 );
185 return pages.flat();
186 }),
187
188 reconcile: Effect.fn(function* ({ id, news, output }) {
189 const bucketName = news.bucketName;
190 const managedFolderName = yield* toFolderName(
191 id,
192 news.managedFolderName,
193 output?.managedFolderName,
194 );
195
196 let current = yield* getByName(bucketName, managedFolderName);
197
198 if (current === undefined) {
199 const created = yield* storage
200 .insertManagedFolders({
201 bucket: bucketName,
202 body: { name: managedFolderName },
203 })
204 .pipe(Effect.catchTag("Conflict", () => getByName(bucketName, managedFolderName)));
205 current = created ?? undefined;
206 }
207
208 if (current === undefined || !(current.name ?? current.id)) {
209 return yield* new ManagedNotResolved({
210 bucketName,
211 managedFolderName,
212 });
213 }
214
215 return toAttrs(current, bucketName);
216 }),
217
218 delete: Effect.fn(function* ({ output }) {
219 const bucketName = output.bucketName;
220 const managedFolderName = output.managedFolderName;
221 if (!bucketName || !managedFolderName) return;
222 yield* storage
223 .deleteManagedFolders({
224 bucket: bucketName,
225 managedFolder: managedFolderName,
226 allowNonEmpty: true,
227 })
228 .pipe(Effect.catchTag("NotFound", () => Effect.void));
229 yield* waitUntilGone(bucketName, managedFolderName);
230 }),
231 });