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

main
ts 177 lines 6.66 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import * as Planetscale from "@alchemy.run/planetscale";
3 import { describe, expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as Data from "effect/Data";
6 import * as Effect from "effect/Effect";
7 import * as HttpClient from "effect/http/HttpClient";
8 import * as HttpClientRequest from "effect/http/HttpClientRequest";
9 import type { HttpClientResponse } from "effect/http/HttpClientResponse";
10 import * as Layer from "effect/Layer";
11 import { MinimumLogLevel } from "effect/References";
12 import * as Schedule from "effect/Schedule";
13 import HyperdriveWorker from "./fixtures/hyperdrive-worker.ts";
14 import type { Widget } from "./fixtures/schema.ts";
15 import { Hyperdrive, PlanetscaleDb } from "./fixtures/Stack.ts";
16
17 const providers = Layer.mergeAll(Cloudflare.providers(), Planetscale.providers());
18
19 const { test } = Test.make({ providers });
20
21 const { test: devTest } = Test.make({ providers, dev: true });
22
23 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
24
25 class WorkerNotReady extends Data.TaggedError("WorkerNotReady")<{ status: number; body: string }> {}
26
27 const fetchReady = (req: Effect.Effect<any, any, any>) =>
28 req.pipe(
29 Effect.flatMap((res: any) =>
30 res.status >= 200 && res.status < 300
31 ? res.text.pipe(Effect.as(res))
32 : res.text.pipe(
33 Effect.flatMap((body: string) =>
34 Effect.fail(new WorkerNotReady({ status: res.status, body })),
35 ),
36 ),
37 ),
38 Effect.retry({
39 while: (e: unknown): e is WorkerNotReady =>
40 e instanceof WorkerNotReady && e.status >= 400 && e.status < 600,
41 schedule: Schedule.max([Schedule.exponential("500 millis"), Schedule.recurs(20)]),
42 }),
43 ) as Effect.Effect<HttpClientResponse>;
44
45 const expectWidgetRoundTrip = (baseUrl: string, widget: Widget) =>
46 Effect.gen(function* () {
47 const initial = yield* fetchReady(HttpClient.get(`${baseUrl}/widgets`));
48 expect(initial.status).toBe(200);
49 const initialBody = (yield* initial.json) as { widgets: Widget[] };
50 expect(Array.isArray(initialBody.widgets)).toBe(true);
51
52 const insertRes = yield* fetchReady(
53 HttpClient.execute(
54 HttpClientRequest.post(`${baseUrl}/widgets`).pipe(HttpClientRequest.bodyJsonUnsafe(widget)),
55 ),
56 );
57 expect(insertRes.status).toBe(200);
58 const insertBody = (yield* insertRes.json) as { widget: Widget };
59 expect(insertBody.widget).toMatchObject(widget);
60
61 const after = yield* fetchReady(HttpClient.get(`${baseUrl}/widgets`));
62 expect(after.status).toBe(200);
63 const afterBody = (yield* after.json) as { widgets: Widget[] };
64 expect(afterBody.widgets.some((w) => w.id === widget.id)).toBe(true);
65
66 const deleteRes = yield* fetchReady(
67 HttpClient.execute(HttpClientRequest.delete(`${baseUrl}/widgets/${widget.id}`)),
68 );
69 expect(deleteRes.status).toBe(200);
70
71 const final = yield* fetchReady(HttpClient.get(`${baseUrl}/widgets`));
72 const finalBody = (yield* final.json) as { widgets: Widget[] };
73 expect(finalBody.widgets.some((w) => w.id === widget.id)).toBe(false);
74 });
75
76 describe.skipIf(!process.env.PLANETSCALE_TEST).sequential(
77 "Hyperdrive",
78 {
79 tags: [
80 "provider:cloudflare",
81 "provider:cloudflare:hyperdrive",
82 "provider:cloudflare:worker",
83 "provider:planetscale",
84 "provider:planetscale:postgres",
85 "live",
86 ],
87 },
88 () => {
89 /**
90 * End-to-end: deploy a {@link Planetscale.PostgresDatabase} + branch +
91 * role, point a {@link Cloudflare.Hyperdrive.Connection} at the role's origin, and
92 * exercise the Drizzle Effect client over real Postgres via a Worker.
93 *
94 * Validates that:
95 * - migrations applied from the fixtures dir produce the expected table
96 * - `Cloudflare.Hyperdrive.Connect(...) + Drizzle.Postgres(...)` produces
97 * a working Effect-native client at runtime
98 * - INSERT / SELECT / DELETE round-trip through Hyperdrive to Planetscale
99 */
100 test.provider(
101 "PostgresBranch + Hyperdrive + Drizzle round-trips through a Worker",
102 (stack) =>
103 Effect.gen(function* () {
104 yield* stack.destroy();
105
106 const { hyperdrive, worker } = yield* stack.deploy(
107 Effect.gen(function* () {
108 yield* PlanetscaleDb;
109 const hyperdrive = yield* Hyperdrive;
110 const worker = yield* HyperdriveWorker;
111 return { hyperdrive, worker };
112 }),
113 );
114
115 expect(worker.url).toBeTypeOf("string");
116 expect(hyperdrive.origin).toMatchObject({ port: 5432 });
117 expect(hyperdrive.dev).toMatchObject({ port: 6432 });
118 const baseUrl = (worker.url as string).replace(/\/+$/, "");
119 yield* expectWidgetRoundTrip(baseUrl, { id: 1, name: "alpha" });
120
121 yield* stack.destroy();
122 }).pipe(logLevel),
123 { timeout: 600_000 },
124 );
125
126 /**
127 * End-to-end: deploy the same fixture in local-dev mode. Hyperdrive is
128 * bypassed in local dev, so `role.pooledOrigin` must provide a working
129 * direct connection for the Worker runtime binding.
130 */
131 devTest.provider(
132 "PostgresRole pooledOrigin works as the Hyperdrive dev origin",
133 (stack) =>
134 Effect.gen(function* () {
135 yield* stack.destroy();
136
137 const { hyperdrive, role, worker } = yield* stack.deploy(
138 Effect.gen(function* () {
139 const { role } = yield* PlanetscaleDb;
140 const hyperdrive = yield* Hyperdrive;
141 const worker = yield* HyperdriveWorker;
142 return { hyperdrive, role, worker };
143 }),
144 );
145
146 expect(worker.url).toBeTypeOf("string");
147 expect(hyperdrive.origin).toMatchObject({ port: 5432 });
148 expect(hyperdrive.dev).toMatchObject({
149 host: role.pooledOrigin.host,
150 port: 6432,
151 database: role.pooledOrigin.database,
152 user: role.pooledOrigin.user,
153 });
154
155 const baseUrl = (worker.url as string).replace(/\/+$/, "");
156 const metadataRes = yield* fetchReady(HttpClient.get(`${baseUrl}/hyperdrive`));
157 const metadata = (yield* metadataRes.json) as {
158 host: string;
159 port: number;
160 database: string;
161 user: string;
162 };
163 expect(metadata).toMatchObject({
164 host: role.pooledOrigin.host,
165 port: 6432,
166 database: role.pooledOrigin.database,
167 user: role.pooledOrigin.user,
168 });
169
170 yield* expectWidgetRoundTrip(baseUrl, { id: 2, name: "beta" });
171
172 yield* stack.destroy();
173 }).pipe(logLevel),
174 { timeout: 600_000 },
175 );
176 },
177 );