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

main
ts 150 lines 5.7 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { CloudflareApiLive } from "@alchemy.run/cloudflare/Providers";
4 import { expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as Effect from "effect/Effect";
7 import { HttpClientResponse } from "effect/http";
8 import * as HttpClient from "effect/http/HttpClient";
9 import { MinimumLogLevel } from "effect/References";
10 import * as Schedule from "effect/Schedule";
11 import Stack from "./fixtures/stack.ts";
12 import { waitForMetadata, waitForVectorize } from "./Readiness.ts";
13
14 /**
15 * End-to-end test of the `Cloudflare.Vectorize` native worker binding against a
16 * real Cloudflare Worker + Vectorize index, covering BOTH invocation styles:
17 *
18 * - effect-worker: `yield* Cloudflare.Vectorize.SearchIndex(index)` inside a
19 * `Cloudflare.Worker` init, binding provided via `SearchIndexBinding`.
20 * - async-worker: the index declared on the Worker `env`, used as the native
21 * runtime `Vectorize` binding from a plain `async fetch`.
22 *
23 * Both workers share ONE index (vectors are id-prefixed by style so they stay
24 * independent) and are driven by a single `exercise(label, baseUrl)` flow that
25 * upserts → describes → queries → filtered-queries → getByIds. Vectorize
26 * mutations are eventually consistent, so reads are polled until visible.
27 */
28 const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
29 providers: Cloudflare.providers(),
30 });
31
32 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
33
34 // Fresh workers.dev URLs take a few seconds to start serving 200s, and edge
35 // propagation can still transiently 404/500 individual route hits after the
36 // script is resolvable. Bound both the retry count and the entire request.
37 const readinessRetry = {
38 schedule: Schedule.max([Schedule.spaced("1 second"), Schedule.recurs(8)]),
39 } as const;
40
41 const getJson = (url: string) =>
42 HttpClient.get(url).pipe(
43 Effect.flatMap(HttpClientResponse.filterStatusOk),
44 Effect.flatMap((res) => res.json),
45 Effect.retry(readinessRetry),
46 Effect.timeout("15 seconds"),
47 );
48
49 const postJson = (url: string) =>
50 HttpClient.post(url).pipe(
51 Effect.flatMap(HttpClientResponse.filterStatusOk),
52 Effect.flatMap((res) => res.json),
53 Effect.retry(readinessRetry),
54 Effect.timeout("15 seconds"),
55 );
56
57 /** Drives the client surface using this worker's vector ID prefix. */
58 const exercise = (label: string, baseUrl: string) =>
59 Effect.gen(function* () {
60 // Gate on /health first to prove the script is resolvable.
61 yield* HttpClient.get(`${baseUrl}/health`).pipe(
62 Effect.flatMap(HttpClientResponse.filterStatusOk),
63 Effect.timeout("5 seconds"),
64 Effect.retry({ schedule: Schedule.max([Schedule.spaced("1 second"), Schedule.recurs(8)]) }),
65 Effect.timeout("15 seconds"),
66 );
67
68 const upsertRes = yield* postJson(`${baseUrl}/upsert`);
69 expect(upsertRes).toMatchObject({ mutationId: expect.any(String) });
70
71 const describeRes = yield* getJson(`${baseUrl}/describe`);
72 expect(describeRes).toMatchObject({ dimensions: 32 });
73
74 // Observe all read surfaces under one readiness budget. Both workers
75 // write to the shared index, so readiness is judged by this worker's
76 // own vectors rather than the index-wide processed mutation.
77 const { queryBody, getRes, filteredBody } = yield* waitForVectorize({
78 description: `[${label}] upserted vectors visible to query, ID lookup and metadata filtering`,
79 effect: Effect.all(
80 {
81 queryBody: getJson(`${baseUrl}/query`).pipe(
82 Effect.map((body) => body as { count: number; ids: string[] }),
83 ),
84 getRes: getJson(`${baseUrl}/get`).pipe(Effect.map((body) => body as { ids: string[] })),
85 filteredBody: getJson(`${baseUrl}/query-filtered`).pipe(
86 Effect.map((body) => body as { count: number; ids: string[]; kinds: string[] }),
87 ),
88 },
89 { concurrency: "unbounded" },
90 ),
91 predicate: ({ queryBody, getRes, filteredBody }) =>
92 queryBody.count >= 3 &&
93 getRes.ids.length === 2 &&
94 filteredBody.ids.length === 1 &&
95 filteredBody.kinds.length === 1,
96 });
97 expect(queryBody.count).toBeGreaterThanOrEqual(3);
98 expect(queryBody.ids[0]).toBe(`${label}-a`);
99 expect(getRes).toEqual({ ids: [`${label}-a`, `${label}-b`] });
100 expect(filteredBody.ids).toEqual([`${label}-b`]);
101 expect(filteredBody.kinds).toEqual(["second"]);
102 }).pipe(logLevel);
103
104 const stack = beforeAll(
105 Effect.gen(function* () {
106 yield* destroy(Stack);
107 const deployed = yield* deploy(Stack);
108 const { accountId } = yield* yield* CloudflareEnvironment;
109 yield* waitForMetadata(accountId, deployed.indexName, [
110 { propertyName: "kind", indexType: "string" },
111 ]);
112 return deployed;
113 }).pipe(Effect.provide(CloudflareApiLive())),
114 { timeout: 210_000 },
115 );
116 afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack));
117
118 test(
119 "effect-worker: SearchIndex(index) exercises the client surface",
120 Effect.gen(function* () {
121 const { effectWorkerUrl } = yield* stack;
122 yield* exercise("effect", effectWorkerUrl);
123 }),
124 {
125 tags: [
126 "provider:cloudflare",
127 "provider:cloudflare:vectorize",
128 "provider:cloudflare:worker",
129 "live",
130 ],
131 timeout: 210_000,
132 },
133 );
134
135 test(
136 "async-worker: env Vectorize binding exercises the client surface",
137 Effect.gen(function* () {
138 const { asyncWorkerUrl } = yield* stack;
139 yield* exercise("async", asyncWorkerUrl);
140 }),
141 {
142 tags: [
143 "provider:cloudflare",
144 "provider:cloudflare:vectorize",
145 "provider:cloudflare:worker",
146 "live",
147 ],
148 timeout: 210_000,
149 },
150 );