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

main
ts 256 lines 8.37 KB
Raw
1 import * as scc from "@distilled.cloud/gcp/securitycenter_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 Stream from "effect/Stream";
8 import { GcpEnvironment } from "../Environment.ts";
9 import { createInternalLabels } from "../Labels.ts";
10 import type { Providers } from "../Providers.ts";
11 import {
12 encodeDescription,
13 folderIdOf,
14 folderParent,
15 hasOwnershipMarker,
16 lastSegment,
17 ownedByAlchemy,
18 parseName,
19 parseOwnership,
20 replaceOn,
21 resolveFolder,
22 sameText,
23 SecuritycenterNotResolved,
24 toPhysicalId,
25 tryResolveFolder,
26 updateMaskOf,
27 } from "./internal.ts";
28
29 export type FolderBigQueryExportProps = {
30 /**
31 * Export id (the `{export}` segment of
32 * `folders/{folder}/bigQueryExports/{export}`). If omitted, a unique id
33 * is generated from the stack, stage, and logical id. Letters, digits,
34 * and hyphens; max 63 characters. Immutable — changing it replaces the
35 * export.
36 */
37 exportId?: string;
38 /**
39 * Parent folder (`folders/{folder}` or the numeric id). Defaults to
40 * the project's Resource Manager folder ancestor.
41 * Immutable — changing it replaces the export.
42 */
43 folder?: string;
44 /**
45 * Destination dataset
46 * (`projects/{project}/datasets/{dataset}`).
47 */
48 dataset: string;
49 /**
50 * Finding filter. Empty or omitted exports every finding under the
51 * parent.
52 */
53 filter?: string;
54 /**
55 * Human-readable description. BigQuery exports have no labels field, so
56 * Alchemy ownership is stored in a `[alchemy …]` prefix and stripped
57 * from attributes.
58 */
59 description?: string;
60 };
61
62 export type FolderBigQueryExport = Resource<
63 "GCP.SecurityCenter.FolderBigQueryExport",
64 FolderBigQueryExportProps,
65 {
66 /** Full resource name `folders/{folder}/bigQueryExports/{export}`. */
67 name: string;
68 /** Export id (last path segment). */
69 exportId: string;
70 /** Folder resource name. */
71 folder: string;
72 /** Folder id. */
73 folderId: string;
74 /** Project id of the deploying stack. */
75 project: string;
76 /** Destination dataset. */
77 dataset: string;
78 /** Finding filter. */
79 filter: string | undefined;
80 /** User description with the Alchemy ownership prefix stripped. */
81 description: string | undefined;
82 /** Principal Security Command Center uses to write to the dataset. */
83 principal: string | undefined;
84 /** Most recent editor of the export. */
85 mostRecentEditor: string | undefined;
86 /** RFC3339 creation timestamp. */
87 createTime: string | undefined;
88 /** RFC3339 last-update timestamp. */
89 updateTime: string | undefined;
90 },
91 never,
92 Providers
93 >;
94
95 /**
96 * A folder-scoped Security Command Center BigQuery export.
97 *
98 * Exports have no labels field — Alchemy stamps ownership into the
99 * description so `list` / nuke can find them. Export id and folder are
100 * identity. Dataset, filter, and description update in place.
101 *
102 * ### Creating a BigQuery Export
103 * **Example:** Export active findings to a dataset
104 * ```typescript
105 * const dataset = yield* GCP.BigQuery.Dataset("SccFindings", {
106 * location: "US",
107 * forceDestroy: true,
108 * });
109 * const exp = yield* GCP.SecurityCenter.FolderBigQueryExport("Findings", {
110 * dataset: `projects/${dataset.project}/datasets/${dataset.datasetId}`,
111 * filter: 'state="ACTIVE"',
112 * description: "active findings",
113 * });
114 * ```
115 *
116 * **Example:** Named export on an explicit folder
117 * ```typescript
118 * const exp = yield* GCP.SecurityCenter.FolderBigQueryExport("Findings", {
119 * folder: "folders/123456789",
120 * exportId: "active-findings",
121 * dataset: "projects/my-project/datasets/scc",
122 * });
123 * ```
124 *
125 * @resource
126 * @category SecurityCenter
127 */
128 export const FolderBigQueryExport = Resource<FolderBigQueryExport>(
129 "GCP.SecurityCenter.FolderBigQueryExport",
130 );
131
132 const resourceName = (folder: string, exportId: string) => `${folder}/bigQueryExports/${exportId}`;
133
134 const toAttrs = (
135 exp: scc.GoogleCloudSecuritycenterV1BigQueryExport,
136 folder: string,
137 project: string,
138 ) => {
139 const name = exp.name ?? "";
140 const parsed = parseName(name, "bigQueryExports");
141 const ownership = parseOwnership(exp.description);
142 return {
143 name,
144 exportId: parsed.id || lastSegment(name),
145 folder,
146 folderId: folderIdOf(folder),
147 project,
148 dataset: exp.dataset ?? "",
149 filter: exp.filter,
150 description: ownership.text,
151 principal: exp.principal,
152 mostRecentEditor: exp.mostRecentEditor,
153 createTime: exp.createTime,
154 updateTime: exp.updateTime,
155 };
156 };
157
158 const getByName = (name: string) =>
159 name.length === 0
160 ? Effect.undefined
161 : scc
162 .getFoldersBigQueryExports({ name })
163 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
164
165 export const FolderBigQueryExportProvider = () =>
166 Provider.succeed(FolderBigQueryExport, {
167 stables: ["name", "exportId", "folder", "folderId", "project", "createTime"],
168
169 diff: Effect.fn(function* ({ news, olds, output }) {
170 if (!isResolved(news)) return undefined;
171 return (
172 replaceOn(olds?.exportId ?? output?.exportId, news.exportId) ??
173 replaceOn(
174 olds?.folder ?? output?.folder,
175 news.folder !== undefined ? folderParent(news.folder) : undefined,
176 )
177 );
178 }),
179
180 read: Effect.fn(function* ({ id, olds, output }) {
181 const env = yield* GcpEnvironment.current;
182 const folder = yield* resolveFolder(olds?.folder ?? output?.folder, output?.folder);
183 const exportId = yield* toPhysicalId(id, olds?.exportId, output?.exportId);
184 const name = output?.name ?? resourceName(folder, exportId);
185 const existing = yield* getByName(name);
186 if (existing === undefined) return undefined;
187 const attrs = toAttrs(existing, folder, env.project);
188 return (yield* ownedByAlchemy(id, existing.description)) ? attrs : Unowned(attrs);
189 }),
190
191 list: () =>
192 Effect.gen(function* () {
193 const env = yield* GcpEnvironment.current;
194 const folder = yield* tryResolveFolder();
195 if (folder === undefined) return [];
196 return yield* scc.listFoldersBigQueryExports.pages({ parent: folder, pageSize: 100 }).pipe(
197 Stream.flatMap((page) => Stream.fromIterable(page.bigQueryExports ?? [])),
198 Stream.filter((exp) => hasOwnershipMarker(exp.description)),
199 Stream.map((exp) => toAttrs(exp, folder, env.project)),
200 Stream.runCollect,
201 Effect.map((chunk) => Array.from(chunk)),
202 Effect.catchTag("NotFound", () => Effect.succeed([])),
203 );
204 }),
205
206 reconcile: Effect.fn(function* ({ id, news, output }) {
207 const env = yield* GcpEnvironment.current;
208 const folder = yield* resolveFolder(news.folder, output?.folder);
209 const exportId = yield* toPhysicalId(id, news.exportId, output?.exportId);
210 const name = resourceName(folder, exportId);
211 const ownership = yield* createInternalLabels(id);
212 const description = encodeDescription(ownership, news.description);
213 const dataset = news.dataset;
214 const filter = news.filter;
215
216 let current = yield* getByName(output?.name ?? name);
217
218 if (current === undefined) {
219 const created = yield* scc
220 .createFoldersBigQueryExports({
221 parent: folder,
222 bigQueryExportId: exportId,
223 body: { dataset, filter, description },
224 })
225 .pipe(Effect.catchTag("Conflict", () => getByName(name)));
226 current = created ?? undefined;
227 }
228
229 if (current === undefined) {
230 return yield* new SecuritycenterNotResolved({ resourceName: name });
231 }
232
233 const currentName = current.name ?? name;
234 const updateMask = updateMaskOf(
235 !sameText(current.dataset, dataset) ? "dataset" : undefined,
236 !sameText(current.filter, filter) ? "filter" : undefined,
237 !sameText(current.description, description) ? "description" : undefined,
238 );
239
240 if (updateMask.length > 0) {
241 current = yield* scc.patchFoldersBigQueryExports({
242 name: currentName,
243 updateMask,
244 body: { dataset, filter, description },
245 });
246 }
247
248 return toAttrs(current, folder, env.project);
249 }),
250
251 delete: Effect.fn(function* ({ output }) {
252 yield* scc
253 .deleteFoldersBigQueryExports({ name: output.name })
254 .pipe(Effect.catchTag("NotFound", () => Effect.void));
255 }),
256 });