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

main
ts 129 lines 4.58 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as queues from "@distilled.cloud/cloudflare/queues";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as HttpClient from "effect/http/HttpClient";
9 import * as HttpClientRequest from "effect/http/HttpClientRequest";
10 import * as HttpClientResponse from "effect/http/HttpClientResponse";
11 import { MinimumLogLevel } from "effect/References";
12 import * as Schedule from "effect/Schedule";
13 import * as Stream from "effect/Stream";
14 import DeadLetterWorker, {
15 ByNameQueue,
16 ByRefQueue,
17 ByResourceQueue,
18 DeadLetters,
19 type DeadLetterSource,
20 } from "./fixtures/dead-letter-worker.ts";
21
22 const { test } = Test.make({ providers: Cloudflare.providers() });
23
24 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
25
26 class NotYetDeadLettered extends Data.TaggedError("NotYetDeadLettered")<{
27 received: string[];
28 }> {}
29
30 const sources: DeadLetterSource[] = ["resource", "ref", "name"];
31
32 /**
33 * `consumeQueueMessages(queue, { deadLetterQueue })` accepts the dead-letter
34 * queue as a Queue resource, a `Queue.ref(...)`, or its name. Each source
35 * queue's handler always fails, so its message is dead-lettered and must
36 * reach the dead-letter queue's own consumer (#2464).
37 */
38 test.provider(
39 "dead-letters by Queue resource, Queue.ref, and queue name reach the dead-letter consumer",
40 (stack) =>
41 Effect.gen(function* () {
42 yield* stack.destroy();
43
44 // The dead-letter queue must be in state for `Queue.ref` to resolve.
45 yield* stack.deploy(DeadLetters);
46
47 const out = yield* stack.deploy(
48 Effect.gen(function* () {
49 const deadLetters = yield* DeadLetters;
50 const worker = yield* DeadLetterWorker;
51 return {
52 url: worker.url,
53 deadLetterQueueName: deadLetters.queueName,
54 sourceQueueIds: [
55 (yield* ByResourceQueue).queueId,
56 (yield* ByRefQueue).queueId,
57 (yield* ByNameQueue).queueId,
58 ],
59 };
60 }),
61 );
62 const baseUrl = out.url as string;
63
64 // Out of band: each source queue's consumer names the dead-letter queue.
65 const { accountId } = yield* yield* CloudflareEnvironment;
66 for (const queueId of out.sourceQueueIds) {
67 const consumers = yield* queues.listConsumers
68 .items({ accountId, queueId })
69 .pipe(Stream.runCollect);
70 expect(
71 Array.from(consumers).map((consumer) =>
72 "deadLetterQueue" in consumer ? consumer.deadLetterQueue : undefined,
73 ),
74 ).toEqual([out.deadLetterQueueName]);
75 }
76
77 for (const source of sources) {
78 const res = yield* HttpClient.execute(
79 HttpClientRequest.post(`${baseUrl}/send/${source}`).pipe(
80 HttpClientRequest.bodyText("poison"),
81 ),
82 ).pipe(
83 Effect.flatMap((res) =>
84 res.status === 202
85 ? Effect.succeed(res)
86 : Effect.fail(new Error(`Worker not ready: ${res.status}`)),
87 ),
88 Effect.retry({
89 schedule: Schedule.max([
90 Schedule.min([Schedule.exponential("500 millis"), Schedule.spaced("3 seconds")]),
91 Schedule.recurs(10),
92 ]),
93 }),
94 );
95 expect(res.status).toBe(202);
96 }
97
98 const expected = sources.map((source) => `${source}:poison`);
99 const received = yield* HttpClient.get(`${baseUrl}/dead-letters`).pipe(
100 Effect.flatMap(HttpClientResponse.filterStatusOk),
101 Effect.flatMap((res) => res.json),
102 Effect.map((body) => (body as { received: string[] }).received),
103 Effect.flatMap((received) =>
104 expected.every((entry) => received.includes(entry))
105 ? Effect.succeed(received)
106 : Effect.fail(new NotYetDeadLettered({ received })),
107 ),
108 Effect.retry({
109 schedule: Schedule.max([
110 Schedule.min([Schedule.exponential("500 millis"), Schedule.spaced("4 seconds")]),
111 Schedule.recurs(15),
112 ]),
113 }),
114 );
115 // Queues deliver at least once, so a message can be recorded twice.
116 expect([...new Set(received)].sort()).toEqual([...expected].sort());
117
118 yield* stack.destroy();
119 }).pipe(logLevel),
120 {
121 tags: [
122 "provider:cloudflare",
123 "provider:cloudflare:queue",
124 "provider:cloudflare:worker",
125 "live",
126 ],
127 timeout: 180_000,
128 },
129 );