@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 5,346 lines 184 KB
Raw
1 import { App as PrismaApp, AppProvider } from "@alchemy.run/prisma/App";
2 import { Branch as PrismaBranch, BranchProvider } from "@alchemy.run/prisma/Branch";
3 import {
4 PrismaApiError,
5 PrismaClient,
6 type DatabaseCreateResult,
7 } from "@alchemy.run/prisma/Client";
8 import type { PrismaManagementClient } from "@alchemy.run/prisma/Client";
9 import { Compute as PrismaCompute } from "@alchemy.run/prisma/Compute";
10 import { Connect, ConnectBinding, connectEnvKeys } from "@alchemy.run/prisma/Connect";
11 import { Connection as PrismaConnection, ConnectionProvider } from "@alchemy.run/prisma/Connection";
12 import {
13 CustomDomain as PrismaCustomDomain,
14 CustomDomainProvider,
15 } from "@alchemy.run/prisma/CustomDomain";
16 import { Database as PrismaDatabase, DatabaseProvider } from "@alchemy.run/prisma/Database";
17 import { Deployment as PrismaDeployment, DeploymentProvider } from "@alchemy.run/prisma/Deployment";
18 import {
19 EnvironmentVariable as PrismaEnvironmentVariable,
20 EnvironmentVariableProvider,
21 } from "@alchemy.run/prisma/EnvironmentVariable";
22 import { Project as PrismaProject, ProjectProvider } from "@alchemy.run/prisma/Project";
23 import { Providers as PrismaProviderCollection } from "@alchemy.run/prisma/Providers";
24 import {
25 SourceRepository as PrismaSourceRepository,
26 SourceRepositoryProvider,
27 } from "@alchemy.run/prisma/SourceRepository";
28 import type { Database as ApiDatabase } from "@alchemy.run/prisma/Types";
29 import { describe, expect, it } from "@alchemy.run/test";
30 import { Unowned } from "alchemy/AdoptPolicy";
31 import { AlchemyContext } from "alchemy/AlchemyContext";
32 import * as Output from "alchemy/Output";
33 import * as Provider from "alchemy/Provider";
34 import { ResourceContext } from "alchemy/ResourceContext";
35 import { RuntimeContext } from "alchemy/RuntimeContext";
36 import { Stack, type StackSpec } from "alchemy/Stack";
37 import { Stage } from "alchemy/Stage";
38 import { inMemoryState } from "alchemy/State/InMemoryState";
39 import { PlatformServices } from "alchemy/Util/PlatformServices";
40 import * as ConfigProvider from "effect/ConfigProvider";
41 import * as Effect from "effect/Effect";
42 import * as FetchHttpClient from "effect/http/FetchHttpClient";
43 import * as Layer from "effect/Layer";
44 import * as Redacted from "effect/Redacted";
45 import * as Result from "effect/Result";
46 import { resourceContext } from "../Util/ResourceContext.ts";
47 import {
48 type Captured,
49 conflict,
50 data as envelope,
51 dispatchTo,
52 failure,
53 json,
54 makeFakeManagementApi,
55 notFound,
56 page,
57 routesOf,
58 unhandled,
59 wireConnection,
60 wireCreatedDatabase,
61 wireDatabase,
62 wireProject,
63 } from "./fixtures/FakeManagementApi.ts";
64 import { testStackContext } from "./fixtures/StackContext.ts";
65
66 type Call = [operation: string, input?: unknown];
67 type Equal<A, B> =
68 (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
69 type Expect<T extends true> = T;
70
71 const createdAt = "2026-01-01T00:00:00Z";
72 const updatedAt = "2026-01-01T00:00:01Z";
73
74 const redactedValue = (value: string | Redacted.Redacted<string> | undefined) => {
75 if (!Redacted.isRedacted(value)) {
76 throw new Error("Expected a redacted value");
77 }
78 return Redacted.value(value);
79 };
80
81 const expectJsonNotToContain = (value: unknown, ...secrets: string[]) => {
82 const json = JSON.stringify(value);
83 for (const secret of secrets) {
84 expect(json).not.toContain(secret);
85 }
86 };
87
88 const resourceRef = (kind: string, id: string, name = id) => ({
89 id,
90 url: `https://api.prisma.test/v1/${kind}/${id}`,
91 name,
92 });
93
94 const databaseConnection = (databaseId: string, connectionId = `connection-${databaseId}`) => ({
95 id: connectionId,
96 type: "connection" as const,
97 url: `https://api.prisma.test/v1/connections/${connectionId}`,
98 name: "default",
99 createdAt,
100 kind: "postgres" as const,
101 endpoints: {
102 direct: {
103 host: "db.prisma.test",
104 port: 5432,
105 connectionString: `postgres://user:password@db.prisma.test/${databaseId}`,
106 },
107 },
108 database: resourceRef("databases", databaseId),
109 });
110
111 const makeClient = () => {
112 const calls: Call[] = [];
113 const client = {
114 listProjects: () => {
115 calls.push(["listProjects"]);
116 return Effect.succeed([]);
117 },
118 createProject: (input: unknown) => {
119 calls.push(["createProject", input]);
120 return Effect.succeed({
121 id: "project-1",
122 type: "project",
123 url: "https://api.prisma.test/v1/projects/project-1",
124 name: "app",
125 createdAt,
126 defaultRegion: "us-east-1",
127 workspace: resourceRef("workspaces", "workspace-1", "team"),
128 database: null,
129 });
130 },
131 listProjectDatabases: (projectId: string, query: unknown) => {
132 calls.push(["listProjectDatabases", { projectId, query }]);
133 return Effect.succeed([]);
134 },
135 createDatabase: (input: { logicalId?: string }) => {
136 calls.push(["createDatabase", input]);
137 return Effect.succeed({
138 logicalId: input.logicalId ?? null,
139 id: "database-1",
140 type: "database",
141 url: "https://api.prisma.test/v1/databases/database-1",
142 name: "main",
143 status: "ready",
144 createdAt,
145 isDefault: false,
146 defaultConnectionId: "connection-1",
147 connections: [
148 {
149 id: "connection-1",
150 type: "connection",
151 url: "https://api.prisma.test/v1/connections/connection-1",
152 name: "default",
153 createdAt,
154 kind: "postgres",
155 endpoints: {
156 direct: { host: "db.prisma.test", port: 5432, connectionString: "postgres://direct" },
157 pooled: {
158 host: "pool.prisma.test",
159 port: 5432,
160 connectionString: "postgres://pooled",
161 },
162 },
163 database: resourceRef("databases", "database-1", "main"),
164 },
165 ],
166 project: resourceRef("projects", "project-1", "app"),
167 region: { id: "us-east-1", name: "US East" },
168 source: { type: "empty" },
169 branchId: null,
170 });
171 },
172 listDatabaseConnections: (databaseId: string, query: unknown) => {
173 calls.push(["listDatabaseConnections", { databaseId, query }]);
174 return Effect.succeed([]);
175 },
176 createConnection: (input: unknown) => {
177 calls.push(["createConnection", input]);
178 return Effect.succeed({
179 id: "connection-2",
180 type: "connection",
181 url: "https://api.prisma.test/v1/connections/connection-2",
182 name: "api",
183 createdAt,
184 kind: "postgres",
185 endpoints: {
186 direct: { host: "db.prisma.test", port: 5432, connectionString: "postgres://api-direct" },
187 },
188 database: resourceRef("databases", "database-1", "main"),
189 });
190 },
191 listBranches: (projectId: string, query: unknown) => {
192 calls.push(["listBranches", { projectId, query }]);
193 const gitName = (query as { gitName?: string } | undefined)?.gitName;
194 return Effect.succeed(
195 gitName !== undefined && gitName !== "main"
196 ? []
197 : [
198 {
199 id: "branch-1",
200 type: "branch",
201 url: "https://api.prisma.test/v1/branches/branch-1",
202 gitName: "main",
203 isDefault: true,
204 role: "production",
205 createdAt,
206 updatedAt,
207 project: resourceRef("projects", "project-1", "app"),
208 },
209 ],
210 );
211 },
212 getBranch: (id: string) => {
213 calls.push(["getBranch", id]);
214 return Effect.succeed({
215 id,
216 type: "branch",
217 url: `https://api.prisma.test/v1/branches/${id}`,
218 gitName: "main",
219 isDefault: true,
220 role: "production",
221 createdAt,
222 updatedAt,
223 project: resourceRef("projects", "project-1", "app"),
224 });
225 },
226 createBranch: (projectId: string, input: { gitName: string; isDefault?: boolean }) => {
227 calls.push(["createBranch", { projectId, input }]);
228 return Effect.succeed({
229 id: "branch-2",
230 type: "branch",
231 url: "https://api.prisma.test/v1/branches/branch-2",
232 gitName: input.gitName,
233 isDefault: input.isDefault ?? false,
234 role: "preview",
235 createdAt,
236 updatedAt,
237 project: resourceRef("projects", "project-1", "app"),
238 });
239 },
240 listApps: (query: unknown) => {
241 calls.push(["listApps", query]);
242 return Effect.succeed([]);
243 },
244 createApp: (input: { projectId: string; logicalId?: string }) => {
245 calls.push(["createApp", input]);
246 return Effect.succeed({
247 logicalId: input.logicalId ?? null,
248 id: "service-1",
249 type: "app",
250 url: "https://api.prisma.test/v1/services/service-1",
251 name: "api",
252 region: { id: "us-east-1", name: "US East" },
253 projectId: "project-1",
254 branchId: "branch-1",
255 latestDeploymentId: null,
256 appEndpointDomain: "service-1.prisma.build",
257 createdAt,
258 });
259 },
260 getApp: (id: string) => {
261 calls.push(["getApp", id]);
262 return Effect.succeed({
263 id,
264 type: "app",
265 url: `https://api.prisma.test/v1/services/${id}`,
266 name: "api",
267 region: { id: "us-east-1", name: "US East" },
268 projectId: "project-1",
269 branchId: "branch-1",
270 latestDeploymentId: "version-1",
271 appEndpointDomain: "service-1.prisma.build",
272 createdAt,
273 });
274 },
275 createAppDeployment: (appId: string, input: unknown) => {
276 calls.push(["createAppDeployment", { appId, input }]);
277 return Effect.succeed({
278 id: "version-1",
279 type: "deployment",
280 url: "https://api.prisma.test/v1/deployments/version-1",
281 foundryVersionId: "foundry-1",
282 uploadUrl: null,
283 });
284 },
285 listAppDomains: (appId: string) => {
286 calls.push(["listAppDomains", appId]);
287 return Effect.succeed([]);
288 },
289 createAppDomain: (appId: string, input: { hostname: string }) => {
290 calls.push(["createAppDomain", { appId, input }]);
291 return Effect.succeed({
292 status: 201 as const,
293 domain: {
294 id: "domain-1",
295 type: "custom-domain" as const,
296 url: "https://api.prisma.test/v1/domains/domain-1",
297 hostname: input.hostname,
298 appId: appId,
299 status: "pending_dns" as const,
300 foundryStatus: "pending_dns",
301 failureReason: null,
302 failureCategory: null,
303 certExpiresAt: null,
304 dnsRecords: [
305 {
306 type: "CNAME" as const,
307 name: input.hostname,
308 value: "service-1.prisma.build",
309 ttl: null,
310 },
311 ],
312 createdAt,
313 updatedAt,
314 },
315 });
316 },
317 getDeployment: (id: string) => {
318 calls.push(["getDeployment", id]);
319 return Effect.succeed({
320 id,
321 type: "deployment",
322 serviceId: "service-1",
323 url: `https://api.prisma.test/v1/deployments/${id}`,
324 foundryVersionId: "foundry-1",
325 status: "new",
326 previewDomain: null,
327 createdAt,
328 });
329 },
330 listEnvironmentVariables: (query: unknown) => {
331 calls.push(["listEnvironmentVariables", query]);
332 return Effect.succeed([]);
333 },
334 createEnvironmentVariable: (input: unknown) => {
335 calls.push(["createEnvironmentVariable", input]);
336 return Effect.succeed({
337 id: "env-1",
338 type: "environment-variable",
339 url: "https://api.prisma.test/v1/environment-variables/env-1",
340 projectId: "project-1",
341 branchId: null,
342 class: "production",
343 key: "TOKEN",
344 valueKid: "kid-1",
345 isManagedBySystem: false,
346 createdAt,
347 updatedAt,
348 });
349 },
350 listSourceRepositories: (query: unknown) => {
351 calls.push(["listSourceRepositories", query]);
352 return Effect.succeed([]);
353 },
354 createSourceRepository: (input: unknown) => {
355 calls.push(["createSourceRepository", input]);
356 return Effect.succeed({
357 id: "repo-1",
358 type: "source-repository",
359 url: "https://api.prisma.test/v1/source-repositories/repo-1",
360 repoId: 123,
361 provider: "github",
362 repoFullName: "acme/api",
363 defaultBranch: "main",
364 isPrivate: true,
365 status: "active",
366 projectId: "project-1",
367 installationId: "installation-1",
368 createdAt,
369 updatedAt,
370 });
371 },
372 getSourceRepository: (id: string) => {
373 calls.push(["getSourceRepository", id]);
374 return Effect.succeed({
375 id,
376 type: "source-repository",
377 url: `https://api.prisma.test/v1/source-repositories/${id}`,
378 repoId: 123,
379 provider: "github",
380 repoFullName: "acme/api",
381 defaultBranch: "main",
382 isPrivate: true,
383 status: "active",
384 projectId: "project-1",
385 installationId: "installation-1",
386 createdAt,
387 updatedAt,
388 });
389 },
390 } as unknown as PrismaManagementClient;
391 return { client, calls };
392 };
393
394 const liveProviderContext = Layer.succeed(AlchemyContext, {
395 dotAlchemy: ".alchemy-test",
396 dev: false,
397 adopt: false,
398 });
399
400 /**
401 * Serve the Management API from the same hermetic client-shaped handlers
402 * these suites already declare, for the resources that now call distilled
403 * operations. `dispatchTo` maps each handler's result onto the wire (see the
404 * fixture).
405 */
406 // The logical-ID lookups list these routes before most operations; a suite
407 // that does not declare them sees empty lists.
408 const emptyList = () => Effect.succeed([]);
409
410 const dispatchManagement = (client: any, request: Captured): Response => {
411 {
412 const segments = request.pathname.split("/").filter((s) => s.length > 0);
413 const body = request.bodyJson as any;
414 const { call, callVoid, list } = dispatchTo(request);
415
416 // segments[0] is the "v1" prefix.
417 const [head, id, tail] = segments.slice(1) as [
418 string | undefined,
419 string | undefined,
420 string | undefined,
421 ];
422
423 if (head === "projects") {
424 if (id === undefined) {
425 return request.method === "GET"
426 ? call(client.listProjects, [], list)
427 : call(client.createProject, [body]);
428 }
429 if (tail === "databases") {
430 return request.method === "GET"
431 ? call(client.listProjectDatabases, [id, { limit: 100 }], list)
432 : call(client.createProjectDatabase, [id, body]);
433 }
434 if (tail === "branches") {
435 return request.method === "GET"
436 ? call(
437 client.listBranches ?? emptyList,
438 [id, Object.fromEntries(new URLSearchParams(request.search))],
439 list,
440 )
441 : call(client.createBranch, [id, body]);
442 }
443 if (request.method === "GET") return call(client.getProject, [id]);
444 if (request.method === "PATCH") return call(client.updateProject, [id, body]);
445 if (request.method === "DELETE") {
446 return callVoid(client.deleteProject, [id]);
447 }
448 }
449
450 if (head === "databases") {
451 if (id === undefined) {
452 return request.method === "GET"
453 ? call(
454 client.listDatabases ?? emptyList,
455 [Object.fromEntries(new URLSearchParams(request.search))],
456 list,
457 )
458 : call(client.createDatabase, [body]);
459 }
460 if (tail === "connections") {
461 return request.method === "GET"
462 ? call(client.listDatabaseConnections, [id, { limit: 100 }], list)
463 : call(client.createDatabaseConnection, [id, body]);
464 }
465 if (request.method === "GET") return call(client.getDatabase, [id]);
466 if (request.method === "PATCH") return call(client.updateDatabase, [id, body]);
467 if (request.method === "DELETE") {
468 return callVoid(client.deleteDatabase, [id]);
469 }
470 }
471
472 if (head === "connections") {
473 if (id === undefined) {
474 return request.method === "GET"
475 ? call(client.listConnections, [], list)
476 : call(client.createConnection, [body]);
477 }
478 if (tail === "rotate") return call(client.rotateConnection, [id]);
479 if (request.method === "GET") return call(client.getConnection, [id]);
480 if (request.method === "DELETE") {
481 return callVoid(client.deleteConnection, [id]);
482 }
483 }
484
485 if (head === "environment-variables") {
486 if (id === undefined) {
487 return request.method === "GET"
488 ? call(
489 client.listEnvironmentVariables,
490 [Object.fromEntries(new URLSearchParams(request.search))],
491 list,
492 )
493 : call(client.createEnvironmentVariable, [body]);
494 }
495 if (request.method === "GET") {
496 return call(client.getEnvironmentVariable, [id]);
497 }
498 if (request.method === "PATCH") {
499 return call(client.updateEnvironmentVariable, [id, body]);
500 }
501 if (request.method === "DELETE") {
502 return callVoid(client.deleteEnvironmentVariable, [id]);
503 }
504 }
505
506 if (head === "source-repositories") {
507 if (id === undefined) {
508 return request.method === "GET"
509 ? call(
510 client.listSourceRepositories,
511 [Object.fromEntries(new URLSearchParams(request.search))],
512 list,
513 )
514 : call(client.createSourceRepository, [body]);
515 }
516 if (request.method === "GET") {
517 return call(client.getSourceRepository, [id]);
518 }
519 if (request.method === "DELETE") {
520 return callVoid(client.deleteSourceRepository, [id]);
521 }
522 }
523
524 if (head === "buckets") {
525 if (id === undefined) {
526 return request.method === "GET"
527 ? call(client.listBuckets, [], list)
528 : call(client.createBucket, [body]);
529 }
530 if (tail === "keys") {
531 return request.method === "GET"
532 ? call(client.listBucketKeys, [id, { limit: 100 }], list)
533 : call(client.createBucketKey, [id, body]);
534 }
535 if (request.method === "GET") return call(client.getBucket, [id]);
536 if (request.method === "DELETE") {
537 return callVoid(client.deleteBucket, [id]);
538 }
539 }
540
541 if (head === "services") {
542 if (id === undefined) {
543 return request.method === "GET"
544 ? call(
545 client.listApps ?? emptyList,
546 [Object.fromEntries(new URLSearchParams(request.search))],
547 list,
548 )
549 : call(client.createApp, [body]);
550 }
551 if (tail === "deployments") {
552 return request.method === "GET"
553 ? call(
554 client.listAppDeployments,
555 [id, Object.fromEntries(new URLSearchParams(request.search))],
556 list,
557 )
558 : call(client.createAppDeployment, [id, body]);
559 }
560 if (tail === undefined) {
561 if (request.method === "GET") return call(client.getApp, [id]);
562 if (request.method === "PATCH") return call(client.updateApp, [id, body]);
563 }
564 }
565
566 if (head === "deployments" && id !== undefined) {
567 if (tail === "start") return call(client.startDeployment, [id]);
568 if (tail === "stop") {
569 return callVoid(client.stopDeployment, [id]);
570 }
571 if (request.method === "GET") return call(client.getDeployment, [id]);
572 if (request.method === "DELETE") {
573 return callVoid(client.deleteDeployment, [id]);
574 }
575 }
576
577 if (head === "services" && id !== undefined && tail === "promote") {
578 return call(client.promoteApp, [id, body]);
579 }
580 if (head === "services" && id !== undefined && tail === "rollback") {
581 return call(client.rollbackApp, [id, body]);
582 }
583 if (
584 head === "services" &&
585 id !== undefined &&
586 tail === undefined &&
587 request.method === "DELETE"
588 ) {
589 return callVoid(client.deleteApp, [id]);
590 }
591
592 if (head === "branches" && id !== undefined) {
593 if (request.method === "GET") return call(client.getBranch, [id]);
594 if (request.method === "PATCH") return call(client.updateBranch, [id, body]);
595 if (request.method === "DELETE") {
596 return callVoid(client.deleteBranch, [id]);
597 }
598 }
599
600 return unhandled(request);
601 }
602 };
603
604 const managementApi = (client: any) =>
605 makeFakeManagementApi((request) => dispatchManagement(client, request));
606
607 const providerLayer = (client: PrismaManagementClient) =>
608 Layer.mergeAll(
609 ProjectProvider(),
610 DatabaseProvider(),
611 ConnectionProvider(),
612 BranchProvider(),
613 AppProvider(),
614 DeploymentProvider(),
615 CustomDomainProvider(),
616 EnvironmentVariableProvider(),
617 SourceRepositoryProvider(),
618 ).pipe(
619 Layer.provide(Layer.succeed(PrismaClient, client)),
620 Layer.provide(liveProviderContext),
621 Layer.provide(testStackContext),
622 Layer.provide(PlatformServices),
623 );
624
625 const reconcileInput = <Props, Attrs>(id: string, news: Props, output?: Attrs, olds?: Props) => ({
626 id,
627 fqn: id,
628 instanceId: "00000000000000000000000000000000",
629 news,
630 olds,
631 output,
632 session: undefined as never,
633 bindings: [],
634 });
635
636 const deleteInput = (id: string, output: unknown) =>
637 ({
638 id,
639 fqn: id,
640 instanceId: "00000000000000000000000000000000",
641 olds: {} as never,
642 output,
643 session: undefined as never,
644 bindings: [],
645 }) as never;
646
647 const readInput = <Props, Attrs>(id: string, olds: Props, output?: Attrs) =>
648 ({ id, fqn: id, instanceId: "00000000000000000000000000000000", olds, output }) as never;
649
650 const diffInput = <Props, Attrs>(olds: Props, news: Props, output?: Attrs) =>
651 ({
652 id: "Resource",
653 fqn: "Resource",
654 instanceId: "00000000000000000000000000000000",
655 olds,
656 news,
657 oldBindings: [],
658 newBindings: [],
659 output,
660 }) as never;
661
662 describe("Prisma resource providers", { tags: ["unit", "provider:prisma", "local"] }, () => {
663 it(
664 "derives namespaced-safe env keys for connection bindings",
665 () => {
666 expect(
667 connectEnvKeys({ FQN: "Connection", LogicalId: "Connection" }).directConnectionString,
668 ).toBe("PRISMA_CONNECTION_DIRECT_CONNECTION_STRING");
669 expect(
670 connectEnvKeys({ FQN: "Api/Connection", LogicalId: "Connection" }).directConnectionString,
671 ).toBe("PRISMA_API_CONNECTION_DIRECT_CONNECTION_STRING");
672 },
673 { tags: ["provider:prisma:connect"] },
674 );
675
676 it.effect(
677 "ConnectBinding resolves bound connection outputs at runtime",
678 () => {
679 const stored: Record<string, Output.Output> = {};
680 const runtime = {
681 Type: "Prisma.Compute",
682 id: "App",
683 env: stored,
684 set: (id: string, output: Output.Output) =>
685 Effect.sync(() => {
686 const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
687 stored[key] = output;
688 return key;
689 }),
690 get: <T>(key: string): Effect.Effect<T> => {
691 const output = stored[key];
692 if (!output) return Effect.die(`missing runtime binding ${key}`);
693 return Output.evaluate(output, {}) as Effect.Effect<T>;
694 },
695 };
696 const escapedPooledConnectionString = "__ALCHEMY_PRISMA_CONNECTION_VALUE__:prisma://pooled";
697 const connection = {
698 Type: "Prisma.Connection",
699 LogicalId: "Connection",
700 FQN: "Api/Connection",
701 connectionId: Output.asOutput("connection-1"),
702 databaseId: Output.asOutput("database-1"),
703 directConnectionString: Output.asOutput(Redacted.make("postgres://direct")),
704 pooledConnectionString: Output.asOutput(Redacted.make(escapedPooledConnectionString)),
705 accelerateConnectionString: Output.asOutput(undefined),
706 host: Output.asOutput("db.example.test"),
707 user: Output.asOutput(null),
708 password: Output.asOutput(Redacted.make("password")),
709 } as PrismaConnection;
710
711 return Effect.gen(function* () {
712 const db = yield* Connect(connection);
713 const keys = connectEnvKeys(connection);
714 // Bound through the host's RuntimeContext under the documented keys,
715 // whatever the host type.
716 expect(Object.keys(stored).sort()).toEqual(Object.values(keys).sort());
717 const encodedEnv = yield* Output.evaluate(stored, {}) as Effect.Effect<
718 Record<string, unknown>
719 >;
720 expect(encodedEnv[keys.accelerateConnectionString]).toEqual(expect.any(String));
721 expect(encodedEnv[keys.user]).toEqual(expect.any(String));
722 expect(yield* db.connectionId).toBe("connection-1");
723 expect(Redacted.value(yield* db.databaseUrl)).toBe(escapedPooledConnectionString);
724 expect(Redacted.value((yield* db.directConnectionString)!)).toBe("postgres://direct");
725 expect(Redacted.value((yield* db.pooledConnectionString)!)).toBe(
726 escapedPooledConnectionString,
727 );
728 expect(yield* db.accelerateConnectionString).toBeUndefined();
729 expect(yield* db.user).toBeNull();
730 expect(Redacted.value((yield* db.password)!)).toBe("password");
731 }).pipe(
732 Effect.provide(ConnectBinding),
733 Effect.provide(Layer.succeed(RuntimeContext, runtime)),
734 Effect.provide(
735 Layer.succeed(
736 ConfigProvider.ConfigProvider,
737 ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
738 ),
739 ),
740 );
741 },
742 { tags: ["provider:prisma:connect", "provider:prisma:connection"] },
743 );
744
745 it.effect(
746 "ConnectBinding does not require the deploy-time host at runtime",
747 () => {
748 const stored: Record<string, Output.Output> = {};
749 const runtime = {
750 Type: "Prisma.Compute",
751 id: "App",
752 env: stored,
753 set: (id: string, output: Output.Output) =>
754 Effect.sync(() => {
755 const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
756 stored[key] = output;
757 return key;
758 }),
759 get: <T>(key: string): Effect.Effect<T> => {
760 const output = stored[key];
761 if (!output) return Effect.die(`missing runtime binding ${key}`);
762 return Output.evaluate(output, {}) as Effect.Effect<T>;
763 },
764 };
765 const connection = {
766 Type: "Prisma.Connection",
767 LogicalId: "Connection",
768 FQN: "Connection",
769 connectionId: Output.asOutput("connection-1"),
770 databaseId: Output.asOutput("database-1"),
771 directConnectionString: Output.asOutput(Redacted.make("postgres://runtime")),
772 pooledConnectionString: Output.asOutput(undefined),
773 accelerateConnectionString: Output.asOutput(undefined),
774 host: Output.asOutput("db.example.test"),
775 user: Output.asOutput("api"),
776 password: Output.asOutput(Redacted.make("password")),
777 } as PrismaConnection;
778
779 // Bundles fold `__ALCHEMY_RUNTIME__` to `true`; simulate the deployed
780 // runtime, where no deploy-time host (Self) exists.
781 const wasRuntime = globalThis.__ALCHEMY_RUNTIME__;
782 globalThis.__ALCHEMY_RUNTIME__ = true;
783 return Effect.gen(function* () {
784 const db = yield* Connect(connection);
785
786 expect(yield* db.connectionId).toBe("connection-1");
787 expect(Redacted.value(yield* db.databaseUrl)).toBe("postgres://runtime");
788 }).pipe(
789 Effect.provide(ConnectBinding),
790 Effect.provide(Layer.succeed(RuntimeContext, runtime)),
791 Effect.provide(
792 Layer.succeed(
793 ConfigProvider.ConfigProvider,
794 ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
795 ),
796 ),
797 Effect.ensuring(
798 Effect.sync(() => {
799 globalThis.__ALCHEMY_RUNTIME__ = wasRuntime;
800 }),
801 ),
802 );
803 },
804 { tags: ["provider:prisma:connect", "provider:prisma:connection"] },
805 );
806
807 it.effect(
808 "Prisma.Compute carries Connect outputs in its env through RuntimeContext",
809 () => {
810 const stack: Omit<StackSpec, "output"> = {
811 name: "prisma-compute-binding-test",
812 stage: "test",
813 resources: {},
814 bindings: {},
815 actions: {},
816 };
817 const connection = {
818 Type: "Prisma.Connection",
819 LogicalId: "Connection",
820 FQN: "Api/Connection",
821 connectionId: Output.asOutput("connection-1"),
822 databaseId: Output.asOutput("database-1"),
823 directConnectionString: Output.asOutput(Redacted.make("postgres://api")),
824 pooledConnectionString: Output.asOutput(Redacted.make("prisma+postgres://api")),
825 accelerateConnectionString: Output.asOutput(undefined),
826 host: Output.asOutput("db.example.test"),
827 user: Output.asOutput("api"),
828 password: Output.asOutput(Redacted.make("password")),
829 } as PrismaConnection;
830
831 return Effect.gen(function* () {
832 const app = yield* PrismaCompute(
833 "App",
834 { project: "project-1", appName: "api", main: "app.ts" },
835 Effect.gen(function* () {
836 yield* Connect(connection);
837 }).pipe(Effect.provide(ConnectBinding)),
838 );
839
840 const keys = connectEnvKeys(connection);
841 const env = (yield* Output.evaluate(
842 (app.Props as { env?: Record<string, unknown> }).env ?? {},
843 {},
844 )) as Record<string, string | Redacted.Redacted<string>>;
845 // Compute's RuntimeContext.set JSON-packs values; secrets stay Redacted.
846 const unpack = (value: string | Redacted.Redacted<string> | undefined) =>
847 Redacted.isRedacted(value)
848 ? Redacted.make(JSON.parse(Redacted.value(value)).value as string)
849 : value === undefined
850 ? undefined
851 : (JSON.parse(value) as string);
852
853 expect(stack.bindings[app.FQN]).toBeUndefined();
854 expect(Object.keys(env)).toEqual(expect.arrayContaining(Object.values(keys)));
855 expect(unpack(env[keys.connectionId])).toBe("connection-1");
856 expect(unpack(env[keys.databaseId])).toBe("database-1");
857 expect(redactedValue(unpack(env[keys.directConnectionString]))).toBe("postgres://api");
858 expect(redactedValue(unpack(env[keys.pooledConnectionString]))).toBe(
859 "prisma+postgres://api",
860 );
861 expect(redactedValue(unpack(env[keys.password]))).toBe("password");
862 }).pipe(
863 Effect.provide(inMemoryState()),
864 Effect.provide(
865 Layer.succeed(PrismaProviderCollection, {
866 kind: "ProviderCollection" as const,
867 get: () => undefined,
868 providers: {},
869 }),
870 ),
871 Effect.provideService(Stack, stack),
872 Effect.provideService(Stage, "test"),
873 Effect.provide(
874 Layer.succeed(
875 ConfigProvider.ConfigProvider,
876 ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "plan" }),
877 ),
878 ),
879 );
880 },
881 { tags: ["provider:prisma:compute", "provider:prisma:connect", "provider:prisma:connection"] },
882 );
883
884 it.effect(
885 "rejects conflicting App branch inputs",
886 () => {
887 const { client } = makeClient();
888
889 return Effect.gen(function* () {
890 const serviceProvider = yield* PrismaApp.Provider;
891 const error = yield* serviceProvider
892 .reconcile(
893 reconcileInput("App", {
894 project: "project-1",
895 displayName: "api",
896 branchId: "branch-1",
897 branchGitName: "main",
898 }),
899 )
900 .pipe(Effect.flip);
901
902 expect(error).toBeInstanceOf(Error);
903 expect((error as Error).message).toContain(
904 "branchId and branchGitName are mutually exclusive",
905 );
906 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
907 },
908 {
909 tags: [
910 "provider:prisma:app",
911 "provider:prisma:branch",
912 "provider:prisma:connection",
913 "provider:prisma:customdomain",
914 "provider:prisma:database",
915 "provider:prisma:deployment",
916 "provider:prisma:environmentvariable",
917 "provider:prisma:project",
918 "provider:prisma:sourcerepository",
919 ],
920 },
921 );
922
923 it.effect(
924 "rejects conflicting Database branch inputs",
925 () => {
926 const { client } = makeClient();
927
928 return Effect.gen(function* () {
929 const databaseProvider = yield* PrismaDatabase.Provider;
930 const error = yield* databaseProvider
931 .reconcile(
932 reconcileInput("Database", {
933 project: "project-1",
934 name: "main",
935 branchId: "branch-1",
936 branchGitName: "main",
937 }),
938 )
939 .pipe(Effect.flip);
940
941 expect(error).toBeInstanceOf(Error);
942 expect((error as Error).message).toContain(
943 "branchId and branchGitName are mutually exclusive",
944 );
945 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
946 },
947 {
948 tags: [
949 "provider:prisma:app",
950 "provider:prisma:branch",
951 "provider:prisma:connection",
952 "provider:prisma:customdomain",
953 "provider:prisma:database",
954 "provider:prisma:deployment",
955 "provider:prisma:environmentvariable",
956 "provider:prisma:project",
957 "provider:prisma:sourcerepository",
958 ],
959 },
960 );
961
962 it.effect(
963 "classifies Prisma resource diffs as updates or replacements",
964 () => {
965 const { client } = makeClient();
966
967 return Effect.gen(function* () {
968 const projectProvider = yield* PrismaProject.Provider;
969 const databaseProvider = yield* PrismaDatabase.Provider;
970 const connectionProvider = yield* PrismaConnection.Provider;
971 const branchProvider = yield* PrismaBranch.Provider;
972 const serviceProvider = yield* PrismaApp.Provider;
973 const versionProvider = yield* PrismaDeployment.Provider;
974 const envProvider = yield* PrismaEnvironmentVariable.Provider;
975 const repoProvider = yield* PrismaSourceRepository.Provider;
976
977 expect(
978 yield* projectProvider.diff!(
979 diffInput(
980 { name: "app", region: "us-east-1", createDatabase: false },
981 { name: "renamed", region: "us-east-1", createDatabase: false },
982 ),
983 ),
984 ).toEqual({ action: "update" });
985 expect(
986 yield* projectProvider.diff!(
987 diffInput(
988 { name: "app", region: "us-east-1", createDatabase: false },
989 { name: "app", region: "us-west-2", createDatabase: false },
990 ),
991 ),
992 ).toBeUndefined();
993 expect(
994 yield* projectProvider.diff!(
995 diffInput(
996 { name: "app", region: "us-east-1", createDatabase: false },
997 { name: "app", region: "us-west-2", createDatabase: Output.asOutput(false) },
998 ),
999 ),
1000 ).toBeUndefined();
1001 expect(
1002 yield* projectProvider.diff!(
1003 diffInput(
1004 { name: "app", region: "us-east-1", createDatabase: false },
1005 {
1006 name: "app",
1007 region: "us-west-2",
1008 createDatabase: false,
1009 settings: Output.asOutput({}),
1010 },
1011 ),
1012 ),
1013 ).toBeUndefined();
1014 expect(
1015 yield* projectProvider.diff!(
1016 diffInput(
1017 {
1018 name: "app",
1019 region: "us-east-1",
1020 createDatabase: false,
1021 settings: { preview: true, tier: "dev" },
1022 },
1023 {
1024 name: "app",
1025 region: "us-east-1",
1026 createDatabase: false,
1027 settings: { tier: "dev", preview: true },
1028 },
1029 ),
1030 ),
1031 ).toEqual({ action: "update" });
1032
1033 expect(
1034 yield* databaseProvider.diff!(
1035 diffInput(
1036 { project: "project-1", name: "main", region: "us-east-1" },
1037 { project: "project-1", name: "primary", region: "us-east-1" },
1038 ),
1039 ),
1040 ).toEqual({ action: "update" });
1041 expect(
1042 yield* databaseProvider.diff!(
1043 diffInput(
1044 {
1045 project: "project-1",
1046 name: "main",
1047 region: "us-east-1",
1048 source: { type: "backup", databaseId: "database-source", backupId: "backup-1" },
1049 },
1050 {
1051 project: "project-1",
1052 name: "main",
1053 region: "us-east-1",
1054 source: { backupId: "backup-1", databaseId: "database-source", type: "backup" },
1055 },
1056 ),
1057 ),
1058 ).toBeUndefined();
1059 expect(
1060 yield* databaseProvider.diff!(
1061 diffInput(
1062 { project: "project-1", name: "main", region: "us-east-1" },
1063 { project: Output.asOutput("project-1"), name: "main", region: "us-west-2" },
1064 ),
1065 ),
1066 ).toEqual({ action: "replace", deleteFirst: true });
1067 expect(
1068 yield* databaseProvider.diff!(
1069 diffInput(
1070 { project: "project-1", name: "main", region: "us-east-1", branchId: "branch-1" },
1071 {
1072 project: "project-1",
1073 name: "main",
1074 region: "us-west-2",
1075 branchId: Output.asOutput("branch-1"),
1076 },
1077 ),
1078 ),
1079 ).toEqual({ action: "replace", deleteFirst: true });
1080
1081 expect(
1082 yield* connectionProvider.diff!(
1083 diffInput(
1084 { database: "database-1", name: "api", rotate: false },
1085 { database: "database-1", name: "api", rotate: true },
1086 ),
1087 ),
1088 ).toEqual({ action: "update" });
1089 expect(
1090 yield* connectionProvider.diff!(
1091 diffInput(
1092 { database: "database-1", name: "api" },
1093 { database: "database-1", name: "worker" },
1094 ),
1095 ),
1096 ).toEqual({ action: "replace" });
1097 expect(
1098 yield* connectionProvider.diff!(
1099 diffInput(
1100 { database: "database-1", name: "api" },
1101 { database: Output.asOutput("database-1"), name: "worker" },
1102 ),
1103 ),
1104 ).toEqual({ action: "replace" });
1105 expect(
1106 yield* connectionProvider.diff!(
1107 diffInput(
1108 { database: "database-1", name: "api", rotate: false },
1109 { database: "database-1", name: "worker", rotate: Output.asOutput(false) },
1110 ),
1111 ),
1112 ).toEqual({ action: "replace" });
1113
1114 expect(
1115 yield* branchProvider.diff!(
1116 diffInput(
1117 { project: "project-1", gitName: "main", isDefault: false },
1118 { project: "project-1", gitName: "main", isDefault: true },
1119 ),
1120 ),
1121 ).toEqual({ action: "update" });
1122 expect(
1123 yield* branchProvider.diff!(
1124 diffInput(
1125 { project: "project-1", gitName: "main", isDefault: true },
1126 { project: "project-1", gitName: "main", isDefault: false },
1127 ),
1128 ),
1129 ).toBeUndefined();
1130 expect(
1131 yield* branchProvider.diff!(
1132 diffInput(
1133 { project: "project-1", gitName: "main" },
1134 { project: "project-1", gitName: "release" },
1135 ),
1136 ),
1137 ).toEqual({ action: "replace" });
1138 expect(
1139 yield* branchProvider.diff!(
1140 diffInput(
1141 { project: "project-1", gitName: "main" },
1142 { project: Output.asOutput("project-1"), gitName: "release" },
1143 ),
1144 ),
1145 ).toEqual({ action: "replace" });
1146 expect(
1147 yield* branchProvider.diff!(
1148 diffInput(
1149 { project: "project-1", gitName: "main", isDefault: false },
1150 { project: "project-1", gitName: "release", isDefault: Output.asOutput(false) },
1151 ),
1152 ),
1153 ).toEqual({ action: "replace" });
1154
1155 expect(
1156 yield* serviceProvider.diff!(
1157 diffInput(
1158 { project: "project-1", displayName: "api", regionId: "us-east-1" },
1159 { project: "project-1", displayName: "web", regionId: "us-east-1" },
1160 ),
1161 ),
1162 ).toEqual({ action: "update" });
1163 const appRegionChanges = yield* Effect.forEach(
1164 [
1165 serviceProvider.diff!(
1166 diffInput(
1167 { project: "project-1", displayName: "api", regionId: "us-east-1" },
1168 { project: "project-1", displayName: "api", regionId: "us-west-2" },
1169 ),
1170 ),
1171 serviceProvider.diff!(
1172 diffInput(
1173 { project: "project-1", displayName: "api", regionId: "us-east-1" },
1174 {
1175 project: Output.asOutput("project-1"),
1176 displayName: "api",
1177 regionId: "us-west-2",
1178 },
1179 ),
1180 ),
1181 serviceProvider.diff!(
1182 diffInput(
1183 {
1184 project: "project-1",
1185 displayName: "api",
1186 regionId: "us-east-1",
1187 branchId: "branch-1",
1188 },
1189 {
1190 project: "project-1",
1191 displayName: "api",
1192 regionId: "us-west-2",
1193 branchId: Output.asOutput("branch-1"),
1194 },
1195 ),
1196 ),
1197 ],
1198 (change) => change.pipe(Effect.result),
1199 );
1200 for (const change of appRegionChanges) {
1201 expect(Result.isFailure(change)).toBe(true);
1202 if (Result.isFailure(change)) {
1203 expect(String(change.failure)).toContain("cannot atomically move");
1204 }
1205 }
1206
1207 expect(
1208 yield* versionProvider.diff!(
1209 diffInput({ app: "service-1", start: false }, { app: "service-1", start: true }),
1210 ),
1211 ).toEqual({ action: "update" });
1212 expect(
1213 yield* versionProvider.diff!(
1214 diffInput(
1215 { app: "service-1", portMapping: { http: 3000 } },
1216 { app: "service-1", portMapping: { http: 8080 } },
1217 ),
1218 ),
1219 ).toEqual({ action: "replace" });
1220 expect(
1221 yield* versionProvider.diff!(
1222 diffInput(
1223 { app: "service-1", portMapping: { http: 3000 } },
1224 { app: Output.asOutput("service-1"), portMapping: { http: 8080 } },
1225 ),
1226 ),
1227 ).toEqual({ action: "replace" });
1228 expect(
1229 yield* versionProvider.diff!(
1230 diffInput(
1231 { app: "service-1", portMapping: { http: 3000 }, start: false },
1232 { app: "service-1", portMapping: { http: 8080 }, start: Output.asOutput(false) },
1233 ),
1234 ),
1235 ).toEqual({ action: "replace" });
1236
1237 expect(
1238 yield* envProvider.diff!(
1239 diffInput(
1240 {
1241 project: "project-1",
1242 class: "production" as const,
1243 key: "TOKEN",
1244 value: Redacted.make("old"),
1245 },
1246 {
1247 project: "project-1",
1248 class: "production" as const,
1249 key: "TOKEN",
1250 value: Redacted.make("new"),
1251 },
1252 ),
1253 ),
1254 ).toEqual({ action: "update" });
1255 expect(
1256 yield* envProvider.diff!(
1257 diffInput(
1258 {
1259 project: "project-1",
1260 class: "production" as const,
1261 key: "TOKEN",
1262 value: Redacted.make("same"),
1263 },
1264 {
1265 project: "project-1",
1266 class: "production" as const,
1267 key: "TOKEN",
1268 value: Redacted.make("same"),
1269 },
1270 ),
1271 ),
1272 ).toEqual({ action: "update" });
1273 expect(
1274 yield* envProvider.diff!(
1275 diffInput(
1276 {
1277 project: "project-1",
1278 class: "production" as const,
1279 key: "TOKEN",
1280 value: Redacted.make("secret"),
1281 },
1282 {
1283 project: "project-1",
1284 class: "preview" as const,
1285 key: "TOKEN",
1286 value: Redacted.make("secret"),
1287 },
1288 ),
1289 ),
1290 ).toEqual({ action: "replace" });
1291 expect(
1292 yield* envProvider.diff!(
1293 diffInput(
1294 {
1295 project: "project-1",
1296 class: "production" as const,
1297 key: "TOKEN",
1298 value: Redacted.make("secret"),
1299 },
1300 {
1301 project: Output.asOutput("project-1"),
1302 class: "preview" as const,
1303 key: "TOKEN",
1304 value: Output.asOutput(Redacted.make("secret")),
1305 },
1306 ),
1307 ),
1308 ).toEqual({ action: "replace" });
1309 expect(
1310 yield* envProvider.diff!(
1311 diffInput(
1312 {
1313 project: "project-1",
1314 class: "production" as const,
1315 key: "TOKEN",
1316 value: Redacted.make("secret"),
1317 },
1318 {
1319 project: "project-1",
1320 class: "preview" as const,
1321 key: Output.asOutput("TOKEN"),
1322 value: Redacted.make("secret"),
1323 },
1324 ),
1325 ),
1326 ).toEqual({ action: "replace" });
1327
1328 const repositoryChanges = yield* Effect.forEach(
1329 [
1330 repoProvider.diff!(
1331 diffInput(
1332 { project: "project-1", providerRepositoryId: 123 },
1333 { project: "project-1", providerRepositoryId: 456 },
1334 ),
1335 ),
1336 repoProvider.diff!(
1337 diffInput(
1338 { project: "project-1", providerRepositoryId: 123 },
1339 { project: Output.asOutput("project-1"), providerRepositoryId: 456 },
1340 ),
1341 ),
1342 repoProvider.diff!(
1343 diffInput(
1344 { project: "project-1", providerRepositoryId: 123, installationId: "install-1" },
1345 {
1346 project: "project-1",
1347 providerRepositoryId: 456,
1348 installationId: Output.asOutput("install-1"),
1349 },
1350 ),
1351 ),
1352 ],
1353 (change) => change.pipe(Effect.result),
1354 );
1355 for (const change of repositoryChanges) {
1356 expect(Result.isFailure(change)).toBe(true);
1357 if (Result.isFailure(change)) {
1358 expect(String(change.failure)).toContain("cannot be replaced atomically");
1359 }
1360 }
1361 }).pipe(
1362 Effect.provide(providerLayer(client)),
1363 Effect.provide(managementApi(client).layer),
1364 Effect.provide(FetchHttpClient.layer),
1365 Effect.provideService(Stack, {
1366 name: "prisma-provider-diff-test",
1367 stage: "test",
1368 resources: {},
1369 bindings: {},
1370 actions: {},
1371 }),
1372 Effect.provideService(Stage, "test"),
1373 );
1374 },
1375 {
1376 tags: [
1377 "provider:prisma:app",
1378 "provider:prisma:branch",
1379 "provider:prisma:connection",
1380 "provider:prisma:customdomain",
1381 "provider:prisma:database",
1382 "provider:prisma:deployment",
1383 "provider:prisma:environmentvariable",
1384 "provider:prisma:project",
1385 "provider:prisma:sourcerepository",
1386 ],
1387 },
1388 );
1389
1390 it.effect(
1391 "reads existing Prisma resources for adoption and refresh",
1392 () => {
1393 const calls: Call[] = [];
1394 const database = {
1395 id: "database-1",
1396 type: "database" as const,
1397 url: "https://api.prisma.test/v1/databases/database-1",
1398 name: "main",
1399 status: "ready" as const,
1400 createdAt,
1401 isDefault: true,
1402 defaultConnectionId: "connection-1",
1403 connections: [databaseConnection("database-1", "connection-1")],
1404 project: resourceRef("projects", "project-1", "app"),
1405 region: { id: "us-east-1", name: "US East" },
1406 source: { type: "empty" },
1407 branchId: null,
1408 };
1409 const fake = makeFakeManagementApi((request) => {
1410 if (request.pathname === "/v1/projects" && request.method === "GET") {
1411 return page([wireProject()]);
1412 }
1413 if (request.pathname === "/v1/projects/project-1" && request.method === "GET") {
1414 return envelope(wireProject());
1415 }
1416 if (request.pathname === "/v1/projects/project-1/databases" && request.method === "GET") {
1417 return page([
1418 wireDatabase({
1419 isDefault: true,
1420 defaultConnectionId: "connection-1",
1421 connections: [wireConnection()],
1422 }),
1423 ]);
1424 }
1425 return dispatchManagement(client, request);
1426 });
1427
1428 const client = {
1429 listProjectDatabases: (projectId: string, query: unknown) =>
1430 Effect.sync(() => {
1431 calls.push(["listProjectDatabases", { projectId, query }]);
1432 return [database];
1433 }),
1434 listDatabaseConnections: (databaseId: string, query: unknown) =>
1435 Effect.sync(() => {
1436 calls.push(["listDatabaseConnections", { databaseId, query }]);
1437 return [
1438 {
1439 id: "connection-1",
1440 type: "connection" as const,
1441 url: "https://api.prisma.test/v1/connections/connection-1",
1442 name: "api",
1443 createdAt,
1444 kind: "postgres" as const,
1445 endpoints: { direct: { host: "db.prisma.test", port: 5432 } },
1446 database: resourceRef("databases", "database-1", "main"),
1447 },
1448 ];
1449 }),
1450 listBranches: (projectId: string, query: unknown) =>
1451 Effect.sync(() => {
1452 calls.push(["listBranches", { projectId, query }]);
1453 return [
1454 {
1455 id: "branch-1",
1456 type: "branch" as const,
1457 url: "https://api.prisma.test/v1/branches/branch-1",
1458 gitName: "main",
1459 isDefault: true,
1460 createdAt,
1461 updatedAt,
1462 project: resourceRef("projects", "project-1", "app"),
1463 },
1464 ];
1465 }),
1466 listApps: (query: { projectId: string; limit?: number }) =>
1467 Effect.sync(() => {
1468 calls.push(["listApps", query]);
1469 return [
1470 {
1471 id: "service-1",
1472 type: "app" as const,
1473 url: "https://api.prisma.test/v1/services/service-1",
1474 name: "api",
1475 region: { id: "us-east-1", name: "US East" },
1476 projectId: query.projectId,
1477 branchId: "branch-1",
1478 latestDeploymentId: "version-1",
1479 appEndpointDomain: "api.prisma.build",
1480 createdAt,
1481 },
1482 ];
1483 }),
1484 listAppDeployments: (appId: string, query: unknown) =>
1485 Effect.sync(() => {
1486 calls.push(["listAppDeployments", { appId, query }]);
1487 return [
1488 {
1489 id: "version-1",
1490 type: "deployment" as const,
1491 serviceId: "service-1",
1492 url: "https://api.prisma.test/v1/deployments/version-1",
1493 foundryVersionId: "foundry-1",
1494 createdAt,
1495 },
1496 ];
1497 }),
1498 getDeployment: (id: string) =>
1499 Effect.sync(() => {
1500 calls.push(["getDeployment", id]);
1501 return {
1502 id,
1503 type: "deployment" as const,
1504 serviceId: "service-1",
1505 url: `https://api.prisma.test/v1/deployments/${id}`,
1506 foundryVersionId: "foundry-1",
1507 status: "running",
1508 previewDomain: "version-1.preview.prisma.build",
1509 createdAt,
1510 };
1511 }),
1512 listEnvironmentVariables: (query: unknown) =>
1513 Effect.sync(() => {
1514 calls.push(["listEnvironmentVariables", query]);
1515 return [
1516 {
1517 id: "env-1",
1518 type: "environment-variable" as const,
1519 url: "https://api.prisma.test/v1/environment-variables/env-1",
1520 projectId: "project-1",
1521 branchId: null,
1522 class: "production" as const,
1523 key: "TOKEN",
1524 valueKid: "kid-1",
1525 isManagedBySystem: false,
1526 createdAt,
1527 updatedAt,
1528 },
1529 ];
1530 }),
1531 listSourceRepositories: (query: unknown) =>
1532 Effect.sync(() => {
1533 calls.push(["listSourceRepositories", query]);
1534 return [
1535 {
1536 id: "repo-1",
1537 type: "source-repository" as const,
1538 url: "https://api.prisma.test/v1/source-repositories/repo-1",
1539 repoId: 123,
1540 provider: "github" as const,
1541 repoFullName: "acme/api",
1542 defaultBranch: "main",
1543 isPrivate: true,
1544 status: "active" as const,
1545 projectId: "project-1",
1546 installationId: "installation-1",
1547 createdAt,
1548 updatedAt,
1549 },
1550 ];
1551 }),
1552 } as unknown as PrismaManagementClient;
1553
1554 return Effect.gen(function* () {
1555 const projectProvider = yield* Provider.findProvider(PrismaProject);
1556 const databaseProvider = yield* Provider.findProvider(PrismaDatabase);
1557 const connectionProvider = yield* Provider.findProvider(PrismaConnection);
1558 const branchProvider = yield* Provider.findProvider(PrismaBranch);
1559 const serviceProvider = yield* Provider.findProvider(PrismaApp);
1560 const versionProvider = yield* Provider.findProvider(PrismaDeployment);
1561 const envProvider = yield* Provider.findProvider(PrismaEnvironmentVariable);
1562 const repoProvider = yield* Provider.findProvider(PrismaSourceRepository);
1563
1564 const project = yield* projectProvider.read!(readInput("Project", { name: "app" }));
1565 const database = yield* databaseProvider.read!(
1566 readInput("Database", { project: "project-1", name: "main" }),
1567 );
1568 const connection = yield* connectionProvider.read!(
1569 readInput("Connection", { database: "database-1", name: "api" }),
1570 );
1571 const branch = yield* branchProvider.read!(
1572 readInput("Branch", { project: "project-1", gitName: "main" }),
1573 );
1574 const service = yield* serviceProvider.read!(
1575 readInput("App", { project: "project-1", displayName: "api" }),
1576 );
1577 const version = yield* versionProvider.read!(
1578 readInput(
1579 "Deployment",
1580 { app: "service-1" },
1581 {
1582 deploymentId: "version-1",
1583 appId: "service-1",
1584 foundryVersionId: "foundry-1",
1585 status: "new",
1586 previewDomain: null,
1587 uploadUrl: null,
1588 appEndpointDomain: undefined,
1589 createdAt,
1590 },
1591 ),
1592 );
1593 const env = yield* envProvider.read!(
1594 readInput("EnvironmentVariable", {
1595 project: "project-1",
1596 class: "production" as const,
1597 key: "TOKEN",
1598 value: Redacted.make("secret"),
1599 }),
1600 );
1601 const repo = yield* repoProvider.read!(
1602 readInput("SourceRepository", { project: "project-1", providerRepositoryId: 123 }),
1603 );
1604
1605 expect(project?.projectId).toBe("project-1");
1606 expect(project?.databaseId).toBe("database-1");
1607 expect(database?.databaseId).toBe("database-1");
1608 expect(connection?.connectionId).toBe("connection-1");
1609 expect(branch?.branchId).toBe("branch-1");
1610 expect(service?.appId).toBe("service-1");
1611 expect(version?.deploymentId).toBe("version-1");
1612 expect(version?.status).toBe("running");
1613 expect(env?.environmentVariableId).toBe("env-1");
1614 expect(env?.valueKid).toBe("kid-1");
1615 expect(env?.value && Redacted.value(env.value)).toBe("");
1616 expect(repo?.sourceRepositoryId).toBe("repo-1");
1617 expect(Unowned.is(project!)).toBe(true);
1618 expect(Unowned.is(database!)).toBe(true);
1619 expect(Unowned.is(branch!)).toBe(true);
1620 expect(Unowned.is(env!)).toBe(true);
1621 expect(Unowned.is(repo!)).toBe(true);
1622 expect(routesOf(fake.captured)).toEqual([
1623 "GET /v1/projects",
1624 "GET /v1/projects/project-1/databases",
1625 // Database: logical-ID lookup, then the name fallback.
1626 "GET /v1/projects/project-1/branches",
1627 "GET /v1/databases",
1628 "GET /v1/projects/project-1/databases",
1629 "GET /v1/databases/database-1/connections",
1630 "GET /v1/databases/database-1/connections",
1631 "GET /v1/databases/database-1/connections",
1632 "GET /v1/projects/project-1/branches",
1633 // App: logical-ID lookup, then the display-name fallback.
1634 "GET /v1/projects/project-1/branches",
1635 "GET /v1/services",
1636 "GET /v1/services",
1637 "GET /v1/projects/project-1/branches",
1638 "GET /v1/deployments/version-1",
1639 "GET /v1/services/service-1/deployments",
1640 "GET /v1/environment-variables",
1641 "GET /v1/source-repositories",
1642 ]);
1643 expect(calls.map(([operation]) => operation)).toEqual([
1644 "listBranches",
1645 "listDatabaseConnections",
1646 "listDatabaseConnections",
1647 "listDatabaseConnections",
1648 "listBranches",
1649 "listBranches",
1650 "listApps",
1651 "listApps",
1652 "listBranches",
1653 "getDeployment",
1654 "listAppDeployments",
1655 "listEnvironmentVariables",
1656 "listSourceRepositories",
1657 ]);
1658 expect(routesOf(fake.captured)).not.toContain("POST /v1/projects");
1659 }).pipe(
1660 Effect.provide(providerLayer(client)),
1661 Effect.provide(fake.layer),
1662 Effect.provide(FetchHttpClient.layer),
1663 Effect.provideService(Stack, {
1664 name: "prisma-provider-read-test",
1665 stage: "test",
1666 resources: {},
1667 bindings: {},
1668 actions: {},
1669 }),
1670 Effect.provideService(Stage, "test"),
1671 );
1672 },
1673 {
1674 tags: [
1675 "provider:prisma:app",
1676 "provider:prisma:branch",
1677 "provider:prisma:connection",
1678 "provider:prisma:customdomain",
1679 "provider:prisma:database",
1680 "provider:prisma:deployment",
1681 "provider:prisma:environmentvariable",
1682 "provider:prisma:project",
1683 "provider:prisma:sourcerepository",
1684 ],
1685 },
1686 );
1687
1688 it.effect(
1689 "treats Prisma 404 during delete as already gone",
1690 () => {
1691 const calls: Call[] = [];
1692 const notFound = (method: "GET" | "DELETE", path: string) =>
1693 new PrismaApiError({ method, path, status: 404, message: "not found" });
1694 const failNotFound = (
1695 operation: string,
1696 id: string,
1697 method: "GET" | "DELETE",
1698 path: string,
1699 ) =>
1700 Effect.gen(function* () {
1701 calls.push([operation, id]);
1702 return yield* Effect.fail(notFound(method, path));
1703 });
1704
1705 const client = {
1706 listApps: (query: unknown) =>
1707 Effect.sync(() => {
1708 calls.push(["listApps", query]);
1709 return [];
1710 }),
1711 deleteProject: (id: string) =>
1712 failNotFound("deleteProject", id, "DELETE", `/v1/projects/${id}`),
1713 getDatabase: (id: string) => failNotFound("getDatabase", id, "GET", `/v1/databases/${id}`),
1714 deleteDatabase: (id: string) =>
1715 failNotFound("deleteDatabase", id, "DELETE", `/v1/databases/${id}`),
1716 getConnection: (id: string) =>
1717 failNotFound("getConnection", id, "GET", `/v1/connections/${id}`),
1718 deleteConnection: (id: string) =>
1719 failNotFound("deleteConnection", id, "DELETE", `/v1/connections/${id}`),
1720 getBranch: (id: string) => failNotFound("getBranch", id, "GET", `/v1/branches/${id}`),
1721 deleteBranch: (id: string) =>
1722 failNotFound("deleteBranch", id, "DELETE", `/v1/branches/${id}`),
1723 getEnvironmentVariable: (id: string) =>
1724 failNotFound("getEnvironmentVariable", id, "GET", `/v1/environment-variables/${id}`),
1725 deleteEnvironmentVariable: (id: string) =>
1726 failNotFound(
1727 "deleteEnvironmentVariable",
1728 id,
1729 "DELETE",
1730 `/v1/environment-variables/${id}`,
1731 ),
1732 deleteSourceRepository: (id: string) =>
1733 failNotFound("deleteSourceRepository", id, "DELETE", `/v1/source-repositories/${id}`),
1734 getSourceRepository: (id: string) =>
1735 failNotFound("getSourceRepository", id, "GET", `/v1/source-repositories/${id}`),
1736 listAppDeployments: (appId: string) =>
1737 failNotFound("listAppDeployments", appId, "GET", `/v1/services/${appId}/deployments`),
1738 deleteApp: (id: string) => failNotFound("deleteApp", id, "DELETE", `/v1/services/${id}`),
1739 getApp: (id: string) => failNotFound("getApp", id, "GET", `/v1/services/${id}`),
1740 getDeployment: (id: string) =>
1741 failNotFound("getDeployment", id, "GET", `/v1/deployments/${id}`),
1742 } as unknown as PrismaManagementClient;
1743
1744 return Effect.gen(function* () {
1745 const projectProvider = yield* PrismaProject.Provider;
1746 const databaseProvider = yield* PrismaDatabase.Provider;
1747 const connectionProvider = yield* PrismaConnection.Provider;
1748 const branchProvider = yield* PrismaBranch.Provider;
1749 const serviceProvider = yield* PrismaApp.Provider;
1750 const versionProvider = yield* PrismaDeployment.Provider;
1751 const envProvider = yield* PrismaEnvironmentVariable.Provider;
1752 const repoProvider = yield* PrismaSourceRepository.Provider;
1753
1754 yield* projectProvider.delete!(deleteInput("Project", { projectId: "project-1" }));
1755 yield* databaseProvider.delete!(deleteInput("Database", { databaseId: "database-1" }));
1756 yield* connectionProvider.delete!(
1757 deleteInput("Connection", { connectionId: "connection-1" }),
1758 );
1759 yield* branchProvider.delete!(deleteInput("Branch", { branchId: "branch-1" }));
1760 yield* envProvider.delete!(
1761 deleteInput("EnvironmentVariable", { environmentVariableId: "env-1" }),
1762 );
1763 yield* repoProvider.delete!(
1764 deleteInput("SourceRepository", { sourceRepositoryId: "repo-1" }),
1765 );
1766 yield* serviceProvider.delete!(deleteInput("App", { appId: "service-1" }));
1767 yield* versionProvider.delete!(deleteInput("Deployment", { deploymentId: "version-1" }));
1768
1769 expect(calls).toEqual([
1770 // Over the wire, query params arrive as strings.
1771 ["listApps", { limit: "100", projectId: "project-1" }],
1772 ["deleteProject", "project-1"],
1773 ["getDatabase", "database-1"],
1774 ["getConnection", "connection-1"],
1775 ["getBranch", "branch-1"],
1776 ["getEnvironmentVariable", "env-1"],
1777 ["getSourceRepository", "repo-1"],
1778 ["getApp", "service-1"],
1779 ["getDeployment", "version-1"],
1780 ]);
1781 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
1782 },
1783 {
1784 tags: [
1785 "provider:prisma:app",
1786 "provider:prisma:branch",
1787 "provider:prisma:connection",
1788 "provider:prisma:customdomain",
1789 "provider:prisma:database",
1790 "provider:prisma:deployment",
1791 "provider:prisma:environmentvariable",
1792 "provider:prisma:project",
1793 "provider:prisma:sourcerepository",
1794 ],
1795 },
1796 );
1797
1798 it.effect(
1799 "does not delete cloud projects for dev placeholder project IDs",
1800 () => {
1801 const calls: Call[] = [];
1802 const client = {
1803 listProjects: () =>
1804 Effect.sync(() => {
1805 calls.push(["listProjects"]);
1806 return [
1807 {
1808 id: "project-cloud",
1809 type: "project",
1810 url: "https://api.prisma.test/v1/projects/project-cloud",
1811 name: "local-project",
1812 createdAt,
1813 defaultRegion: "us-east-1",
1814 workspace: resourceRef("workspaces", "workspace-1", "team"),
1815 database: null,
1816 },
1817 ];
1818 }),
1819 deleteProject: (id: string) =>
1820 Effect.sync(() => {
1821 calls.push(["deleteProject", id]);
1822 }),
1823 } as unknown as PrismaManagementClient;
1824
1825 return Effect.gen(function* () {
1826 const projectProvider = yield* PrismaProject.Provider;
1827
1828 yield* projectProvider.delete!(
1829 deleteInput("Project", {
1830 projectId: "dev:project:Project",
1831 projectName: "local-project",
1832 }),
1833 );
1834
1835 expect(calls).toEqual([]);
1836 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
1837 },
1838 {
1839 tags: [
1840 "provider:prisma:app",
1841 "provider:prisma:branch",
1842 "provider:prisma:connection",
1843 "provider:prisma:customdomain",
1844 "provider:prisma:database",
1845 "provider:prisma:deployment",
1846 "provider:prisma:environmentvariable",
1847 "provider:prisma:project",
1848 "provider:prisma:sourcerepository",
1849 ],
1850 },
1851 );
1852
1853 it.effect(
1854 "reconciles each greenfield Prisma resource through the client",
1855 () => {
1856 const { client, calls } = makeClient();
1857 const fake = makeFakeManagementApi((request) => {
1858 if (request.pathname === "/v1/projects" && request.method === "POST") {
1859 return envelope({ ...wireProject(), database: null }, { status: 201 });
1860 }
1861 return dispatchManagement(client, request);
1862 });
1863
1864 return Effect.gen(function* () {
1865 const projectProvider = yield* PrismaProject.Provider;
1866 const databaseProvider = yield* PrismaDatabase.Provider;
1867 const connectionProvider = yield* PrismaConnection.Provider;
1868 const branchProvider = yield* PrismaBranch.Provider;
1869 const serviceProvider = yield* PrismaApp.Provider;
1870 const versionProvider = yield* PrismaDeployment.Provider;
1871 const envProvider = yield* PrismaEnvironmentVariable.Provider;
1872 const repoProvider = yield* PrismaSourceRepository.Provider;
1873
1874 const project = yield* projectProvider.reconcile(
1875 reconcileInput("Project", { name: "app", createDatabase: false, region: "us-east-1" }),
1876 );
1877 const database = yield* databaseProvider.reconcile(
1878 reconcileInput("Database", {
1879 project: project.projectId,
1880 name: "main",
1881 region: "us-east-1",
1882 }),
1883 );
1884 const connection = yield* connectionProvider.reconcile(
1885 reconcileInput("Connection", { database: database.databaseId, name: "api" }),
1886 );
1887 const branch = yield* branchProvider.reconcile(
1888 reconcileInput("Branch", {
1889 project: project.projectId,
1890 gitName: "preview",
1891 isDefault: false,
1892 }),
1893 );
1894 const service = yield* serviceProvider.reconcile(
1895 reconcileInput("App", {
1896 project: project.projectId,
1897 displayName: "api",
1898 regionId: "us-east-1",
1899 }),
1900 );
1901 const version = yield* versionProvider.reconcile(
1902 reconcileInput("Deployment", {
1903 app: service.appId,
1904 portMapping: { http: 3000 },
1905 skipCodeUpload: true,
1906 }),
1907 );
1908 const env = yield* envProvider.reconcile(
1909 reconcileInput("EnvironmentVariable", {
1910 project: project.projectId,
1911 class: "production" as const,
1912 key: "TOKEN",
1913 value: Redacted.make("secret"),
1914 }),
1915 );
1916 const repo = yield* repoProvider.reconcile(
1917 reconcileInput("SourceRepository", {
1918 project: project.projectId,
1919 providerRepositoryId: 123,
1920 }),
1921 );
1922
1923 expect(project.projectId).toBe("project-1");
1924 expect(database.databaseId).toBe("database-1");
1925 expect(Redacted.value(database.directConnectionString!)).toBe("postgres://direct");
1926 expect(connection.connectionId).toBe("connection-2");
1927 expectJsonNotToContain(database, "postgres://direct", "postgres://pooled");
1928 expectJsonNotToContain(connection, "postgres://api-direct");
1929 expect(branch.branchId).toBe("branch-2");
1930 expect(service.appId).toBe("service-1");
1931 expect(version.deploymentId).toBe("version-1");
1932 expect(env.environmentVariableId).toBe("env-1");
1933 expect(Redacted.value(env.value)).toBe("secret");
1934 expectJsonNotToContain(env, "secret");
1935 expect(repo.sourceRepositoryId).toBe("repo-1");
1936
1937 expect(routesOf(fake.captured)).toEqual([
1938 "POST /v1/projects",
1939 // Database looks up its logical ID before creating.
1940 "GET /v1/projects/project-1/branches",
1941 "GET /v1/databases",
1942 "POST /v1/databases",
1943 "GET /v1/databases/database-1/connections",
1944 "POST /v1/connections",
1945 "GET /v1/projects/project-1/branches",
1946 "POST /v1/projects/project-1/branches",
1947 "GET /v1/projects/project-1/branches",
1948 "POST /v1/services",
1949 "GET /v1/projects/project-1/branches",
1950 "POST /v1/services/service-1/deployments",
1951 "GET /v1/deployments/version-1",
1952 "POST /v1/environment-variables",
1953 "GET /v1/services",
1954 "GET /v1/projects/project-1/databases",
1955 "POST /v1/source-repositories",
1956 "GET /v1/source-repositories/repo-1",
1957 "GET /v1/projects/project-1/branches",
1958 ]);
1959 expect(fake.captured[0]?.bodyJson).toEqual({
1960 name: "app",
1961 createDatabase: false,
1962 region: "us-east-1",
1963 });
1964 expect(calls).toEqual([
1965 ["listBranches", { projectId: "project-1", query: { limit: "100" } }],
1966 [
1967 "createDatabase",
1968 // JSON transport drops `undefined` members.
1969 {
1970 projectId: "project-1",
1971 region: "us-east-1",
1972 name: "main",
1973 isDefault: false,
1974 logicalId: "Database",
1975 },
1976 ],
1977 ["listDatabaseConnections", { databaseId: "database-1", query: { limit: 100 } }],
1978 ["createConnection", { databaseId: "database-1", name: "api-000000000000" }],
1979 ["listBranches", { projectId: "project-1", query: {} }],
1980 [
1981 "createBranch",
1982 { projectId: "project-1", input: { gitName: "preview", isDefault: false } },
1983 ],
1984 ["listBranches", { projectId: "project-1", query: { limit: "100" } }],
1985 [
1986 "createApp",
1987 // JSON transport drops `undefined` members.
1988 {
1989 projectId: "project-1",
1990 displayName: "api",
1991 branchId: "branch-1",
1992 regionId: "us-east-1",
1993 logicalId: "App",
1994 },
1995 ],
1996 ["listBranches", { projectId: "project-1", query: { limit: "100" } }],
1997 [
1998 "createAppDeployment",
1999 { appId: "service-1", input: { portMapping: { http: 3000 }, skipCodeUpload: true } },
2000 ],
2001 ["getDeployment", "version-1"],
2002 [
2003 "createEnvironmentVariable",
2004 { projectId: "project-1", class: "production", key: "TOKEN", value: "secret" },
2005 ],
2006 [
2007 "listApps",
2008 // Query parameters arrive as strings over the wire.
2009 { limit: "100", projectId: "project-1", branchId: "unassigned" },
2010 ],
2011 ["listProjectDatabases", { projectId: "project-1", query: { limit: 100 } }],
2012 [
2013 "createSourceRepository",
2014 // JSON transport drops `undefined` members.
2015 { projectId: "project-1", provider: "github", providerRepositoryId: 123 },
2016 ],
2017 ["getSourceRepository", "repo-1"],
2018 ["listBranches", { projectId: "project-1", query: { limit: "100", gitName: "main" } }],
2019 ]);
2020 }).pipe(
2021 Effect.provide(providerLayer(client)),
2022 Effect.provide(fake.layer),
2023 Effect.provide(FetchHttpClient.layer),
2024 Effect.provideService(Stack, {
2025 name: "prisma-provider-test",
2026 stage: "test",
2027 resources: {},
2028 bindings: {},
2029 actions: {},
2030 }),
2031 Effect.provideService(Stage, "test"),
2032 );
2033 },
2034 {
2035 tags: [
2036 "provider:prisma:app",
2037 "provider:prisma:branch",
2038 "provider:prisma:connection",
2039 "provider:prisma:customdomain",
2040 "provider:prisma:database",
2041 "provider:prisma:deployment",
2042 "provider:prisma:environmentvariable",
2043 "provider:prisma:project",
2044 "provider:prisma:sourcerepository",
2045 ],
2046 },
2047 );
2048
2049 it.effect(
2050 "reconciles a Prisma custom domain through the client",
2051 () => {
2052 const { client, calls } = makeClient();
2053
2054 return Effect.gen(function* () {
2055 const domainProvider = yield* PrismaCustomDomain.Provider;
2056 const domain = yield* domainProvider.reconcile(
2057 reconcileInput("CustomDomain", { app: "service-1", hostname: "api.custom.test" }),
2058 );
2059
2060 expect(domain.customDomainId).toBe("domain-1");
2061 expect(domain.hostname).toBe("api.custom.test");
2062 expect(domain.appId).toBe("service-1");
2063 expect(domain.foundryStatus).toBe("pending_dns");
2064 expect(domain.dnsRecords[0]?.type).toBe("CNAME");
2065 expect(calls).toEqual([
2066 ["listAppDomains", "service-1"],
2067 ["createAppDomain", { appId: "service-1", input: { hostname: "api.custom.test" } }],
2068 ]);
2069 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2070 },
2071 {
2072 tags: [
2073 "provider:prisma:app",
2074 "provider:prisma:branch",
2075 "provider:prisma:connection",
2076 "provider:prisma:customdomain",
2077 "provider:prisma:database",
2078 "provider:prisma:deployment",
2079 "provider:prisma:environmentvariable",
2080 "provider:prisma:project",
2081 "provider:prisma:sourcerepository",
2082 ],
2083 },
2084 );
2085
2086 it.effect(
2087 "refuses to claim an existing custom domain during reconcile",
2088 () => {
2089 const { client, calls } = makeClient();
2090 const existing = {
2091 id: "domain-existing",
2092 type: "custom-domain" as const,
2093 url: "https://api.prisma.test/v1/domains/domain-existing",
2094 hostname: "api.custom.test",
2095 appId: "service-1",
2096 status: "active" as const,
2097 foundryStatus: "ready",
2098 failureReason: null,
2099 failureCategory: null,
2100 certExpiresAt: null,
2101 dnsRecords: [],
2102 createdAt,
2103 updatedAt,
2104 };
2105 Object.assign(client, {
2106 listAppDomains: (appId: string) =>
2107 Effect.sync(() => {
2108 calls.push(["listAppDomains", appId]);
2109 return [existing];
2110 }),
2111 createAppDomain: () => Effect.die("must not claim an existing domain"),
2112 });
2113
2114 return Effect.gen(function* () {
2115 const domainProvider = yield* PrismaCustomDomain.Provider;
2116 const error = yield* domainProvider
2117 .reconcile(
2118 reconcileInput("CustomDomain", { app: "service-1", hostname: "api.custom.test" }),
2119 )
2120 .pipe(Effect.flip);
2121
2122 expect((error as Error).message).toContain("explicit adoption");
2123 expect(calls).toEqual([["listAppDomains", "service-1"]]);
2124 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2125 },
2126 {
2127 tags: [
2128 "provider:prisma:app",
2129 "provider:prisma:branch",
2130 "provider:prisma:connection",
2131 "provider:prisma:customdomain",
2132 "provider:prisma:database",
2133 "provider:prisma:deployment",
2134 "provider:prisma:environmentvariable",
2135 "provider:prisma:project",
2136 "provider:prisma:sourcerepository",
2137 ],
2138 },
2139 );
2140
2141 it.effect(
2142 "routes a 200 custom-domain create race through explicit adoption",
2143 () => {
2144 const { client, calls } = makeClient();
2145 let visible = false;
2146 const raced = {
2147 id: "domain-raced",
2148 type: "custom-domain" as const,
2149 url: "https://api.prisma.test/v1/domains/domain-raced",
2150 hostname: "api.custom.test",
2151 appId: "service-1",
2152 status: "pending_dns" as const,
2153 foundryStatus: "pending",
2154 failureReason: null,
2155 failureCategory: null,
2156 certExpiresAt: null,
2157 dnsRecords: [],
2158 createdAt,
2159 updatedAt,
2160 };
2161 Object.assign(client, {
2162 listAppDomains: (appId: string) =>
2163 Effect.sync(() => {
2164 calls.push(["listAppDomains", appId]);
2165 return visible ? [raced] : [];
2166 }),
2167 createAppDomain: (appId: string, input: unknown) =>
2168 Effect.sync(() => {
2169 calls.push(["createAppDomain", { appId, input }]);
2170 visible = true;
2171 return { status: 200 as const, domain: raced };
2172 }),
2173 });
2174
2175 return Effect.gen(function* () {
2176 const domainProvider = yield* Provider.findProvider(PrismaCustomDomain);
2177 const error = yield* domainProvider
2178 .reconcile(reconcileInput("CustomDomain", { app: "service-1", hostname: raced.hostname }))
2179 .pipe(Effect.flip);
2180
2181 expect((error as Error).message).toContain("explicit adoption");
2182 expect(calls).toContainEqual([
2183 "createAppDomain",
2184 { appId: "service-1", input: { hostname: raced.hostname } },
2185 ]);
2186
2187 const observed = yield* domainProvider.read!(
2188 readInput("CustomDomain", { app: "service-1", hostname: raced.hostname }),
2189 );
2190 expect(observed?.customDomainId).toBe(raced.id);
2191 expect(Unowned.is(observed!)).toBe(true);
2192 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2193 },
2194 {
2195 tags: [
2196 "provider:prisma:app",
2197 "provider:prisma:branch",
2198 "provider:prisma:connection",
2199 "provider:prisma:customdomain",
2200 "provider:prisma:database",
2201 "provider:prisma:deployment",
2202 "provider:prisma:environmentvariable",
2203 "provider:prisma:project",
2204 "provider:prisma:sourcerepository",
2205 ],
2206 },
2207 );
2208
2209 it.effect(
2210 "normalizes Prisma custom domain hostnames when matching",
2211 () => {
2212 const { client, calls } = makeClient();
2213 Object.assign(client, {
2214 listAppDomains: (appId: string) =>
2215 Effect.sync(() => {
2216 calls.push(["listAppDomains", appId]);
2217 return [
2218 {
2219 id: "domain-1",
2220 type: "custom-domain" as const,
2221 url: "https://api.prisma.test/v1/domains/domain-1",
2222 hostname: "api.custom.test",
2223 appId: appId,
2224 status: "pending_dns" as const,
2225 foundryStatus: "pending",
2226 failureReason: null,
2227 failureCategory: null,
2228 certExpiresAt: null,
2229 dnsRecords: [
2230 {
2231 type: "CNAME" as const,
2232 name: "api.custom.test",
2233 value: "service-1.prisma.build",
2234 ttl: null,
2235 },
2236 ],
2237 createdAt,
2238 updatedAt,
2239 },
2240 ];
2241 }),
2242 });
2243
2244 return Effect.gen(function* () {
2245 const domainProvider = yield* Provider.findProvider(PrismaCustomDomain);
2246 const domain = yield* domainProvider.read!(
2247 readInput("CustomDomain", { app: "service-1", hostname: "API.CUSTOM.TEST." }),
2248 );
2249
2250 expect(domain?.customDomainId).toBe("domain-1");
2251 expect(domain?.hostname).toBe("api.custom.test");
2252 expect(Unowned.is(domain!)).toBe(true);
2253 expect(calls).toEqual([["listAppDomains", "service-1"]]);
2254 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2255 },
2256 {
2257 tags: [
2258 "provider:prisma:app",
2259 "provider:prisma:branch",
2260 "provider:prisma:connection",
2261 "provider:prisma:customdomain",
2262 "provider:prisma:database",
2263 "provider:prisma:deployment",
2264 "provider:prisma:environmentvariable",
2265 "provider:prisma:project",
2266 "provider:prisma:sourcerepository",
2267 ],
2268 },
2269 );
2270
2271 it.effect(
2272 "attaches Prisma custom domains to apps on non-default branches",
2273 () => {
2274 const { client, calls } = makeClient();
2275 Object.assign(client, {
2276 getBranch: (id: string) =>
2277 Effect.sync(() => {
2278 calls.push(["getBranch", id]);
2279 return {
2280 id,
2281 type: "branch" as const,
2282 url: `https://api.prisma.test/v1/branches/${id}`,
2283 gitName: "preview",
2284 isDefault: false,
2285 createdAt,
2286 updatedAt,
2287 project: resourceRef("projects", "project-1", "app"),
2288 };
2289 }),
2290 });
2291
2292 return Effect.gen(function* () {
2293 const domainProvider = yield* PrismaCustomDomain.Provider;
2294 const domain = yield* domainProvider.reconcile(
2295 reconcileInput("CustomDomain", { app: "service-1", hostname: "api.preview.test" }),
2296 );
2297
2298 expect(domain.customDomainId).toBe("domain-1");
2299 expect(domain.hostname).toBe("api.preview.test");
2300 expect(domain.appId).toBe("service-1");
2301 expect(calls).toContainEqual([
2302 "createAppDomain",
2303 { appId: "service-1", input: { hostname: "api.preview.test" } },
2304 ]);
2305 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2306 },
2307 {
2308 tags: [
2309 "provider:prisma:app",
2310 "provider:prisma:branch",
2311 "provider:prisma:connection",
2312 "provider:prisma:customdomain",
2313 "provider:prisma:database",
2314 "provider:prisma:deployment",
2315 "provider:prisma:environmentvariable",
2316 "provider:prisma:project",
2317 "provider:prisma:sourcerepository",
2318 ],
2319 },
2320 );
2321
2322 it.effect(
2323 "starts a direct deployment only after observing status",
2324 () => {
2325 const calls: Call[] = [];
2326 let status = "new";
2327 let latestDeploymentId: string | null = null;
2328 const client = {
2329 createAppDeployment: (appId: string, input: unknown) =>
2330 Effect.sync(() => {
2331 calls.push(["createAppDeployment", { appId, input }]);
2332 return {
2333 id: "version-1",
2334 type: "deployment" as const,
2335 url: "https://api.prisma.test/v1/deployments/version-1",
2336 foundryVersionId: "foundry-1",
2337 uploadUrl: null,
2338 };
2339 }),
2340 getDeployment: (id: string) =>
2341 Effect.sync(() => {
2342 calls.push(["getDeployment", id]);
2343 return {
2344 id,
2345 type: "deployment" as const,
2346 serviceId: "service-1",
2347 url: `https://api.prisma.test/v1/deployments/${id}`,
2348 foundryVersionId: "foundry-1",
2349 status,
2350 previewDomain: status === "running" ? "version-1.preview.prisma.build" : null,
2351 createdAt,
2352 };
2353 }),
2354 startDeployment: (id: string) =>
2355 Effect.sync(() => {
2356 calls.push(["startDeployment", id]);
2357 status = "running";
2358 return { previewDomain: "version-1.preview.prisma.build" };
2359 }),
2360 getApp: (id: string) =>
2361 Effect.sync(() => {
2362 calls.push(["getApp", id]);
2363 return {
2364 id,
2365 type: "app" as const,
2366 url: `https://api.prisma.test/v1/services/${id}`,
2367 name: "api-000000000000",
2368 region: { id: "us-east-1", name: "US East" },
2369 projectId: "project-1",
2370 branchId: null,
2371 latestDeploymentId,
2372 appEndpointDomain: "api.prisma.build",
2373 createdAt,
2374 };
2375 }),
2376 promoteApp: (appId: string, { deploymentId }: { deploymentId: string }) =>
2377 Effect.sync(() => {
2378 calls.push(["promoteApp", { appId, deploymentId }]);
2379 latestDeploymentId = deploymentId;
2380 return { appEndpointDomain: "api.prisma.build" };
2381 }),
2382 } as unknown as PrismaManagementClient;
2383
2384 return Effect.gen(function* () {
2385 const provider = yield* PrismaDeployment.Provider;
2386 const output = yield* provider.reconcile(
2387 reconcileInput("Deployment", {
2388 app: "service-1",
2389 skipCodeUpload: true,
2390 start: true,
2391 promote: true,
2392 }),
2393 );
2394
2395 expect(output.status).toBe("running");
2396 expect(output.previewDomain).toBe("version-1.preview.prisma.build");
2397 expect(output.appEndpointDomain).toBe("api.prisma.build");
2398 expect(calls).toEqual([
2399 [
2400 "createAppDeployment",
2401 { appId: "service-1", input: { portMapping: undefined, skipCodeUpload: true } },
2402 ],
2403 ["getDeployment", "version-1"],
2404 ["startDeployment", "version-1"],
2405 ["getDeployment", "version-1"],
2406 ["promoteApp", { appId: "service-1", deploymentId: "version-1" }],
2407 ["getApp", "service-1"],
2408 ]);
2409 }).pipe(
2410 Effect.provide(providerLayer(client)),
2411 Effect.provide(managementApi(client).layer),
2412 Effect.provide(FetchHttpClient.layer),
2413 Effect.provideService(Stack, {
2414 name: "prisma-deployment-test",
2415 stage: "test",
2416 resources: {},
2417 bindings: {},
2418 actions: {},
2419 }),
2420 Effect.provideService(Stage, "test"),
2421 );
2422 },
2423 {
2424 tags: [
2425 "provider:prisma:app",
2426 "provider:prisma:branch",
2427 "provider:prisma:connection",
2428 "provider:prisma:customdomain",
2429 "provider:prisma:database",
2430 "provider:prisma:deployment",
2431 "provider:prisma:environmentvariable",
2432 "provider:prisma:project",
2433 "provider:prisma:sourcerepository",
2434 ],
2435 },
2436 );
2437
2438 it.effect(
2439 "ignores branch env overrides when reconciling project env vars",
2440 () => {
2441 const calls: Call[] = [];
2442 const branchVariable = {
2443 id: "env-branch",
2444 type: "environment-variable" as const,
2445 url: "https://api.prisma.test/v1/environment-variables/env-branch",
2446 projectId: "project-1",
2447 branchId: "branch-1",
2448 class: "production" as const,
2449 key: "TOKEN",
2450 valueKid: "kid-branch",
2451 isManagedBySystem: false,
2452 createdAt,
2453 updatedAt,
2454 };
2455 const projectVariable = {
2456 id: "env-project",
2457 type: "environment-variable" as const,
2458 url: "https://api.prisma.test/v1/environment-variables/env-project",
2459 projectId: "project-1",
2460 branchId: null,
2461 class: "production" as const,
2462 key: "TOKEN",
2463 valueKid: "kid-old",
2464 isManagedBySystem: false,
2465 createdAt,
2466 updatedAt,
2467 };
2468 const client = {
2469 listEnvironmentVariables: (query: unknown) =>
2470 Effect.sync(() => {
2471 calls.push(["listEnvironmentVariables", query]);
2472 return [
2473 branchVariable,
2474 { ...branchVariable, id: "env-branch-2", branchId: "branch-2" },
2475 projectVariable,
2476 ];
2477 }),
2478 getEnvironmentVariable: (id: string) =>
2479 Effect.sync(() => {
2480 calls.push(["getEnvironmentVariable", id]);
2481 return projectVariable;
2482 }),
2483 updateEnvironmentVariable: (id: string, input: unknown) =>
2484 Effect.sync(() => {
2485 calls.push(["updateEnvironmentVariable", { id, input }]);
2486 return {
2487 ...projectVariable,
2488 id,
2489 valueKid: "kid-new",
2490 updatedAt: "2026-01-01T00:00:02Z",
2491 };
2492 }),
2493 } as unknown as PrismaManagementClient;
2494
2495 return Effect.gen(function* () {
2496 const envProvider = yield* Provider.findProvider(PrismaEnvironmentVariable);
2497 const observed = yield* envProvider.read!(
2498 readInput("EnvironmentVariable", {
2499 project: "project-1",
2500 class: "production" as const,
2501 key: "TOKEN",
2502 value: Redacted.make("secret"),
2503 }),
2504 );
2505 expect(Unowned.is(observed!)).toBe(true);
2506 const env = yield* envProvider.reconcile(
2507 reconcileInput(
2508 "EnvironmentVariable",
2509 {
2510 project: "project-1",
2511 class: "production" as const,
2512 key: "TOKEN",
2513 value: Redacted.make("secret"),
2514 },
2515 observed,
2516 ),
2517 );
2518
2519 expect(env.environmentVariableId).toBe("env-project");
2520 expect(env.branchId).toBeNull();
2521 expect(redactedValue(env.value)).toBe("secret");
2522 expect(calls).toEqual([
2523 [
2524 "listEnvironmentVariables",
2525 // Query parameters arrive as strings over the wire.
2526 { limit: "100", projectId: "project-1", class: "production", key: "TOKEN" },
2527 ],
2528 ["getEnvironmentVariable", "env-project"],
2529 ["updateEnvironmentVariable", { id: "env-project", input: { value: "secret" } }],
2530 ]);
2531 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2532 },
2533 {
2534 tags: [
2535 "provider:prisma:app",
2536 "provider:prisma:branch",
2537 "provider:prisma:connection",
2538 "provider:prisma:customdomain",
2539 "provider:prisma:database",
2540 "provider:prisma:deployment",
2541 "provider:prisma:environmentvariable",
2542 "provider:prisma:project",
2543 "provider:prisma:sourcerepository",
2544 ],
2545 },
2546 );
2547
2548 it.effect(
2549 "refuses to mutate system-managed environment variables",
2550 () => {
2551 const calls: Call[] = [];
2552 const systemVariable = {
2553 id: "env-system",
2554 type: "environment-variable" as const,
2555 url: "https://api.prisma.test/v1/environment-variables/env-system",
2556 projectId: "project-1",
2557 branchId: null,
2558 class: "production" as const,
2559 key: "PRISMA_INTERNAL_URL",
2560 valueKid: "kid-system",
2561 isManagedBySystem: true,
2562 createdAt,
2563 updatedAt,
2564 };
2565 const client = {
2566 listEnvironmentVariables: (query: unknown) =>
2567 Effect.sync(() => {
2568 calls.push(["listEnvironmentVariables", query]);
2569 return [systemVariable];
2570 }),
2571 getEnvironmentVariable: (id: string) =>
2572 Effect.sync(() => {
2573 calls.push(["getEnvironmentVariable", id]);
2574 return systemVariable;
2575 }),
2576 updateEnvironmentVariable: (id: string, input: unknown) =>
2577 Effect.sync(() => {
2578 calls.push(["updateEnvironmentVariable", { id, input }]);
2579 return systemVariable;
2580 }),
2581 } as unknown as PrismaManagementClient;
2582
2583 return Effect.gen(function* () {
2584 const envProvider = yield* Provider.findProvider(PrismaEnvironmentVariable);
2585 const observed = yield* envProvider.read!(
2586 readInput("EnvironmentVariable", {
2587 project: "project-1",
2588 class: "production" as const,
2589 key: "PRISMA_INTERNAL_URL",
2590 value: Redacted.make("secret"),
2591 }),
2592 );
2593 const error = yield* envProvider
2594 .reconcile(
2595 reconcileInput(
2596 "EnvironmentVariable",
2597 {
2598 project: "project-1",
2599 class: "production" as const,
2600 key: "PRISMA_INTERNAL_URL",
2601 value: Redacted.make("secret"),
2602 },
2603 observed,
2604 ),
2605 )
2606 .pipe(Effect.flip);
2607
2608 expect(error).toBeInstanceOf(Error);
2609 expect((error as Error).message).toContain(
2610 "is managed by Prisma and cannot be managed by Alchemy",
2611 );
2612 expect(calls).toEqual([
2613 [
2614 "listEnvironmentVariables",
2615 // Query parameters arrive as strings over the wire.
2616 {
2617 limit: "100",
2618 projectId: "project-1",
2619 class: "production",
2620 key: "PRISMA_INTERNAL_URL",
2621 },
2622 ],
2623 ["getEnvironmentVariable", "env-system"],
2624 ]);
2625 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2626 },
2627 {
2628 tags: [
2629 "provider:prisma:app",
2630 "provider:prisma:branch",
2631 "provider:prisma:connection",
2632 "provider:prisma:customdomain",
2633 "provider:prisma:database",
2634 "provider:prisma:deployment",
2635 "provider:prisma:environmentvariable",
2636 "provider:prisma:project",
2637 "provider:prisma:sourcerepository",
2638 ],
2639 },
2640 );
2641
2642 it.effect(
2643 "skips direct delete for system-managed environment variables",
2644 () => {
2645 const calls: Call[] = [];
2646 const notes: string[] = [];
2647 const client = {
2648 getEnvironmentVariable: (id: string) =>
2649 Effect.sync(() => {
2650 calls.push(["getEnvironmentVariable", id]);
2651 return {
2652 id,
2653 type: "environment-variable" as const,
2654 url: `https://api.prisma.test/v1/environment-variables/${id}`,
2655 projectId: "project-1",
2656 branchId: null,
2657 class: "production" as const,
2658 key: "PRISMA_INTERNAL_URL",
2659 valueKid: "kid-system",
2660 isManagedBySystem: true,
2661 createdAt,
2662 updatedAt,
2663 };
2664 }),
2665 deleteEnvironmentVariable: (id: string) =>
2666 Effect.sync(() => {
2667 calls.push(["deleteEnvironmentVariable", id]);
2668 }),
2669 } as unknown as PrismaManagementClient;
2670
2671 return Effect.gen(function* () {
2672 const envProvider = yield* PrismaEnvironmentVariable.Provider;
2673 yield* envProvider.delete!({
2674 id: "EnvironmentVariable",
2675 fqn: "EnvironmentVariable",
2676 instanceId: "00000000000000000000000000000000",
2677 olds: {} as never,
2678 output: {
2679 environmentVariableId: "env-system",
2680 projectId: "project-1",
2681 branchId: null,
2682 class: "production",
2683 key: "PRISMA_INTERNAL_URL",
2684 value: Redacted.make("secret"),
2685 valueKid: "kid-system",
2686 isManagedBySystem: true,
2687 createdAt,
2688 updatedAt,
2689 },
2690 session: {
2691 note: (message: string) =>
2692 Effect.sync(() => {
2693 notes.push(message);
2694 }),
2695 } as never,
2696 bindings: [],
2697 });
2698
2699 expect(calls).toEqual([["getEnvironmentVariable", "env-system"]]);
2700 expect(notes).toEqual([
2701 "Skipping direct delete for system-managed Prisma environment variable 'PRISMA_INTERNAL_URL'.",
2702 ]);
2703 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2704 },
2705 {
2706 tags: [
2707 "provider:prisma:app",
2708 "provider:prisma:branch",
2709 "provider:prisma:connection",
2710 "provider:prisma:customdomain",
2711 "provider:prisma:database",
2712 "provider:prisma:deployment",
2713 "provider:prisma:environmentvariable",
2714 "provider:prisma:project",
2715 "provider:prisma:sourcerepository",
2716 ],
2717 },
2718 );
2719
2720 it.effect(
2721 "checks live environment variable ownership before deleting",
2722 () => {
2723 const calls: Call[] = [];
2724 const client = {
2725 getEnvironmentVariable: (id: string) =>
2726 Effect.sync(() => {
2727 calls.push(["getEnvironmentVariable", id]);
2728 return {
2729 id,
2730 type: "environment-variable" as const,
2731 url: `https://api.prisma.test/v1/environment-variables/${id}`,
2732 projectId: "project-1",
2733 branchId: null,
2734 class: "production" as const,
2735 key: "PRISMA_INTERNAL_URL",
2736 valueKid: "kid-system",
2737 isManagedBySystem: true,
2738 createdAt,
2739 updatedAt,
2740 };
2741 }),
2742 deleteEnvironmentVariable: (id: string) =>
2743 Effect.sync(() => {
2744 calls.push(["deleteEnvironmentVariable", id]);
2745 }),
2746 } as unknown as PrismaManagementClient;
2747
2748 const session = {
2749 note: (message: string) =>
2750 Effect.sync(() => {
2751 calls.push(["note", message]);
2752 }),
2753 };
2754
2755 return Effect.gen(function* () {
2756 const envProvider = yield* PrismaEnvironmentVariable.Provider;
2757 yield* envProvider.delete!({
2758 id: "EnvironmentVariable",
2759 fqn: "EnvironmentVariable",
2760 instanceId: "00000000000000000000000000000000",
2761 olds: {} as never,
2762 output: {
2763 environmentVariableId: "env-system",
2764 projectId: "project-1",
2765 branchId: null,
2766 class: "production",
2767 key: "PRISMA_INTERNAL_URL",
2768 value: Redacted.make("secret"),
2769 valueKid: "kid-user",
2770 isManagedBySystem: false,
2771 createdAt,
2772 updatedAt,
2773 },
2774 session: session as never,
2775 bindings: [],
2776 });
2777
2778 expect(calls).toEqual([
2779 ["getEnvironmentVariable", "env-system"],
2780 [
2781 "note",
2782 "Skipping direct delete for system-managed Prisma environment variable 'PRISMA_INTERNAL_URL'.",
2783 ],
2784 ]);
2785 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2786 },
2787 {
2788 tags: [
2789 "provider:prisma:app",
2790 "provider:prisma:branch",
2791 "provider:prisma:connection",
2792 "provider:prisma:customdomain",
2793 "provider:prisma:database",
2794 "provider:prisma:deployment",
2795 "provider:prisma:environmentvariable",
2796 "provider:prisma:project",
2797 "provider:prisma:sourcerepository",
2798 ],
2799 },
2800 );
2801
2802 it.effect(
2803 "deletes an environment variable when stale state says system-managed",
2804 () => {
2805 const calls: Call[] = [];
2806 const client = {
2807 getEnvironmentVariable: (id: string) =>
2808 Effect.sync(() => {
2809 calls.push(["getEnvironmentVariable", id]);
2810 return {
2811 id,
2812 type: "environment-variable" as const,
2813 url: `https://api.prisma.test/v1/environment-variables/${id}`,
2814 projectId: "project-1",
2815 branchId: null,
2816 class: "production" as const,
2817 key: "PRISMA_INTERNAL_URL",
2818 valueKid: "kid-user",
2819 isManagedBySystem: false,
2820 createdAt,
2821 updatedAt,
2822 };
2823 }),
2824 deleteEnvironmentVariable: (id: string) =>
2825 Effect.sync(() => {
2826 calls.push(["deleteEnvironmentVariable", id]);
2827 }),
2828 } as unknown as PrismaManagementClient;
2829
2830 return Effect.gen(function* () {
2831 const envProvider = yield* PrismaEnvironmentVariable.Provider;
2832 yield* envProvider.delete!({
2833 id: "EnvironmentVariable",
2834 fqn: "EnvironmentVariable",
2835 instanceId: "00000000000000000000000000000000",
2836 olds: {} as never,
2837 output: {
2838 environmentVariableId: "env-1",
2839 projectId: "project-1",
2840 branchId: null,
2841 class: "production",
2842 key: "PRISMA_INTERNAL_URL",
2843 value: Redacted.make("secret"),
2844 valueKid: "kid-system",
2845 isManagedBySystem: true,
2846 createdAt,
2847 updatedAt,
2848 },
2849 session: undefined as never,
2850 bindings: [],
2851 });
2852
2853 expect(calls).toEqual([
2854 ["getEnvironmentVariable", "env-1"],
2855 ["deleteEnvironmentVariable", "env-1"],
2856 ]);
2857 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2858 },
2859 {
2860 tags: [
2861 "provider:prisma:app",
2862 "provider:prisma:branch",
2863 "provider:prisma:connection",
2864 "provider:prisma:customdomain",
2865 "provider:prisma:database",
2866 "provider:prisma:deployment",
2867 "provider:prisma:environmentvariable",
2868 "provider:prisma:project",
2869 "provider:prisma:sourcerepository",
2870 ],
2871 },
2872 );
2873
2874 it.effect(
2875 "validates Prisma environment variable writes locally",
2876 () => {
2877 const calls: Call[] = [];
2878 const client = {
2879 listEnvironmentVariables: (query: unknown) =>
2880 Effect.sync(() => {
2881 calls.push(["listEnvironmentVariables", query]);
2882 return [];
2883 }),
2884 createEnvironmentVariable: (input: unknown) =>
2885 Effect.sync(() => {
2886 calls.push(["createEnvironmentVariable", input]);
2887 return {
2888 id: "env-1",
2889 type: "environment-variable" as const,
2890 url: "https://api.prisma.test/v1/environment-variables/env-1",
2891 projectId: "project-1",
2892 branchId: null,
2893 class: "production" as const,
2894 key: "TOKEN",
2895 valueKid: "kid-1",
2896 isManagedBySystem: false,
2897 createdAt,
2898 updatedAt,
2899 };
2900 }),
2901 } as unknown as PrismaManagementClient;
2902
2903 return Effect.gen(function* () {
2904 const envProvider = yield* PrismaEnvironmentVariable.Provider;
2905 const invalidKey = yield* envProvider
2906 .reconcile(
2907 reconcileInput("EnvironmentVariable", {
2908 project: "project-1",
2909 class: "production" as const,
2910 key: "bad-key",
2911 value: Redacted.make("secret"),
2912 }),
2913 )
2914 .pipe(Effect.flip);
2915 const emptyValue = yield* envProvider
2916 .reconcile(
2917 reconcileInput("EnvironmentVariable", {
2918 project: "project-1",
2919 class: "production" as const,
2920 key: "TOKEN",
2921 value: Redacted.make(""),
2922 }),
2923 )
2924 .pipe(Effect.flip);
2925
2926 expect(invalidKey).toBeInstanceOf(Error);
2927 expect((invalidKey as Error).message).toContain("must match POSIX env-var key shape");
2928 expect(emptyValue).toBeInstanceOf(Error);
2929 expect((emptyValue as Error).message).toContain("value must be non-empty");
2930 expect(calls).toEqual([]);
2931 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
2932 },
2933 {
2934 tags: [
2935 "provider:prisma:app",
2936 "provider:prisma:branch",
2937 "provider:prisma:connection",
2938 "provider:prisma:customdomain",
2939 "provider:prisma:database",
2940 "provider:prisma:deployment",
2941 "provider:prisma:environmentvariable",
2942 "provider:prisma:project",
2943 "provider:prisma:sourcerepository",
2944 ],
2945 },
2946 );
2947
2948 it.effect(
2949 "updates mutable Prisma resources from observed state",
2950 () => {
2951 const calls: Call[] = [];
2952 const client = {
2953 getDatabase: (id: string) =>
2954 Effect.sync(() => {
2955 calls.push(["getDatabase", id]);
2956 return {
2957 id,
2958 type: "database" as const,
2959 url: `https://api.prisma.test/v1/databases/${id}`,
2960 name: "main",
2961 status: "ready" as const,
2962 createdAt,
2963 isDefault: false,
2964 defaultConnectionId: "connection-1",
2965 connections: [databaseConnection(id, "connection-1")],
2966 project: resourceRef("projects", "project-1", "app"),
2967 region: { id: "us-east-1", name: "US East" },
2968 source: { type: "empty" },
2969 branchId: null,
2970 };
2971 }),
2972 updateDatabase: (id: string, input: unknown) =>
2973 Effect.sync(() => {
2974 calls.push(["updateDatabase", { id, input }]);
2975 return {
2976 id,
2977 type: "database" as const,
2978 url: `https://api.prisma.test/v1/databases/${id}`,
2979 name: "primary",
2980 status: "ready" as const,
2981 createdAt,
2982 isDefault: false,
2983 defaultConnectionId: "connection-1",
2984 connections: [databaseConnection(id, "connection-1")],
2985 project: resourceRef("projects", "project-1", "app"),
2986 region: { id: "us-east-1", name: "US East" },
2987 source: { type: "empty" },
2988 branchId: "branch-1",
2989 };
2990 }),
2991 getConnection: (id: string) =>
2992 Effect.sync(() => {
2993 calls.push(["getConnection", id]);
2994 return {
2995 id,
2996 type: "connection" as const,
2997 url: `https://api.prisma.test/v1/connections/${id}`,
2998 name: "api-000000000000",
2999 createdAt,
3000 kind: "postgres" as const,
3001 endpoints: {
3002 direct: {
3003 host: "db.prisma.test",
3004 port: 5432,
3005 connectionString: "postgres://old-direct",
3006 },
3007 },
3008 database: resourceRef("databases", "database-1", "main"),
3009 };
3010 }),
3011 rotateConnection: (id: string) =>
3012 Effect.sync(() => {
3013 calls.push(["rotateConnection", id]);
3014 return {
3015 id,
3016 type: "connection" as const,
3017 url: `https://api.prisma.test/v1/connections/${id}`,
3018 name: "api-000000000000",
3019 createdAt,
3020 kind: "postgres" as const,
3021 endpoints: {
3022 direct: {
3023 host: "db.prisma.test",
3024 port: 5432,
3025 connectionString: "postgres://app:new-password@db.prisma.test/database-1",
3026 },
3027 },
3028 database: resourceRef("databases", "database-1", "main"),
3029 };
3030 }),
3031 getBranch: (id: string) =>
3032 Effect.sync(() => {
3033 calls.push(["getBranch", id]);
3034 return {
3035 id,
3036 type: "branch" as const,
3037 url: `https://api.prisma.test/v1/branches/${id}`,
3038 gitName: "main",
3039 isDefault: false,
3040 role: "preview" as const,
3041 createdAt,
3042 updatedAt,
3043 project: resourceRef("projects", "project-1", "app"),
3044 };
3045 }),
3046 updateBranch: (id: string, input: unknown) =>
3047 Effect.sync(() => {
3048 calls.push(["updateBranch", { id, input }]);
3049 return {
3050 id,
3051 type: "branch" as const,
3052 url: `https://api.prisma.test/v1/branches/${id}`,
3053 gitName: "main",
3054 isDefault: true,
3055 role: "preview" as const,
3056 createdAt,
3057 updatedAt: "2026-01-01T00:00:02Z",
3058 project: resourceRef("projects", "project-1", "app"),
3059 };
3060 }),
3061 listBranches: (projectId: string, query: unknown) =>
3062 Effect.sync(() => {
3063 calls.push(["listBranches", { projectId, query }]);
3064 return [
3065 {
3066 id: "branch-default",
3067 type: "branch" as const,
3068 url: "https://api.prisma.test/v1/branches/branch-default",
3069 gitName: "production",
3070 isDefault: true,
3071 role: "production" as const,
3072 createdAt,
3073 updatedAt,
3074 project: resourceRef("projects", projectId, "app"),
3075 },
3076 ];
3077 }),
3078 getApp: (id: string) =>
3079 Effect.sync(() => {
3080 calls.push(["getApp", id]);
3081 return {
3082 id,
3083 type: "app" as const,
3084 url: `https://api.prisma.test/v1/services/${id}`,
3085 name: "api",
3086 region: { id: "us-east-1", name: "US East" },
3087 projectId: "project-1",
3088 branchId: null,
3089 latestDeploymentId: null,
3090 appEndpointDomain: "service-1.prisma.build",
3091 createdAt,
3092 };
3093 }),
3094 updateApp: (id: string, input: unknown) =>
3095 Effect.sync(() => {
3096 calls.push(["updateApp", { id, input }]);
3097 return {
3098 id,
3099 type: "app" as const,
3100 url: `https://api.prisma.test/v1/services/${id}`,
3101 name: "web",
3102 region: { id: "us-east-1", name: "US East" },
3103 projectId: "project-1",
3104 branchId: "branch-1",
3105 latestDeploymentId: null,
3106 appEndpointDomain: "service-1.prisma.build",
3107 createdAt,
3108 };
3109 }),
3110 getEnvironmentVariable: (id: string) =>
3111 Effect.sync(() => {
3112 calls.push(["getEnvironmentVariable", id]);
3113 return {
3114 id,
3115 type: "environment-variable" as const,
3116 url: `https://api.prisma.test/v1/environment-variables/${id}`,
3117 projectId: "project-1",
3118 branchId: null,
3119 class: "production" as const,
3120 key: "TOKEN",
3121 valueKid: "kid-old",
3122 isManagedBySystem: false,
3123 createdAt,
3124 updatedAt,
3125 };
3126 }),
3127 updateEnvironmentVariable: (id: string, input: unknown) =>
3128 Effect.sync(() => {
3129 calls.push(["updateEnvironmentVariable", { id, input }]);
3130 return {
3131 id,
3132 type: "environment-variable" as const,
3133 url: `https://api.prisma.test/v1/environment-variables/${id}`,
3134 projectId: "project-1",
3135 branchId: null,
3136 class: "production" as const,
3137 key: "TOKEN",
3138 valueKid: "kid-new",
3139 isManagedBySystem: false,
3140 createdAt,
3141 updatedAt: "2026-01-01T00:00:02Z",
3142 };
3143 }),
3144 } as unknown as PrismaManagementClient;
3145
3146 return Effect.gen(function* () {
3147 const databaseProvider = yield* PrismaDatabase.Provider;
3148 const connectionProvider = yield* PrismaConnection.Provider;
3149 const branchProvider = yield* PrismaBranch.Provider;
3150 const serviceProvider = yield* PrismaApp.Provider;
3151 const envProvider = yield* PrismaEnvironmentVariable.Provider;
3152
3153 const database = yield* databaseProvider.reconcile(
3154 reconcileInput(
3155 "Database",
3156 { project: "project-1", name: "primary", region: "us-east-1", branchId: "branch-1" },
3157 {
3158 databaseId: "database-1",
3159 databaseName: "main",
3160 projectId: "project-1",
3161 status: "ready",
3162 region: "us-east-1",
3163 isDefault: false,
3164 branchId: null,
3165 defaultConnectionId: "connection-1",
3166 createdAt,
3167 directConnectionString: undefined,
3168 pooledConnectionString: undefined,
3169 accelerateConnectionString: undefined,
3170 host: undefined,
3171 user: undefined,
3172 password: undefined,
3173 logicalId: null,
3174 },
3175 ),
3176 );
3177 const connection = yield* connectionProvider.reconcile(
3178 reconcileInput(
3179 "Connection",
3180 { database: "database-1", name: "api", rotate: true },
3181 {
3182 connectionId: "connection-1",
3183 connectionName: "api-000000000000",
3184 databaseId: "database-1",
3185 kind: "postgres" as const,
3186 createdAt,
3187 directConnectionString: Redacted.make("postgres://old-direct"),
3188 pooledConnectionString: undefined,
3189 accelerateConnectionString: undefined,
3190 host: "db.prisma.test",
3191 user: undefined,
3192 password: undefined,
3193 databaseUrl: Redacted.make("postgres://old-direct"),
3194 origin: undefined,
3195 pooledOrigin: undefined,
3196 },
3197 { database: "database-1", name: "api", rotate: false },
3198 ),
3199 );
3200 const branch = yield* branchProvider.reconcile(
3201 reconcileInput(
3202 "Branch",
3203 { project: "project-1", gitName: "main", isDefault: true },
3204 {
3205 branchId: "branch-1",
3206 gitName: "main",
3207 projectId: "project-1",
3208 isDefault: false,
3209 role: "preview",
3210 createdAt,
3211 updatedAt,
3212 },
3213 ),
3214 );
3215 const service = yield* serviceProvider.reconcile(
3216 reconcileInput(
3217 "App",
3218 {
3219 project: "project-1",
3220 displayName: "web",
3221 regionId: "us-east-1",
3222 branchId: "branch-1",
3223 },
3224 {
3225 appId: "service-1",
3226 name: "api",
3227 projectId: "project-1",
3228 regionId: "us-east-1",
3229 branchId: null,
3230 latestDeploymentId: null,
3231 appEndpointDomain: "service-1.prisma.build",
3232 createdAt,
3233 logicalId: null,
3234 },
3235 ),
3236 );
3237 const env = yield* envProvider.reconcile(
3238 reconcileInput(
3239 "EnvironmentVariable",
3240 {
3241 project: "project-1",
3242 class: "production" as const,
3243 key: "TOKEN",
3244 value: Redacted.make("new-secret"),
3245 },
3246 {
3247 environmentVariableId: "env-1",
3248 projectId: "project-1",
3249 branchId: null,
3250 class: "production" as const,
3251 key: "TOKEN",
3252 value: Redacted.make("old-secret"),
3253 valueKid: "kid-old",
3254 isManagedBySystem: false,
3255 createdAt,
3256 updatedAt,
3257 },
3258 ),
3259 );
3260
3261 expect(database.databaseName).toBe("primary");
3262 expect(database.branchId).toBe("branch-1");
3263 expect(Redacted.value(connection.directConnectionString!)).toBe(
3264 "postgres://app:new-password@db.prisma.test/database-1",
3265 );
3266 expect(connection.user).toBe("app");
3267 expect(Redacted.value(connection.password!)).toBe("new-password");
3268 expectJsonNotToContain(
3269 connection,
3270 "postgres://app:new-password@db.prisma.test/database-1",
3271 "new-password",
3272 );
3273 expect(branch.isDefault).toBe(true);
3274 expect(service.name).toBe("web");
3275 expect(service.branchId).toBe("branch-1");
3276 expect(env.valueKid).toBe("kid-new");
3277 expect(Redacted.value(env.value)).toBe("new-secret");
3278 expectJsonNotToContain(env, "new-secret");
3279 expect(calls).toEqual([
3280 ["getDatabase", "database-1"],
3281 [
3282 "updateDatabase",
3283 {
3284 id: "database-1",
3285 // JSON transport drops `undefined` members.
3286 input: { name: "primary", branchId: "branch-1" },
3287 },
3288 ],
3289 // A database from before logical IDs gets its fqn stamped once.
3290 ["updateDatabase", { id: "database-1", input: { logicalId: "Database" } }],
3291 ["getConnection", "connection-1"],
3292 ["rotateConnection", "connection-1"],
3293 ["getBranch", "branch-1"],
3294 ["listBranches", { projectId: "project-1", query: {} }],
3295 ["updateBranch", { id: "branch-1", input: { isDefault: true } }],
3296 ["getApp", "service-1"],
3297 [
3298 "updateApp",
3299 {
3300 id: "service-1",
3301 input: { displayName: "web", branchId: "branch-1", branchGitName: undefined },
3302 },
3303 ],
3304 ["updateApp", { id: "service-1", input: { logicalId: "App" } }],
3305 ["getEnvironmentVariable", "env-1"],
3306 ["updateEnvironmentVariable", { id: "env-1", input: { value: "new-secret" } }],
3307 ]);
3308 }).pipe(
3309 Effect.provide(providerLayer(client)),
3310 Effect.provide(managementApi(client).layer),
3311 Effect.provide(FetchHttpClient.layer),
3312 Effect.provideService(Stack, {
3313 name: "prisma-provider-update-test",
3314 stage: "test",
3315 resources: {},
3316 bindings: {},
3317 actions: {},
3318 }),
3319 Effect.provideService(Stage, "test"),
3320 );
3321 },
3322 {
3323 tags: [
3324 "provider:prisma:app",
3325 "provider:prisma:branch",
3326 "provider:prisma:connection",
3327 "provider:prisma:customdomain",
3328 "provider:prisma:database",
3329 "provider:prisma:deployment",
3330 "provider:prisma:environmentvariable",
3331 "provider:prisma:project",
3332 "provider:prisma:sourcerepository",
3333 ],
3334 },
3335 );
3336
3337 it.effect(
3338 "skips branchGitName updates when observed branch ids already match",
3339 () => {
3340 const calls: Call[] = [];
3341 const branch = {
3342 id: "branch-main",
3343 type: "branch" as const,
3344 url: "https://api.prisma.test/v1/branches/branch-main",
3345 gitName: "main",
3346 isDefault: true,
3347 createdAt,
3348 updatedAt,
3349 project: resourceRef("projects", "project-1", "app"),
3350 };
3351 const client = {
3352 getDatabase: (id: string) =>
3353 Effect.sync(() => {
3354 calls.push(["getDatabase", id]);
3355 return {
3356 id,
3357 type: "database" as const,
3358 url: `https://api.prisma.test/v1/databases/${id}`,
3359 name: "main",
3360 status: "ready" as const,
3361 createdAt,
3362 isDefault: false,
3363 defaultConnectionId: "connection-1",
3364 connections: [databaseConnection(id, "connection-1")],
3365 project: resourceRef("projects", "project-1", "app"),
3366 region: { id: "us-east-1", name: "US East" },
3367 source: { type: "empty" },
3368 branchId: "branch-main",
3369 logicalId: "Database",
3370 };
3371 }),
3372 getApp: (id: string) =>
3373 Effect.sync(() => {
3374 calls.push(["getApp", id]);
3375 return {
3376 id,
3377 type: "app" as const,
3378 url: `https://api.prisma.test/v1/services/${id}`,
3379 name: "api",
3380 region: { id: "us-east-1", name: "US East" },
3381 projectId: "project-1",
3382 branchId: "branch-main",
3383 latestDeploymentId: null,
3384 appEndpointDomain: "service-1.prisma.build",
3385 createdAt,
3386 logicalId: "App",
3387 };
3388 }),
3389 listBranches: (projectId: string, query: unknown) =>
3390 Effect.sync(() => {
3391 calls.push(["listBranches", { projectId, query }]);
3392 return [branch];
3393 }),
3394 updateDatabase: (id: string, input: unknown) =>
3395 Effect.sync(() => {
3396 calls.push(["updateDatabase", { id, input }]);
3397 throw new Error("updateDatabase should not be called");
3398 }),
3399 updateApp: (id: string, input: unknown) =>
3400 Effect.sync(() => {
3401 calls.push(["updateApp", { id, input }]);
3402 throw new Error("updateApp should not be called");
3403 }),
3404 } as unknown as PrismaManagementClient;
3405
3406 return Effect.gen(function* () {
3407 const databaseProvider = yield* PrismaDatabase.Provider;
3408 const serviceProvider = yield* PrismaApp.Provider;
3409
3410 const database = yield* databaseProvider.reconcile(
3411 reconcileInput(
3412 "Database",
3413 { project: "project-1", name: "main", region: "us-east-1", branchGitName: "main" },
3414 {
3415 databaseId: "database-1",
3416 databaseName: "main",
3417 projectId: "project-1",
3418 status: "ready",
3419 region: "us-east-1",
3420 isDefault: false,
3421 branchId: "branch-main",
3422 defaultConnectionId: "connection-1",
3423 createdAt,
3424 directConnectionString: undefined,
3425 pooledConnectionString: undefined,
3426 accelerateConnectionString: undefined,
3427 host: undefined,
3428 user: undefined,
3429 password: undefined,
3430 logicalId: null,
3431 },
3432 ),
3433 );
3434 const service = yield* serviceProvider.reconcile(
3435 reconcileInput(
3436 "App",
3437 {
3438 project: "project-1",
3439 displayName: "api",
3440 regionId: "us-east-1",
3441 branchGitName: "main",
3442 },
3443 {
3444 appId: "service-1",
3445 name: "api",
3446 projectId: "project-1",
3447 regionId: "us-east-1",
3448 branchId: "branch-main",
3449 latestDeploymentId: null,
3450 appEndpointDomain: "service-1.prisma.build",
3451 createdAt,
3452 logicalId: null,
3453 },
3454 ),
3455 );
3456
3457 expect(database.branchId).toBe("branch-main");
3458 expect(service.branchId).toBe("branch-main");
3459 expect(calls).toEqual([
3460 ["getDatabase", "database-1"],
3461 [
3462 "listBranches",
3463 // Query parameters arrive as strings over the wire.
3464 { projectId: "project-1", query: { limit: "2", gitName: "main" } },
3465 ],
3466 ["listBranches", { projectId: "project-1", query: { limit: "100", gitName: "main" } }],
3467 ["getApp", "service-1"],
3468 ["listBranches", { projectId: "project-1", query: { limit: "100", gitName: "main" } }],
3469 ]);
3470 }).pipe(
3471 Effect.provide(providerLayer(client)),
3472 Effect.provide(managementApi(client).layer),
3473 Effect.provide(FetchHttpClient.layer),
3474 Effect.provideService(Stack, {
3475 name: "prisma-branch-noop-test",
3476 stage: "test",
3477 resources: {},
3478 bindings: {},
3479 actions: {},
3480 }),
3481 Effect.provideService(Stage, "test"),
3482 );
3483 },
3484 {
3485 tags: [
3486 "provider:prisma:app",
3487 "provider:prisma:branch",
3488 "provider:prisma:connection",
3489 "provider:prisma:customdomain",
3490 "provider:prisma:database",
3491 "provider:prisma:deployment",
3492 "provider:prisma:environmentvariable",
3493 "provider:prisma:project",
3494 "provider:prisma:sourcerepository",
3495 ],
3496 },
3497 );
3498
3499 it.effect(
3500 "normalizes Management API clone source ids before comparing immutable state",
3501 () => {
3502 const calls: Call[] = [];
3503 const database = {
3504 id: "database-clone",
3505 type: "database" as const,
3506 url: "https://api.prisma.test/v1/databases/database-clone",
3507 name: "clone",
3508 status: "ready" as const,
3509 createdAt,
3510 isDefault: false,
3511 defaultConnectionId: "connection-clone",
3512 connections: [databaseConnection("database-clone", "connection-clone")],
3513 project: resourceRef("projects", "project-1", "app"),
3514 region: { id: "us-east-1", name: "US East" },
3515 source: { type: "database" as const, databaseId: "source" },
3516 branchId: null,
3517 logicalId: "Database",
3518 };
3519 const client = {
3520 getDatabase: (id: string) =>
3521 Effect.sync(() => {
3522 calls.push(["getDatabase", id]);
3523 return database;
3524 }),
3525 updateDatabase: () => Effect.die("normalized clone source must not trigger an update"),
3526 } as unknown as PrismaManagementClient;
3527
3528 return Effect.gen(function* () {
3529 const provider = yield* PrismaDatabase.Provider;
3530 const result = yield* provider.reconcile(
3531 reconcileInput(
3532 "Database",
3533 {
3534 project: "project-1",
3535 name: "clone",
3536 region: "us-east-1",
3537 source: { type: "database" as const, databaseId: "db_source" },
3538 },
3539 {
3540 databaseId: "database-clone",
3541 databaseName: "clone",
3542 projectId: "project-1",
3543 status: "ready" as const,
3544 region: "us-east-1",
3545 isDefault: false,
3546 branchId: null,
3547 defaultConnectionId: "connection-clone",
3548 createdAt,
3549 directConnectionString: undefined,
3550 pooledConnectionString: undefined,
3551 accelerateConnectionString: undefined,
3552 host: undefined,
3553 user: undefined,
3554 password: undefined,
3555 logicalId: null,
3556 },
3557 ),
3558 );
3559
3560 expect(result.databaseId).toBe("database-clone");
3561 expect(calls).toEqual([["getDatabase", "database-clone"]]);
3562 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
3563 },
3564 {
3565 tags: [
3566 "provider:prisma:app",
3567 "provider:prisma:branch",
3568 "provider:prisma:connection",
3569 "provider:prisma:customdomain",
3570 "provider:prisma:database",
3571 "provider:prisma:deployment",
3572 "provider:prisma:environmentvariable",
3573 "provider:prisma:project",
3574 "provider:prisma:sourcerepository",
3575 ],
3576 },
3577 );
3578
3579 it.effect(
3580 "refuses convergence when the observed source shape is unrecognized",
3581 () => {
3582 const database = {
3583 id: "database-exotic",
3584 type: "database" as const,
3585 url: "https://api.prisma.test/v1/databases/database-exotic",
3586 name: "exotic",
3587 status: "ready" as const,
3588 createdAt,
3589 isDefault: false,
3590 defaultConnectionId: "connection-exotic",
3591 connections: [databaseConnection("database-exotic", "connection-exotic")],
3592 project: resourceRef("projects", "project-1", "app"),
3593 region: { id: "us-east-1", name: "US East" },
3594 source: { type: "replica", replicaOf: "db_source" },
3595 branchId: null,
3596 };
3597 const client = {
3598 getDatabase: () => Effect.succeed(database),
3599 updateDatabase: () => Effect.die("an unrecognized source must refuse before updating"),
3600 } as unknown as PrismaManagementClient;
3601
3602 return Effect.gen(function* () {
3603 const provider = yield* PrismaDatabase.Provider;
3604 const error = yield* provider
3605 .reconcile(
3606 reconcileInput(
3607 "Database",
3608 { project: "project-1", name: "exotic", region: "us-east-1" },
3609 {
3610 databaseId: "database-exotic",
3611 databaseName: "exotic",
3612 projectId: "project-1",
3613 status: "ready" as const,
3614 region: "us-east-1",
3615 isDefault: false,
3616 branchId: null,
3617 defaultConnectionId: "connection-exotic",
3618 createdAt,
3619 directConnectionString: undefined,
3620 pooledConnectionString: undefined,
3621 accelerateConnectionString: undefined,
3622 host: undefined,
3623 user: undefined,
3624 password: undefined,
3625 logicalId: null,
3626 },
3627 ),
3628 )
3629 .pipe(Effect.flip);
3630
3631 expect((error as Error).message).toContain("immutable source");
3632 expect((error as Error).message).toContain('"replica"');
3633 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
3634 },
3635 {
3636 tags: [
3637 "provider:prisma:app",
3638 "provider:prisma:branch",
3639 "provider:prisma:connection",
3640 "provider:prisma:customdomain",
3641 "provider:prisma:database",
3642 "provider:prisma:deployment",
3643 "provider:prisma:environmentvariable",
3644 "provider:prisma:project",
3645 "provider:prisma:sourcerepository",
3646 ],
3647 },
3648 );
3649
3650 it.effect(
3651 "leaves the observed branch alone when branch props are omitted",
3652 () => {
3653 const calls: Call[] = [];
3654 const database = {
3655 id: "database-1",
3656 type: "database" as const,
3657 url: "https://api.prisma.test/v1/databases/database-1",
3658 name: "main",
3659 status: "ready" as const,
3660 createdAt,
3661 isDefault: false,
3662 defaultConnectionId: "connection-1",
3663 connections: [],
3664 project: resourceRef("projects", "project-1", "app"),
3665 region: { id: "us-east-1", name: "US East" },
3666 source: { type: "empty" as const },
3667 branchId: "branch-1",
3668 logicalId: "Database",
3669 };
3670 const client = {
3671 getDatabase: (id: string) =>
3672 Effect.sync(() => {
3673 calls.push(["getDatabase", id]);
3674 return database;
3675 }),
3676 updateDatabase: () =>
3677 Effect.die("every database belongs to a Branch; omitted branch props must not detach"),
3678 rotateConnection: () =>
3679 Effect.die("persisted credentials must prevent an unrelated rotation"),
3680 } as unknown as PrismaManagementClient;
3681
3682 return Effect.gen(function* () {
3683 const provider = yield* PrismaDatabase.Provider;
3684 const result = yield* provider.reconcile(
3685 reconcileInput(
3686 "Database",
3687 { project: "project-1", name: "main", region: "us-east-1" },
3688 {
3689 databaseId: "database-1",
3690 databaseName: "main",
3691 projectId: "project-1",
3692 status: "ready" as const,
3693 region: "us-east-1",
3694 isDefault: false,
3695 branchId: "branch-1",
3696 defaultConnectionId: "connection-1",
3697 createdAt,
3698 directConnectionString: Redacted.make("postgres://persisted"),
3699 pooledConnectionString: undefined,
3700 accelerateConnectionString: undefined,
3701 host: "db.prisma.test",
3702 user: "user",
3703 password: undefined,
3704 logicalId: null,
3705 },
3706 { project: "project-1", name: "main", region: "us-east-1", branchId: "branch-1" },
3707 ),
3708 );
3709
3710 expect(result.branchId).toBe("branch-1");
3711 expect(calls).toEqual([["getDatabase", "database-1"]]);
3712 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
3713 },
3714 {
3715 tags: [
3716 "provider:prisma:app",
3717 "provider:prisma:branch",
3718 "provider:prisma:connection",
3719 "provider:prisma:customdomain",
3720 "provider:prisma:database",
3721 "provider:prisma:deployment",
3722 "provider:prisma:environmentvariable",
3723 "provider:prisma:project",
3724 "provider:prisma:sourcerepository",
3725 ],
3726 },
3727 );
3728
3729 it.effect(
3730 "forces Project and Database reconcile when adoption rotation is enabled",
3731 () => {
3732 const { client } = makeClient();
3733
3734 return Effect.gen(function* () {
3735 const projectProvider = yield* PrismaProject.Provider;
3736 const databaseProvider = yield* PrismaDatabase.Provider;
3737
3738 expect(
3739 yield* projectProvider.diff!(
3740 diffInput(
3741 { name: "app", createDatabase: false, rotateCredentialsOnAdopt: false },
3742 { name: "app", createDatabase: false, rotateCredentialsOnAdopt: true },
3743 ),
3744 ),
3745 ).toEqual({ action: "update" });
3746 expect(
3747 yield* databaseProvider.diff!(
3748 diffInput(
3749 {
3750 project: "project-1",
3751 name: "main",
3752 region: "us-east-1",
3753 rotateCredentialsOnAdopt: false,
3754 },
3755 {
3756 project: "project-1",
3757 name: "main",
3758 region: "us-east-1",
3759 rotateCredentialsOnAdopt: true,
3760 },
3761 ),
3762 ),
3763 ).toEqual({ action: "update" });
3764 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
3765 },
3766 {
3767 tags: [
3768 "provider:prisma:app",
3769 "provider:prisma:branch",
3770 "provider:prisma:connection",
3771 "provider:prisma:customdomain",
3772 "provider:prisma:database",
3773 "provider:prisma:deployment",
3774 "provider:prisma:environmentvariable",
3775 "provider:prisma:project",
3776 "provider:prisma:sourcerepository",
3777 ],
3778 },
3779 );
3780
3781 it.effect(
3782 "rejects non-atomic explicit-name database branch creation",
3783 () => {
3784 let created = false;
3785 const client = {
3786 createDatabase: () =>
3787 Effect.sync(() => {
3788 created = true;
3789 throw new Error("must fail before create");
3790 }),
3791 } as unknown as PrismaManagementClient;
3792
3793 return Effect.gen(function* () {
3794 const provider = yield* PrismaDatabase.Provider;
3795 const error = yield* provider
3796 .reconcile(
3797 reconcileInput("Database", {
3798 project: "project-1",
3799 name: "main",
3800 region: "us-east-1",
3801 branchGitName: "main",
3802 }),
3803 )
3804 .pipe(Effect.flip);
3805
3806 expect((error as Error).message).toContain(
3807 "cannot be distinguished from a foreign database",
3808 );
3809 expect(created).toBe(false);
3810 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
3811 },
3812 {
3813 tags: [
3814 "provider:prisma:app",
3815 "provider:prisma:branch",
3816 "provider:prisma:connection",
3817 "provider:prisma:customdomain",
3818 "provider:prisma:database",
3819 "provider:prisma:deployment",
3820 "provider:prisma:environmentvariable",
3821 "provider:prisma:project",
3822 "provider:prisma:sourcerepository",
3823 ],
3824 },
3825 );
3826
3827 it.effect(
3828 "recovers credentials after a generated database create conflict",
3829 () => {
3830 const calls: Call[] = [];
3831 let attemptedName: string | undefined;
3832 const recoveredDatabase = () => ({
3833 id: "database-recovered",
3834 type: "database" as const,
3835 url: "https://api.prisma.test/v1/databases/database-recovered",
3836 name: attemptedName!,
3837 status: "ready" as const,
3838 createdAt,
3839 isDefault: false,
3840 defaultConnectionId: "connection-recovered",
3841 connections: [],
3842 project: resourceRef("projects", "project-1", "app"),
3843 region: { id: "us-east-1", name: "US East" },
3844 source: { type: "empty" as const },
3845 branchId: "branch-main",
3846 logicalId: "Database",
3847 });
3848 const client = {
3849 listProjectDatabases: (projectId: string, query: unknown) =>
3850 Effect.sync(() => {
3851 calls.push(["listProjectDatabases", { projectId, query }]);
3852 return attemptedName === undefined ? [] : [recoveredDatabase()];
3853 }),
3854 createDatabase: (input: { name: string }) =>
3855 Effect.gen(function* () {
3856 calls.push(["createDatabase", input]);
3857 attemptedName = input.name;
3858 return yield* Effect.fail(
3859 new PrismaApiError({
3860 method: "POST",
3861 path: "/v1/databases",
3862 status: 409,
3863 message: "already exists",
3864 }),
3865 );
3866 }),
3867 listBranches: () => Effect.succeed([{ id: "branch-main", gitName: "main" }]),
3868 rotateConnection: (id: string) =>
3869 Effect.sync(() => {
3870 calls.push(["rotateConnection", id]);
3871 return databaseConnection("database-recovered", id);
3872 }),
3873 } as unknown as PrismaManagementClient;
3874
3875 return Effect.gen(function* () {
3876 const provider = yield* PrismaDatabase.Provider;
3877 const recovered = yield* provider.reconcile(
3878 reconcileInput("Database", {
3879 project: "project-1",
3880 region: "us-east-1",
3881 branchGitName: "main",
3882 }),
3883 );
3884
3885 expect(attemptedName).toContain("-Database-test-");
3886 expect(redactedValue(recovered.directConnectionString)).toContain("database-recovered");
3887 expect(calls).toContainEqual(["rotateConnection", "connection-recovered"]);
3888 }).pipe(
3889 Effect.provide(providerLayer(client)),
3890 Effect.provide(managementApi(client).layer),
3891 Effect.provideService(Stack, {
3892 name: "prisma-database-recovery-test",
3893 stage: "test",
3894 resources: {},
3895 bindings: {},
3896 actions: {},
3897 }),
3898 Effect.provideService(Stage, "test"),
3899 Effect.provideService(ResourceContext, resourceContext("00000000000000000000000000000000")),
3900 );
3901 },
3902 {
3903 tags: [
3904 "provider:prisma:app",
3905 "provider:prisma:branch",
3906 "provider:prisma:connection",
3907 "provider:prisma:customdomain",
3908 "provider:prisma:database",
3909 "provider:prisma:deployment",
3910 "provider:prisma:environmentvariable",
3911 "provider:prisma:project",
3912 "provider:prisma:sourcerepository",
3913 ],
3914 },
3915 );
3916
3917 it.effect(
3918 "recovers default credentials after a generated project create conflict",
3919 () => {
3920 const calls: Call[] = [];
3921 let attemptedName: string | undefined;
3922 const database = wireDatabase({
3923 id: "database-default",
3924 name: "default",
3925 isDefault: true,
3926 defaultConnectionId: "connection-default",
3927 projectId: "project-recovered",
3928 projectName: "recovered",
3929 });
3930 // The 409 below is served as a real wire response; distilled's status
3931 // matcher is what turns it into the `Conflict` tag the provider catches.
3932 const fake = makeFakeManagementApi((request) => {
3933 if (request.pathname === "/v1/projects" && request.method === "GET") {
3934 return page(
3935 attemptedName === undefined
3936 ? []
3937 : [wireProject({ id: "project-recovered", name: attemptedName })],
3938 );
3939 }
3940 if (request.pathname === "/v1/projects" && request.method === "POST") {
3941 attemptedName = (request.bodyJson as { name: string }).name;
3942 return conflict("already exists");
3943 }
3944 if (
3945 request.pathname === "/v1/projects/project-recovered/databases" &&
3946 request.method === "GET"
3947 ) {
3948 return page([database]);
3949 }
3950 return dispatchManagement(client, request);
3951 });
3952 const client = {
3953 rotateConnection: (id: string) =>
3954 Effect.sync(() => {
3955 calls.push(["rotateConnection", id]);
3956 return databaseConnection("database-default", id);
3957 }),
3958 } as unknown as PrismaManagementClient;
3959
3960 return Effect.gen(function* () {
3961 const provider = yield* PrismaProject.Provider;
3962 const recovered = yield* provider.reconcile(
3963 reconcileInput("Project", { createDatabase: true, region: "us-east-1" }),
3964 );
3965
3966 expect(attemptedName).toContain("-Project-test-");
3967 expect(redactedValue(recovered.directConnectionString)).toContain("database-default");
3968 expect(calls).toContainEqual(["rotateConnection", "connection-default"]);
3969 // The create really was rejected with 409 over the wire and recovery
3970 // ran off the follow-up list.
3971 expect(routesOf(fake.captured)).toEqual([
3972 "GET /v1/projects",
3973 "POST /v1/projects",
3974 "GET /v1/projects",
3975 "GET /v1/projects/project-recovered/databases",
3976 "POST /v1/connections/connection-default/rotate",
3977 ]);
3978 }).pipe(
3979 Effect.provide(providerLayer(client)),
3980 Effect.provide(fake.layer),
3981 Effect.provideService(Stack, {
3982 name: "prisma-project-recovery-test",
3983 stage: "test",
3984 resources: {},
3985 bindings: {},
3986 actions: {},
3987 }),
3988 Effect.provideService(Stage, "test"),
3989 Effect.provideService(ResourceContext, resourceContext("00000000000000000000000000000000")),
3990 );
3991 },
3992 {
3993 tags: [
3994 "provider:prisma:app",
3995 "provider:prisma:branch",
3996 "provider:prisma:connection",
3997 "provider:prisma:customdomain",
3998 "provider:prisma:database",
3999 "provider:prisma:deployment",
4000 "provider:prisma:environmentvariable",
4001 "provider:prisma:project",
4002 "provider:prisma:sourcerepository",
4003 ],
4004 },
4005 );
4006
4007 it.effect(
4008 "rejects a createDatabase false response that contains a default database",
4009 () => {
4010 const fake = makeFakeManagementApi((request) => {
4011 if (request.pathname === "/v1/projects" && request.method === "POST") {
4012 return envelope(
4013 {
4014 ...wireProject(),
4015 database: wireCreatedDatabase({
4016 id: "database-unexpected",
4017 name: "default",
4018 isDefault: true,
4019 }),
4020 },
4021 { status: 201 },
4022 );
4023 }
4024 return unhandled(request);
4025 });
4026
4027 return Effect.gen(function* () {
4028 const provider = yield* PrismaProject.Provider;
4029 const error = yield* provider
4030 .reconcile(
4031 reconcileInput("Project", { name: "app", createDatabase: false, region: "us-east-1" }),
4032 )
4033 .pipe(Effect.flip);
4034
4035 expect((error as Error).message).toContain("created unexpected default database");
4036 expect(routesOf(fake.captured)).toEqual(["POST /v1/projects"]);
4037 expect(fake.captured[0]?.bodyJson).toEqual({
4038 name: "app",
4039 createDatabase: false,
4040 region: "us-east-1",
4041 });
4042 }).pipe(
4043 Effect.provide(providerLayer({} as PrismaManagementClient)),
4044 Effect.provide(fake.layer),
4045 );
4046 },
4047 {
4048 tags: [
4049 "provider:prisma:app",
4050 "provider:prisma:branch",
4051 "provider:prisma:connection",
4052 "provider:prisma:customdomain",
4053 "provider:prisma:database",
4054 "provider:prisma:deployment",
4055 "provider:prisma:environmentvariable",
4056 "provider:prisma:project",
4057 "provider:prisma:sourcerepository",
4058 ],
4059 },
4060 );
4061
4062 it.effect(
4063 "ensures a default database on an existing Prisma project",
4064 () => {
4065 let createdDefault: unknown;
4066 const defaultDatabase = () =>
4067 wireDatabase({
4068 isDefault: true,
4069 defaultConnectionId: "connection-1",
4070 connections: [wireConnection({ directConnectionString: "postgres://direct" })],
4071 });
4072 const fake = makeFakeManagementApi((request) => {
4073 if (request.pathname === "/v1/projects" && request.method === "GET") {
4074 return page([wireProject()]);
4075 }
4076 if (request.pathname === "/v1/projects/project-1" && request.method === "GET") {
4077 return envelope(wireProject());
4078 }
4079 if (request.pathname === "/v1/projects/project-1/databases" && request.method === "GET") {
4080 return page([
4081 wireDatabase({ id: "database-reporting", name: "reporting" }),
4082 ...(createdDefault === undefined ? [] : [createdDefault]),
4083 ]);
4084 }
4085 if (request.pathname === "/v1/projects/project-1/databases" && request.method === "POST") {
4086 createdDefault = defaultDatabase();
4087 return envelope(
4088 wireCreatedDatabase({
4089 isDefault: true,
4090 defaultConnectionId: "connection-1",
4091 connections: [wireConnection({ directConnectionString: "postgres://direct" })],
4092 }),
4093 { status: 201 },
4094 );
4095 }
4096 return unhandled(request);
4097 });
4098
4099 return Effect.gen(function* () {
4100 const projectProvider = yield* Provider.findProvider(PrismaProject);
4101 const observed = yield* projectProvider.read!(
4102 readInput("Project", { name: "app", region: "us-east-1" }),
4103 );
4104 expect(Unowned.is(observed!)).toBe(true);
4105 const project = yield* projectProvider.reconcile(
4106 reconcileInput("Project", { name: "app", region: "us-east-1" }, observed),
4107 );
4108
4109 expect(project.projectId).toBe("project-1");
4110 expect(project.databaseId).toBe("database-1");
4111 expect(Redacted.value(project.directConnectionString!)).toBe("postgres://direct");
4112 expectJsonNotToContain(project, "postgres://direct");
4113 expect(routesOf(fake.captured)).toEqual([
4114 "GET /v1/projects",
4115 "GET /v1/projects/project-1/databases",
4116 "GET /v1/projects/project-1",
4117 "GET /v1/projects/project-1/databases",
4118 "POST /v1/projects/project-1/databases",
4119 "GET /v1/projects/project-1",
4120 "GET /v1/projects/project-1/databases",
4121 ]);
4122 expect(fake.captured.find((request) => request.method === "POST")?.bodyJson).toEqual({
4123 region: "us-east-1",
4124 isDefault: true,
4125 });
4126 }).pipe(
4127 Effect.provide(
4128 ProjectProvider().pipe(
4129 Layer.provide(Layer.succeed(PrismaClient, {} as PrismaManagementClient)),
4130 Layer.provide(liveProviderContext),
4131 ),
4132 ),
4133 Effect.provide(fake.layer),
4134 Effect.provide(FetchHttpClient.layer),
4135 Effect.provideService(Stack, {
4136 name: "prisma-project-ensure-test",
4137 stage: "test",
4138 resources: {},
4139 bindings: {},
4140 actions: {},
4141 }),
4142 Effect.provideService(Stage, "test"),
4143 );
4144 },
4145 { tags: ["provider:prisma:project"] },
4146 );
4147
4148 it.effect(
4149 "clears previously managed project settings",
4150 () => {
4151 const fake = makeFakeManagementApi((request) => {
4152 if (request.pathname === "/v1/projects/project-1") {
4153 if (request.method === "GET" || request.method === "PATCH") {
4154 return envelope(wireProject());
4155 }
4156 }
4157 if (request.pathname === "/v1/projects/project-1/databases" && request.method === "GET") {
4158 return page([]);
4159 }
4160 return unhandled(request);
4161 });
4162
4163 return Effect.gen(function* () {
4164 const projectProvider = yield* PrismaProject.Provider;
4165 const project = yield* projectProvider.reconcile(
4166 reconcileInput(
4167 "Project",
4168 { name: "app", createDatabase: false },
4169 {
4170 projectId: "project-1",
4171 projectName: "app",
4172 workspaceId: "workspace-1",
4173 createdAt,
4174 defaultRegion: "us-east-1",
4175 databaseId: undefined,
4176 defaultConnectionId: undefined,
4177 directConnectionString: undefined,
4178 pooledConnectionString: undefined,
4179 accelerateConnectionString: undefined,
4180 host: undefined,
4181 user: undefined,
4182 password: undefined,
4183 },
4184 { name: "app", createDatabase: false, settings: { preview: true } },
4185 ),
4186 );
4187
4188 expect(project.projectId).toBe("project-1");
4189 expect(routesOf(fake.captured)).toEqual([
4190 "GET /v1/projects/project-1",
4191 "GET /v1/projects/project-1/databases",
4192 "PATCH /v1/projects/project-1",
4193 ]);
4194 expect(fake.captured.at(-1)?.bodyJson).toEqual({ name: "app", settings: {} });
4195 }).pipe(
4196 Effect.provide(
4197 ProjectProvider().pipe(
4198 Layer.provide(Layer.succeed(PrismaClient, {} as PrismaManagementClient)),
4199 Layer.provide(liveProviderContext),
4200 ),
4201 ),
4202 Effect.provide(fake.layer),
4203 Effect.provide(FetchHttpClient.layer),
4204 Effect.provideService(Stack, {
4205 name: "prisma-project-settings-test",
4206 stage: "test",
4207 resources: {},
4208 bindings: {},
4209 actions: {},
4210 }),
4211 Effect.provideService(Stage, "test"),
4212 );
4213 },
4214 { tags: ["provider:prisma:project"] },
4215 );
4216
4217 it.effect(
4218 "renames a project without clearing unmanaged settings",
4219 () => {
4220 const fake = makeFakeManagementApi((request) => {
4221 if (request.pathname === "/v1/projects/project-1" && request.method === "GET") {
4222 return envelope(wireProject());
4223 }
4224 if (request.pathname === "/v1/projects/project-1" && request.method === "PATCH") {
4225 return envelope(wireProject({ name: "renamed" }));
4226 }
4227 if (request.pathname === "/v1/projects/project-1/databases" && request.method === "GET") {
4228 return page([]);
4229 }
4230 return unhandled(request);
4231 });
4232
4233 return Effect.gen(function* () {
4234 const projectProvider = yield* PrismaProject.Provider;
4235 yield* projectProvider.reconcile(
4236 reconcileInput(
4237 "Project",
4238 { name: "renamed", createDatabase: false },
4239 {
4240 projectId: "project-1",
4241 projectName: "app",
4242 workspaceId: "workspace-1",
4243 createdAt,
4244 defaultRegion: "us-east-1",
4245 databaseId: undefined,
4246 defaultConnectionId: undefined,
4247 directConnectionString: undefined,
4248 pooledConnectionString: undefined,
4249 accelerateConnectionString: undefined,
4250 host: undefined,
4251 user: undefined,
4252 password: undefined,
4253 },
4254 { name: "app", createDatabase: false },
4255 ),
4256 );
4257
4258 expect(routesOf(fake.captured)).toEqual([
4259 "GET /v1/projects/project-1",
4260 "GET /v1/projects/project-1/databases",
4261 "PATCH /v1/projects/project-1",
4262 ]);
4263 expect(fake.captured.at(-1)?.bodyJson).toEqual({ name: "renamed" });
4264 }).pipe(
4265 Effect.provide(
4266 ProjectProvider().pipe(
4267 Layer.provide(Layer.succeed(PrismaClient, {} as PrismaManagementClient)),
4268 Layer.provide(liveProviderContext),
4269 ),
4270 ),
4271 Effect.provide(fake.layer),
4272 Effect.provide(FetchHttpClient.layer),
4273 Effect.provideService(Stack, {
4274 name: "prisma-project-rename-test",
4275 stage: "test",
4276 resources: {},
4277 bindings: {},
4278 actions: {},
4279 }),
4280 Effect.provideService(Stage, "test"),
4281 );
4282 },
4283 { tags: ["provider:prisma:project"] },
4284 );
4285
4286 it.effect(
4287 "deletes Prisma resources through their management APIs",
4288 () => {
4289 const calls: Call[] = [];
4290 const status = new Map([["version-1", "running"]]);
4291 const client = {
4292 deleteProject: (id: string) =>
4293 Effect.sync(() => {
4294 calls.push(["deleteProject", id]);
4295 }),
4296 deleteDatabase: (id: string) =>
4297 Effect.sync(() => {
4298 calls.push(["deleteDatabase", id]);
4299 }),
4300 getDatabase: (id: string) =>
4301 Effect.sync(() => {
4302 calls.push(["getDatabase", id]);
4303 return { id, isDefault: false };
4304 }),
4305 deleteConnection: (id: string) =>
4306 Effect.sync(() => {
4307 calls.push(["deleteConnection", id]);
4308 }),
4309 getConnection: (id: string) =>
4310 Effect.sync(() => {
4311 calls.push(["getConnection", id]);
4312 return { id, name: "api-000000000000", database: { id: "database-1" } };
4313 }),
4314 deleteBranch: (id: string) =>
4315 Effect.sync(() => {
4316 calls.push(["deleteBranch", id]);
4317 }),
4318 getBranch: (id: string) =>
4319 Effect.sync(() => {
4320 calls.push(["getBranch", id]);
4321 return {
4322 id,
4323 gitName: "preview",
4324 isDefault: false,
4325 role: "preview" as const,
4326 project: { id: "project-1" },
4327 };
4328 }),
4329 listApps: (query: unknown) =>
4330 Effect.sync(() => {
4331 calls.push(["listApps", query]);
4332 return [];
4333 }),
4334 listAppDeployments: (appId: string, query: unknown) =>
4335 Effect.sync(() => {
4336 calls.push(["listAppDeployments", { appId, query }]);
4337 return [
4338 {
4339 id: "version-1",
4340 type: "deployment" as const,
4341 serviceId: "service-1",
4342 url: "https://api.prisma.test/v1/deployments/version-1",
4343 foundryVersionId: "foundry-1",
4344 createdAt,
4345 },
4346 ];
4347 }),
4348 getDeployment: (id: string) =>
4349 Effect.sync(() => {
4350 calls.push(["getDeployment", id]);
4351 return {
4352 id,
4353 type: "deployment" as const,
4354 serviceId: "service-1",
4355 url: `https://api.prisma.test/v1/deployments/${id}`,
4356 foundryVersionId: "foundry-1",
4357 status: status.get(id) ?? "stopped",
4358 previewDomain: null,
4359 createdAt,
4360 };
4361 }),
4362 stopDeployment: (id: string) =>
4363 Effect.sync(() => {
4364 calls.push(["stopDeployment", id]);
4365 status.set(id, "stopped");
4366 }),
4367 deleteDeployment: (id: string) =>
4368 Effect.sync(() => {
4369 calls.push(["deleteDeployment", id]);
4370 }),
4371 deleteApp: (id: string) =>
4372 Effect.sync(() => {
4373 calls.push(["deleteApp", id]);
4374 }),
4375 getApp: (id: string) =>
4376 Effect.sync(() => {
4377 calls.push(["getApp", id]);
4378 return {
4379 id,
4380 name: "api",
4381 projectId: "project-1",
4382 region: { id: "us-east-1" },
4383 branchId: "branch-1",
4384 };
4385 }),
4386 deleteCustomDomain: (id: string) =>
4387 Effect.sync(() => {
4388 calls.push(["deleteCustomDomain", id]);
4389 }),
4390 getCustomDomain: (id: string) =>
4391 Effect.sync(() => {
4392 calls.push(["getCustomDomain", id]);
4393 return { id, appId: "service-1", hostname: "api.custom.test" };
4394 }),
4395 getEnvironmentVariable: (id: string) =>
4396 Effect.sync(() => {
4397 calls.push(["getEnvironmentVariable", id]);
4398 return {
4399 id,
4400 type: "environment-variable" as const,
4401 url: `https://api.prisma.test/v1/environment-variables/${id}`,
4402 projectId: "project-1",
4403 branchId: null,
4404 class: "production" as const,
4405 key: "TOKEN",
4406 valueKid: "kid-1",
4407 isManagedBySystem: false,
4408 createdAt,
4409 updatedAt,
4410 };
4411 }),
4412 deleteEnvironmentVariable: (id: string) =>
4413 Effect.sync(() => {
4414 calls.push(["deleteEnvironmentVariable", id]);
4415 }),
4416 deleteSourceRepository: (id: string) =>
4417 Effect.sync(() => {
4418 calls.push(["deleteSourceRepository", id]);
4419 }),
4420 getSourceRepository: (id: string) =>
4421 Effect.sync(() => {
4422 calls.push(["getSourceRepository", id]);
4423 return {
4424 id,
4425 projectId: "project-1",
4426 repoId: 123,
4427 provider: "github" as const,
4428 installationId: "installation-1",
4429 };
4430 }),
4431 } as unknown as PrismaManagementClient;
4432
4433 return Effect.gen(function* () {
4434 const projectProvider = yield* PrismaProject.Provider;
4435 const databaseProvider = yield* PrismaDatabase.Provider;
4436 const connectionProvider = yield* PrismaConnection.Provider;
4437 const branchProvider = yield* PrismaBranch.Provider;
4438 const serviceProvider = yield* PrismaApp.Provider;
4439 const versionProvider = yield* PrismaDeployment.Provider;
4440 const domainProvider = yield* PrismaCustomDomain.Provider;
4441 const envProvider = yield* PrismaEnvironmentVariable.Provider;
4442 const repoProvider = yield* PrismaSourceRepository.Provider;
4443
4444 yield* versionProvider.delete(
4445 deleteInput("Deployment", { deploymentId: "version-1", appId: "service-1" }),
4446 );
4447 yield* serviceProvider.delete(
4448 deleteInput("App", {
4449 appId: "service-1",
4450 projectId: "project-1",
4451 regionId: "us-east-1",
4452 name: "api",
4453 branchId: "branch-1",
4454 }),
4455 );
4456 yield* repoProvider.delete(
4457 deleteInput("SourceRepository", {
4458 sourceRepositoryId: "repo-1",
4459 projectId: "project-1",
4460 repoId: 123,
4461 provider: "github",
4462 installationId: "installation-1",
4463 }),
4464 );
4465 yield* domainProvider.delete(
4466 deleteInput("CustomDomain", {
4467 customDomainId: "domain-1",
4468 appId: "service-1",
4469 hostname: "api.custom.test",
4470 }),
4471 );
4472 yield* envProvider.delete(
4473 deleteInput("EnvironmentVariable", {
4474 environmentVariableId: "env-1",
4475 projectId: "project-1",
4476 branchId: null,
4477 class: "production",
4478 key: "TOKEN",
4479 }),
4480 );
4481 yield* branchProvider.delete(
4482 deleteInput("Branch", {
4483 branchId: "branch-1",
4484 projectId: "project-1",
4485 gitName: "preview",
4486 }),
4487 );
4488 yield* connectionProvider.delete(
4489 deleteInput("Connection", {
4490 connectionId: "connection-1",
4491 databaseId: "database-1",
4492 connectionName: "api-000000000000",
4493 }),
4494 );
4495 yield* databaseProvider.delete(deleteInput("Database", { databaseId: "database-1" }));
4496 yield* projectProvider.delete(deleteInput("Project", { projectId: "project-1" }));
4497
4498 expect(calls).toEqual([
4499 ["getDeployment", "version-1"],
4500 // Over the wire, an empty query arrives as an empty object.
4501 ["listAppDeployments", { appId: "service-1", query: {} }],
4502 ["getDeployment", "version-1"],
4503 ["stopDeployment", "version-1"],
4504 ["getDeployment", "version-1"],
4505 ["deleteDeployment", "version-1"],
4506 ["getApp", "service-1"],
4507 ["deleteApp", "service-1"],
4508 ["getSourceRepository", "repo-1"],
4509 ["deleteSourceRepository", "repo-1"],
4510 ["getCustomDomain", "domain-1"],
4511 ["deleteCustomDomain", "domain-1"],
4512 ["getEnvironmentVariable", "env-1"],
4513 ["deleteEnvironmentVariable", "env-1"],
4514 ["getBranch", "branch-1"],
4515 ["deleteBranch", "branch-1"],
4516 ["getConnection", "connection-1"],
4517 ["deleteConnection", "connection-1"],
4518 ["getDatabase", "database-1"],
4519 ["deleteDatabase", "database-1"],
4520 // Over the wire, query params arrive as strings.
4521 ["listApps", { limit: "100", projectId: "project-1" }],
4522 ["deleteProject", "project-1"],
4523 ]);
4524 }).pipe(
4525 Effect.provide(providerLayer(client)),
4526 Effect.provide(managementApi(client).layer),
4527 Effect.provide(FetchHttpClient.layer),
4528 Effect.provideService(Stack, {
4529 name: "prisma-provider-delete-test",
4530 stage: "test",
4531 resources: {},
4532 bindings: {},
4533 actions: {},
4534 }),
4535 Effect.provideService(Stage, "test"),
4536 );
4537 },
4538 {
4539 tags: [
4540 "provider:prisma:app",
4541 "provider:prisma:branch",
4542 "provider:prisma:connection",
4543 "provider:prisma:customdomain",
4544 "provider:prisma:database",
4545 "provider:prisma:deployment",
4546 "provider:prisma:environmentvariable",
4547 "provider:prisma:project",
4548 "provider:prisma:sourcerepository",
4549 ],
4550 },
4551 );
4552
4553 it.effect(
4554 "rejects direct delete for a default Prisma database",
4555 () => {
4556 const calls: Call[] = [];
4557 const client = {
4558 getDatabase: (id: string) =>
4559 Effect.sync(() => {
4560 calls.push(["getDatabase", id]);
4561 return { id, isDefault: true };
4562 }),
4563 deleteDatabase: (id: string) =>
4564 Effect.sync(() => {
4565 calls.push(["deleteDatabase", id]);
4566 }),
4567 } as unknown as PrismaManagementClient;
4568
4569 return Effect.gen(function* () {
4570 const databaseProvider = yield* PrismaDatabase.Provider;
4571 const result = yield* databaseProvider
4572 .delete({
4573 id: "Postgres",
4574 fqn: "Postgres",
4575 instanceId: "00000000000000000000000000000000",
4576 olds: {} as never,
4577 output: { databaseId: "database-1", projectId: "project-1", isDefault: true },
4578 session: undefined,
4579 bindings: [],
4580 } as never)
4581 .pipe(Effect.result);
4582
4583 expect(Result.isFailure(result)).toBe(true);
4584 if (Result.isFailure(result)) {
4585 expect(String(result.failure)).toContain("Cannot delete default Prisma database");
4586 }
4587 expect(calls).toEqual([["getDatabase", "database-1"]]);
4588 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4589 },
4590 {
4591 tags: [
4592 "provider:prisma:app",
4593 "provider:prisma:branch",
4594 "provider:prisma:connection",
4595 "provider:prisma:customdomain",
4596 "provider:prisma:database",
4597 "provider:prisma:deployment",
4598 "provider:prisma:environmentvariable",
4599 "provider:prisma:project",
4600 "provider:prisma:sourcerepository",
4601 ],
4602 },
4603 );
4604
4605 it.effect(
4606 "checks live database default state before deleting",
4607 () => {
4608 const calls: Call[] = [];
4609 const client = {
4610 getDatabase: (id: string) =>
4611 Effect.sync(() => {
4612 calls.push(["getDatabase", id]);
4613 return { id, isDefault: true };
4614 }),
4615 deleteDatabase: (id: string) =>
4616 Effect.sync(() => {
4617 calls.push(["deleteDatabase", id]);
4618 }),
4619 } as unknown as PrismaManagementClient;
4620
4621 return Effect.gen(function* () {
4622 const databaseProvider = yield* PrismaDatabase.Provider;
4623 const result = yield* databaseProvider
4624 .delete({
4625 id: "Postgres",
4626 fqn: "Postgres",
4627 instanceId: "00000000000000000000000000000000",
4628 olds: {} as never,
4629 output: { databaseId: "database-1", projectId: "project-1", isDefault: false },
4630 session: undefined,
4631 bindings: [],
4632 } as never)
4633 .pipe(Effect.result);
4634
4635 expect(Result.isFailure(result)).toBe(true);
4636 expect(calls).toEqual([["getDatabase", "database-1"]]);
4637 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4638 },
4639 {
4640 tags: [
4641 "provider:prisma:app",
4642 "provider:prisma:branch",
4643 "provider:prisma:connection",
4644 "provider:prisma:customdomain",
4645 "provider:prisma:database",
4646 "provider:prisma:deployment",
4647 "provider:prisma:environmentvariable",
4648 "provider:prisma:project",
4649 "provider:prisma:sourcerepository",
4650 ],
4651 },
4652 );
4653
4654 it.effect(
4655 "rejects default Prisma database delete without a session",
4656 () => {
4657 const calls: Call[] = [];
4658 const client = {
4659 getDatabase: (id: string) =>
4660 Effect.sync(() => {
4661 calls.push(["getDatabase", id]);
4662 return { id, isDefault: true };
4663 }),
4664 deleteDatabase: (id: string) =>
4665 Effect.sync(() => {
4666 calls.push(["deleteDatabase", id]);
4667 }),
4668 } as unknown as PrismaManagementClient;
4669
4670 return Effect.gen(function* () {
4671 const databaseProvider = yield* PrismaDatabase.Provider;
4672 const result = yield* databaseProvider
4673 .delete({
4674 id: "Postgres",
4675 fqn: "Postgres",
4676 instanceId: "00000000000000000000000000000000",
4677 olds: {} as never,
4678 output: { databaseId: "database-1", projectId: "project-1", isDefault: true },
4679 session: undefined,
4680 bindings: [],
4681 } as never)
4682 .pipe(Effect.result);
4683
4684 expect(Result.isFailure(result)).toBe(true);
4685 expect(calls).toEqual([["getDatabase", "database-1"]]);
4686 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4687 },
4688 {
4689 tags: [
4690 "provider:prisma:app",
4691 "provider:prisma:branch",
4692 "provider:prisma:connection",
4693 "provider:prisma:customdomain",
4694 "provider:prisma:database",
4695 "provider:prisma:deployment",
4696 "provider:prisma:environmentvariable",
4697 "provider:prisma:project",
4698 "provider:prisma:sourcerepository",
4699 ],
4700 },
4701 );
4702
4703 it.effect(
4704 "deletes a database when stale state says it is default",
4705 () => {
4706 const calls: Call[] = [];
4707 const client = {
4708 getDatabase: (id: string) =>
4709 Effect.sync(() => {
4710 calls.push(["getDatabase", id]);
4711 return { id, isDefault: false };
4712 }),
4713 deleteDatabase: (id: string) =>
4714 Effect.sync(() => {
4715 calls.push(["deleteDatabase", id]);
4716 }),
4717 } as unknown as PrismaManagementClient;
4718
4719 return Effect.gen(function* () {
4720 const databaseProvider = yield* PrismaDatabase.Provider;
4721 yield* databaseProvider.delete({
4722 id: "Postgres",
4723 fqn: "Postgres",
4724 instanceId: "00000000000000000000000000000000",
4725 olds: {} as never,
4726 output: { databaseId: "database-1", projectId: "project-1", isDefault: true },
4727 session: undefined,
4728 bindings: [],
4729 } as never);
4730
4731 expect(calls).toEqual([
4732 ["getDatabase", "database-1"],
4733 ["deleteDatabase", "database-1"],
4734 ]);
4735 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4736 },
4737 {
4738 tags: [
4739 "provider:prisma:app",
4740 "provider:prisma:branch",
4741 "provider:prisma:connection",
4742 "provider:prisma:customdomain",
4743 "provider:prisma:database",
4744 "provider:prisma:deployment",
4745 "provider:prisma:environmentvariable",
4746 "provider:prisma:project",
4747 "provider:prisma:sourcerepository",
4748 ],
4749 },
4750 );
4751
4752 it.effect(
4753 "rejects direct delete for a default Prisma branch",
4754 () => {
4755 const calls: Call[] = [];
4756 const client = {
4757 getBranch: (id: string) =>
4758 Effect.sync(() => {
4759 calls.push(["getBranch", id]);
4760 return {
4761 id,
4762 gitName: "preview",
4763 isDefault: true,
4764 role: "preview" as const,
4765 project: { id: "project-1" },
4766 };
4767 }),
4768 deleteBranch: (id: string) =>
4769 Effect.sync(() => {
4770 calls.push(["deleteBranch", id]);
4771 }),
4772 } as unknown as PrismaManagementClient;
4773
4774 return Effect.gen(function* () {
4775 const branchProvider = yield* PrismaBranch.Provider;
4776 const result = yield* branchProvider
4777 .delete({
4778 id: "MainBranch",
4779 fqn: "MainBranch",
4780 instanceId: "00000000000000000000000000000000",
4781 olds: {} as never,
4782 output: {
4783 branchId: "branch-1",
4784 projectId: "project-1",
4785 gitName: "preview",
4786 isDefault: true,
4787 role: "preview",
4788 },
4789 session: undefined,
4790 bindings: [],
4791 } as never)
4792 .pipe(Effect.result);
4793
4794 expect(Result.isFailure(result)).toBe(true);
4795 if (Result.isFailure(result)) {
4796 expect(String(result.failure)).toContain("Cannot safely delete default Prisma branch");
4797 }
4798 expect(calls).toEqual([["getBranch", "branch-1"]]);
4799 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4800 },
4801 {
4802 tags: [
4803 "provider:prisma:app",
4804 "provider:prisma:branch",
4805 "provider:prisma:connection",
4806 "provider:prisma:customdomain",
4807 "provider:prisma:database",
4808 "provider:prisma:deployment",
4809 "provider:prisma:environmentvariable",
4810 "provider:prisma:project",
4811 "provider:prisma:sourcerepository",
4812 ],
4813 },
4814 );
4815
4816 it.effect(
4817 "checks live branch default state before deleting",
4818 () => {
4819 const calls: Call[] = [];
4820 const client = {
4821 getBranch: (id: string) =>
4822 Effect.sync(() => {
4823 calls.push(["getBranch", id]);
4824 return {
4825 id,
4826 gitName: "preview",
4827 isDefault: true,
4828 role: "preview" as const,
4829 project: { id: "project-1" },
4830 };
4831 }),
4832 deleteBranch: (id: string) =>
4833 Effect.sync(() => {
4834 calls.push(["deleteBranch", id]);
4835 }),
4836 } as unknown as PrismaManagementClient;
4837
4838 return Effect.gen(function* () {
4839 const branchProvider = yield* PrismaBranch.Provider;
4840 const result = yield* branchProvider
4841 .delete({
4842 id: "MainBranch",
4843 fqn: "MainBranch",
4844 instanceId: "00000000000000000000000000000000",
4845 olds: {} as never,
4846 output: {
4847 branchId: "branch-1",
4848 projectId: "project-1",
4849 gitName: "preview",
4850 isDefault: false,
4851 role: "preview",
4852 },
4853 session: undefined,
4854 bindings: [],
4855 } as never)
4856 .pipe(Effect.result);
4857
4858 expect(Result.isFailure(result)).toBe(true);
4859 expect(calls).toEqual([["getBranch", "branch-1"]]);
4860 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4861 },
4862 {
4863 tags: [
4864 "provider:prisma:app",
4865 "provider:prisma:branch",
4866 "provider:prisma:connection",
4867 "provider:prisma:customdomain",
4868 "provider:prisma:database",
4869 "provider:prisma:deployment",
4870 "provider:prisma:environmentvariable",
4871 "provider:prisma:project",
4872 "provider:prisma:sourcerepository",
4873 ],
4874 },
4875 );
4876
4877 it.effect(
4878 "rejects default Prisma branch delete without a session",
4879 () => {
4880 const calls: Call[] = [];
4881 const client = {
4882 getBranch: (id: string) =>
4883 Effect.sync(() => {
4884 calls.push(["getBranch", id]);
4885 return {
4886 id,
4887 gitName: "preview",
4888 isDefault: true,
4889 role: "preview" as const,
4890 project: { id: "project-1" },
4891 };
4892 }),
4893 deleteBranch: (id: string) =>
4894 Effect.sync(() => {
4895 calls.push(["deleteBranch", id]);
4896 }),
4897 } as unknown as PrismaManagementClient;
4898
4899 return Effect.gen(function* () {
4900 const branchProvider = yield* PrismaBranch.Provider;
4901 const result = yield* branchProvider
4902 .delete({
4903 id: "MainBranch",
4904 fqn: "MainBranch",
4905 instanceId: "00000000000000000000000000000000",
4906 olds: {} as never,
4907 output: {
4908 branchId: "branch-1",
4909 projectId: "project-1",
4910 gitName: "preview",
4911 isDefault: true,
4912 role: "preview",
4913 },
4914 session: undefined,
4915 bindings: [],
4916 } as never)
4917 .pipe(Effect.result);
4918
4919 expect(Result.isFailure(result)).toBe(true);
4920 expect(calls).toEqual([["getBranch", "branch-1"]]);
4921 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4922 },
4923 {
4924 tags: [
4925 "provider:prisma:app",
4926 "provider:prisma:branch",
4927 "provider:prisma:connection",
4928 "provider:prisma:customdomain",
4929 "provider:prisma:database",
4930 "provider:prisma:deployment",
4931 "provider:prisma:environmentvariable",
4932 "provider:prisma:project",
4933 "provider:prisma:sourcerepository",
4934 ],
4935 },
4936 );
4937
4938 it.effect(
4939 "deletes a branch when stale state says it is default",
4940 () => {
4941 const calls: Call[] = [];
4942 const client = {
4943 getBranch: (id: string) =>
4944 Effect.sync(() => {
4945 calls.push(["getBranch", id]);
4946 return {
4947 id,
4948 gitName: "preview",
4949 isDefault: false,
4950 role: "preview" as const,
4951 project: { id: "project-1" },
4952 };
4953 }),
4954 deleteBranch: (id: string) =>
4955 Effect.sync(() => {
4956 calls.push(["deleteBranch", id]);
4957 }),
4958 } as unknown as PrismaManagementClient;
4959
4960 return Effect.gen(function* () {
4961 const branchProvider = yield* PrismaBranch.Provider;
4962 yield* branchProvider.delete({
4963 id: "MainBranch",
4964 fqn: "MainBranch",
4965 instanceId: "00000000000000000000000000000000",
4966 olds: {} as never,
4967 output: {
4968 branchId: "branch-1",
4969 projectId: "project-1",
4970 gitName: "preview",
4971 isDefault: true,
4972 role: "preview",
4973 },
4974 session: undefined,
4975 bindings: [],
4976 } as never);
4977
4978 expect(calls).toEqual([
4979 ["getBranch", "branch-1"],
4980 ["deleteBranch", "branch-1"],
4981 ]);
4982 }).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
4983 },
4984 {
4985 tags: [
4986 "provider:prisma:app",
4987 "provider:prisma:branch",
4988 "provider:prisma:connection",
4989 "provider:prisma:customdomain",
4990 "provider:prisma:database",
4991 "provider:prisma:deployment",
4992 "provider:prisma:environmentvariable",
4993 "provider:prisma:project",
4994 "provider:prisma:sourcerepository",
4995 ],
4996 },
4997 );
4998
4999 it.effect(
5000 "refuses to adopt explicit identities after create races",
Showing first 5,000 of 5,346 lines. View raw