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

main
ts 89 lines 2.97 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import * as Context from "effect/Context";
3 import * as Effect from "effect/Effect";
4 import * as HttpServerResponse from "effect/http/HttpServerResponse";
5 import * as Layer from "effect/Layer";
6 import * as Stream from "effect/Stream";
7
8 // Partial batch failure fixture: messages whose body starts with `fail-` are
9 // reported in `batchItemFailures` on their first delivery and forwarded on the
10 // retry; every other message is forwarded on its first delivery. Each body is
11 // forwarded as `<body>#<receiveCount>`, so the test can see which messages
12 // Lambda redelivered.
13 export class PartialFailureFunction extends AWS.Lambda.Function<AWS.Lambda.Function>()(
14 "PartialFailureFunction",
15 ) {}
16
17 export class PartialFailureQueues extends Context.Service<
18 PartialFailureQueues,
19 {
20 source: AWS.SQS.Queue;
21 result: AWS.SQS.Queue;
22 }
23 >()("PartialFailureQueues") {}
24
25 export const PartialFailureQueuesLive = Layer.effect(
26 PartialFailureQueues,
27 Effect.gen(function* () {
28 // A short visibility timeout so the failed message is redelivered quickly.
29 const source = yield* AWS.SQS.Queue("PartialFailureSourceQueue", {
30 visibilityTimeout: "10 seconds",
31 });
32 const result = yield* AWS.SQS.Queue("PartialFailureResultQueue");
33 return { source, result };
34 }),
35 );
36
37 export default PartialFailureFunction.make(
38 {
39 main: import.meta.url,
40 functionUrl: true,
41 },
42 Effect.gen(function* () {
43 const { source, result } = yield* PartialFailureQueues;
44 const sink = yield* AWS.SQS.QueueSink(result);
45
46 yield* AWS.SQS.consumeQueueMessages(
47 source,
48 { batchSize: 10, maximumBatchingWindow: "3 seconds" },
49 Effect.fn(function* (event) {
50 const failed = event.Records.filter(
51 (record) =>
52 record.body.startsWith("fail-") && record.attributes.ApproximateReceiveCount === "1",
53 );
54 yield* Stream.fromIterable(event.Records).pipe(
55 Stream.filter((record) => !failed.includes(record)),
56 Stream.map((record) => ({
57 MessageBody: `${record.body}#${record.attributes.ApproximateReceiveCount}`,
58 })),
59 Stream.run(sink),
60 );
61 return {
62 batchItemFailures: failed.map((record) => ({ itemIdentifier: record.messageId })),
63 };
64 }),
65 );
66
67 const sourceQueueUrl = yield* source.queueUrl;
68 const sourceQueueArn = yield* source.queueArn;
69 const resultQueueUrl = yield* result.queueUrl;
70
71 return {
72 fetch: Effect.gen(function* () {
73 return yield* HttpServerResponse.json({
74 ok: true,
75 sourceQueueUrl: yield* sourceQueueUrl,
76 sourceQueueArn: yield* sourceQueueArn,
77 resultQueueUrl: yield* resultQueueUrl,
78 });
79 }).pipe(Effect.orDie),
80 };
81 }).pipe(
82 Effect.provide(
83 Layer.provideMerge(
84 Layer.mergeAll(AWS.Lambda.QueueEventSource, AWS.SQS.QueueSinkHttp),
85 Layer.mergeAll(AWS.SQS.SendMessageBatchHttp, PartialFailureQueuesLive),
86 ),
87 ),
88 ),
89 );