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

main
ts 207 lines 6.49 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 { GcpEnvironment } from "../Environment.ts";
9 import type { Providers } from "../Providers.ts";
10 import {
11 expandRulesetName,
12 getRelease,
13 isGeneratedReleaseId,
14 listReleases,
15 projectParent,
16 releaseIdOf,
17 releaseResourceName,
18 sameText,
19 toReleaseId,
20 } from "./internal.ts";
21
22 export type ReleaseProps = {
23 /**
24 * Release id (the `{release_id}` segment of
25 * `projects/{project}/releases/{release_id}`). May contain `/` (e.g.
26 * `cloud.firestore` or `prod/v23`). If omitted, a unique `alc-`
27 * prefixed name is generated from the stack, stage, and logical id.
28 * Firebase Rules releases have no labels field, so generated ids carry
29 * the `alc-` prefix for `list` / nuke. Immutable — changing it
30 * replaces the release.
31 */
32 releaseId?: string;
33 /**
34 * Ruleset this release points at
35 * (`projects/{project}/rulesets/{rulesetId}` or a bare ruleset id).
36 * The ruleset must exist. Updating this patches the release in place.
37 */
38 rulesetName: string;
39 };
40
41 export type Release = Resource<
42 "GCP.FirebaseRules.Release",
43 ReleaseProps,
44 {
45 /** Full resource name `projects/{project}/releases/{releaseId}`. */
46 name: string;
47 /** Release id (path after `/releases/`). */
48 releaseId: string;
49 /** Project id. */
50 project: string;
51 /** Full ruleset resource name this release refers to. */
52 rulesetName: string;
53 /** RFC3339 creation timestamp. */
54 createTime: string | undefined;
55 /** RFC3339 last-update timestamp. */
56 updateTime: string | undefined;
57 },
58 never,
59 Providers
60 >;
61
62 /**
63 * A named Firebase Security Rules release pointing at a `Ruleset`.
64 *
65 * Releases have no labels field. Generated release ids are prefixed
66 * `alc-` so `list` / nuke can find them. `releaseId` is identity —
67 * changing it replaces the release. `rulesetName` updates in place.
68 *
69 * ### Creating a Release
70 * **Example:** Generated id
71 * ```typescript
72 * const ruleset = yield* GCP.FirebaseRules.Ruleset("Firestore", {
73 * source: {
74 * files: [
75 * {
76 * name: "firestore.rules",
77 * content: "rules_version = '2'; service cloud.firestore { match /databases/{database}/documents { match /{document=**} { allow read, write: if false; } } }",
78 * },
79 * ],
80 * },
81 * });
82 * const release = yield* GCP.FirebaseRules.Release("Live", {
83 * rulesetName: ruleset.name,
84 * });
85 * ```
86 *
87 * **Example:** Named release
88 * ```typescript
89 * const release = yield* GCP.FirebaseRules.Release("Live", {
90 * releaseId: "prod",
91 * rulesetName: ruleset.name,
92 * });
93 * ```
94 *
95 * ### Updating a Release
96 * **Example:** Point at a new ruleset
97 * ```typescript
98 * const release = yield* GCP.FirebaseRules.Release("Live", {
99 * rulesetName: nextRuleset.name,
100 * });
101 * ```
102 *
103 * @resource
104 * @category FirebaseRules
105 */
106 export const Release = Resource<Release>("GCP.FirebaseRules.Release");
107
108 export class ReleaseNotResolved extends Data.TaggedError("GCP.FirebaseRules.ReleaseNotResolved")<{
109 resourceName: string;
110 }> {}
111
112 const toAttrs = (release: firebaserules.Release, project: string) => {
113 const name = release.name ?? "";
114 return {
115 name,
116 releaseId: releaseIdOf(name),
117 project,
118 rulesetName: release.rulesetName ?? "",
119 createTime: release.createTime,
120 updateTime: release.updateTime,
121 };
122 };
123
124 export const ReleaseProvider = () =>
125 Provider.succeed(Release, {
126 stables: ["name", "releaseId", "project", "createTime"],
127
128 diff: Effect.fn(function* ({ news, olds, output }) {
129 if (!isResolved(news)) return undefined;
130 const previous = olds?.releaseId ?? output?.releaseId;
131 if (news.releaseId !== undefined && previous !== undefined && news.releaseId !== previous) {
132 return { action: "replace" as const, deleteFirst: false };
133 }
134 return undefined;
135 }),
136
137 read: Effect.fn(function* ({ id, olds, output }) {
138 const env = yield* GcpEnvironment.current;
139 const releaseId = yield* toReleaseId(id, olds?.releaseId, output?.releaseId);
140 const name = output?.name ?? releaseResourceName(env.project, releaseId);
141 const existing = yield* getRelease(name);
142 if (existing === undefined) return undefined;
143 const attrs = toAttrs(existing, env.project);
144 if (isGeneratedReleaseId(attrs.releaseId) || output?.name === attrs.name) {
145 return attrs;
146 }
147 return Unowned(attrs);
148 }),
149
150 list: () =>
151 Effect.gen(function* () {
152 const env = yield* GcpEnvironment.current;
153 const releases = yield* listReleases(env.project);
154 return releases
155 .filter((release) => isGeneratedReleaseId(releaseIdOf(release.name ?? "")))
156 .map((release) => toAttrs(release, env.project));
157 }),
158
159 reconcile: Effect.fn(function* ({ id, news, output }) {
160 const env = yield* GcpEnvironment.current;
161 const parent = projectParent(env.project);
162 const releaseId = yield* toReleaseId(id, news.releaseId, output?.releaseId);
163 const name = releaseResourceName(env.project, releaseId);
164 const desiredRuleset = expandRulesetName(env.project, news.rulesetName);
165
166 let current = yield* getRelease(output?.name ?? name);
167
168 if (current === undefined) {
169 const created = yield* firebaserules
170 .createProjectsReleases({
171 name: parent,
172 body: {
173 name,
174 rulesetName: desiredRuleset,
175 },
176 })
177 .pipe(Effect.catchTag("Conflict", () => getRelease(name)));
178 current = created ?? undefined;
179 }
180
181 if (current === undefined) {
182 return yield* new ReleaseNotResolved({ resourceName: name });
183 }
184
185 if (!sameText(current.rulesetName, desiredRuleset)) {
186 current = yield* firebaserules.patchProjectsReleases({
187 name: current.name ?? name,
188 body: {
189 release: {
190 name: current.name ?? name,
191 rulesetName: desiredRuleset,
192 },
193 updateMask: "rulesetName",
194 },
195 });
196 }
197
198 return toAttrs(current, env.project);
199 }),
200
201 delete: Effect.fn(function* ({ output }) {
202 if (!output.name) return;
203 yield* firebaserules
204 .deleteProjectsReleases({ name: output.name })
205 .pipe(Effect.catchTag("NotFound", () => Effect.void));
206 }),
207 });