@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, 07:15 UTC

main
ts 260 lines 9.03 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 addressing from "@distilled.cloud/cloudflare/addressing";
7 import * as dns from "@distilled.cloud/cloudflare/dns";
8 import * as Provider from "alchemy/Provider";
9 import * as Effect from "effect/Effect";
10 import { MinimumLogLevel } from "effect/References";
11 import * as Result from "effect/Result";
12 import * as Schedule from "effect/Schedule";
13 import * as Stream from "effect/Stream";
14 import { testName } from "../../names.ts";
15
16 const { test } = Test.make({ providers: Cloudflare.providers() });
17
18 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
19
20 const zoneName = process.env.CLOUDFLARE_TEST_DNS_ZONE_NAME ?? "alchemy-test-2.us";
21
22 // Deterministic per-test hostname (never derive from Date.now()/random).
23 const HOSTNAME = `${testName("alchemy-regional")}.${zoneName}`;
24
25 const resolveZoneId = Effect.gen(function* () {
26 const { accountId } = yield* yield* CloudflareEnvironment;
27 const zone = yield* findZoneByName({ accountId, name: zoneName });
28 if (!zone) {
29 return yield* Effect.die(new Error(`zone "${zoneName}" not found in account`));
30 }
31 return zone.id;
32 });
33
34 // A freshly minted scoped token propagates eventually-consistently across
35 // Cloudflare's edge — retry the typed `Forbidden` blips on out-of-band calls.
36 const forbiddenRetrySchedule = Schedule.exponential("500 millis");
37
38 const retryForbidden = <A, E extends { _tag: string }, R>(effect: Effect.Effect<A, E, R>) =>
39 effect.pipe(
40 Effect.retry({
41 while: (e) => e._tag === "Forbidden",
42 schedule: forbiddenRetrySchedule,
43 times: 8,
44 }),
45 );
46
47 const getRegionalHostname = (zoneId: string, hostname: string) =>
48 retryForbidden(addressing.getRegionalHostname({ zoneId, hostname })).pipe(
49 Effect.catchTag(["RegionalHostnameNotFound", "RegionalHostnameEmpty"], () =>
50 Effect.succeed(undefined),
51 ),
52 );
53
54 const deleteRegionalHostname = (zoneId: string, hostname: string) =>
55 retryForbidden(addressing.deleteRegionalHostname({ zoneId, hostname })).pipe(
56 Effect.catchTag(["RegionalHostnameNotFound", "RegionalHostnameEmpty"], () => Effect.void),
57 );
58
59 // Regionalization only takes effect for hostnames with a DNS record — and
60 // creation rejects hostnames without one. Ensure an A record exists for the
61 // test hostname (idempotently) before exercising the resource.
62 const ensureDnsRecord = (zoneId: string) =>
63 Effect.gen(function* () {
64 const existing = yield* retryForbidden(
65 dns.listRecords.items({ zoneId, name: { exact: HOSTNAME }, type: "A" }).pipe(
66 Stream.runCollect,
67 Effect.map((c) => Array.from(c)),
68 ),
69 );
70 if (existing.length === 0) {
71 yield* retryForbidden(
72 dns.createRecord({
73 zoneId,
74 name: HOSTNAME,
75 type: "A",
76 content: "203.0.113.77",
77 ttl: 300,
78 proxied: true,
79 }),
80 );
81 }
82 });
83
84 const purgeDnsRecord = (zoneId: string) =>
85 retryForbidden(
86 dns.listRecords.items({ zoneId, name: { exact: HOSTNAME }, type: "A" }).pipe(
87 Stream.runCollect,
88 Effect.map((c) => Array.from(c)),
89 ),
90 ).pipe(
91 Effect.flatMap(
92 Effect.forEach((r) =>
93 dns.deleteRecord({ zoneId, dnsRecordId: r.id }).pipe(Effect.catch(() => Effect.void)),
94 ),
95 ),
96 );
97
98 // Regional Hostnames require the Data Localization Suite / Regional Services
99 // entitlement on the zone. The test probes a raw create once: unentitled
100 // zones assert the typed error tag; entitled zones run the full lifecycle
101 // (create, patch regionKey in place, destroy, verify gone).
102 test.provider(
103 "regional hostname lifecycle (typed error on unentitled zones)",
104 (stack) =>
105 Effect.gen(function* () {
106 const zoneId = yield* resolveZoneId;
107
108 yield* stack.destroy();
109 yield* ensureDnsRecord(zoneId);
110 // Purge leftovers from interrupted runs.
111 yield* deleteRegionalHostname(zoneId, HOSTNAME);
112
113 const probe = yield* retryForbidden(
114 addressing.createRegionalHostname({
115 zoneId,
116 hostname: HOSTNAME,
117 regionKey: "eu",
118 }),
119 ).pipe(Effect.result);
120
121 if (Result.isFailure(probe)) {
122 // Unentitled — must surface as a typed tag from the operation's
123 // error union, never an untyped catch-all.
124 expect(["InvalidHostname", "RegionalHostnameEmpty"]).toContain(probe.failure._tag);
125 yield* purgeDnsRecord(zoneId);
126 yield* stack.destroy();
127 return;
128 }
129
130 // Entitled — remove the probe hostname and run the full lifecycle.
131 yield* deleteRegionalHostname(zoneId, HOSTNAME);
132
133 const created = yield* stack.deploy(
134 Effect.gen(function* () {
135 return yield* Cloudflare.RegionalHostname.RegionalHostname("Regional", {
136 zoneId,
137 hostname: HOSTNAME,
138 regionKey: "eu",
139 });
140 }),
141 );
142 expect(created.zoneId).toEqual(zoneId);
143 expect(created.hostname).toEqual(HOSTNAME);
144 expect(created.regionKey).toEqual("eu");
145 expect(created.createdOn).toBeDefined();
146
147 // Out-of-band verification via the distilled API.
148 const live = yield* getRegionalHostname(zoneId, HOSTNAME);
149 expect(live?.regionKey).toEqual("eu");
150
151 // Move the hostname to another region in place — same identifier.
152 const updated = yield* stack.deploy(
153 Effect.gen(function* () {
154 return yield* Cloudflare.RegionalHostname.RegionalHostname("Regional", {
155 zoneId,
156 hostname: HOSTNAME,
157 regionKey: "us",
158 });
159 }),
160 );
161 expect(updated.hostname).toEqual(HOSTNAME);
162 expect(updated.regionKey).toEqual("us");
163
164 const patched = yield* getRegionalHostname(zoneId, HOSTNAME);
165 expect(patched?.regionKey).toEqual("us");
166
167 // Destroy and verify the hostname is gone (typed not-found read).
168 yield* stack.destroy();
169 const gone = yield* getRegionalHostname(zoneId, HOSTNAME);
170 expect(gone).toBeUndefined();
171
172 yield* purgeDnsRecord(zoneId);
173 }).pipe(logLevel),
174 {
175 tags: [
176 "provider:cloudflare",
177 "provider:cloudflare:addressing",
178 "provider:cloudflare:dns",
179 "provider:cloudflare:regionalhostname",
180 "provider:cloudflare:zone",
181 "live",
182 ],
183 timeout: 120_000,
184 },
185 );
186
187 // Canonical `list()` test (zone-scoped collection): `list()` fans out over
188 // every zone via `listAllZones` and exhaustively paginates each zone's
189 // regional hostnames. Data Localization is entitlement-gated, so the deploy
190 // is probe-gated: when the zone is entitled we assert the deployed hostname
191 // appears in the result; otherwise we still assert `list()` returns a
192 // well-typed (possibly empty) array.
193 test.provider(
194 "list enumerates regional hostnames across zones",
195 (stack) =>
196 Effect.gen(function* () {
197 const zoneId = yield* resolveZoneId;
198
199 yield* stack.destroy();
200 yield* ensureDnsRecord(zoneId);
201 yield* deleteRegionalHostname(zoneId, HOSTNAME);
202
203 // Probe entitlement once: unentitled zones reject create with a typed tag.
204 const probe = yield* retryForbidden(
205 addressing.createRegionalHostname({
206 zoneId,
207 hostname: HOSTNAME,
208 regionKey: "eu",
209 }),
210 ).pipe(Effect.result);
211
212 const entitled = Result.isSuccess(probe);
213 if (!entitled) {
214 expect(["InvalidHostname", "RegionalHostnameEmpty"]).toContain(probe.failure._tag);
215 } else {
216 // Remove the raw probe so the resource owns the hostname.
217 yield* deleteRegionalHostname(zoneId, HOSTNAME);
218 yield* stack.deploy(
219 Effect.gen(function* () {
220 return yield* Cloudflare.RegionalHostname.RegionalHostname("Regional", {
221 zoneId,
222 hostname: HOSTNAME,
223 regionKey: "eu",
224 });
225 }),
226 );
227 }
228
229 const provider = yield* Provider.findProvider(Cloudflare.RegionalHostname.RegionalHostname);
230 const all = yield* provider.list();
231
232 // `list()` always returns the full Attributes shape for each item.
233 expect(Array.isArray(all)).toBe(true);
234 for (const item of all) {
235 expect(typeof item.zoneId).toBe("string");
236 expect(typeof item.hostname).toBe("string");
237 expect(typeof item.regionKey).toBe("string");
238 }
239
240 if (entitled) {
241 // The deployed hostname must appear in the exhaustively-paginated result.
242 expect(all.some((item) => item.zoneId === zoneId && item.hostname === HOSTNAME)).toBe(true);
243 }
244
245 yield* stack.destroy();
246 yield* deleteRegionalHostname(zoneId, HOSTNAME);
247 yield* purgeDnsRecord(zoneId);
248 }).pipe(logLevel),
249 {
250 tags: [
251 "provider:cloudflare",
252 "provider:cloudflare:addressing",
253 "provider:cloudflare:dns",
254 "provider:cloudflare:regionalhostname",
255 "provider:cloudflare:zone",
256 "live",
257 ],
258 timeout: 120_000,
259 },
260 );