@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 141 lines 5.85 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { findZoneByName } from "@alchemy.run/cloudflare/Zone/lookup";
4 import { describe, expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as emailRouting from "@distilled.cloud/cloudflare/email-routing";
7 import * as Effect from "effect/Effect";
8 import { MinimumLogLevel } from "effect/References";
9 import * as Schedule from "effect/Schedule";
10 import RuleTargetWorker from "./fixtures/rule-target-worker.ts";
11 import { EMAIL_ROUTING_ZONE, emailRoutingScoped } from "./scope.ts";
12
13 const { test } = Test.make({ providers: Cloudflare.providers() });
14
15 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
16
17 const zoneName = process.env.CLOUDFLARE_TEST_DNS_ZONE_NAME ?? "alchemy-test-2.us";
18
19 const resolveZoneId = Effect.gen(function* () {
20 const { accountId } = yield* yield* CloudflareEnvironment;
21 const zone = yield* findZoneByName({ accountId, name: zoneName });
22 if (!zone) {
23 return yield* Effect.die(new Error(`zone "${zoneName}" not found in account`));
24 }
25 return zone.id;
26 });
27
28 // The scoped API token the test harness mints propagates eventually-
29 // consistently across Cloudflare's edge — a fresh token intermittently 403s.
30 const enableRouting = (zoneId: string) =>
31 emailRouting.enableEmailRouting({ zoneId }).pipe(
32 Effect.retry({
33 while: (e) => e._tag === "Forbidden",
34 schedule: Schedule.exponential("500 millis"),
35 times: 8,
36 }),
37 );
38
39 describe.sequential.skipIf(!emailRoutingScoped)(
40 "Email.Rule -> Worker in one apply",
41 {
42 tags: [
43 "provider:cloudflare",
44 "provider:cloudflare:email",
45 "provider:cloudflare:worker",
46 "provider:cloudflare:zone",
47 "live",
48 ],
49 },
50 () => {
51 // Coverage for the shape reported in #1348: a Worker plus a routing
52 // resource whose `{ type: "worker", value: [scriptName] }` action names
53 // it, both created in the same apply, into a stage that did not exist.
54 //
55 // NOTE: this is a smoke test, NOT the regression guard for #1348. It was
56 // confirmed to still pass with the provider's retry removed — by us and
57 // independently by the reporter, who mutated the retry away and got three
58 // green runs. The Worker provider pre-creates a stub script before the
59 // rule is created (see "pre-creating" in a deploy log), so by the time
60 // Cloudflare validates the action the name already resolves.
61 //
62 // The retry itself is guarded deterministically in `retry.test.ts`, which
63 // injects the failure and does fail when the retry is removed. The error
64 // is real and typed (`WorkerScriptNotFound`, Cloudflare code 2016,
65 // observed live on both createRule and putRuleCatchAll).
66 test.provider(
67 "first deploy of a fresh stage creates the rule targeting the worker",
68 (stack) =>
69 Effect.gen(function* () {
70 const zoneId = yield* resolveZoneId;
71
72 // A never-before-deployed stage is the precondition — start from a
73 // torn-down stack so the Worker really is created in this apply.
74 yield* stack.destroy();
75 yield* enableRouting(zoneId);
76
77 const { rule, workerName } = yield* stack.deploy(
78 Effect.gen(function* () {
79 const routing = yield* Cloudflare.Email.Routing("Routing", { zone: zoneName });
80 const worker = yield* RuleTargetWorker;
81 const rule = yield* Cloudflare.Email.Rule("WorkerRule", {
82 zone: { zoneId: routing.zoneId },
83 matchers: [{ type: "literal", field: "to", value: `worker-target@${zoneName}` }],
84 actions: [{ type: "worker", value: [worker.workerName] }],
85 });
86 return { rule, workerName: worker.workerName };
87 }),
88 );
89
90 expect(rule.ruleId).not.toEqual("");
91 expect(rule.zoneId).toEqual(zoneId);
92 expect(rule.actions).toEqual([{ type: "worker", value: [workerName] }]);
93
94 // Verify out-of-band that Cloudflare really stored the worker action.
95 const live = yield* emailRouting.getRule({ zoneId, ruleIdentifier: rule.ruleId }).pipe(
96 Effect.retry({
97 while: (e) => e._tag === "Forbidden",
98 schedule: Schedule.exponential("500 millis"),
99 times: 8,
100 }),
101 );
102 expect(live.actions?.[0]?.type).toEqual("worker");
103 expect(live.actions?.[0]?.value).toEqual([workerName]);
104
105 yield* stack.destroy();
106 }).pipe(logLevel),
107 { timeout: 180_000, exclusive: EMAIL_ROUTING_ZONE },
108 );
109
110 // The catch-all rule takes a `worker` action through a different endpoint
111 // (`/rules/catch_all`) and hits the same validation window.
112 test.provider(
113 "catch-all pointed at a Worker created in the same apply",
114 (stack) =>
115 Effect.gen(function* () {
116 const zoneId = yield* resolveZoneId;
117
118 yield* stack.destroy();
119 yield* enableRouting(zoneId);
120
121 const { catchAll, workerName } = yield* stack.deploy(
122 Effect.gen(function* () {
123 const routing = yield* Cloudflare.Email.Routing("Routing", { zone: zoneName });
124 const worker = yield* RuleTargetWorker;
125 const catchAll = yield* Cloudflare.Email.CatchAll("CatchAll", {
126 zone: { zoneId: routing.zoneId },
127 actions: [{ type: "worker", value: [worker.workerName] }],
128 });
129 return { catchAll, workerName: worker.workerName };
130 }),
131 );
132
133 expect(catchAll.zoneId).toEqual(zoneId);
134 expect(catchAll.actions).toEqual([{ type: "worker", value: [workerName] }]);
135
136 yield* stack.destroy();
137 }).pipe(logLevel),
138 { timeout: 180_000, exclusive: EMAIL_ROUTING_ZONE },
139 );
140 },
141 );