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

main
ts 452 lines 16.7 KB
Raw
1 import * as Prisma from "@alchemy.run/prisma";
2 import { expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import {
5 getBranch,
6 getDatabase,
7 getProject,
8 getProjectBranches,
9 updateDatabase,
10 } from "@distilled.cloud/prisma/management";
11 import { adopt, OwnedBySomeoneElse } from "alchemy/AdoptPolicy";
12 import * as Effect from "effect/Effect";
13 import * as Schedule from "effect/Schedule";
14 import { failureOf, forgetState, markCreating, patchStateAttr } from "./fixtures/Live.ts";
15
16 const { test } = Test.make({ providers: Prisma.providers() });
17
18 const expectDatabase = Effect.fn(function* (
19 database: Prisma.Database["Attributes"],
20 branchId: string,
21 ) {
22 const observed = yield* getDatabase({ databaseId: database.databaseId });
23 expect(observed.data.id).toBe(database.databaseId);
24 expect(observed.data.project.id).toBe(database.projectId);
25 expect(observed.data.name).toBe(database.databaseName);
26 expect(observed.data.branchId).toBe(branchId);
27 expect(database.branchId).toBe(branchId);
28 });
29
30 const expectGone = <E, R>(read: Effect.Effect<boolean, E, R>) =>
31 read.pipe(
32 Effect.repeat({
33 schedule: Schedule.spaced("1 second"),
34 times: 8,
35 until: (gone) => gone,
36 }),
37 Effect.tap((gone) => Effect.sync(() => expect(gone).toBe(true))),
38 );
39
40 const expectDatabaseGone = (databaseId: string) =>
41 expectGone(
42 getDatabase({ databaseId }).pipe(
43 Effect.as(false),
44 Effect.catchTag("NotFound", () => Effect.succeed(true)),
45 ),
46 );
47
48 const expectBranchGone = (branchId: string) =>
49 expectGone(
50 getBranch({ branchId }).pipe(
51 Effect.as(false),
52 Effect.catchTag("NotFound", () => Effect.succeed(true)),
53 ),
54 );
55
56 const expectProjectGone = (id: string) =>
57 expectGone(
58 getProject({ id }).pipe(
59 Effect.as(false),
60 Effect.catchTag("NotFound", () => Effect.succeed(true)),
61 ),
62 );
63
64 test.provider(
65 "attaches named and generated databases to the default branch and preserves it on updates",
66 Effect.fn(function* (stack: Test.ScratchStack) {
67 yield* stack.destroy();
68
69 const resources = (updated = false) =>
70 Effect.gen(function* () {
71 const project = yield* Prisma.Project("Project", {
72 createDatabase: false,
73 });
74 const generated = yield* Prisma.Database("Generated", {
75 project,
76 name: updated ? "generated-updated" : undefined,
77 });
78 const named = yield* Prisma.Database("Named", {
79 project,
80 name: updated ? "named-updated" : "named-database",
81 });
82 return { project, generated, named };
83 });
84
85 const initial = yield* stack.deploy(resources());
86 const branches = yield* getProjectBranches({
87 projectId: initial.project.projectId,
88 });
89 const defaults = branches.data.filter((branch) => branch.isDefault);
90 expect(defaults).toHaveLength(1);
91 const defaultBranch = defaults[0]!;
92 yield* expectDatabase(initial.generated, defaultBranch.id);
93 yield* expectDatabase(initial.named, defaultBranch.id);
94
95 const updated = yield* stack.deploy(resources(true));
96 expect(updated.generated.databaseId).toBe(initial.generated.databaseId);
97 expect(updated.named.databaseId).toBe(initial.named.databaseId);
98 expect(updated.generated.databaseName).toBe("generated-updated");
99 expect(updated.named.databaseName).toBe("named-updated");
100 yield* expectDatabase(updated.generated, defaultBranch.id);
101 yield* expectDatabase(updated.named, defaultBranch.id);
102
103 const repeated = yield* stack.deploy(resources(true));
104 expect(repeated.generated.databaseId).toBe(initial.generated.databaseId);
105 expect(repeated.named.databaseId).toBe(initial.named.databaseId);
106 yield* expectDatabase(repeated.generated, defaultBranch.id);
107 yield* expectDatabase(repeated.named, defaultBranch.id);
108
109 yield* stack.destroy();
110 yield* expectDatabaseGone(initial.generated.databaseId);
111 yield* expectDatabaseGone(initial.named.databaseId);
112 yield* expectProjectGone(initial.project.projectId);
113 }),
114 {
115 tags: ["provider:prisma", "provider:prisma:database", "provider:prisma:project", "live"],
116 timeout: 120_000,
117 },
118 );
119
120 test.provider(
121 "preserves a non-default branch when explicit branch props are removed or the attachment changes out of band",
122 Effect.fn(function* (stack: Test.ScratchStack) {
123 yield* stack.destroy();
124
125 const resources = (attachment: "id" | "gitName" | "omitted", name?: string) =>
126 Effect.gen(function* () {
127 const project = yield* Prisma.Project("Project", {
128 createDatabase: false,
129 });
130 const first = yield* Prisma.Branch("First", {
131 project,
132 gitName: "feature/first",
133 });
134 const second = yield* Prisma.Branch("Second", {
135 project,
136 gitName: "feature/second",
137 });
138 const database = yield* Prisma.Database("Database", {
139 project,
140 name,
141 ...(attachment === "id"
142 ? { branchId: first.branchId }
143 : attachment === "gitName"
144 ? { branchGitName: second.gitName }
145 : {}),
146 });
147 return { project, first, second, database };
148 });
149
150 const initial = yield* stack.deploy(resources("id"));
151 expect(initial.first.isDefault).toBe(false);
152 expect(initial.second.isDefault).toBe(false);
153 yield* expectDatabase(initial.database, initial.first.branchId);
154
155 const byName = yield* stack.deploy(resources("gitName"));
156 expect(byName.database.databaseId).toBe(initial.database.databaseId);
157 yield* expectDatabase(byName.database, initial.second.branchId);
158
159 const omitted = yield* stack.deploy(resources("omitted", "renamed"));
160 expect(omitted.database.databaseId).toBe(initial.database.databaseId);
161 expect(omitted.database.databaseName).toBe("renamed");
162 yield* expectDatabase(omitted.database, initial.second.branchId);
163
164 yield* updateDatabase({
165 databaseId: initial.database.databaseId,
166 branchId: initial.first.branchId,
167 });
168 const drifted = yield* stack.deploy(resources("omitted", "renamed-again"));
169 expect(drifted.database.databaseId).toBe(initial.database.databaseId);
170 expect(drifted.database.databaseName).toBe("renamed-again");
171 yield* expectDatabase(drifted.database, initial.first.branchId);
172
173 const explicit = yield* stack.deploy(resources("gitName", "renamed-again"));
174 expect(explicit.database.databaseId).toBe(initial.database.databaseId);
175 yield* expectDatabase(explicit.database, initial.second.branchId);
176
177 yield* stack.destroy();
178 yield* expectDatabaseGone(initial.database.databaseId);
179 yield* expectBranchGone(initial.first.branchId);
180 yield* expectBranchGone(initial.second.branchId);
181 yield* expectProjectGone(initial.project.projectId);
182 }),
183 {
184 tags: [
185 "provider:prisma",
186 "provider:prisma:branch",
187 "provider:prisma:database",
188 "provider:prisma:project",
189 "live",
190 ],
191 timeout: 120_000,
192 },
193 );
194
195 const logicalIdTags = [
196 "provider:prisma",
197 "provider:prisma:database",
198 "provider:prisma:project",
199 "live",
200 ];
201
202 const observeDatabase = (databaseId: string) =>
203 getDatabase({ databaseId }).pipe(Effect.map((response) => response.data));
204
205 const databaseStack = (props: { name?: string; logicalId?: string } = {}) =>
206 Effect.gen(function* () {
207 const project = yield* Prisma.Project("Project", { createDatabase: false });
208 const database = yield* Prisma.Database("Main", { project, ...props });
209 return { project, database };
210 });
211
212 test.provider(
213 "an explicitly named database moves region by replacing itself delete-first",
214 Effect.fn(function* (stack: Test.ScratchStack) {
215 yield* stack.destroy();
216
217 const regional = (region: "us-east-1" | "eu-central-1") =>
218 Effect.gen(function* () {
219 const project = yield* Prisma.Project("Project", { createDatabase: false });
220 const database = yield* Prisma.Database("Regional", {
221 project,
222 name: "regional",
223 region,
224 });
225 return { project, database };
226 });
227
228 const initial = yield* stack.deploy(regional("us-east-1"));
229 expect((yield* observeDatabase(initial.database.databaseId)).region?.id).toBe("us-east-1");
230
231 // The replacement reuses the explicit name, so the old database goes first.
232 const moved = yield* stack.deploy(regional("eu-central-1"));
233 expect(moved.database.databaseId).not.toBe(initial.database.databaseId);
234 expect(moved.database.databaseName).toBe("regional");
235 expect((yield* observeDatabase(moved.database.databaseId)).region?.id).toBe("eu-central-1");
236 yield* expectDatabaseGone(initial.database.databaseId);
237
238 yield* stack.destroy();
239 yield* expectDatabaseGone(moved.database.databaseId);
240 yield* expectProjectGone(moved.project.projectId);
241 }),
242 { tags: logicalIdTags, timeout: 180_000 },
243 );
244
245 test.provider(
246 "creates a database under its fqn logical ID and rebinds the logical ID in place",
247 Effect.fn(function* (stack: Test.ScratchStack) {
248 yield* stack.destroy();
249
250 const initial = yield* stack.deploy(databaseStack());
251 expect(initial.database.logicalId).toBe("Main");
252 expect((yield* observeDatabase(initial.database.databaseId)).logicalId).toBe("Main");
253
254 const overridden = yield* stack.deploy(databaseStack({ logicalId: "main-db" }));
255 expect(overridden.database.databaseId).toBe(initial.database.databaseId);
256 expect((yield* observeDatabase(initial.database.databaseId)).logicalId).toBe("main-db");
257
258 const reverted = yield* stack.deploy(databaseStack());
259 expect(reverted.database.databaseId).toBe(initial.database.databaseId);
260 expect((yield* observeDatabase(initial.database.databaseId)).logicalId).toBe("Main");
261
262 yield* stack.destroy();
263 yield* expectDatabaseGone(initial.database.databaseId);
264 yield* expectProjectGone(initial.project.projectId);
265 }),
266 { tags: logicalIdTags, timeout: 180_000 },
267 );
268
269 test.provider(
270 "after lost state, adoption finds the database by its logical ID despite a Console rename",
271 Effect.fn(function* (stack: Test.ScratchStack) {
272 yield* stack.destroy();
273
274 const initial = yield* stack.deploy(databaseStack({ name: "main-db" }));
275 yield* updateDatabase({ databaseId: initial.database.databaseId, name: "renamed-in-console" });
276 yield* forgetState(stack, "Main");
277
278 const refused = yield* failureOf(stack.deploy(databaseStack({ name: "main-db" })));
279 expect(refused.errors.some((error) => error instanceof OwnedBySomeoneElse)).toBe(true);
280
281 const adopted = yield* stack.deploy(
282 Effect.gen(function* () {
283 const project = yield* Prisma.Project("Project", { createDatabase: false });
284 const database = yield* Prisma.Database("Main", { project, name: "main-db" }).pipe(
285 adopt(true),
286 );
287 return { project, database };
288 }),
289 );
290 expect(adopted.database.databaseId).toBe(initial.database.databaseId);
291 const observed = yield* observeDatabase(initial.database.databaseId);
292 expect(observed.name).toBe("main-db");
293 expect(observed.logicalId).toBe("Main");
294
295 yield* stack.destroy();
296 yield* expectDatabaseGone(initial.database.databaseId);
297 yield* expectProjectGone(initial.project.projectId);
298 }),
299 { tags: logicalIdTags, timeout: 180_000 },
300 );
301
302 test.provider(
303 "recovers an interrupted database create as owned",
304 Effect.fn(function* (stack: Test.ScratchStack) {
305 yield* stack.destroy();
306
307 const initial = yield* stack.deploy(databaseStack());
308 yield* markCreating(stack, "Main");
309
310 const recovered = yield* stack.deploy(databaseStack());
311 expect(recovered.database.databaseId).toBe(initial.database.databaseId);
312 expect((yield* observeDatabase(initial.database.databaseId)).logicalId).toBe("Main");
313
314 yield* stack.destroy();
315 yield* expectDatabaseGone(initial.database.databaseId);
316 yield* expectProjectGone(initial.project.projectId);
317 }),
318 { tags: logicalIdTags, timeout: 180_000 },
319 );
320
321 test.provider(
322 "sets the logical ID on a database deployed before logical IDs existed",
323 Effect.fn(function* (stack: Test.ScratchStack) {
324 yield* stack.destroy();
325
326 const initial = yield* stack.deploy(databaseStack());
327 yield* updateDatabase({ databaseId: initial.database.databaseId, logicalId: null });
328 yield* patchStateAttr(stack, "Main", { logicalId: null });
329 expect((yield* observeDatabase(initial.database.databaseId)).logicalId).toBeNull();
330
331 const stamped = yield* stack.deploy(databaseStack());
332 expect(stamped.database.databaseId).toBe(initial.database.databaseId);
333 expect((yield* observeDatabase(initial.database.databaseId)).logicalId).toBe("Main");
334
335 yield* stack.destroy();
336 yield* expectDatabaseGone(initial.database.databaseId);
337 yield* expectProjectGone(initial.project.projectId);
338 }),
339 { tags: logicalIdTags, timeout: 180_000 },
340 );
341
342 test.provider(
343 "creates a database on a git branch that does not exist yet, then sets its logical ID",
344 Effect.fn(function* (stack: Test.ScratchStack) {
345 yield* stack.destroy();
346
347 const resources = Effect.gen(function* () {
348 const project = yield* Prisma.Project("Project", { createDatabase: false });
349 const database = yield* Prisma.Database("Preview", {
350 project,
351 branchGitName: "feature/preview",
352 });
353 return { project, database };
354 });
355
356 const initial = yield* stack.deploy(resources);
357 const branches = yield* getProjectBranches({
358 projectId: initial.project.projectId,
359 gitName: "feature/preview",
360 });
361 expect(branches.data).toHaveLength(1);
362 const observed = yield* observeDatabase(initial.database.databaseId);
363 expect(observed.branchId).toBe(branches.data[0]!.id);
364 expect(observed.logicalId).toBe("Preview");
365
366 const repeated = yield* stack.deploy(resources);
367 expect(repeated.database.databaseId).toBe(initial.database.databaseId);
368
369 yield* stack.destroy();
370 yield* expectDatabaseGone(initial.database.databaseId);
371 yield* expectProjectGone(initial.project.projectId);
372 }),
373 { tags: logicalIdTags, timeout: 180_000 },
374 );
375
376 test.provider(
377 "rejects a logical ID that another database on the branch holds",
378 Effect.fn(function* (stack: Test.ScratchStack) {
379 yield* stack.destroy();
380
381 const resources = (secondLogicalId: string) =>
382 Effect.gen(function* () {
383 const project = yield* Prisma.Project("Project", { createDatabase: false });
384 const first = yield* Prisma.Database("First", { project, logicalId: "shared" });
385 const second = yield* Prisma.Database("Second", { project, logicalId: secondLogicalId });
386 return { project, first, second };
387 });
388
389 const initial = yield* stack.deploy(resources("second"));
390 const failure = yield* failureOf(stack.deploy(resources("shared")));
391 expect(failure.text).toContain("logical ID 'shared'");
392 expect((yield* observeDatabase(initial.first.databaseId)).logicalId).toBe("shared");
393
394 yield* stack.destroy();
395 yield* expectDatabaseGone(initial.first.databaseId);
396 yield* expectDatabaseGone(initial.second.databaseId);
397 yield* expectProjectGone(initial.project.projectId);
398 }),
399 { tags: logicalIdTags, timeout: 180_000 },
400 );
401
402 test.provider(
403 "region inherit uses the project default region when the project has no default database",
404 Effect.fn(function* (stack: Test.ScratchStack) {
405 yield* stack.destroy();
406
407 const resources = Effect.gen(function* () {
408 const project = yield* Prisma.Project("Project", {
409 createDatabase: false,
410 region: "eu-central-1",
411 });
412 const database = yield* Prisma.Database("Inherited", { project, region: "inherit" });
413 return { project, database };
414 });
415
416 const initial = yield* stack.deploy(resources);
417 expect((yield* getProject({ id: initial.project.projectId })).data.defaultRegion).toBe(
418 "eu-central-1",
419 );
420 expect(initial.database.region).toBe("eu-central-1");
421 expect((yield* observeDatabase(initial.database.databaseId)).region?.id).toBe("eu-central-1");
422
423 const repeated = yield* stack.deploy(resources);
424 expect(repeated.database.databaseId).toBe(initial.database.databaseId);
425
426 yield* stack.destroy();
427 yield* expectDatabaseGone(initial.database.databaseId);
428 yield* expectProjectGone(initial.project.projectId);
429 }),
430 { tags: logicalIdTags, timeout: 180_000 },
431 );
432
433 test.provider(
434 "region inherit fails before creating anything when the project has no region",
435 Effect.fn(function* (stack: Test.ScratchStack) {
436 yield* stack.destroy();
437
438 const failure = yield* failureOf(
439 stack.deploy(
440 Effect.gen(function* () {
441 const project = yield* Prisma.Project("Project", { createDatabase: false });
442 const database = yield* Prisma.Database("Inherited", { project, region: "inherit" });
443 return { project, database };
444 }),
445 ),
446 );
447 expect(failure.text).toContain("has no default region and no default database region");
448
449 yield* stack.destroy();
450 }),
451 { tags: logicalIdTags, timeout: 180_000 },
452 );