@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 247 lines 8.54 KB
Raw
1 import * as logging from "@distilled.cloud/gcp/logging_v2";
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 Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Stream from "effect/Stream";
9 import { GcpEnvironment } from "../Environment.ts";
10 import type { Providers } from "../Providers.ts";
11 import {
12 createOwnership,
13 encodeDescription,
14 hasOwnershipMarker,
15 lastSegment,
16 ownedBy,
17 parseDescription,
18 parseLoggingName,
19 toPhysicalId,
20 } from "./internal.ts";
21
22 export type FolderBucketsViewProps = {
23 /**
24 * Full resource name of the parent log bucket
25 * (`{parent}/locations/{location}/buckets/{bucket}`). Immutable —
26 * changing it replaces the view.
27 */
28 bucketName: string;
29 /**
30 * View id (the `{view}` segment of `{bucket}/views/{view}`). If omitted,
31 * a unique name is generated from the stack, stage, and logical id.
32 * Limited to 100 characters: letters, digits, underscores, hyphens.
33 * Immutable — changing it replaces the view.
34 */
35 viewId?: string;
36 /**
37 * Filter that restricts which log entries in the bucket are visible.
38 * Must be a logical conjunction of `SOURCE()`, `resource.type`, and
39 * `LOG_ID()`, optionally negated with `NOT`.
40 */
41 filter?: string;
42 /**
43 * Human-readable description. Log views have no labels field, so
44 * Alchemy ownership is stored in a `[alchemy …]` prefix and stripped
45 * from attributes.
46 */
47 description?: string;
48 };
49
50 export type FolderBucketsView = Resource<
51 "GCP.Logging.FolderBucketsView",
52 FolderBucketsViewProps,
53 {
54 /** Full resource name `{bucket}/views/{viewId}`. */
55 name: string;
56 /** View id (last path segment). */
57 viewId: string;
58 /** Parent bucket resource name. */
59 bucketName: string;
60 /** View filter, if set. */
61 filter: string | undefined;
62 /** User description with the Alchemy ownership prefix stripped. */
63 description: string | undefined;
64 /** RFC3339 creation timestamp. */
65 createTime: string | undefined;
66 /** RFC3339 last-update timestamp. */
67 updateTime: string | undefined;
68 },
69 never,
70 Providers
71 >;
72
73 /**
74 * A Cloud Logging view over log entries in a folder (or project) log bucket.
75 *
76 * A bucket may contain at most 30 views. Views have no labels field, so
77 * Alchemy stamps ownership into the description for `list` / nuke. `viewId`
78 * and `bucketName` are identity — changing either replaces the view.
79 *
80 * ### Creating a Folder Bucket View
81 * **Example:** View over error entries
82 * ```typescript
83 * const bucket = yield* GCP.Logging.FolderBucket("AppLogs", {});
84 * const view = yield* GCP.Logging.FolderBucketsView("Errors", {
85 * bucketName: bucket.name,
86 * filter: "severity>=ERROR",
87 * description: "errors only",
88 * });
89 * ```
90 *
91 * ### Updating a Folder Bucket View
92 * **Example:** Change the filter
93 * ```typescript
94 * const view = yield* GCP.Logging.FolderBucketsView("Errors", {
95 * bucketName: bucket.name,
96 * filter: "severity>=WARNING",
97 * description: "warnings and errors",
98 * });
99 * ```
100 *
101 * @resource
102 * @category Logging
103 */
104 export const FolderBucketsView = Resource<FolderBucketsView>("GCP.Logging.FolderBucketsView");
105
106 export class FolderBucketsViewNotResolved extends Data.TaggedError(
107 "GCP.Logging.FolderBucketsViewNotResolved",
108 )<{
109 resourceName: string;
110 }> {}
111
112 const resourceName = (bucketName: string, viewId: string) => `${bucketName}/views/${viewId}`;
113
114 const toAttrs = (view: logging.LogView, bucketName: string) => {
115 const parsed = parseLoggingName(view.name ?? "");
116 const viewId = parsed.viewId ?? lastSegment(view.name ?? "");
117 const description = parseDescription(view.description);
118 return {
119 name: view.name ?? resourceName(bucketName, viewId),
120 viewId,
121 bucketName,
122 filter: view.filter,
123 description: description.description,
124 createTime: view.createTime,
125 updateTime: view.updateTime,
126 };
127 };
128
129 const getByName = (name: string) =>
130 logging
131 .getFoldersLocationsBucketsViews({ name })
132 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
133
134 export const FolderBucketsViewProvider = () =>
135 Provider.succeed(FolderBucketsView, {
136 stables: ["name", "viewId", "bucketName", "createTime"],
137
138 diff: Effect.fn(function* ({ news, olds, output }) {
139 if (!isResolved(news)) return undefined;
140 const previousId = olds?.viewId ?? output?.viewId;
141 const idChanged =
142 previousId !== undefined && news.viewId !== undefined && news.viewId !== previousId;
143 const previousBucket = olds?.bucketName ?? output?.bucketName;
144 const bucketChanged = previousBucket !== undefined && news.bucketName !== previousBucket;
145 if (!idChanged && !bucketChanged) return undefined;
146 return { action: "replace" as const, deleteFirst: false };
147 }),
148
149 read: Effect.fn(function* ({ id, olds, output }) {
150 const viewId = yield* toPhysicalId(id, olds?.viewId, output?.viewId, "v");
151 const bucketName = olds?.bucketName ?? output?.bucketName;
152 if (bucketName === undefined) return undefined;
153 const name = output?.name ?? resourceName(bucketName, viewId);
154 const existing = yield* getByName(name);
155 if (existing === undefined) return undefined;
156 const attrs = toAttrs(existing, bucketName);
157 const { labels } = parseDescription(existing.description);
158 return (yield* ownedBy(id, labels)) ? attrs : Unowned(attrs);
159 }),
160
161 list: () =>
162 Effect.gen(function* () {
163 const env = yield* GcpEnvironment.current;
164 const buckets = yield* logging.listFoldersLocationsBuckets
165 .pages({
166 parent: `projects/${env.project}/locations/-`,
167 pageSize: 1000,
168 })
169 .pipe(
170 Stream.flatMap((page) => Stream.fromIterable(page.buckets ?? [])),
171 Stream.runCollect,
172 Effect.map((chunk) => Array.from(chunk)),
173 );
174 const views: ReturnType<typeof toAttrs>[] = [];
175 for (const bucket of buckets) {
176 if (bucket.name === undefined) continue;
177 const listed = yield* logging.listFoldersLocationsBucketsViews
178 .pages({
179 parent: bucket.name,
180 pageSize: 1000,
181 })
182 .pipe(
183 Stream.flatMap((page) => Stream.fromIterable(page.views ?? [])),
184 Stream.filter((view) => hasOwnershipMarker(view.description)),
185 Stream.map((view) => toAttrs(view, bucket.name ?? "")),
186 Stream.runCollect,
187 Effect.map((chunk) => Array.from(chunk)),
188 Effect.catchTag("NotFound", () => Effect.succeed([] as ReturnType<typeof toAttrs>[])),
189 );
190 views.push(...listed);
191 }
192 return views;
193 }),
194
195 reconcile: Effect.fn(function* ({ id, news, output }) {
196 const viewId = yield* toPhysicalId(id, news.viewId, output?.viewId, "v");
197 const name = resourceName(news.bucketName, viewId);
198 const ownership = yield* createOwnership(id);
199 const desiredDescription = encodeDescription(ownership, news.description);
200
201 let current = yield* getByName(output?.name ?? name);
202
203 if (current === undefined) {
204 const created = yield* logging
205 .createFoldersLocationsBucketsViews({
206 parent: news.bucketName,
207 viewId,
208 body: {
209 filter: news.filter,
210 description: desiredDescription,
211 },
212 })
213 .pipe(Effect.catchTag("Conflict", () => getByName(name)));
214 current = created ?? undefined;
215 }
216
217 if (current === undefined) {
218 return yield* new FolderBucketsViewNotResolved({ resourceName: name });
219 }
220
221 const filterChanged = (current.filter ?? "") !== (news.filter ?? "");
222 const descriptionChanged = (current.description ?? "") !== desiredDescription;
223 const updateMask = [
224 filterChanged ? "filter" : undefined,
225 descriptionChanged ? "description" : undefined,
226 ].filter((field): field is string => field !== undefined);
227
228 if (updateMask.length > 0) {
229 current = yield* logging.patchFoldersLocationsBucketsViews({
230 name: current.name ?? name,
231 updateMask: updateMask.join(","),
232 body: {
233 filter: news.filter ?? "",
234 description: desiredDescription,
235 },
236 });
237 }
238
239 return toAttrs(current, news.bucketName);
240 }),
241
242 delete: Effect.fn(function* ({ output }) {
243 yield* logging
244 .deleteFoldersLocationsBucketsViews({ name: output.name })
245 .pipe(Effect.catchTag("NotFound", () => Effect.void));
246 }),
247 });