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

main
ts 243 lines 8.24 KB
Raw
1 import * as firebaserules from "@distilled.cloud/gcp/firebaserules_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 Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Schedule from "effect/Schedule";
9 import { GcpEnvironment } from "../Environment.ts";
10 import { createInternalLabels } from "../Labels.ts";
11 import type { Providers } from "../Providers.ts";
12 import {
13 findOwnedRuleset,
14 getRuleset,
15 listFullRulesets,
16 listOwnedRulesets,
17 ownedByAlchemy,
18 projectParent,
19 rulesetIdOf,
20 sameText,
21 sourceFingerprint,
22 stampSource,
23 toUserFiles,
24 type RulesetFile,
25 type RulesetSource,
26 } from "./internal.ts";
27
28 export type { RulesetFile, RulesetSource };
29
30 export type RulesetProps = {
31 /**
32 * Source files for this ruleset. Rulesets are immutable — changing
33 * `source` replaces the ruleset. Firebase Rules has no labels field,
34 * so Alchemy stamps ownership into a `// [alchemy …]` comment on the
35 * first file and strips it from attributes.
36 */
37 source: RulesetSource;
38 /**
39 * Intended resource this ruleset should be released to, e.g.
40 * `firestore.googleapis.com/projects/{project}/databases/(default)`.
41 * May be left blank for the default release. Immutable — changing it
42 * replaces the ruleset.
43 */
44 attachmentPoint?: string;
45 };
46
47 export type Ruleset = Resource<
48 "GCP.FirebaseRules.Ruleset",
49 RulesetProps,
50 {
51 /** Full resource name `projects/{project}/rulesets/{rulesetId}`. */
52 name: string;
53 /** Server-assigned ruleset id (last path segment). */
54 rulesetId: string;
55 /** Project id. */
56 project: string;
57 /** User source with the Alchemy ownership comment stripped. */
58 source: RulesetSource;
59 /** Services declared by this ruleset (`cloud.firestore`, …). */
60 services: string[];
61 /** Intended release attachment point, if set. */
62 attachmentPoint: string | undefined;
63 /** RFC3339 creation timestamp. */
64 createTime: string | undefined;
65 },
66 never,
67 Providers
68 >;
69
70 /**
71 * An immutable Firebase Security Rules ruleset.
72 *
73 * Rulesets have no labels field, so Alchemy stamps ownership into a
74 * `// [alchemy …]` comment on the first source file for `list` / nuke.
75 * Source and `attachmentPoint` are identity — changing either replaces
76 * the ruleset. The ruleset id is assigned by the service.
77 *
78 * ### Creating a Ruleset
79 * **Example:** Firestore rules
80 * ```typescript
81 * const ruleset = yield* GCP.FirebaseRules.Ruleset("Firestore", {
82 * source: {
83 * files: [{
84 * name: "firestore.rules",
85 * content: "rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if false; } } }",
86 * }],
87 * },
88 * });
89 * ```
90 *
91 * **Example:** Storage rules with an attachment point
92 * ```typescript
93 * const ruleset = yield* GCP.FirebaseRules.Ruleset("Storage", {
94 * attachmentPoint:
95 * "firebase.storage.googleapis.com/projects/my-project/buckets/my-bucket",
96 * source: {
97 * files: [{
98 * name: "storage.rules",
99 * content: "rules_version = '2'; service firebase.storage { match /b/{bucket}/o { match /{allPaths=**} { allow read, write: if false; } } }",
100 * }],
101 * },
102 * });
103 * ```
104 *
105 * ### Replacing a Ruleset
106 * **Example:** New source (new ruleset id)
107 * ```typescript
108 * const ruleset = yield* GCP.FirebaseRules.Ruleset("Firestore", {
109 * source: {
110 * files: [{
111 * name: "firestore.rules",
112 * content: "rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if request.auth != null; } } }",
113 * }],
114 * },
115 * });
116 * ```
117 *
118 * @resource
119 * @category FirebaseRules
120 */
121 export const Ruleset = Resource<Ruleset>("GCP.FirebaseRules.Ruleset");
122
123 export class RulesetNotResolved extends Data.TaggedError("GCP.FirebaseRules.RulesetNotResolved")<{
124 resourceName: string;
125 }> {}
126
127 const toAttrs = (ruleset: firebaserules.Ruleset, project: string) => {
128 const name = ruleset.name ?? "";
129 return {
130 name,
131 rulesetId: rulesetIdOf(name),
132 project,
133 source: { files: toUserFiles(ruleset.source?.files) },
134 services: [...(ruleset.metadata?.services ?? [])],
135 attachmentPoint: ruleset.attachmentPoint,
136 createTime: ruleset.createTime,
137 };
138 };
139
140 export const RulesetProvider = () =>
141 Provider.succeed(Ruleset, {
142 stables: ["name", "rulesetId", "project", "createTime"],
143
144 diff: Effect.fn(function* ({ news, output }) {
145 if (!isResolved(news)) return undefined;
146 if (output === undefined) return undefined;
147 const sourceChanged =
148 sourceFingerprint(news.source.files) !== sourceFingerprint(output.source.files);
149 const attachmentChanged =
150 news.attachmentPoint !== undefined &&
151 (news.attachmentPoint ?? "") !== (output.attachmentPoint ?? "");
152 if (!sourceChanged && !attachmentChanged) return undefined;
153 return { action: "replace" as const, deleteFirst: false };
154 }),
155
156 read: Effect.fn(function* ({ id, output, previous }) {
157 const env = yield* GcpEnvironment.current;
158 let existing = yield* getRuleset(output?.name ?? "");
159 if (existing === undefined) {
160 existing = yield* findOwnedRuleset(yield* listFullRulesets(env.project), id, output?.name);
161 }
162 if (existing === undefined) return undefined;
163 // A replacement creates a new ruleset under the same logical id: the one
164 // it is replacing is not the replacement.
165 if (output === undefined && existing.name === previous?.name) return undefined;
166 const attrs = toAttrs(existing, env.project);
167 return (yield* ownedByAlchemy(id, existing.source)) ? attrs : Unowned(attrs);
168 }),
169
170 list: () =>
171 Effect.gen(function* () {
172 const env = yield* GcpEnvironment.current;
173 const rulesets = yield* listOwnedRulesets(env.project);
174 return rulesets.map((ruleset) => toAttrs(ruleset, env.project));
175 }),
176
177 reconcile: Effect.fn(function* ({ id, news, output }) {
178 const env = yield* GcpEnvironment.current;
179 const parent = projectParent(env.project);
180 const ownership = yield* createInternalLabels(id);
181 const desiredSource = stampSource(news.source, ownership);
182
183 let current = yield* getRuleset(output?.name ?? "");
184 if (current === undefined) {
185 const found = yield* findOwnedRuleset(
186 yield* listFullRulesets(env.project),
187 id,
188 output?.name,
189 );
190 // Replacement uses the same logical id as the old generation. Only
191 // reuse a scanned ruleset when source matches (crash-after-create);
192 // a different source must become a new ruleset.
193 if (
194 found !== undefined &&
195 (output?.name === found.name ||
196 (sourceFingerprint(found.source?.files) === sourceFingerprint(news.source.files) &&
197 sameText(found.attachmentPoint, news.attachmentPoint)))
198 ) {
199 current = found;
200 }
201 }
202
203 if (current === undefined) {
204 const created = yield* firebaserules
205 .createProjectsRulesets({
206 name: parent,
207 body: {
208 source: desiredSource,
209 attachmentPoint: news.attachmentPoint,
210 },
211 })
212 .pipe(
213 Effect.catchTag("Conflict", () =>
214 listFullRulesets(env.project).pipe(
215 Effect.flatMap((rulesets) => findOwnedRuleset(rulesets, id, undefined)),
216 ),
217 ),
218 );
219 current = created ?? undefined;
220 }
221
222 if (current === undefined) {
223 return yield* new RulesetNotResolved({
224 resourceName: output?.name ?? `${parent}/rulesets`,
225 });
226 }
227
228 return toAttrs(current, env.project);
229 }),
230
231 delete: Effect.fn(function* ({ output }) {
232 if (!output.name) return;
233 yield* firebaserules.deleteProjectsRulesets({ name: output.name }).pipe(
234 // A just-deleted release's reference to this ruleset lingers briefly.
235 Effect.retry({
236 while: (error) => error._tag === "Conflict" || error._tag === "RulesetInUse",
237 times: 8,
238 schedule: Schedule.spaced("2 seconds"),
239 }),
240 Effect.catchTag("NotFound", () => Effect.void),
241 );
242 }),
243 });