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

main
ts 87 lines 3.23 KB
Raw
1 import { expect } from "@alchemy.run/test";
2 import * as Test from "@alchemy.run/test/Alchemy";
3 import { defaultStage } from "@alchemy.run/test/Core";
4 import * as Turso from "@alchemy.run/turso";
5 import { organization } from "@alchemy.run/turso/Credentials";
6 import * as Hrana from "@alchemy.run/turso/Hrana";
7 import * as turso from "@distilled.cloud/turso/turso";
8 import * as Alchemy from "alchemy";
9 import * as Effect from "effect/Effect";
10
11 // The Preview databases guide, with per-developer stage names: `<stage>-staging`
12 // owns the group and database, `<stage>-pr` forks staging's database.
13 const { test, deploy, destroy } = Test.make({
14 providers: Turso.providers(),
15 state: Alchemy.localState(),
16 });
17
18 const staging = `${defaultStage()}-staging`;
19 const pr = `${defaultStage()}-pr`;
20
21 const Stack = Alchemy.Stack(
22 "TursoPreviewDatabases",
23 { providers: Turso.providers(), state: Alchemy.localState() },
24 Effect.gen(function* () {
25 const { stage } = yield* Alchemy.Stack;
26 const preview = stage === pr;
27
28 const group = preview
29 ? yield* Turso.Group.ref("Group", { stage: staging })
30 : yield* Turso.Group("Group", { location: "aws-us-east-1" });
31
32 const source = preview ? yield* Turso.Database.ref("Db", { stage: staging }) : undefined;
33
34 const db = yield* Turso.Database("Db", {
35 group: group.name,
36 seed: source ? { type: "database", name: source.name } : undefined,
37 });
38 return { db, group: group.name };
39 }),
40 );
41
42 const sql = (database: string, hostname: string, statement: string) =>
43 Effect.gen(function* () {
44 const org = yield* organization;
45 const { jwt } = yield* turso.createDatabaseToken({
46 organizationSlug: org,
47 databaseName: database,
48 expiration: "5m",
49 });
50 return yield* Hrana.query({ url: `https://${hostname}`, authToken: jwt! }, statement);
51 });
52
53 const exists = (database: string) =>
54 Effect.gen(function* () {
55 const org = yield* organization;
56 return yield* turso.getDatabase({ organizationSlug: org, databaseName: database }).pipe(
57 Effect.map(() => true),
58 Effect.catchTag("NotFound", () => Effect.succeed(false)),
59 );
60 });
61
62 test.provider(
63 "a preview stage forks staging's database and is destroyed alone",
64 () =>
65 Effect.gen(function* () {
66 yield* destroy(Stack, { stage: pr });
67 yield* destroy(Stack, { stage: staging });
68
69 const stagingOut = yield* deploy(Stack, { stage: staging });
70 yield* sql(stagingOut.db.name, stagingOut.db.hostname, "CREATE TABLE t (v INTEGER)");
71 yield* sql(stagingOut.db.name, stagingOut.db.hostname, "INSERT INTO t VALUES (42)");
72
73 const prOut = yield* deploy(Stack, { stage: pr });
74 expect(prOut.group).toBe(stagingOut.group);
75 expect(prOut.db.name).not.toBe(stagingOut.db.name);
76 expect(yield* sql(prOut.db.name, prOut.db.hostname, "SELECT v FROM t")).toEqual([{ v: 42 }]);
77
78 // Destroying the preview deletes only its fork.
79 yield* destroy(Stack, { stage: pr });
80 expect(yield* exists(prOut.db.name)).toBe(false);
81 expect(yield* exists(stagingOut.db.name)).toBe(true);
82
83 yield* destroy(Stack, { stage: staging });
84 expect(yield* exists(stagingOut.db.name)).toBe(false);
85 }),
86 { tags: ["provider:turso", "provider:turso:database", "live"], timeout: 240_000 },
87 );