import { App as PrismaApp, AppProvider } from "@alchemy.run/prisma/App";
import { Branch as PrismaBranch, BranchProvider } from "@alchemy.run/prisma/Branch";
import {
PrismaApiError,
PrismaClient,
type DatabaseCreateResult,
} from "@alchemy.run/prisma/Client";
import type { PrismaManagementClient } from "@alchemy.run/prisma/Client";
import { Compute as PrismaCompute } from "@alchemy.run/prisma/Compute";
import { Connect, ConnectBinding, connectEnvKeys } from "@alchemy.run/prisma/Connect";
import { Connection as PrismaConnection, ConnectionProvider } from "@alchemy.run/prisma/Connection";
import {
CustomDomain as PrismaCustomDomain,
CustomDomainProvider,
} from "@alchemy.run/prisma/CustomDomain";
import { Database as PrismaDatabase, DatabaseProvider } from "@alchemy.run/prisma/Database";
import { Deployment as PrismaDeployment, DeploymentProvider } from "@alchemy.run/prisma/Deployment";
import {
EnvironmentVariable as PrismaEnvironmentVariable,
EnvironmentVariableProvider,
} from "@alchemy.run/prisma/EnvironmentVariable";
import { Project as PrismaProject, ProjectProvider } from "@alchemy.run/prisma/Project";
import { Providers as PrismaProviderCollection } from "@alchemy.run/prisma/Providers";
import {
SourceRepository as PrismaSourceRepository,
SourceRepositoryProvider,
} from "@alchemy.run/prisma/SourceRepository";
import type { Database as ApiDatabase } from "@alchemy.run/prisma/Types";
import { describe, expect, it } from "@alchemy.run/test";
import { Unowned } from "alchemy/AdoptPolicy";
import { AlchemyContext } from "alchemy/AlchemyContext";
import * as Output from "alchemy/Output";
import * as Provider from "alchemy/Provider";
import { ResourceContext } from "alchemy/ResourceContext";
import { RuntimeContext } from "alchemy/RuntimeContext";
import { Stack, type StackSpec } from "alchemy/Stack";
import { Stage } from "alchemy/Stage";
import { inMemoryState } from "alchemy/State/InMemoryState";
import { PlatformServices } from "alchemy/Util/PlatformServices";
import * as ConfigProvider from "effect/ConfigProvider";
import * as Effect from "effect/Effect";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import * as Result from "effect/Result";
import { resourceContext } from "../Util/ResourceContext.ts";
import {
type Captured,
conflict,
data as envelope,
dispatchTo,
failure,
json,
makeFakeManagementApi,
notFound,
page,
routesOf,
unhandled,
wireConnection,
wireCreatedDatabase,
wireDatabase,
wireProject,
} from "./fixtures/FakeManagementApi.ts";
import { testStackContext } from "./fixtures/StackContext.ts";
type Call = [operation: string, input?: unknown];
type Equal<A, B> =
(<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false;
type Expect<T extends true> = T;
const createdAt = "2026-01-01T00:00:00Z";
const updatedAt = "2026-01-01T00:00:01Z";
const redactedValue = (value: string | Redacted.Redacted<string> | undefined) => {
if (!Redacted.isRedacted(value)) {
throw new Error("Expected a redacted value");
}
return Redacted.value(value);
};
const expectJsonNotToContain = (value: unknown, ...secrets: string[]) => {
const json = JSON.stringify(value);
for (const secret of secrets) {
expect(json).not.toContain(secret);
}
};
const resourceRef = (kind: string, id: string, name = id) => ({
id,
url: `https://api.prisma.test/v1/${kind}/${id}`,
name,
});
const databaseConnection = (databaseId: string, connectionId = `connection-${databaseId}`) => ({
id: connectionId,
type: "connection" as const,
url: `https://api.prisma.test/v1/connections/${connectionId}`,
name: "default",
createdAt,
kind: "postgres" as const,
endpoints: {
direct: {
host: "db.prisma.test",
port: 5432,
connectionString: `postgres://user:password@db.prisma.test/${databaseId}`,
},
},
database: resourceRef("databases", databaseId),
});
const makeClient = () => {
const calls: Call[] = [];
const client = {
listProjects: () => {
calls.push(["listProjects"]);
return Effect.succeed([]);
},
createProject: (input: unknown) => {
calls.push(["createProject", input]);
return Effect.succeed({
id: "project-1",
type: "project",
url: "https://api.prisma.test/v1/projects/project-1",
name: "app",
createdAt,
defaultRegion: "us-east-1",
workspace: resourceRef("workspaces", "workspace-1", "team"),
database: null,
});
},
listProjectDatabases: (projectId: string, query: unknown) => {
calls.push(["listProjectDatabases", { projectId, query }]);
return Effect.succeed([]);
},
createDatabase: (input: { logicalId?: string }) => {
calls.push(["createDatabase", input]);
return Effect.succeed({
logicalId: input.logicalId ?? null,
id: "database-1",
type: "database",
url: "https://api.prisma.test/v1/databases/database-1",
name: "main",
status: "ready",
createdAt,
isDefault: false,
defaultConnectionId: "connection-1",
connections: [
{
id: "connection-1",
type: "connection",
url: "https://api.prisma.test/v1/connections/connection-1",
name: "default",
createdAt,
kind: "postgres",
endpoints: {
direct: { host: "db.prisma.test", port: 5432, connectionString: "postgres://direct" },
pooled: {
host: "pool.prisma.test",
port: 5432,
connectionString: "postgres://pooled",
},
},
database: resourceRef("databases", "database-1", "main"),
},
],
project: resourceRef("projects", "project-1", "app"),
region: { id: "us-east-1", name: "US East" },
source: { type: "empty" },
branchId: null,
});
},
listDatabaseConnections: (databaseId: string, query: unknown) => {
calls.push(["listDatabaseConnections", { databaseId, query }]);
return Effect.succeed([]);
},
createConnection: (input: unknown) => {
calls.push(["createConnection", input]);
return Effect.succeed({
id: "connection-2",
type: "connection",
url: "https://api.prisma.test/v1/connections/connection-2",
name: "api",
createdAt,
kind: "postgres",
endpoints: {
direct: { host: "db.prisma.test", port: 5432, connectionString: "postgres://api-direct" },
},
database: resourceRef("databases", "database-1", "main"),
});
},
listBranches: (projectId: string, query: unknown) => {
calls.push(["listBranches", { projectId, query }]);
const gitName = (query as { gitName?: string } | undefined)?.gitName;
return Effect.succeed(
gitName !== undefined && gitName !== "main"
? []
: [
{
id: "branch-1",
type: "branch",
url: "https://api.prisma.test/v1/branches/branch-1",
gitName: "main",
isDefault: true,
role: "production",
createdAt,
updatedAt,
project: resourceRef("projects", "project-1", "app"),
},
],
);
},
getBranch: (id: string) => {
calls.push(["getBranch", id]);
return Effect.succeed({
id,
type: "branch",
url: `https://api.prisma.test/v1/branches/${id}`,
gitName: "main",
isDefault: true,
role: "production",
createdAt,
updatedAt,
project: resourceRef("projects", "project-1", "app"),
});
},
createBranch: (projectId: string, input: { gitName: string; isDefault?: boolean }) => {
calls.push(["createBranch", { projectId, input }]);
return Effect.succeed({
id: "branch-2",
type: "branch",
url: "https://api.prisma.test/v1/branches/branch-2",
gitName: input.gitName,
isDefault: input.isDefault ?? false,
role: "preview",
createdAt,
updatedAt,
project: resourceRef("projects", "project-1", "app"),
});
},
listApps: (query: unknown) => {
calls.push(["listApps", query]);
return Effect.succeed([]);
},
createApp: (input: { projectId: string; logicalId?: string }) => {
calls.push(["createApp", input]);
return Effect.succeed({
logicalId: input.logicalId ?? null,
id: "service-1",
type: "app",
url: "https://api.prisma.test/v1/services/service-1",
name: "api",
region: { id: "us-east-1", name: "US East" },
projectId: "project-1",
branchId: "branch-1",
latestDeploymentId: null,
appEndpointDomain: "service-1.prisma.build",
createdAt,
});
},
getApp: (id: string) => {
calls.push(["getApp", id]);
return Effect.succeed({
id,
type: "app",
url: `https://api.prisma.test/v1/services/${id}`,
name: "api",
region: { id: "us-east-1", name: "US East" },
projectId: "project-1",
branchId: "branch-1",
latestDeploymentId: "version-1",
appEndpointDomain: "service-1.prisma.build",
createdAt,
});
},
createAppDeployment: (appId: string, input: unknown) => {
calls.push(["createAppDeployment", { appId, input }]);
return Effect.succeed({
id: "version-1",
type: "deployment",
url: "https://api.prisma.test/v1/deployments/version-1",
foundryVersionId: "foundry-1",
uploadUrl: null,
});
},
listAppDomains: (appId: string) => {
calls.push(["listAppDomains", appId]);
return Effect.succeed([]);
},
createAppDomain: (appId: string, input: { hostname: string }) => {
calls.push(["createAppDomain", { appId, input }]);
return Effect.succeed({
status: 201 as const,
domain: {
id: "domain-1",
type: "custom-domain" as const,
url: "https://api.prisma.test/v1/domains/domain-1",
hostname: input.hostname,
appId: appId,
status: "pending_dns" as const,
foundryStatus: "pending_dns",
failureReason: null,
failureCategory: null,
certExpiresAt: null,
dnsRecords: [
{
type: "CNAME" as const,
name: input.hostname,
value: "service-1.prisma.build",
ttl: null,
},
],
createdAt,
updatedAt,
},
});
},
getDeployment: (id: string) => {
calls.push(["getDeployment", id]);
return Effect.succeed({
id,
type: "deployment",
serviceId: "service-1",
url: `https://api.prisma.test/v1/deployments/${id}`,
foundryVersionId: "foundry-1",
status: "new",
previewDomain: null,
createdAt,
});
},
listEnvironmentVariables: (query: unknown) => {
calls.push(["listEnvironmentVariables", query]);
return Effect.succeed([]);
},
createEnvironmentVariable: (input: unknown) => {
calls.push(["createEnvironmentVariable", input]);
return Effect.succeed({
id: "env-1",
type: "environment-variable",
url: "https://api.prisma.test/v1/environment-variables/env-1",
projectId: "project-1",
branchId: null,
class: "production",
key: "TOKEN",
valueKid: "kid-1",
isManagedBySystem: false,
createdAt,
updatedAt,
});
},
listSourceRepositories: (query: unknown) => {
calls.push(["listSourceRepositories", query]);
return Effect.succeed([]);
},
createSourceRepository: (input: unknown) => {
calls.push(["createSourceRepository", input]);
return Effect.succeed({
id: "repo-1",
type: "source-repository",
url: "https://api.prisma.test/v1/source-repositories/repo-1",
repoId: 123,
provider: "github",
repoFullName: "acme/api",
defaultBranch: "main",
isPrivate: true,
status: "active",
projectId: "project-1",
installationId: "installation-1",
createdAt,
updatedAt,
});
},
getSourceRepository: (id: string) => {
calls.push(["getSourceRepository", id]);
return Effect.succeed({
id,
type: "source-repository",
url: `https://api.prisma.test/v1/source-repositories/${id}`,
repoId: 123,
provider: "github",
repoFullName: "acme/api",
defaultBranch: "main",
isPrivate: true,
status: "active",
projectId: "project-1",
installationId: "installation-1",
createdAt,
updatedAt,
});
},
} as unknown as PrismaManagementClient;
return { client, calls };
};
const liveProviderContext = Layer.succeed(AlchemyContext, {
dotAlchemy: ".alchemy-test",
dev: false,
adopt: false,
});
/**
* Serve the Management API from the same hermetic client-shaped handlers
* these suites already declare, for the resources that now call distilled
* operations. `dispatchTo` maps each handler's result onto the wire (see the
* fixture).
*/
// The logical-ID lookups list these routes before most operations; a suite
// that does not declare them sees empty lists.
const emptyList = () => Effect.succeed([]);
const dispatchManagement = (client: any, request: Captured): Response => {
{
const segments = request.pathname.split("/").filter((s) => s.length > 0);
const body = request.bodyJson as any;
const { call, callVoid, list } = dispatchTo(request);
// segments[0] is the "v1" prefix.
const [head, id, tail] = segments.slice(1) as [
string | undefined,
string | undefined,
string | undefined,
];
if (head === "projects") {
if (id === undefined) {
return request.method === "GET"
? call(client.listProjects, [], list)
: call(client.createProject, [body]);
}
if (tail === "databases") {
return request.method === "GET"
? call(client.listProjectDatabases, [id, { limit: 100 }], list)
: call(client.createProjectDatabase, [id, body]);
}
if (tail === "branches") {
return request.method === "GET"
? call(
client.listBranches ?? emptyList,
[id, Object.fromEntries(new URLSearchParams(request.search))],
list,
)
: call(client.createBranch, [id, body]);
}
if (request.method === "GET") return call(client.getProject, [id]);
if (request.method === "PATCH") return call(client.updateProject, [id, body]);
if (request.method === "DELETE") {
return callVoid(client.deleteProject, [id]);
}
}
if (head === "databases") {
if (id === undefined) {
return request.method === "GET"
? call(
client.listDatabases ?? emptyList,
[Object.fromEntries(new URLSearchParams(request.search))],
list,
)
: call(client.createDatabase, [body]);
}
if (tail === "connections") {
return request.method === "GET"
? call(client.listDatabaseConnections, [id, { limit: 100 }], list)
: call(client.createDatabaseConnection, [id, body]);
}
if (request.method === "GET") return call(client.getDatabase, [id]);
if (request.method === "PATCH") return call(client.updateDatabase, [id, body]);
if (request.method === "DELETE") {
return callVoid(client.deleteDatabase, [id]);
}
}
if (head === "connections") {
if (id === undefined) {
return request.method === "GET"
? call(client.listConnections, [], list)
: call(client.createConnection, [body]);
}
if (tail === "rotate") return call(client.rotateConnection, [id]);
if (request.method === "GET") return call(client.getConnection, [id]);
if (request.method === "DELETE") {
return callVoid(client.deleteConnection, [id]);
}
}
if (head === "environment-variables") {
if (id === undefined) {
return request.method === "GET"
? call(
client.listEnvironmentVariables,
[Object.fromEntries(new URLSearchParams(request.search))],
list,
)
: call(client.createEnvironmentVariable, [body]);
}
if (request.method === "GET") {
return call(client.getEnvironmentVariable, [id]);
}
if (request.method === "PATCH") {
return call(client.updateEnvironmentVariable, [id, body]);
}
if (request.method === "DELETE") {
return callVoid(client.deleteEnvironmentVariable, [id]);
}
}
if (head === "source-repositories") {
if (id === undefined) {
return request.method === "GET"
? call(
client.listSourceRepositories,
[Object.fromEntries(new URLSearchParams(request.search))],
list,
)
: call(client.createSourceRepository, [body]);
}
if (request.method === "GET") {
return call(client.getSourceRepository, [id]);
}
if (request.method === "DELETE") {
return callVoid(client.deleteSourceRepository, [id]);
}
}
if (head === "buckets") {
if (id === undefined) {
return request.method === "GET"
? call(client.listBuckets, [], list)
: call(client.createBucket, [body]);
}
if (tail === "keys") {
return request.method === "GET"
? call(client.listBucketKeys, [id, { limit: 100 }], list)
: call(client.createBucketKey, [id, body]);
}
if (request.method === "GET") return call(client.getBucket, [id]);
if (request.method === "DELETE") {
return callVoid(client.deleteBucket, [id]);
}
}
if (head === "services") {
if (id === undefined) {
return request.method === "GET"
? call(
client.listApps ?? emptyList,
[Object.fromEntries(new URLSearchParams(request.search))],
list,
)
: call(client.createApp, [body]);
}
if (tail === "deployments") {
return request.method === "GET"
? call(
client.listAppDeployments,
[id, Object.fromEntries(new URLSearchParams(request.search))],
list,
)
: call(client.createAppDeployment, [id, body]);
}
if (tail === undefined) {
if (request.method === "GET") return call(client.getApp, [id]);
if (request.method === "PATCH") return call(client.updateApp, [id, body]);
}
}
if (head === "deployments" && id !== undefined) {
if (tail === "start") return call(client.startDeployment, [id]);
if (tail === "stop") {
return callVoid(client.stopDeployment, [id]);
}
if (request.method === "GET") return call(client.getDeployment, [id]);
if (request.method === "DELETE") {
return callVoid(client.deleteDeployment, [id]);
}
}
if (head === "services" && id !== undefined && tail === "promote") {
return call(client.promoteApp, [id, body]);
}
if (head === "services" && id !== undefined && tail === "rollback") {
return call(client.rollbackApp, [id, body]);
}
if (
head === "services" &&
id !== undefined &&
tail === undefined &&
request.method === "DELETE"
) {
return callVoid(client.deleteApp, [id]);
}
if (head === "branches" && id !== undefined) {
if (request.method === "GET") return call(client.getBranch, [id]);
if (request.method === "PATCH") return call(client.updateBranch, [id, body]);
if (request.method === "DELETE") {
return callVoid(client.deleteBranch, [id]);
}
}
return unhandled(request);
}
};
const managementApi = (client: any) =>
makeFakeManagementApi((request) => dispatchManagement(client, request));
const providerLayer = (client: PrismaManagementClient) =>
Layer.mergeAll(
ProjectProvider(),
DatabaseProvider(),
ConnectionProvider(),
BranchProvider(),
AppProvider(),
DeploymentProvider(),
CustomDomainProvider(),
EnvironmentVariableProvider(),
SourceRepositoryProvider(),
).pipe(
Layer.provide(Layer.succeed(PrismaClient, client)),
Layer.provide(liveProviderContext),
Layer.provide(testStackContext),
Layer.provide(PlatformServices),
);
const reconcileInput = <Props, Attrs>(id: string, news: Props, output?: Attrs, olds?: Props) => ({
id,
fqn: id,
instanceId: "00000000000000000000000000000000",
news,
olds,
output,
session: undefined as never,
bindings: [],
});
const deleteInput = (id: string, output: unknown) =>
({
id,
fqn: id,
instanceId: "00000000000000000000000000000000",
olds: {} as never,
output,
session: undefined as never,
bindings: [],
}) as never;
const readInput = <Props, Attrs>(id: string, olds: Props, output?: Attrs) =>
({ id, fqn: id, instanceId: "00000000000000000000000000000000", olds, output }) as never;
const diffInput = <Props, Attrs>(olds: Props, news: Props, output?: Attrs) =>
({
id: "Resource",
fqn: "Resource",
instanceId: "00000000000000000000000000000000",
olds,
news,
oldBindings: [],
newBindings: [],
output,
}) as never;
describe("Prisma resource providers", { tags: ["unit", "provider:prisma", "local"] }, () => {
it(
"derives namespaced-safe env keys for connection bindings",
() => {
expect(
connectEnvKeys({ FQN: "Connection", LogicalId: "Connection" }).directConnectionString,
).toBe("PRISMA_CONNECTION_DIRECT_CONNECTION_STRING");
expect(
connectEnvKeys({ FQN: "Api/Connection", LogicalId: "Connection" }).directConnectionString,
).toBe("PRISMA_API_CONNECTION_DIRECT_CONNECTION_STRING");
},
{ tags: ["provider:prisma:connect"] },
);
it.effect(
"ConnectBinding resolves bound connection outputs at runtime",
() => {
const stored: Record<string, Output.Output> = {};
const runtime = {
Type: "Prisma.Compute",
id: "App",
env: stored,
set: (id: string, output: Output.Output) =>
Effect.sync(() => {
const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
stored[key] = output;
return key;
}),
get: <T>(key: string): Effect.Effect<T> => {
const output = stored[key];
if (!output) return Effect.die(`missing runtime binding ${key}`);
return Output.evaluate(output, {}) as Effect.Effect<T>;
},
};
const escapedPooledConnectionString = "__ALCHEMY_PRISMA_CONNECTION_VALUE__:prisma://pooled";
const connection = {
Type: "Prisma.Connection",
LogicalId: "Connection",
FQN: "Api/Connection",
connectionId: Output.asOutput("connection-1"),
databaseId: Output.asOutput("database-1"),
directConnectionString: Output.asOutput(Redacted.make("postgres://direct")),
pooledConnectionString: Output.asOutput(Redacted.make(escapedPooledConnectionString)),
accelerateConnectionString: Output.asOutput(undefined),
host: Output.asOutput("db.example.test"),
user: Output.asOutput(null),
password: Output.asOutput(Redacted.make("password")),
} as PrismaConnection;
return Effect.gen(function* () {
const db = yield* Connect(connection);
const keys = connectEnvKeys(connection);
// Bound through the host's RuntimeContext under the documented keys,
// whatever the host type.
expect(Object.keys(stored).sort()).toEqual(Object.values(keys).sort());
const encodedEnv = yield* Output.evaluate(stored, {}) as Effect.Effect<
Record<string, unknown>
>;
expect(encodedEnv[keys.accelerateConnectionString]).toEqual(expect.any(String));
expect(encodedEnv[keys.user]).toEqual(expect.any(String));
expect(yield* db.connectionId).toBe("connection-1");
expect(Redacted.value(yield* db.databaseUrl)).toBe(escapedPooledConnectionString);
expect(Redacted.value((yield* db.directConnectionString)!)).toBe("postgres://direct");
expect(Redacted.value((yield* db.pooledConnectionString)!)).toBe(
escapedPooledConnectionString,
);
expect(yield* db.accelerateConnectionString).toBeUndefined();
expect(yield* db.user).toBeNull();
expect(Redacted.value((yield* db.password)!)).toBe("password");
}).pipe(
Effect.provide(ConnectBinding),
Effect.provide(Layer.succeed(RuntimeContext, runtime)),
Effect.provide(
Layer.succeed(
ConfigProvider.ConfigProvider,
ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
),
),
);
},
{ tags: ["provider:prisma:connect", "provider:prisma:connection"] },
);
it.effect(
"ConnectBinding does not require the deploy-time host at runtime",
() => {
const stored: Record<string, Output.Output> = {};
const runtime = {
Type: "Prisma.Compute",
id: "App",
env: stored,
set: (id: string, output: Output.Output) =>
Effect.sync(() => {
const key = id.replaceAll(/[^a-zA-Z0-9]/g, "_");
stored[key] = output;
return key;
}),
get: <T>(key: string): Effect.Effect<T> => {
const output = stored[key];
if (!output) return Effect.die(`missing runtime binding ${key}`);
return Output.evaluate(output, {}) as Effect.Effect<T>;
},
};
const connection = {
Type: "Prisma.Connection",
LogicalId: "Connection",
FQN: "Connection",
connectionId: Output.asOutput("connection-1"),
databaseId: Output.asOutput("database-1"),
directConnectionString: Output.asOutput(Redacted.make("postgres://runtime")),
pooledConnectionString: Output.asOutput(undefined),
accelerateConnectionString: Output.asOutput(undefined),
host: Output.asOutput("db.example.test"),
user: Output.asOutput("api"),
password: Output.asOutput(Redacted.make("password")),
} as PrismaConnection;
// Bundles fold `__ALCHEMY_RUNTIME__` to `true`; simulate the deployed
// runtime, where no deploy-time host (Self) exists.
const wasRuntime = globalThis.__ALCHEMY_RUNTIME__;
globalThis.__ALCHEMY_RUNTIME__ = true;
return Effect.gen(function* () {
const db = yield* Connect(connection);
expect(yield* db.connectionId).toBe("connection-1");
expect(Redacted.value(yield* db.databaseUrl)).toBe("postgres://runtime");
}).pipe(
Effect.provide(ConnectBinding),
Effect.provide(Layer.succeed(RuntimeContext, runtime)),
Effect.provide(
Layer.succeed(
ConfigProvider.ConfigProvider,
ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "runtime" }),
),
),
Effect.ensuring(
Effect.sync(() => {
globalThis.__ALCHEMY_RUNTIME__ = wasRuntime;
}),
),
);
},
{ tags: ["provider:prisma:connect", "provider:prisma:connection"] },
);
it.effect(
"Prisma.Compute carries Connect outputs in its env through RuntimeContext",
() => {
const stack: Omit<StackSpec, "output"> = {
name: "prisma-compute-binding-test",
stage: "test",
resources: {},
bindings: {},
actions: {},
};
const connection = {
Type: "Prisma.Connection",
LogicalId: "Connection",
FQN: "Api/Connection",
connectionId: Output.asOutput("connection-1"),
databaseId: Output.asOutput("database-1"),
directConnectionString: Output.asOutput(Redacted.make("postgres://api")),
pooledConnectionString: Output.asOutput(Redacted.make("prisma+postgres://api")),
accelerateConnectionString: Output.asOutput(undefined),
host: Output.asOutput("db.example.test"),
user: Output.asOutput("api"),
password: Output.asOutput(Redacted.make("password")),
} as PrismaConnection;
return Effect.gen(function* () {
const app = yield* PrismaCompute(
"App",
{ project: "project-1", appName: "api", main: "app.ts" },
Effect.gen(function* () {
yield* Connect(connection);
}).pipe(Effect.provide(ConnectBinding)),
);
const keys = connectEnvKeys(connection);
const env = (yield* Output.evaluate(
(app.Props as { env?: Record<string, unknown> }).env ?? {},
{},
)) as Record<string, string | Redacted.Redacted<string>>;
// Compute's RuntimeContext.set JSON-packs values; secrets stay Redacted.
const unpack = (value: string | Redacted.Redacted<string> | undefined) =>
Redacted.isRedacted(value)
? Redacted.make(JSON.parse(Redacted.value(value)).value as string)
: value === undefined
? undefined
: (JSON.parse(value) as string);
expect(stack.bindings[app.FQN]).toBeUndefined();
expect(Object.keys(env)).toEqual(expect.arrayContaining(Object.values(keys)));
expect(unpack(env[keys.connectionId])).toBe("connection-1");
expect(unpack(env[keys.databaseId])).toBe("database-1");
expect(redactedValue(unpack(env[keys.directConnectionString]))).toBe("postgres://api");
expect(redactedValue(unpack(env[keys.pooledConnectionString]))).toBe(
"prisma+postgres://api",
);
expect(redactedValue(unpack(env[keys.password]))).toBe("password");
}).pipe(
Effect.provide(inMemoryState()),
Effect.provide(
Layer.succeed(PrismaProviderCollection, {
kind: "ProviderCollection" as const,
get: () => undefined,
providers: {},
}),
),
Effect.provideService(Stack, stack),
Effect.provideService(Stage, "test"),
Effect.provide(
Layer.succeed(
ConfigProvider.ConfigProvider,
ConfigProvider.fromUnknown({ ALCHEMY_PHASE: "plan" }),
),
),
);
},
{ tags: ["provider:prisma:compute", "provider:prisma:connect", "provider:prisma:connection"] },
);
it.effect(
"rejects conflicting App branch inputs",
() => {
const { client } = makeClient();
return Effect.gen(function* () {
const serviceProvider = yield* PrismaApp.Provider;
const error = yield* serviceProvider
.reconcile(
reconcileInput("App", {
project: "project-1",
displayName: "api",
branchId: "branch-1",
branchGitName: "main",
}),
)
.pipe(Effect.flip);
expect(error).toBeInstanceOf(Error);
expect((error as Error).message).toContain(
"branchId and branchGitName are mutually exclusive",
);
}).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
},
{
tags: [
"provider:prisma:app",
"provider:prisma:branch",
"provider:prisma:connection",
"provider:prisma:customdomain",
"provider:prisma:database",
"provider:prisma:deployment",
"provider:prisma:environmentvariable",
"provider:prisma:project",
"provider:prisma:sourcerepository",
],
},
);
it.effect(
"rejects conflicting Database branch inputs",
() => {
const { client } = makeClient();
return Effect.gen(function* () {
const databaseProvider = yield* PrismaDatabase.Provider;
const error = yield* databaseProvider
.reconcile(
reconcileInput("Database", {
project: "project-1",
name: "main",
branchId: "branch-1",
branchGitName: "main",
}),
)
.pipe(Effect.flip);
expect(error).toBeInstanceOf(Error);
expect((error as Error).message).toContain(
"branchId and branchGitName are mutually exclusive",
);
}).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
},
{
tags: [
"provider:prisma:app",
"provider:prisma:branch",
"provider:prisma:connection",
"provider:prisma:customdomain",
"provider:prisma:database",
"provider:prisma:deployment",
"provider:prisma:environmentvariable",
"provider:prisma:project",
"provider:prisma:sourcerepository",
],
},
);
it.effect(
"classifies Prisma resource diffs as updates or replacements",
() => {
const { client } = makeClient();
return Effect.gen(function* () {
const projectProvider = yield* PrismaProject.Provider;
const databaseProvider = yield* PrismaDatabase.Provider;
const connectionProvider = yield* PrismaConnection.Provider;
const branchProvider = yield* PrismaBranch.Provider;
const serviceProvider = yield* PrismaApp.Provider;
const versionProvider = yield* PrismaDeployment.Provider;
const envProvider = yield* PrismaEnvironmentVariable.Provider;
const repoProvider = yield* PrismaSourceRepository.Provider;
expect(
yield* projectProvider.diff!(
diffInput(
{ name: "app", region: "us-east-1", createDatabase: false },
{ name: "renamed", region: "us-east-1", createDatabase: false },
),
),
).toEqual({ action: "update" });
expect(
yield* projectProvider.diff!(
diffInput(
{ name: "app", region: "us-east-1", createDatabase: false },
{ name: "app", region: "us-west-2", createDatabase: false },
),
),
).toBeUndefined();
expect(
yield* projectProvider.diff!(
diffInput(
{ name: "app", region: "us-east-1", createDatabase: false },
{ name: "app", region: "us-west-2", createDatabase: Output.asOutput(false) },
),
),
).toBeUndefined();
expect(
yield* projectProvider.diff!(
diffInput(
{ name: "app", region: "us-east-1", createDatabase: false },
{
name: "app",
region: "us-west-2",
createDatabase: false,
settings: Output.asOutput({}),
},
),
),
).toBeUndefined();
expect(
yield* projectProvider.diff!(
diffInput(
{
name: "app",
region: "us-east-1",
createDatabase: false,
settings: { preview: true, tier: "dev" },
},
{
name: "app",
region: "us-east-1",
createDatabase: false,
settings: { tier: "dev", preview: true },
},
),
),
).toEqual({ action: "update" });
expect(
yield* databaseProvider.diff!(
diffInput(
{ project: "project-1", name: "main", region: "us-east-1" },
{ project: "project-1", name: "primary", region: "us-east-1" },
),
),
).toEqual({ action: "update" });
expect(
yield* databaseProvider.diff!(
diffInput(
{
project: "project-1",
name: "main",
region: "us-east-1",
source: { type: "backup", databaseId: "database-source", backupId: "backup-1" },
},
{
project: "project-1",
name: "main",
region: "us-east-1",
source: { backupId: "backup-1", databaseId: "database-source", type: "backup" },
},
),
),
).toBeUndefined();
expect(
yield* databaseProvider.diff!(
diffInput(
{ project: "project-1", name: "main", region: "us-east-1" },
{ project: Output.asOutput("project-1"), name: "main", region: "us-west-2" },
),
),
).toEqual({ action: "replace", deleteFirst: true });
expect(
yield* databaseProvider.diff!(
diffInput(
{ project: "project-1", name: "main", region: "us-east-1", branchId: "branch-1" },
{
project: "project-1",
name: "main",
region: "us-west-2",
branchId: Output.asOutput("branch-1"),
},
),
),
).toEqual({ action: "replace", deleteFirst: true });
expect(
yield* connectionProvider.diff!(
diffInput(
{ database: "database-1", name: "api", rotate: false },
{ database: "database-1", name: "api", rotate: true },
),
),
).toEqual({ action: "update" });
expect(
yield* connectionProvider.diff!(
diffInput(
{ database: "database-1", name: "api" },
{ database: "database-1", name: "worker" },
),
),
).toEqual({ action: "replace" });
expect(
yield* connectionProvider.diff!(
diffInput(
{ database: "database-1", name: "api" },
{ database: Output.asOutput("database-1"), name: "worker" },
),
),
).toEqual({ action: "replace" });
expect(
yield* connectionProvider.diff!(
diffInput(
{ database: "database-1", name: "api", rotate: false },
{ database: "database-1", name: "worker", rotate: Output.asOutput(false) },
),
),
).toEqual({ action: "replace" });
expect(
yield* branchProvider.diff!(
diffInput(
{ project: "project-1", gitName: "main", isDefault: false },
{ project: "project-1", gitName: "main", isDefault: true },
),
),
).toEqual({ action: "update" });
expect(
yield* branchProvider.diff!(
diffInput(
{ project: "project-1", gitName: "main", isDefault: true },
{ project: "project-1", gitName: "main", isDefault: false },
),
),
).toBeUndefined();
expect(
yield* branchProvider.diff!(
diffInput(
{ project: "project-1", gitName: "main" },
{ project: "project-1", gitName: "release" },
),
),
).toEqual({ action: "replace" });
expect(
yield* branchProvider.diff!(
diffInput(
{ project: "project-1", gitName: "main" },
{ project: Output.asOutput("project-1"), gitName: "release" },
),
),
).toEqual({ action: "replace" });
expect(
yield* branchProvider.diff!(
diffInput(
{ project: "project-1", gitName: "main", isDefault: false },
{ project: "project-1", gitName: "release", isDefault: Output.asOutput(false) },
),
),
).toEqual({ action: "replace" });
expect(
yield* serviceProvider.diff!(
diffInput(
{ project: "project-1", displayName: "api", regionId: "us-east-1" },
{ project: "project-1", displayName: "web", regionId: "us-east-1" },
),
),
).toEqual({ action: "update" });
const appRegionChanges = yield* Effect.forEach(
[
serviceProvider.diff!(
diffInput(
{ project: "project-1", displayName: "api", regionId: "us-east-1" },
{ project: "project-1", displayName: "api", regionId: "us-west-2" },
),
),
serviceProvider.diff!(
diffInput(
{ project: "project-1", displayName: "api", regionId: "us-east-1" },
{
project: Output.asOutput("project-1"),
displayName: "api",
regionId: "us-west-2",
},
),
),
serviceProvider.diff!(
diffInput(
{
project: "project-1",
displayName: "api",
regionId: "us-east-1",
branchId: "branch-1",
},
{
project: "project-1",
displayName: "api",
regionId: "us-west-2",
branchId: Output.asOutput("branch-1"),
},
),
),
],
(change) => change.pipe(Effect.result),
);
for (const change of appRegionChanges) {
expect(Result.isFailure(change)).toBe(true);
if (Result.isFailure(change)) {
expect(String(change.failure)).toContain("cannot atomically move");
}
}
expect(
yield* versionProvider.diff!(
diffInput({ app: "service-1", start: false }, { app: "service-1", start: true }),
),
).toEqual({ action: "update" });
expect(
yield* versionProvider.diff!(
diffInput(
{ app: "service-1", portMapping: { http: 3000 } },
{ app: "service-1", portMapping: { http: 8080 } },
),
),
).toEqual({ action: "replace" });
expect(
yield* versionProvider.diff!(
diffInput(
{ app: "service-1", portMapping: { http: 3000 } },
{ app: Output.asOutput("service-1"), portMapping: { http: 8080 } },
),
),
).toEqual({ action: "replace" });
expect(
yield* versionProvider.diff!(
diffInput(
{ app: "service-1", portMapping: { http: 3000 }, start: false },
{ app: "service-1", portMapping: { http: 8080 }, start: Output.asOutput(false) },
),
),
).toEqual({ action: "replace" });
expect(
yield* envProvider.diff!(
diffInput(
{
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("old"),
},
{
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("new"),
},
),
),
).toEqual({ action: "update" });
expect(
yield* envProvider.diff!(
diffInput(
{
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("same"),
},
{
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("same"),
},
),
),
).toEqual({ action: "update" });
expect(
yield* envProvider.diff!(
diffInput(
{
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("secret"),
},
{
project: "project-1",
class: "preview" as const,
key: "TOKEN",
value: Redacted.make("secret"),
},
),
),
).toEqual({ action: "replace" });
expect(
yield* envProvider.diff!(
diffInput(
{
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("secret"),
},
{
project: Output.asOutput("project-1"),
class: "preview" as const,
key: "TOKEN",
value: Output.asOutput(Redacted.make("secret")),
},
),
),
).toEqual({ action: "replace" });
expect(
yield* envProvider.diff!(
diffInput(
{
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("secret"),
},
{
project: "project-1",
class: "preview" as const,
key: Output.asOutput("TOKEN"),
value: Redacted.make("secret"),
},
),
),
).toEqual({ action: "replace" });
const repositoryChanges = yield* Effect.forEach(
[
repoProvider.diff!(
diffInput(
{ project: "project-1", providerRepositoryId: 123 },
{ project: "project-1", providerRepositoryId: 456 },
),
),
repoProvider.diff!(
diffInput(
{ project: "project-1", providerRepositoryId: 123 },
{ project: Output.asOutput("project-1"), providerRepositoryId: 456 },
),
),
repoProvider.diff!(
diffInput(
{ project: "project-1", providerRepositoryId: 123, installationId: "install-1" },
{
project: "project-1",
providerRepositoryId: 456,
installationId: Output.asOutput("install-1"),
},
),
),
],
(change) => change.pipe(Effect.result),
);
for (const change of repositoryChanges) {
expect(Result.isFailure(change)).toBe(true);
if (Result.isFailure(change)) {
expect(String(change.failure)).toContain("cannot be replaced atomically");
}
}
}).pipe(
Effect.provide(providerLayer(client)),
Effect.provide(managementApi(client).layer),
Effect.provide(FetchHttpClient.layer),
Effect.provideService(Stack, {
name: "prisma-provider-diff-test",
stage: "test",
resources: {},
bindings: {},
actions: {},
}),
Effect.provideService(Stage, "test"),
);
},
{
tags: [
"provider:prisma:app",
"provider:prisma:branch",
"provider:prisma:connection",
"provider:prisma:customdomain",
"provider:prisma:database",
"provider:prisma:deployment",
"provider:prisma:environmentvariable",
"provider:prisma:project",
"provider:prisma:sourcerepository",
],
},
);
it.effect(
"reads existing Prisma resources for adoption and refresh",
() => {
const calls: Call[] = [];
const database = {
id: "database-1",
type: "database" as const,
url: "https://api.prisma.test/v1/databases/database-1",
name: "main",
status: "ready" as const,
createdAt,
isDefault: true,
defaultConnectionId: "connection-1",
connections: [databaseConnection("database-1", "connection-1")],
project: resourceRef("projects", "project-1", "app"),
region: { id: "us-east-1", name: "US East" },
source: { type: "empty" },
branchId: null,
};
const fake = makeFakeManagementApi((request) => {
if (request.pathname === "/v1/projects" && request.method === "GET") {
return page([wireProject()]);
}
if (request.pathname === "/v1/projects/project-1" && request.method === "GET") {
return envelope(wireProject());
}
if (request.pathname === "/v1/projects/project-1/databases" && request.method === "GET") {
return page([
wireDatabase({
isDefault: true,
defaultConnectionId: "connection-1",
connections: [wireConnection()],
}),
]);
}
return dispatchManagement(client, request);
});
const client = {
listProjectDatabases: (projectId: string, query: unknown) =>
Effect.sync(() => {
calls.push(["listProjectDatabases", { projectId, query }]);
return [database];
}),
listDatabaseConnections: (databaseId: string, query: unknown) =>
Effect.sync(() => {
calls.push(["listDatabaseConnections", { databaseId, query }]);
return [
{
id: "connection-1",
type: "connection" as const,
url: "https://api.prisma.test/v1/connections/connection-1",
name: "api",
createdAt,
kind: "postgres" as const,
endpoints: { direct: { host: "db.prisma.test", port: 5432 } },
database: resourceRef("databases", "database-1", "main"),
},
];
}),
listBranches: (projectId: string, query: unknown) =>
Effect.sync(() => {
calls.push(["listBranches", { projectId, query }]);
return [
{
id: "branch-1",
type: "branch" as const,
url: "https://api.prisma.test/v1/branches/branch-1",
gitName: "main",
isDefault: true,
createdAt,
updatedAt,
project: resourceRef("projects", "project-1", "app"),
},
];
}),
listApps: (query: { projectId: string; limit?: number }) =>
Effect.sync(() => {
calls.push(["listApps", query]);
return [
{
id: "service-1",
type: "app" as const,
url: "https://api.prisma.test/v1/services/service-1",
name: "api",
region: { id: "us-east-1", name: "US East" },
projectId: query.projectId,
branchId: "branch-1",
latestDeploymentId: "version-1",
appEndpointDomain: "api.prisma.build",
createdAt,
},
];
}),
listAppDeployments: (appId: string, query: unknown) =>
Effect.sync(() => {
calls.push(["listAppDeployments", { appId, query }]);
return [
{
id: "version-1",
type: "deployment" as const,
serviceId: "service-1",
url: "https://api.prisma.test/v1/deployments/version-1",
foundryVersionId: "foundry-1",
createdAt,
},
];
}),
getDeployment: (id: string) =>
Effect.sync(() => {
calls.push(["getDeployment", id]);
return {
id,
type: "deployment" as const,
serviceId: "service-1",
url: `https://api.prisma.test/v1/deployments/${id}`,
foundryVersionId: "foundry-1",
status: "running",
previewDomain: "version-1.preview.prisma.build",
createdAt,
};
}),
listEnvironmentVariables: (query: unknown) =>
Effect.sync(() => {
calls.push(["listEnvironmentVariables", query]);
return [
{
id: "env-1",
type: "environment-variable" as const,
url: "https://api.prisma.test/v1/environment-variables/env-1",
projectId: "project-1",
branchId: null,
class: "production" as const,
key: "TOKEN",
valueKid: "kid-1",
isManagedBySystem: false,
createdAt,
updatedAt,
},
];
}),
listSourceRepositories: (query: unknown) =>
Effect.sync(() => {
calls.push(["listSourceRepositories", query]);
return [
{
id: "repo-1",
type: "source-repository" as const,
url: "https://api.prisma.test/v1/source-repositories/repo-1",
repoId: 123,
provider: "github" as const,
repoFullName: "acme/api",
defaultBranch: "main",
isPrivate: true,
status: "active" as const,
projectId: "project-1",
installationId: "installation-1",
createdAt,
updatedAt,
},
];
}),
} as unknown as PrismaManagementClient;
return Effect.gen(function* () {
const projectProvider = yield* Provider.findProvider(PrismaProject);
const databaseProvider = yield* Provider.findProvider(PrismaDatabase);
const connectionProvider = yield* Provider.findProvider(PrismaConnection);
const branchProvider = yield* Provider.findProvider(PrismaBranch);
const serviceProvider = yield* Provider.findProvider(PrismaApp);
const versionProvider = yield* Provider.findProvider(PrismaDeployment);
const envProvider = yield* Provider.findProvider(PrismaEnvironmentVariable);
const repoProvider = yield* Provider.findProvider(PrismaSourceRepository);
const project = yield* projectProvider.read!(readInput("Project", { name: "app" }));
const database = yield* databaseProvider.read!(
readInput("Database", { project: "project-1", name: "main" }),
);
const connection = yield* connectionProvider.read!(
readInput("Connection", { database: "database-1", name: "api" }),
);
const branch = yield* branchProvider.read!(
readInput("Branch", { project: "project-1", gitName: "main" }),
);
const service = yield* serviceProvider.read!(
readInput("App", { project: "project-1", displayName: "api" }),
);
const version = yield* versionProvider.read!(
readInput(
"Deployment",
{ app: "service-1" },
{
deploymentId: "version-1",
appId: "service-1",
foundryVersionId: "foundry-1",
status: "new",
previewDomain: null,
uploadUrl: null,
appEndpointDomain: undefined,
createdAt,
},
),
);
const env = yield* envProvider.read!(
readInput("EnvironmentVariable", {
project: "project-1",
class: "production" as const,
key: "TOKEN",
value: Redacted.make("secret"),
}),
);
const repo = yield* repoProvider.read!(
readInput("SourceRepository", { project: "project-1", providerRepositoryId: 123 }),
);
expect(project?.projectId).toBe("project-1");
expect(project?.databaseId).toBe("database-1");
expect(database?.databaseId).toBe("database-1");
expect(connection?.connectionId).toBe("connection-1");
expect(branch?.branchId).toBe("branch-1");
expect(service?.appId).toBe("service-1");
expect(version?.deploymentId).toBe("version-1");
expect(version?.status).toBe("running");
expect(env?.environmentVariableId).toBe("env-1");
expect(env?.valueKid).toBe("kid-1");
expect(env?.value && Redacted.value(env.value)).toBe("");
expect(repo?.sourceRepositoryId).toBe("repo-1");
expect(Unowned.is(project!)).toBe(true);
expect(Unowned.is(database!)).toBe(true);
expect(Unowned.is(branch!)).toBe(true);
expect(Unowned.is(env!)).toBe(true);
expect(Unowned.is(repo!)).toBe(true);
expect(routesOf(fake.captured)).toEqual([
"GET /v1/projects",
"GET /v1/projects/project-1/databases",
// Database: logical-ID lookup, then the name fallback.
"GET /v1/projects/project-1/branches",
"GET /v1/databases",
"GET /v1/projects/project-1/databases",
"GET /v1/databases/database-1/connections",
"GET /v1/databases/database-1/connections",
"GET /v1/databases/database-1/connections",
"GET /v1/projects/project-1/branches",
// App: logical-ID lookup, then the display-name fallback.
"GET /v1/projects/project-1/branches",
"GET /v1/services",
"GET /v1/services",
"GET /v1/projects/project-1/branches",
"GET /v1/deployments/version-1",
"GET /v1/services/service-1/deployments",
"GET /v1/environment-variables",
"GET /v1/source-repositories",
]);
expect(calls.map(([operation]) => operation)).toEqual([
"listBranches",
"listDatabaseConnections",
"listDatabaseConnections",
"listDatabaseConnections",
"listBranches",
"listBranches",
"listApps",
"listApps",
"listBranches",
"getDeployment",
"listAppDeployments",
"listEnvironmentVariables",
"listSourceRepositories",
]);
expect(routesOf(fake.captured)).not.toContain("POST /v1/projects");
}).pipe(
Effect.provide(providerLayer(client)),
Effect.provide(fake.layer),
Effect.provide(FetchHttpClient.layer),
Effect.provideService(Stack, {
name: "prisma-provider-read-test",
stage: "test",
resources: {},
bindings: {},
actions: {},
}),
Effect.provideService(Stage, "test"),
);
},
{
tags: [
"provider:prisma:app",
"provider:prisma:branch",
"provider:prisma:connection",
"provider:prisma:customdomain",
"provider:prisma:database",
"provider:prisma:deployment",
"provider:prisma:environmentvariable",
"provider:prisma:project",
"provider:prisma:sourcerepository",
],
},
);
it.effect(
"treats Prisma 404 during delete as already gone",
() => {
const calls: Call[] = [];
const notFound = (method: "GET" | "DELETE", path: string) =>
new PrismaApiError({ method, path, status: 404, message: "not found" });
const failNotFound = (
operation: string,
id: string,
method: "GET" | "DELETE",
path: string,
) =>
Effect.gen(function* () {
calls.push([operation, id]);
return yield* Effect.fail(notFound(method, path));
});
const client = {
listApps: (query: unknown) =>
Effect.sync(() => {
calls.push(["listApps", query]);
return [];
}),
deleteProject: (id: string) =>
failNotFound("deleteProject", id, "DELETE", `/v1/projects/${id}`),
getDatabase: (id: string) => failNotFound("getDatabase", id, "GET", `/v1/databases/${id}`),
deleteDatabase: (id: string) =>
failNotFound("deleteDatabase", id, "DELETE", `/v1/databases/${id}`),
getConnection: (id: string) =>
failNotFound("getConnection", id, "GET", `/v1/connections/${id}`),
deleteConnection: (id: string) =>
failNotFound("deleteConnection", id, "DELETE", `/v1/connections/${id}`),
getBranch: (id: string) => failNotFound("getBranch", id, "GET", `/v1/branches/${id}`),
deleteBranch: (id: string) =>
failNotFound("deleteBranch", id, "DELETE", `/v1/branches/${id}`),
getEnvironmentVariable: (id: string) =>
failNotFound("getEnvironmentVariable", id, "GET", `/v1/environment-variables/${id}`),
deleteEnvironmentVariable: (id: string) =>
failNotFound(
"deleteEnvironmentVariable",
id,
"DELETE",
`/v1/environment-variables/${id}`,
),
deleteSourceRepository: (id: string) =>
failNotFound("deleteSourceRepository", id, "DELETE", `/v1/source-repositories/${id}`),
getSourceRepository: (id: string) =>
failNotFound("getSourceRepository", id, "GET", `/v1/source-repositories/${id}`),
listAppDeployments: (appId: string) =>
failNotFound("listAppDeployments", appId, "GET", `/v1/services/${appId}/deployments`),
deleteApp: (id: string) => failNotFound("deleteApp", id, "DELETE", `/v1/services/${id}`),
getApp: (id: string) => failNotFound("getApp", id, "GET", `/v1/services/${id}`),
getDeployment: (id: string) =>
failNotFound("getDeployment", id, "GET", `/v1/deployments/${id}`),
} as unknown as PrismaManagementClient;
return Effect.gen(function* () {
const projectProvider = yield* PrismaProject.Provider;
const databaseProvider = yield* PrismaDatabase.Provider;
const connectionProvider = yield* PrismaConnection.Provider;
const branchProvider = yield* PrismaBranch.Provider;
const serviceProvider = yield* PrismaApp.Provider;
const versionProvider = yield* PrismaDeployment.Provider;
const envProvider = yield* PrismaEnvironmentVariable.Provider;
const repoProvider = yield* PrismaSourceRepository.Provider;
yield* projectProvider.delete!(deleteInput("Project", { projectId: "project-1" }));
yield* databaseProvider.delete!(deleteInput("Database", { databaseId: "database-1" }));
yield* connectionProvider.delete!(
deleteInput("Connection", { connectionId: "connection-1" }),
);
yield* branchProvider.delete!(deleteInput("Branch", { branchId: "branch-1" }));
yield* envProvider.delete!(
deleteInput("EnvironmentVariable", { environmentVariableId: "env-1" }),
);
yield* repoProvider.delete!(
deleteInput("SourceRepository", { sourceRepositoryId: "repo-1" }),
);
yield* serviceProvider.delete!(deleteInput("App", { appId: "service-1" }));
yield* versionProvider.delete!(deleteInput("Deployment", { deploymentId: "version-1" }));
expect(calls).toEqual([
// Over the wire, query params arrive as strings.
["listApps", { limit: "100", projectId: "project-1" }],
["deleteProject", "project-1"],
["getDatabase", "database-1"],
["getConnection", "connection-1"],
["getBranch", "branch-1"],
["getEnvironmentVariable", "env-1"],
["getSourceRepository", "repo-1"],
["getApp", "service-1"],
["getDeployment", "version-1"],
]);
}).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
},
{
tags: [
"provider:prisma:app",
"provider:prisma:branch",
"provider:prisma:connection",
"provider:prisma:customdomain",
"provider:prisma:database",
"provider:prisma:deployment",
"provider:prisma:environmentvariable",
"provider:prisma:project",
"provider:prisma:sourcerepository",
],
},
);
it.effect(
"does not delete cloud projects for dev placeholder project IDs",
() => {
const calls: Call[] = [];
const client = {
listProjects: () =>
Effect.sync(() => {
calls.push(["listProjects"]);
return [
{
id: "project-cloud",
type: "project",
url: "https://api.prisma.test/v1/projects/project-cloud",
name: "local-project",
createdAt,
defaultRegion: "us-east-1",
workspace: resourceRef("workspaces", "workspace-1", "team"),
database: null,
},
];
}),
deleteProject: (id: string) =>
Effect.sync(() => {
calls.push(["deleteProject", id]);
}),
} as unknown as PrismaManagementClient;
return Effect.gen(function* () {
const projectProvider = yield* PrismaProject.Provider;
yield* projectProvider.delete!(
deleteInput("Project", {
projectId: "dev:project:Project",
projectName: "local-project",
}),
);
expect(calls).toEqual([]);
}).pipe(Effect.provide(providerLayer(client)), Effect.provide(managementApi(client).layer));
},
{
tags: [