@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 213 lines 7.06 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 FolderProps = {
14 /**
15 * Name of the hierarchical-namespace bucket that contains this folder.
16 * Immutable — changing it replaces the folder.
17 */
18 bucketName: string;
19 /**
20 * Folder path. A trailing slash is added if omitted. If omitted
21 * entirely, a unique name is generated from the stack, stage, and
22 * logical id. Immutable — changing it replaces the folder.
23 */
24 folderName?: string;
25 };
26
27 export type Folder = Resource<
28 "GCP.Storage.Folder",
29 FolderProps,
30 {
31 /** Parent bucket name. */
32 bucketName: string;
33 /** Folder path, including the trailing slash. */
34 folderName: 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 folder in a hierarchical-namespace bucket.
52 *
53 * Folders exist only on buckets created with `hierarchicalNamespace:
54 * true` (which also requires uniform bucket-level access). Identity is
55 * `(bucket, folder name)`. Folders have no mutable fields and no labels,
56 * so `list` / `pnpm nuke:gcp` discover them by enumerating
57 * alchemy-labeled buckets.
58 *
59 * ### Creating a Folder
60 * **Example:** Generated name
61 * ```typescript
62 * const bucket = yield* GCP.Storage.Bucket("tree", {
63 * hierarchicalNamespace: true,
64 * uniformBucketLevelAccess: true,
65 * forceDestroy: true,
66 * });
67 * const folder = yield* GCP.Storage.Folder("uploads", {
68 * bucketName: bucket.bucketName,
69 * });
70 * ```
71 *
72 * **Example:** Explicit path
73 * ```typescript
74 * const folder = yield* GCP.Storage.Folder("uploads", {
75 * bucketName: bucket.bucketName,
76 * folderName: "uploads/incoming/",
77 * });
78 * ```
79 *
80 * @resource
81 * @category Storage
82 */
83 export const Folder = Resource<Folder>("GCP.Storage.Folder");
84
85 export class FolderNotResolved extends Data.TaggedError("GCP.Storage.FolderNotResolved")<{
86 bucketName: string;
87 folderName: string;
88 }> {}
89
90 const toAttrs = (folder: storage.Folder, bucketName: string) => ({
91 bucketName: folder.bucket ?? bucketName,
92 folderName: withTrailingSlash(folder.name ?? ""),
93 id: folder.id,
94 metageneration: folder.metageneration,
95 createTime: folder.createTime,
96 updateTime: folder.updateTime,
97 selfLink: folder.selfLink,
98 });
99
100 const getByName = (bucketName: string, folderName: string) =>
101 storage
102 .getFolders({ bucket: bucketName, folder: folderName })
103 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
104
105 const listOnBucket = (bucketName: string) =>
106 storage.listFolders.items({ bucket: bucketName, pageSize: 1000 }).pipe(
107 Stream.runCollect,
108 Effect.map((chunk) => Array.from(chunk)),
109 Effect.catchTag("NotFound", () => Effect.succeed([] as storage.Folder[])),
110 );
111
112 const waitUntilGone = (bucketName: string, folderName: string) =>
113 getByName(bucketName, folderName).pipe(
114 Effect.map((existing) => (existing === undefined ? ("gone" as const) : ("found" as const))),
115 Effect.repeat({
116 schedule: Schedule.spaced("1 second"),
117 until: (status) => status === "gone",
118 times: 30,
119 }),
120 Effect.flatMap((status): Effect.Effect<void, DeleteNotConfirmed> =>
121 status === "gone"
122 ? Effect.void
123 : Effect.fail(
124 new DeleteNotConfirmed({
125 resource: `${bucketName}/folders/${folderName}`,
126 }),
127 ),
128 ),
129 );
130
131 export const FolderProvider = () =>
132 Provider.succeed(Folder, {
133 stables: ["bucketName", "folderName", "id", "selfLink", "createTime"],
134
135 diff: Effect.fn(function* ({ news, olds, output }) {
136 if (!isResolved(news)) return undefined;
137 const previousBucket = olds?.bucketName ?? output?.bucketName;
138 if (previousBucket !== undefined && news.bucketName !== previousBucket) {
139 return { action: "replace" as const, deleteFirst: false };
140 }
141 const previousName = olds?.folderName ?? output?.folderName;
142 if (
143 news.folderName !== undefined &&
144 previousName !== undefined &&
145 withTrailingSlash(news.folderName) !== withTrailingSlash(previousName)
146 ) {
147 return { action: "replace" as const, deleteFirst: false };
148 }
149 return undefined;
150 }),
151
152 read: Effect.fn(function* ({ id, olds, output }) {
153 const bucketName = olds?.bucketName ?? output?.bucketName;
154 if (!bucketName) return undefined;
155 const folderName = yield* toFolderName(id, olds?.folderName, output?.folderName);
156 const existing = yield* getByName(bucketName, folderName);
157 if (existing === undefined) return undefined;
158 return toAttrs(existing, bucketName);
159 }),
160
161 list: () =>
162 Effect.gen(function* () {
163 const buckets = yield* listAlchemyBuckets();
164 const pages = yield* Effect.forEach(
165 buckets,
166 (bucket) => {
167 const bucketName = bucket.name;
168 if (!bucketName || bucket.hierarchicalNamespace?.enabled !== true) {
169 return Effect.succeed([] as Array<Folder["Attributes"]>);
170 }
171 return listOnBucket(bucketName).pipe(
172 Effect.map((items) => items.map((item) => toAttrs(item, bucketName))),
173 );
174 },
175 { concurrency: 8 },
176 );
177 return pages.flat();
178 }),
179
180 reconcile: Effect.fn(function* ({ id, news, output }) {
181 const bucketName = news.bucketName;
182 const folderName = yield* toFolderName(id, news.folderName, output?.folderName);
183
184 let current = yield* getByName(bucketName, folderName);
185
186 if (current === undefined) {
187 const created = yield* storage
188 .insertFolders({
189 bucket: bucketName,
190 recursive: true,
191 body: { name: folderName },
192 })
193 .pipe(Effect.catchTag("Conflict", () => getByName(bucketName, folderName)));
194 current = created ?? undefined;
195 }
196
197 if (current === undefined || !(current.name ?? current.id)) {
198 return yield* new FolderNotResolved({ bucketName, folderName });
199 }
200
201 return toAttrs(current, bucketName);
202 }),
203
204 delete: Effect.fn(function* ({ output }) {
205 const bucketName = output.bucketName;
206 const folderName = output.folderName;
207 if (!bucketName || !folderName) return;
208 yield* storage
209 .deleteFolders({ bucket: bucketName, folder: folderName })
210 .pipe(Effect.catchTag("NotFound", () => Effect.void));
211 yield* waitUntilGone(bucketName, folderName);
212 }),
213 });