sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Prisma/ Resources.test.ts

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: [