@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 344 lines 12.1 KB
Raw
1 import { resolve4, resolveNs, Resolver } from "node:dns/promises";
2 /**
3 * `domain.dns` on Prisma websites, deployed for real: a StaticSite whose
4 * custom hostname is published through `Cloudflare.DNS.Adapter()`. Asserts
5 * Cloudflare holds exactly the records `Prisma.CustomDomain.dnsRecords`
6 * reports, Prisma activates the domain and serves HTTPS on it, and destroy
7 * removes both the records and the Prisma domain.
8 *
9 * Prisma verifies the hostname's CNAME on registration, so the composite
10 * publishes it first.
11 */
12 import * as Cloudflare from "@alchemy.run/cloudflare";
13 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
14 import { findZoneByName } from "@alchemy.run/cloudflare/Zone/lookup";
15 import * as Prisma from "@alchemy.run/prisma";
16 import { expect } from "@alchemy.run/test";
17 import * as Test from "@alchemy.run/test/Alchemy";
18 import * as dns from "@distilled.cloud/cloudflare/dns";
19 import { getDomain, getProject, getService } from "@distilled.cloud/prisma/management";
20 import * as Data from "effect/Data";
21 import * as Effect from "effect/Effect";
22 import * as HttpClient from "effect/http/HttpClient";
23 import * as HttpClientError from "effect/http/HttpClientError";
24 import * as Layer from "effect/Layer";
25 import * as Schedule from "effect/Schedule";
26 import * as Stream from "effect/Stream";
27 import * as pathe from "pathe";
28 import { cloneFixture } from "../../Cloudflare/Utils/Fixture.ts";
29
30 const { test } = Test.make({
31 providers: Layer.mergeAll(Prisma.providers(), Cloudflare.providers()),
32 });
33
34 const ZONE = "alchemy-test-2.us";
35 const HOSTNAME = `prisma-dns.${ZONE}`;
36 const MARKER = "StaticSite fixture v1";
37
38 const fixtureDir = pathe.resolve(
39 import.meta.dirname,
40 "../../Cloudflare/Website/staticsite-fixture",
41 );
42 const tempRoot = pathe.resolve(import.meta.dirname, "../../../.tmp");
43
44 class CnameNotPublished extends Data.TaggedError("CnameNotPublished")<{
45 readonly server: string;
46 readonly name: string;
47 }> {}
48
49 class DomainNotActive extends Data.TaggedError("DomainNotActive")<{
50 readonly status: string;
51 readonly foundryStatus: string;
52 readonly failureReason: string | null;
53 }> {}
54
55 class SiteNotServing extends Data.TaggedError("SiteNotServing")<{
56 readonly status: number;
57 }> {}
58
59 const trimDot = (value: string) => value.replace(/\.$/, "").toLowerCase();
60
61 const resolveZoneId = Effect.gen(function* () {
62 const { accountId } = yield* yield* CloudflareEnvironment;
63 const zone = yield* findZoneByName({ accountId, name: ZONE });
64 if (!zone) {
65 return yield* Effect.die(new Error(`zone "${ZONE}" not found`));
66 }
67 return zone.id;
68 });
69
70 /** Every Cloudflare record at or below the hostname. */
71 const recordsUnder = (zoneId: string) =>
72 dns.listRecords.items({ zoneId, name: { endswith: HOSTNAME } }).pipe(
73 Stream.runCollect,
74 Effect.map((chunk) =>
75 Array.from(chunk).filter(
76 (record) =>
77 trimDot(record.name) === HOSTNAME || trimDot(record.name).endsWith(`.${HOSTNAME}`),
78 ),
79 ),
80 );
81
82 const byKey = <T extends { name: string; type: string; value: string }>(
83 records: ReadonlyArray<T>,
84 ) =>
85 [...records].sort((a, b) =>
86 `${a.name}|${a.type}|${a.value}`.localeCompare(`${b.name}|${b.type}|${b.value}`),
87 );
88
89 /** Wait until every authoritative nameserver of the zone answers each CNAME. */
90 const waitForAuthoritativeCnames = (records: ReadonlyArray<{ name: string; value: string }>) =>
91 Effect.gen(function* () {
92 const nameServers = yield* Effect.tryPromise(() => resolveNs(ZONE)).pipe(Effect.orDie);
93 const servers = (yield* Effect.forEach(nameServers, (ns) =>
94 Effect.tryPromise(() => resolve4(ns)).pipe(Effect.orDie),
95 )).flat();
96 yield* Effect.forEach(servers, (server) =>
97 Effect.forEach(records, (record) =>
98 Effect.gen(function* () {
99 const resolver = yield* Effect.sync(() => {
100 const r = new Resolver();
101 r.setServers([server]);
102 return r;
103 });
104 const answers = yield* Effect.tryPromise(() => resolver.resolveCname(record.name)).pipe(
105 Effect.orElseSucceed(() => [] as string[]),
106 );
107 if (!answers.some((answer) => trimDot(answer) === trimDot(record.value))) {
108 return yield* Effect.fail(new CnameNotPublished({ server, name: record.name }));
109 }
110 }).pipe(Effect.retry({ schedule: Schedule.spaced("3 seconds"), times: 20 })),
111 ),
112 );
113 });
114
115 test.provider.skipIf(process.env.ALCHEMY_RUN_LIVE_PRISMA_TESTS !== "true")(
116 "Cloudflare DNS publishes Prisma's records; the hostname activates and serves HTTPS",
117 (stack) =>
118 Effect.gen(function* () {
119 yield* stack.destroy();
120 const zoneId = yield* resolveZoneId;
121 const cwd = yield* cloneFixture(fixtureDir, {
122 prefix: "alchemy-prisma-dns-",
123 tempRoot,
124 entries: ["src", "build.sh"],
125 });
126
127 const site = yield* stack.deploy(
128 Prisma.Website.StaticSite("Site", {
129 cwd,
130 command: "bash build.sh",
131 shell: true,
132 outdir: "dist",
133 domain: { name: HOSTNAME, dns: Cloudflare.DNS.Adapter() },
134 }),
135 );
136 expect(site.url).toBe(`https://${HOSTNAME}`);
137 const domain = site.domain!;
138 const projectId = typeof site.project === "string" ? site.project : site.project!.projectId;
139 expect(domain.hostname).toBe(HOSTNAME);
140 expect(domain.appId).toBe(site.compute!.appId);
141 // The routing CNAME to the app's regional switchboard, published
142 // before Prisma registered (and verified) the hostname.
143 expect(
144 domain.dnsRecords.some(
145 (record) =>
146 record.type === "CNAME" &&
147 trimDot(record.name) === HOSTNAME &&
148 /^switchboard\.[a-z0-9-]+\.prisma\.build$/.test(trimDot(record.value)),
149 ),
150 ).toBe(true);
151
152 // Cloudflare holds exactly the records the CustomDomain reports, DNS-only.
153 const records = yield* recordsUnder(zoneId);
154 expect(
155 byKey(
156 records.map((record) => ({
157 name: trimDot(record.name),
158 type: record.type,
159 value: trimDot(record.content ?? ""),
160 })),
161 ),
162 ).toEqual(
163 byKey(
164 domain.dnsRecords.map((record) => ({
165 name: trimDot(record.name),
166 type: record.type,
167 value: trimDot(record.value),
168 })),
169 ),
170 );
171 expect(records.every((record) => record.proxied !== true)).toBe(true);
172
173 // ...and those are the records Prisma's live API reports.
174 const registered = yield* getDomain({ domainId: domain.customDomainId });
175 expect(registered.data.hostname).toBe(HOSTNAME);
176 expect(
177 byKey(
178 registered.data.dnsRecords.map((record) => ({
179 name: trimDot(record.name),
180 type: record.type,
181 value: trimDot(record.value),
182 })),
183 ),
184 ).toEqual(
185 byKey(
186 domain.dnsRecords.map((record) => ({
187 name: trimDot(record.name),
188 type: record.type,
189 value: trimDot(record.value),
190 })),
191 ),
192 );
193
194 yield* waitForAuthoritativeCnames(domain.dnsRecords);
195
196 const active = yield* getDomain({
197 domainId: domain.customDomainId,
198 }).pipe(
199 Effect.flatMap(({ data }) =>
200 data.status === "active"
201 ? Effect.succeed(data)
202 : Effect.fail(
203 new DomainNotActive({
204 status: data.status,
205 foundryStatus: data.foundryStatus,
206 failureReason: data.failureReason,
207 }),
208 ),
209 ),
210 Effect.tapError((error) => Effect.logInfo("Prisma domain pending", error)),
211 Effect.retry({
212 while: (error) => error._tag === "DomainNotActive",
213 schedule: Schedule.spaced("10 seconds"),
214 times: 30,
215 }),
216 );
217 expect(active.status).toBe("active");
218
219 const client = yield* HttpClient.HttpClient;
220 const body = yield* client.get(`https://${HOSTNAME}/`).pipe(
221 Effect.flatMap(
222 (res): Effect.Effect<string, HttpClientError.HttpClientError | SiteNotServing> =>
223 res.status === 200 ? res.text : Effect.fail(new SiteNotServing({ status: res.status })),
224 ),
225 Effect.timeout("10 seconds"),
226 Effect.tapError((error) =>
227 Effect.logInfo(
228 `https://${HOSTNAME} not serving yet: ${error._tag === "SiteNotServing" ? `HTTP ${error.status}` : error.message}`,
229 ),
230 ),
231 Effect.retry({ schedule: Schedule.spaced("10 seconds"), times: 30 }),
232 );
233 expect(body).toContain(MARKER);
234
235 yield* stack.destroy();
236
237 expect(yield* recordsUnder(zoneId)).toEqual([]);
238 expect(
239 yield* getDomain({ domainId: domain.customDomainId }).pipe(
240 Effect.as("found" as const),
241 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
242 ),
243 ).toBe("gone");
244 expect(
245 yield* getProject({ id: projectId }).pipe(
246 Effect.as("found" as const),
247 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
248 ),
249 ).toBe("gone");
250 }),
251 {
252 tags: [
253 "provider:prisma",
254 "provider:prisma:customdomain",
255 "provider:prisma:website",
256 "provider:cloudflare",
257 "provider:cloudflare:dns",
258 "live",
259 ],
260 timeout: 900_000,
261 },
262 );
263
264 test.provider.skipIf(process.env.ALCHEMY_RUN_LIVE_PRISMA_TESTS !== "true")(
265 "attaches a custom domain to an App on a non-default Branch",
266 (stack) =>
267 Effect.gen(function* () {
268 yield* stack.destroy();
269 const zoneId = yield* resolveZoneId;
270 const hostname = `prisma-preview-${stack.stage.replace(/[^a-z0-9]+/gi, "-").toLowerCase()}.${ZONE}`;
271 const cwd = yield* cloneFixture(fixtureDir, {
272 prefix: "alchemy-prisma-preview-dns-",
273 tempRoot,
274 entries: ["src", "build.sh"],
275 });
276
277 const branchStack = Effect.gen(function* () {
278 const project = yield* Prisma.Project("Project", { createDatabase: false });
279 const branch = yield* Prisma.Branch("Preview", { project, gitName: "preview" });
280 return { project, branch };
281 });
282 // The Branch exists before the site resolves it by git name.
283 yield* stack.deploy(branchStack);
284
285 const deployed = yield* stack.deploy(
286 Effect.gen(function* () {
287 const { project, branch } = yield* branchStack;
288 const site = yield* Prisma.Website.StaticSite("Site", {
289 cwd,
290 command: "bash build.sh",
291 shell: true,
292 outdir: "dist",
293 project,
294 branchGitName: "preview",
295 domain: { name: hostname, dns: Cloudflare.DNS.Adapter() },
296 });
297 return { project, branch, site };
298 }),
299 );
300 const { project, branch, site } = deployed;
301 const domain = site.domain!;
302
303 expect(branch.isDefault).toBe(false);
304 expect(domain.appId).toBe(site.compute!.appId);
305 expect(domain.hostname).toBe(hostname);
306
307 const app = yield* getService({ serviceId: site.compute!.appId });
308 expect(app.data.branchId).toBe(branch.branchId);
309 const registered = yield* getDomain({ domainId: domain.customDomainId });
310 expect(registered.data.appId).toBe(site.compute!.appId);
311 expect(trimDot(registered.data.hostname)).toBe(hostname);
312
313 yield* stack.destroy();
314
315 expect(
316 yield* getDomain({ domainId: domain.customDomainId }).pipe(
317 Effect.as("found" as const),
318 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
319 ),
320 ).toBe("gone");
321 expect(
322 yield* getProject({ id: project.projectId }).pipe(
323 Effect.as("found" as const),
324 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
325 ),
326 ).toBe("gone");
327 const leftover = yield* dns.listRecords
328 .items({ zoneId, name: { exact: hostname } })
329 .pipe(Stream.runCollect);
330 expect(Array.from(leftover)).toEqual([]);
331 }),
332 {
333 tags: [
334 "provider:prisma",
335 "provider:prisma:customdomain",
336 "provider:prisma:branch",
337 "provider:prisma:website",
338 "provider:cloudflare",
339 "provider:cloudflare:dns",
340 "live",
341 ],
342 timeout: 900_000,
343 },
344 );