@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 209 lines 8.76 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as pages from "@distilled.cloud/cloudflare/pages";
6 import { adopt } from "alchemy/AdoptPolicy";
7 import * as Provider from "alchemy/Provider";
8 import * as Effect from "effect/Effect";
9 import { MinimumLogLevel } from "effect/References";
10 import * as Schedule from "effect/Schedule";
11 import { testName } from "../../names.ts";
12
13 const { test } = Test.make({ providers: Cloudflare.providers() });
14
15 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
16
17 // Deterministic project name (never derived from Date.now() or randomness).
18 // Project names form globally-unique *.pages.dev subdomains, so it carries
19 // an alchemy-e3 prefix to avoid collisions.
20 const PROJECT_NAME = testName("alchemy-e3-pages-deployment");
21
22 // Separate project for the `list` suite so the two tests never contend for
23 // the same deterministically-named project.
24 const LIST_PROJECT_NAME = testName("alchemy-e3-pages-deploy-list");
25
26 // The scoped API token the test harness mints propagates eventually-
27 // consistently across Cloudflare's edge — ride out 403 blips (`Forbidden`,
28 // declared in the distilled error union) on the test's own out-of-band
29 // verification calls.
30 const getDeployment = (accountId: string, projectName: string, deploymentId: string) =>
31 pages.getProjectDeployment({ accountId, projectName, deploymentId }).pipe(
32 Effect.retry({
33 while: (e) => e._tag === "Forbidden",
34 schedule: Schedule.exponential("500 millis"),
35 times: 8,
36 }),
37 );
38
39 const expectDeploymentGone = (accountId: string, projectName: string, deploymentId: string) =>
40 getDeployment(accountId, projectName, deploymentId).pipe(
41 Effect.flatMap(() => Effect.fail({ _tag: "DeploymentNotDeleted" } as const)),
42 // A missing deployment surfaces as `DeploymentNotFound` (Cloudflare
43 // error code 8000009) — that's the success condition here. A missing
44 // project (cascade delete) also counts.
45 Effect.catchTag("DeploymentNotFound", () => Effect.void),
46 Effect.catchTag("ProjectNotFound", () => Effect.void),
47 Effect.retry({
48 while: (e) => e._tag === "DeploymentNotDeleted",
49 schedule: Schedule.max([Schedule.exponential("500 millis"), Schedule.recurs(10)]),
50 }),
51 );
52
53 const expectProjectGone = (accountId: string, projectName: string) =>
54 pages.getProject({ accountId, projectName }).pipe(
55 Effect.flatMap(() => Effect.fail({ _tag: "ProjectNotDeleted" } as const)),
56 Effect.catchTag("ProjectNotFound", () => Effect.void),
57 Effect.retry({
58 while: (e) => e._tag === "ProjectNotDeleted" || e._tag === "Forbidden",
59 schedule: Schedule.max([Schedule.exponential("500 millis"), Schedule.recurs(10)]),
60 }),
61 );
62
63 // Purge leftovers from interrupted runs so the deterministically-named
64 // project starts from a clean slate (deleting the project deletes all of
65 // its deployments).
66 const purgeProject = (accountId: string, projectName: string) =>
67 pages.deleteProject({ accountId, projectName }).pipe(
68 Effect.catchTag("ProjectNotFound", () => Effect.void),
69 Effect.retry({
70 while: (e) => e._tag === "Forbidden",
71 schedule: Schedule.exponential("500 millis"),
72 times: 8,
73 }),
74 );
75
76 test.provider(
77 "create, replace on branch change, and destroy a deployment",
78 (stack) =>
79 Effect.gen(function* () {
80 const { accountId } = yield* yield* CloudflareEnvironment;
81
82 yield* stack.destroy();
83 yield* purgeProject(accountId, PROJECT_NAME);
84
85 const makeStack = (branch?: string) =>
86 Effect.gen(function* () {
87 const project = yield* Cloudflare.Pages.Project("DeployProject", {
88 name: PROJECT_NAME,
89 }).pipe(adopt(true));
90 const deployment = yield* Cloudflare.Pages.Deployment("Deployment", {
91 projectName: project.name,
92 ...(branch === undefined ? {} : { branch }),
93 });
94 return { deployment };
95 });
96
97 // 1. Create — no branch means the project's production branch, so
98 // this is the project's first production deployment.
99 const initial = (yield* stack.deploy(makeStack())).deployment;
100
101 expect(initial.deploymentId).toBeDefined();
102 expect(initial.accountId).toEqual(accountId);
103 expect(initial.projectName).toEqual(PROJECT_NAME);
104 expect(initial.environment).toEqual("production");
105 expect(initial.branch).toEqual("main");
106 expect(initial.url).toContain(`${PROJECT_NAME}.pages.dev`);
107 expect(initial.latestStageName).toEqual("deploy");
108 expect(initial.latestStageStatus).toEqual("success");
109
110 const live = yield* getDeployment(accountId, PROJECT_NAME, initial.deploymentId);
111 expect(live.id).toEqual(initial.deploymentId);
112 expect(live.environment).toEqual("production");
113
114 // 2. Redeploying identical props is a no-op — same deployment.
115 const noop = (yield* stack.deploy(makeStack())).deployment;
116 expect(noop.deploymentId).toEqual(initial.deploymentId);
117
118 // 3. Deployments are immutable — changing the branch replaces the
119 // deployment with a new (preview) one.
120 const preview1 = (yield* stack.deploy(makeStack("preview-1"))).deployment;
121 expect(preview1.deploymentId).not.toEqual(initial.deploymentId);
122 expect(preview1.environment).toEqual("preview");
123 expect(preview1.branch).toEqual("preview-1");
124
125 // The replaced deployment was the project's active production
126 // deployment, which Cloudflare refuses to delete — the provider
127 // tolerates that, so it must still exist.
128 const stillLive = yield* getDeployment(accountId, PROJECT_NAME, initial.deploymentId);
129 expect(stillLive.id).toEqual(initial.deploymentId);
130
131 // 4. Replacing a preview deployment force-deletes the old one.
132 const preview2 = (yield* stack.deploy(makeStack("preview-2"))).deployment;
133 expect(preview2.deploymentId).not.toEqual(preview1.deploymentId);
134 expect(preview2.branch).toEqual("preview-2");
135
136 yield* expectDeploymentGone(accountId, PROJECT_NAME, preview1.deploymentId);
137
138 // 5. Destroy — the preview deployment is force-deleted, then the
139 // project (and with it the remaining production deployment) goes.
140 yield* stack.destroy();
141
142 yield* expectProjectGone(accountId, PROJECT_NAME);
143 }).pipe(logLevel),
144 {
145 tags: ["provider:cloudflare", "provider:cloudflare:pages", "live"],
146 timeout: 120_000,
147 },
148 );
149
150 // `list()` fans out over `pages.listProjects` → per-project
151 // `pages.listProjectDeployments`.
152 test.provider(
153 "list enumerates deployments across Pages projects",
154 (stack) =>
155 Effect.gen(function* () {
156 const { accountId } = yield* yield* CloudflareEnvironment;
157
158 yield* stack.destroy();
159 yield* purgeProject(accountId, LIST_PROJECT_NAME);
160
161 yield* Effect.gen(function* () {
162 const deployed = (yield* stack.deploy(
163 Effect.gen(function* () {
164 const project = yield* Cloudflare.Pages.Project("ListDeployProject", {
165 name: LIST_PROJECT_NAME,
166 }).pipe(adopt(true));
167 const deployment = yield* Cloudflare.Pages.Deployment("ListDeployment", {
168 projectName: project.name,
169 });
170 return { deployment };
171 }),
172 )).deployment;
173
174 const provider = yield* Provider.findProvider(Cloudflare.Pages.Deployment);
175 // The deployment fans out across all account projects; ride out edge
176 // propagation of the freshly-created project before asserting presence.
177 const all = yield* provider.list().pipe(
178 Effect.flatMap((rows) =>
179 rows.some((d) => d.deploymentId === deployed.deploymentId)
180 ? Effect.succeed(rows)
181 : Effect.fail({ _tag: "DeploymentNotListedYet" } as const),
182 ),
183 Effect.retry({
184 while: (e) => e._tag === "DeploymentNotListedYet",
185 schedule: Schedule.max([Schedule.exponential("500 millis"), Schedule.recurs(8)]),
186 }),
187 );
188
189 const found = all.find((d) => d.deploymentId === deployed.deploymentId);
190 expect(found).toBeDefined();
191 expect(found?.accountId).toEqual(accountId);
192 expect(found?.projectName).toEqual(LIST_PROJECT_NAME);
193 expect(found?.url).toEqual(deployed.url);
194 expect(found?.shortId).toEqual(deployed.shortId);
195 }).pipe(
196 Effect.ensuring(
197 stack
198 .destroy()
199 .pipe(Effect.andThen(purgeProject(accountId, LIST_PROJECT_NAME)), Effect.ignore),
200 ),
201 );
202
203 yield* expectProjectGone(accountId, LIST_PROJECT_NAME);
204 }).pipe(logLevel),
205 {
206 tags: ["provider:cloudflare", "provider:cloudflare:pages", "live"],
207 timeout: 120_000,
208 },
209 );