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

main
ts 295 lines 9.74 KB
Raw
1 import * as firestore from "@distilled.cloud/gcp/firestore_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 type { Providers } from "../Providers.ts";
11 import {
12 databaseIdOf,
13 databaseNameOf,
14 lastSegment,
15 parseDatabaseName,
16 retryConcurrentChanges,
17 } from "./internal.ts";
18
19 const DEFAULT_RETENTION = "604800s";
20 export type WeeklyRecurrenceDay =
21 | firestore.GoogleFirestoreAdminV1WeeklyRecurrenceDayEnum
22 | (string & {});
23
24 export type DatabasesBackupScheduleProps = {
25 /**
26 * Parent database. Full name `projects/{project}/databases/{database}`
27 * or the database id. Immutable — changing it replaces the schedule.
28 */
29 database: string;
30 /**
31 * How long each backup is retained (e.g. `"604800s"` is 7 days). The
32 * maximum supported retention is 14 weeks.
33 * @default "604800s"
34 */
35 retention?: string;
36 /**
37 * Daily UTC recurrence. Mutually exclusive with `weeklyRecurrence`.
38 * Default when neither recurrence is set. Changing daily vs weekly
39 * replaces the schedule.
40 */
41 dailyRecurrence?: boolean;
42 /**
43 * Weekly UTC recurrence. Mutually exclusive with `dailyRecurrence`.
44 * Changing the day or switching from daily replaces the schedule.
45 */
46 weeklyRecurrence?: {
47 /** Day of week (`MONDAY` … `SUNDAY`). */
48 day: WeeklyRecurrenceDay;
49 };
50 };
51
52 export type DatabasesBackupSchedule = Resource<
53 "GCP.Firestore.DatabasesBackupSchedule",
54 DatabasesBackupScheduleProps,
55 {
56 /** Full resource name `.../databases/{database}/backupSchedules/{schedule}`. */
57 name: string;
58 /** Server-assigned backup schedule id. */
59 backupScheduleId: string;
60 /** Parent database resource name. */
61 database: string;
62 /** Parent database id. */
63 databaseId: string;
64 /** Project id. */
65 project: string;
66 /** Retention duration. */
67 retention: string | undefined;
68 /** Whether this schedule runs daily. */
69 dailyRecurrence: boolean;
70 /** Weekly recurrence day, if any. */
71 weeklyRecurrenceDay: string | undefined;
72 /** RFC3339 creation timestamp. */
73 createTime: string | undefined;
74 /** RFC3339 last-update timestamp. */
75 updateTime: string | undefined;
76 },
77 never,
78 Providers
79 >;
80
81 /**
82 * A scheduled backup for a Cloud Firestore database.
83 *
84 * At most one daily and one weekly schedule can exist per database.
85 * The schedule id is assigned by the API. Retention updates in place;
86 * switching daily vs weekly or moving to another database replaces the
87 * schedule. Backup schedules have no labels field: `read` reports a
88 * schedule it finds without prior state as unowned (adopt it with
89 * `--adopt`).
90 *
91 * ### Creating a Backup Schedule
92 * **Example:** Daily backups retained for 7 days
93 * ```typescript
94 * const database = yield* GCP.Firestore.Database("App", {
95 * location: "us-central1",
96 * });
97 * const schedule = yield* GCP.Firestore.DatabasesBackupSchedule("Nightly", {
98 * database: database.name,
99 * retention: "604800s",
100 * dailyRecurrence: true,
101 * });
102 * ```
103 *
104 * **Example:** Weekly backups
105 * ```typescript
106 * const schedule = yield* GCP.Firestore.DatabasesBackupSchedule("Weekly", {
107 * database: database.name,
108 * retention: "1209600s",
109 * weeklyRecurrence: { day: "SUNDAY" },
110 * });
111 * ```
112 *
113 * @resource
114 * @category Firestore
115 */
116 export const DatabasesBackupSchedule = Resource<DatabasesBackupSchedule>(
117 "GCP.Firestore.DatabasesBackupSchedule",
118 );
119
120 export class BackupScheduleNotResolved extends Data.TaggedError(
121 "GCP.Firestore.BackupScheduleNotResolved",
122 )<{
123 resourceName: string;
124 }> {}
125
126 export class BackupScheduleStillExists extends Data.TaggedError(
127 "GCP.Firestore.BackupScheduleStillExists",
128 )<{
129 resourceName: string;
130 }> {}
131
132 const desiredWeeklyDay = (news: DatabasesBackupScheduleProps): string | undefined =>
133 news.weeklyRecurrence?.day !== undefined ? news.weeklyRecurrence.day.toUpperCase() : undefined;
134
135 const desiredDaily = (news: DatabasesBackupScheduleProps) =>
136 news.weeklyRecurrence === undefined && news.dailyRecurrence !== false;
137
138 const toAttrs = (
139 schedule: firestore.GoogleFirestoreAdminV1BackupSchedule,
140 project: string,
141 ): DatabasesBackupSchedule["Attributes"] => {
142 const name = schedule.name ?? "";
143 const parsed = parseDatabaseName(name);
144 return {
145 name,
146 backupScheduleId: parsed.backupScheduleId || lastSegment(name),
147 database: databaseNameOf(parsed.project || project, parsed.databaseId),
148 databaseId: parsed.databaseId,
149 project: parsed.project || project,
150 retention: schedule.retention,
151 dailyRecurrence: schedule.dailyRecurrence !== undefined,
152 weeklyRecurrenceDay: schedule.weeklyRecurrence?.day,
153 createTime: schedule.createTime,
154 updateTime: schedule.updateTime,
155 };
156 };
157
158 const getByName = (name: string) =>
159 firestore
160 .getProjectsDatabasesBackupSchedules({ name })
161 .pipe(Effect.catchTag("NotFound", () => Effect.undefined));
162
163 const listOnDatabase = (parent: string) =>
164 firestore.listProjectsDatabasesBackupSchedules({ parent }).pipe(
165 Effect.map((page) => page.backupSchedules ?? []),
166 Effect.catchTag("NotFound", () =>
167 Effect.succeed([] as firestore.GoogleFirestoreAdminV1BackupSchedule[]),
168 ),
169 );
170
171 const matchesDesired = (
172 schedule: firestore.GoogleFirestoreAdminV1BackupSchedule,
173 news: DatabasesBackupScheduleProps,
174 ) => {
175 const weeklyDay = desiredWeeklyDay(news);
176 if (weeklyDay !== undefined) {
177 return schedule.weeklyRecurrence?.day?.toUpperCase() === weeklyDay;
178 }
179 return schedule.dailyRecurrence !== undefined;
180 };
181
182 const waitUntilGone = (name: string) =>
183 getByName(name).pipe(
184 Effect.filterOrFail(
185 (schedule) => schedule === undefined,
186 () => new BackupScheduleStillExists({ resourceName: name }),
187 ),
188 Effect.retry({
189 while: (error) => error._tag === "GCP.Firestore.BackupScheduleStillExists",
190 times: 8,
191 schedule: Schedule.spaced("2 seconds"),
192 }),
193 Effect.asVoid,
194 );
195
196 export const DatabasesBackupScheduleProvider = () =>
197 Provider.succeed(DatabasesBackupSchedule, {
198 stables: ["name", "backupScheduleId", "database", "databaseId", "project", "createTime"],
199
200 diff: Effect.fn(function* ({ news, olds, output }) {
201 if (!isResolved(news)) return undefined;
202 const previousDatabase = databaseIdOf(
203 olds?.database ?? output?.database ?? output?.databaseId ?? "",
204 );
205 const nextDatabase = databaseIdOf(news.database);
206 const previousWeekly = (
207 olds?.weeklyRecurrence?.day ??
208 output?.weeklyRecurrenceDay ??
209 ""
210 ).toUpperCase();
211 const nextWeekly = (news.weeklyRecurrence?.day ?? "").toUpperCase();
212 const previousDaily =
213 olds?.weeklyRecurrence === undefined &&
214 (olds?.dailyRecurrence !== false || output?.dailyRecurrence === true);
215 const nextDaily = desiredDaily(news);
216 if (
217 (previousDatabase.length > 0 && previousDatabase !== nextDatabase) ||
218 previousWeekly !== nextWeekly ||
219 previousDaily !== nextDaily
220 ) {
221 return { action: "replace" as const };
222 }
223 return undefined;
224 }),
225
226 read: Effect.fn(function* ({ output }) {
227 const env = yield* GcpEnvironment.current;
228 const name = output?.name;
229 if (name === undefined || name.length === 0) return undefined;
230 const existing = yield* getByName(name);
231 if (existing === undefined) return undefined;
232 const attrs = toAttrs(existing, env.project);
233 // No labels field: without prior state it may not be ours.
234 return output !== undefined ? attrs : Unowned(attrs);
235 }),
236
237 reconcile: Effect.fn(function* ({ news, output }) {
238 const env = yield* GcpEnvironment.current;
239 const parent = databaseNameOf(env.project, news.database);
240 const weeklyDay = desiredWeeklyDay(news);
241 const daily = desiredDaily(news);
242 const retention = news.retention ?? DEFAULT_RETENTION;
243 let current = output?.name !== undefined ? yield* getByName(output.name) : undefined;
244
245 if (current === undefined) {
246 const existing = yield* listOnDatabase(parent);
247 current = existing.find((schedule) => matchesDesired(schedule, news));
248 }
249
250 if (current === undefined) {
251 const created = yield* firestore
252 .createProjectsDatabasesBackupSchedules({
253 parent,
254 body: {
255 retention,
256 dailyRecurrence: daily && weeklyDay === undefined ? {} : undefined,
257 weeklyRecurrence: weeklyDay !== undefined ? { day: weeklyDay } : undefined,
258 },
259 })
260 .pipe(Effect.catchTag("Conflict", () => Effect.undefined));
261 if (created?.name !== undefined) {
262 current = created;
263 } else {
264 const listed = yield* listOnDatabase(parent);
265 current = listed.find((schedule) => matchesDesired(schedule, news));
266 }
267 }
268
269 if (current === undefined || current.name === undefined) {
270 return yield* new BackupScheduleNotResolved({
271 resourceName: `${parent}/backupSchedules`,
272 });
273 }
274
275 const name = current.name;
276 if ((current.retention ?? "") !== retention) {
277 current = yield* retryConcurrentChanges(
278 firestore.patchProjectsDatabasesBackupSchedules({
279 name,
280 updateMask: "retention",
281 body: { retention },
282 }),
283 );
284 }
285
286 return toAttrs(current, env.project);
287 }),
288
289 delete: Effect.fn(function* ({ output }) {
290 yield* firestore
291 .deleteProjectsDatabasesBackupSchedules({ name: output.name })
292 .pipe(Effect.catchTag("NotFound", () => Effect.void));
293 yield* waitUntilGone(output.name);
294 }),
295 });