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

main
ts 351 lines 12.3 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 { expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as pageRules from "@distilled.cloud/cloudflare/page-rules";
7 import { adopt, OwnedBySomeoneElse } from "alchemy/AdoptPolicy";
8 import * as Provider from "alchemy/Provider";
9 import * as Cause from "effect/Cause";
10 import * as Effect from "effect/Effect";
11 import { MinimumLogLevel } from "effect/References";
12 import * as Schedule from "effect/Schedule";
13
14 const { test } = Test.make({ providers: Cloudflare.providers() });
15
16 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
17
18 const zoneName = process.env.CLOUDFLARE_TEST_DNS_ZONE_NAME ?? "alchemy-test-2.us";
19
20 // Deterministic per-test URL targets. Each test owns a disjoint path so
21 // reruns never collide, and the same target is reused on every run (never
22 // derive identity from Date.now()/random). Free zones allow only 3 Page
23 // Rules — every test starts and ends clean to stay within quota.
24 const TARGET_DEFAULT = `${zoneName}/alchemy-pagerule-default/*`;
25 const TARGET_UPDATE = `${zoneName}/alchemy-pagerule-update/*`;
26 const TARGET_UPDATE_MOVED = `${zoneName}/alchemy-pagerule-update-moved/*`;
27 const TARGET_ADOPT = `${zoneName}/alchemy-pagerule-adopt/*`;
28 const TARGET_LIST = `${zoneName}/alchemy-pagerule-list/*`;
29
30 const resolveZoneId = Effect.gen(function* () {
31 const { accountId } = yield* yield* CloudflareEnvironment;
32 const zone = yield* findZoneByName({ accountId, name: zoneName });
33 if (!zone) {
34 return yield* Effect.die(new Error(`zone "${zoneName}" not found in account`));
35 }
36 return zone.id;
37 });
38
39 // The scoped API token the test harness mints propagates eventually-
40 // consistently across Cloudflare's edge — a fresh token intermittently 403s
41 // with "Unable to authenticate request". Ride out the blips on the test's
42 // own out-of-band verification calls by retrying the typed `Forbidden`
43 // error (part of each page-rules operation's error union via distilled
44 // patches).
45 const forbiddenRetrySchedule = Schedule.exponential("500 millis");
46
47 const retryForbidden = <A, E extends { _tag: string }, R>(effect: Effect.Effect<A, E, R>) =>
48 effect.pipe(
49 Effect.retry({
50 while: (e) => e._tag === "Forbidden",
51 schedule: forbiddenRetrySchedule,
52 times: 8,
53 }),
54 );
55
56 const targetOf = (rule: { targets: ReadonlyArray<{ constraint?: { value: string } | null }> }) =>
57 rule.targets[0]?.constraint?.value;
58
59 const listRules = (zoneId: string) => retryForbidden(pageRules.listPageRules({ zoneId }));
60
61 const findRule = (zoneId: string, target: string) =>
62 listRules(zoneId).pipe(Effect.map((rules) => rules.find((r) => targetOf(r) === target)));
63
64 const getRule = (zoneId: string, pageruleId: string) =>
65 retryForbidden(pageRules.getPageRule({ zoneId, pageruleId }));
66
67 // Delete every rule matching one of our deterministic targets — used to
68 // purge leftovers from interrupted runs so tests start from a clean slate
69 // (and stay within the free-plan quota of 3 rules).
70 const purgeRules = (zoneId: string, targets: ReadonlyArray<string>) =>
71 listRules(zoneId).pipe(
72 Effect.flatMap(
73 Effect.forEach((rule) =>
74 targets.includes(targetOf(rule) ?? "")
75 ? pageRules
76 .deletePageRule({ zoneId, pageruleId: rule.id })
77 .pipe(Effect.catchTag("PageRuleNotFound", () => Effect.void))
78 : Effect.void,
79 ),
80 ),
81 );
82
83 test.provider(
84 "create, verify out-of-band, and destroy a page rule",
85 (stack) =>
86 Effect.gen(function* () {
87 const zoneId = yield* resolveZoneId;
88
89 yield* stack.destroy();
90 yield* purgeRules(zoneId, [TARGET_DEFAULT]);
91
92 const rule = yield* stack.deploy(
93 Effect.gen(function* () {
94 return yield* Cloudflare.PageRule.PageRule("DefaultRule", {
95 zoneId,
96 target: TARGET_DEFAULT,
97 actions: [
98 { id: "cache_level", value: "cache_everything" },
99 { id: "edge_cache_ttl", value: 7200 },
100 ],
101 }).pipe(adopt(true));
102 }),
103 );
104
105 expect(rule.pageRuleId).toBeDefined();
106 expect(rule.zoneId).toEqual(zoneId);
107 expect(rule.target).toEqual(TARGET_DEFAULT);
108 // Alchemy defaults differ from the raw API: status active, priority 1.
109 expect(rule.status).toEqual("active");
110 expect(rule.priority).toEqual(1);
111
112 const live = yield* getRule(zoneId, rule.pageRuleId);
113 expect(live.id).toEqual(rule.pageRuleId);
114 expect(targetOf(live)).toEqual(TARGET_DEFAULT);
115 expect(live.status).toEqual("active");
116 const actionIds = live.actions.map((a) => a.id).sort();
117 expect(actionIds).toEqual(["cache_level", "edge_cache_ttl"]);
118
119 yield* stack.destroy();
120
121 const gone = yield* findRule(zoneId, TARGET_DEFAULT);
122 expect(gone).toBeUndefined();
123 }).pipe(logLevel),
124 {
125 tags: [
126 "provider:cloudflare",
127 "provider:cloudflare:pagerule",
128 "provider:cloudflare:zone",
129 "live",
130 ],
131 },
132 );
133
134 test.provider(
135 "updating actions, status, priority and target syncs in place",
136 (stack) =>
137 Effect.gen(function* () {
138 const zoneId = yield* resolveZoneId;
139
140 yield* stack.destroy();
141 yield* purgeRules(zoneId, [TARGET_UPDATE, TARGET_UPDATE_MOVED]);
142
143 const initial = yield* stack.deploy(
144 Effect.gen(function* () {
145 return yield* Cloudflare.PageRule.PageRule("UpdateRule", {
146 zoneId,
147 target: TARGET_UPDATE,
148 actions: [{ id: "cache_level", value: "bypass" }],
149 status: "disabled",
150 }).pipe(adopt(true));
151 }),
152 );
153
154 expect(initial.status).toEqual("disabled");
155 expect(initial.target).toEqual(TARGET_UPDATE);
156
157 const updated = yield* stack.deploy(
158 Effect.gen(function* () {
159 return yield* Cloudflare.PageRule.PageRule("UpdateRule", {
160 zoneId,
161 // Targets are mutable via PUT — same rule, new URL pattern.
162 target: TARGET_UPDATE_MOVED,
163 actions: [
164 { id: "cache_level", value: "cache_everything" },
165 { id: "browser_cache_ttl", value: 3600 },
166 ],
167 status: "active",
168 }).pipe(adopt(true));
169 }),
170 );
171
172 // Same rule updated in place — not a replacement.
173 expect(updated.pageRuleId).toEqual(initial.pageRuleId);
174 expect(updated.target).toEqual(TARGET_UPDATE_MOVED);
175 expect(updated.status).toEqual("active");
176 // Cloudflare clamps priority to the number of rules on the zone
177 // (priority is positional) — a lone rule is always priority 1.
178 expect(updated.priority).toEqual(1);
179
180 const live = yield* getRule(zoneId, updated.pageRuleId);
181 expect(targetOf(live)).toEqual(TARGET_UPDATE_MOVED);
182 expect(live.status).toEqual("active");
183 const actionIds = live.actions.map((a) => a.id).sort();
184 expect(actionIds).toEqual(["browser_cache_ttl", "cache_level"]);
185
186 // Re-deploying the identical desired state is a no-op (sync skips
187 // the PUT entirely) and keeps the same physical rule.
188 const noop = yield* stack.deploy(
189 Effect.gen(function* () {
190 return yield* Cloudflare.PageRule.PageRule("UpdateRule", {
191 zoneId,
192 target: TARGET_UPDATE_MOVED,
193 actions: [
194 { id: "cache_level", value: "cache_everything" },
195 { id: "browser_cache_ttl", value: 3600 },
196 ],
197 status: "active",
198 }).pipe(adopt(true));
199 }),
200 );
201 expect(noop.pageRuleId).toEqual(initial.pageRuleId);
202
203 yield* stack.destroy();
204
205 const gone = yield* findRule(zoneId, TARGET_UPDATE_MOVED);
206 expect(gone).toBeUndefined();
207 }).pipe(logLevel),
208 {
209 tags: [
210 "provider:cloudflare",
211 "provider:cloudflare:pagerule",
212 "provider:cloudflare:zone",
213 "live",
214 ],
215 },
216 );
217
218 test.provider(
219 "adoption — existing rule errors without adopt, takes over with adopt(true)",
220 (stack) =>
221 Effect.gen(function* () {
222 const zoneId = yield* resolveZoneId;
223
224 yield* stack.destroy();
225 yield* purgeRules(zoneId, [TARGET_ADOPT]);
226
227 // Create the rule out-of-band so the stack has no state of its own
228 // for it — exactly the "the rule already exists" scenario.
229 const pre = yield* retryForbidden(
230 pageRules.createPageRule({
231 zoneId,
232 targets: [{ target: "url", constraint: { operator: "matches", value: TARGET_ADOPT } }],
233 actions: [{ id: "cache_level", value: "bypass" }],
234 status: "active",
235 }),
236 );
237 expect(pre.id).toBeDefined();
238
239 // Without `adopt`: Page Rules carry no ownership markers, so the
240 // engine cannot prove we created it and refuses to take it over.
241 const error = yield* stack
242 .deploy(
243 Effect.gen(function* () {
244 return yield* Cloudflare.PageRule.PageRule("AdoptedRule", {
245 zoneId,
246 target: TARGET_ADOPT,
247 actions: [{ id: "cache_level", value: "cache_everything" }],
248 });
249 }),
250 )
251 .pipe(
252 Effect.as(undefined),
253 Effect.catchCause((cause) => Effect.succeed(findOwnedError(cause))),
254 );
255 expect(error).toBeInstanceOf(OwnedBySomeoneElse);
256
257 // With `adopt(true)`: the engine takes over the pre-existing rule
258 // (same physical id) and converges it to the desired actions.
259 const adopted = yield* stack.deploy(
260 Effect.gen(function* () {
261 return yield* Cloudflare.PageRule.PageRule("AdoptedRule", {
262 zoneId,
263 target: TARGET_ADOPT,
264 actions: [{ id: "cache_level", value: "cache_everything" }],
265 }).pipe(adopt(true));
266 }),
267 );
268
269 expect(adopted.pageRuleId).toEqual(pre.id);
270
271 const live = yield* getRule(zoneId, adopted.pageRuleId);
272 const cacheLevel = live.actions.find((a) => a.id === "cache_level");
273 expect(cacheLevel?.id === "cache_level" ? cacheLevel.value : undefined).toEqual(
274 "cache_everything",
275 );
276
277 yield* stack.destroy();
278
279 const gone = yield* findRule(zoneId, TARGET_ADOPT);
280 expect(gone).toBeUndefined();
281 }).pipe(logLevel),
282 {
283 tags: [
284 "provider:cloudflare",
285 "provider:cloudflare:pagerule",
286 "provider:cloudflare:zone",
287 "live",
288 ],
289 },
290 );
291
292 // Canonical `list()` test (zone-scoped collection): `list()` enumerates
293 // every zone via `listAllZones` and lists each zone's Page Rules, hydrating
294 // each into the same `Attributes` shape `read` returns. Deploy a rule with a
295 // deterministic target, then assert it appears in the exhaustive result.
296 test.provider(
297 "list enumerates the deployed page rule",
298 (stack) =>
299 Effect.gen(function* () {
300 const zoneId = yield* resolveZoneId;
301
302 yield* stack.destroy();
303 yield* purgeRules(zoneId, [TARGET_LIST]);
304
305 const rule = yield* stack.deploy(
306 Effect.gen(function* () {
307 return yield* Cloudflare.PageRule.PageRule("ListRule", {
308 zoneId,
309 target: TARGET_LIST,
310 actions: [{ id: "cache_level", value: "cache_everything" }],
311 }).pipe(adopt(true));
312 }),
313 );
314
315 const provider = yield* Provider.findProvider(Cloudflare.PageRule.PageRule);
316 const all = yield* provider.list();
317
318 expect(all.some((r) => r.pageRuleId === rule.pageRuleId)).toBe(true);
319 const found = all.find((r) => r.pageRuleId === rule.pageRuleId);
320 expect(found?.zoneId).toEqual(zoneId);
321 expect(found?.target).toEqual(TARGET_LIST);
322
323 yield* stack.destroy();
324
325 const gone = yield* findRule(zoneId, TARGET_LIST);
326 expect(gone).toBeUndefined();
327 }).pipe(logLevel),
328 {
329 tags: [
330 "provider:cloudflare",
331 "provider:cloudflare:pagerule",
332 "provider:cloudflare:zone",
333 "live",
334 ],
335 },
336 );
337
338 /**
339 * Pull the {@link OwnedBySomeoneElse} value out of a Cause regardless of
340 * whether the engine raised it as a typed failure or a defect.
341 */
342 const findOwnedError = (cause: Cause.Cause<unknown>): OwnedBySomeoneElse | undefined =>
343 cause.reasons
344 .map((reason) =>
345 Cause.isFailReason(reason)
346 ? reason.error
347 : Cause.isDieReason(reason)
348 ? reason.defect
349 : undefined,
350 )
351 .find((value): value is OwnedBySomeoneElse => value instanceof OwnedBySomeoneElse);