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

main
ts 269 lines 9.37 KB
Raw
1 import * as turso from "@distilled.cloud/turso/turso";
2 import { Unowned } from "alchemy/AdoptPolicy";
3 import { deepEqual, isResolved } from "alchemy/Diff";
4 import { createPhysicalName } from "alchemy/PhysicalName";
5 import * as Provider from "alchemy/Provider";
6 import { Resource } from "alchemy/Resource";
7 import * as Data from "effect/Data";
8 import * as Effect from "effect/Effect";
9 import { organization } from "./Credentials.ts";
10 import type { Providers } from "./Providers.ts";
11
12 export class GroupUnexpectedResponse extends Data.TaggedError("GroupUnexpectedResponse")<{
13 readonly message: string;
14 readonly cause?: unknown;
15 }> {}
16
17 /**
18 * A Turso location code, e.g. `"aws-us-east-1"`. List the locations
19 * available to your organization with `turso db locations`.
20 */
21 export type Location =
22 | "aws-ap-northeast-1"
23 | "aws-ap-south-1"
24 | "aws-ap-southeast-2"
25 | "aws-ca-central-1"
26 | "aws-eu-north-1"
27 | "aws-eu-west-1"
28 | "aws-sa-east-1"
29 | "aws-us-east-1"
30 | "aws-us-east-2"
31 | "aws-us-west-2"
32 | (string & {});
33
34 export interface GroupProps {
35 /**
36 * Group name, unique within the organization. Lowercase letters,
37 * numbers, and dashes. If omitted, a unique name is generated from the
38 * stack, stage, and logical ID. Changing it replaces the group.
39 */
40 name?: string;
41 /**
42 * Primary location of the group. Every database in the group lives here.
43 * Changing it replaces the group (and every database in it).
44 * @default "aws-us-east-1"
45 */
46 location?: Location;
47 /**
48 * Additional replica locations. Reconciled in place by adding and
49 * removing locations. AWS-hosted groups do not support replication, so
50 * this only applies to organizations with legacy Fly-hosted groups.
51 */
52 replicas?: Location[];
53 /**
54 * SQLite extensions enabled for the group's databases: `"all"`, or a list
55 * of extension names. Set at creation; changing it replaces the group.
56 */
57 extensions?: "all" | string[];
58 /**
59 * Prevent the group (and its databases) from being deleted. While
60 * enabled, destroying or replacing the group fails; set it to `false`
61 * and deploy before deleting.
62 * @default false
63 */
64 deleteProtection?: boolean;
65 }
66
67 export interface GroupAttributes {
68 /** Group name. */
69 name: string;
70 /** Group UUID. */
71 uuid: string;
72 /** The organization slug that owns the group. */
73 organization: string;
74 /** Primary location of the group. */
75 location: string;
76 /** Every location the group runs in (primary first). */
77 locations: string[];
78 /** The libSQL server version the group's databases run. */
79 version: string;
80 /** Whether delete protection is enabled. */
81 deleteProtection: boolean;
82 }
83
84 export type Group = Resource<"Turso.Group", GroupProps, GroupAttributes, never, Providers>;
85
86 /**
87 * A Turso group. Every Turso database belongs to one group, and the group
88 * decides where its databases run.
89 * @see https://docs.turso.tech/concepts#groups
90 *
91 * ### Creating a Group
92 * **Example:** Group in a single location
93 * ```typescript
94 * const group = yield* Turso.Group("Group", {
95 * location: "aws-us-east-1",
96 * });
97 * ```
98 *
99 * **Example:** Protected group with all extensions enabled
100 * ```typescript
101 * const group = yield* Turso.Group("Group", {
102 * name: "production",
103 * location: "aws-eu-west-1",
104 * extensions: "all",
105 * deleteProtection: true,
106 * });
107 * ```
108 *
109 * ### Adding databases
110 * **Example:** Create a database in the group
111 * ```typescript
112 * const db = yield* Turso.Database("Db", { group: group.name });
113 * ```
114 *
115 * @resource
116 * @product Group
117 */
118 export const Group = Resource<Group>("Turso.Group");
119
120 const DEFAULT_LOCATION = "aws-us-east-1";
121
122 export const GroupProvider = () =>
123 Provider.effect(
124 Group,
125 Effect.gen(function* () {
126 const groupName = (id: string, name: string | undefined) =>
127 name
128 ? Effect.succeed(name)
129 : createPhysicalName({ id, lowercase: true, maxLength: 32, delimiter: "-" });
130
131 const observe = (org: string, name: string) =>
132 turso.getGroup({ organizationSlug: org, groupName: name }).pipe(
133 Effect.map((res) => res.group),
134 Effect.catchTag("NotFound", () => Effect.undefined),
135 );
136
137 const toAttrs = (
138 org: string,
139 group: turso.Group,
140 deleteProtection: boolean,
141 ): GroupAttributes => ({
142 name: group.name!,
143 uuid: group.uuid ?? "",
144 organization: org,
145 location: group.primary ?? "",
146 locations: group.locations ?? [],
147 version: group.version ?? "",
148 deleteProtection,
149 });
150
151 return {
152 stables: ["name", "uuid", "organization", "location"],
153 diff: Effect.fn(function* ({ id, olds, news, output }) {
154 if (!isResolved(news)) return undefined;
155 const name = output?.name ?? (yield* groupName(id, olds?.name));
156 if (news.name !== undefined && news.name !== name) {
157 return { action: "replace" } as const;
158 }
159 if ((news.location ?? DEFAULT_LOCATION) !== (olds?.location ?? DEFAULT_LOCATION)) {
160 return { action: "replace", deleteFirst: news.name !== undefined } as const;
161 }
162 if (!deepEqual(news.extensions, olds?.extensions)) {
163 return { action: "replace", deleteFirst: news.name !== undefined } as const;
164 }
165 }),
166 read: Effect.fn(function* ({ id, olds, output, previous }) {
167 const org = output?.organization ?? (yield* organization);
168 const name = output?.name ?? (yield* groupName(id, olds?.name));
169 const group = yield* observe(org, name);
170 if (!group) return undefined;
171 const attrs = toAttrs(org, group, group.delete_protection ?? false);
172 // Turso has no tags: a group found under an explicit, user-chosen
173 // name without prior state may belong to someone else — unless it
174 // is the generation a delete-first replacement is about to free.
175 const ours =
176 output !== undefined ||
177 olds?.name === undefined ||
178 (previous?.organization === org && previous.name === name);
179 return ours ? attrs : Unowned(attrs);
180 }),
181 reconcile: Effect.fn(function* ({ id, news, output, session }) {
182 const org = output?.organization ?? (yield* organization);
183 const name = output?.name ?? (yield* groupName(id, news.name));
184 const location = news.location ?? DEFAULT_LOCATION;
185
186 // Observe
187 let group = yield* observe(org, name);
188
189 // Ensure
190 if (!group) {
191 yield* session.note(`Creating group ${name}...`);
192 group = yield* turso
193 .createGroup({
194 organizationSlug: org,
195 name,
196 location,
197 extensions: news.extensions,
198 })
199 .pipe(
200 Effect.map((res) => res.group),
201 Effect.catchTag("Conflict", () => observe(org, name)),
202 );
203 if (!group) {
204 return yield* new GroupUnexpectedResponse({
205 message: `Turso group ${name} vanished after create`,
206 });
207 }
208 }
209
210 // Sync replica locations against the observed set.
211 const primary = group.primary ?? location;
212 const desired = new Set([primary, ...(news.replicas ?? [])]);
213 const observed = new Set(group.locations ?? [primary]);
214 for (const loc of desired) {
215 if (!observed.has(loc)) {
216 yield* session.note(`Adding location ${loc}...`);
217 group =
218 (yield* turso.addLocationToGroup({
219 organizationSlug: org,
220 groupName: name,
221 location: loc,
222 })).group ?? group;
223 }
224 }
225 for (const loc of observed) {
226 if (!desired.has(loc)) {
227 yield* session.note(`Removing location ${loc}...`);
228 group =
229 (yield* turso.removeLocationFromGroup({
230 organizationSlug: org,
231 groupName: name,
232 location: loc,
233 })).group ?? group;
234 }
235 }
236
237 // Sync configuration.
238 const config = yield* turso.getGroupConfiguration({
239 organizationSlug: org,
240 groupName: name,
241 });
242 let deleteProtection = config.delete_protection ?? false;
243 const desiredProtection = news.deleteProtection ?? false;
244 if (deleteProtection !== desiredProtection) {
245 const updated = yield* turso.updateGroupConfiguration({
246 organizationSlug: org,
247 groupName: name,
248 delete_protection: desiredProtection,
249 });
250 deleteProtection = updated.delete_protection ?? desiredProtection;
251 }
252
253 return toAttrs(org, group, deleteProtection);
254 }),
255 delete: Effect.fn(function* ({ output }) {
256 yield* turso
257 .deleteGroup({ organizationSlug: output.organization, groupName: output.name })
258 .pipe(Effect.catchTag("NotFound", () => Effect.void));
259 }),
260 list: Effect.fn(function* () {
261 const org = yield* organization;
262 const { groups } = yield* turso.listGroups({ organizationSlug: org });
263 return (groups ?? [])
264 .filter((group) => group.name !== undefined)
265 .map((group) => toAttrs(org, group, group.delete_protection ?? false));
266 }),
267 };
268 }),
269 );