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

import {
  extractConnectionSecrets,
  PrismaApiDecodeError,
  PrismaApiError,
  PrismaClient,
  PrismaClientLive,
  type PrismaManagementClient,
} from "@alchemy.run/prisma/Client";
import { PrismaEnvironment } from "@alchemy.run/prisma/PrismaEnvironment";
import { describe, expect, it } from "@alchemy.run/test";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as HttpBody from "effect/http/HttpBody";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientError from "effect/http/HttpClientError";
import * as HttpClientResponse from "effect/http/HttpClientResponse";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
import { TestClock } from "effect/testing";
import { productionManagementApiRoutes } from "./fixtures/ManagementApiContract.ts";

interface Captured {
  url: string;
  method: string;
  pathname: string;
  search: string;
  authorization: string | undefined;
  bodyJson: unknown;
}

const page = <T>(data: T[], hasMore = false, nextCursor: string | null = null) =>
  json({ data, pagination: { hasMore, nextCursor } });

const data = <T>(value: T) => json({ data: value });

const json = (value: unknown, init?: ResponseInit) =>
  new Response(JSON.stringify(value), {
    status: 200,
    headers: { "content-type": "application/json" },
    ...init,
  });

const empty = () => new Response(null, { status: 204 });

const expectedManagementApiRoutes = [...productionManagementApiRoutes].sort();

const routeTemplateFor = (method: string, pathname: string): string => {
  const concreteSegments = pathname.split("/");
  const route = productionManagementApiRoutes.find((candidate) => {
    const separator = candidate.indexOf(" ");
    const candidateMethod = candidate.slice(0, separator);
    const templatePath = candidate.slice(separator + 1);
    const templateSegments = templatePath.split("/");
    return (
      candidateMethod === method &&
      templateSegments.length === concreteSegments.length &&
      templateSegments.every(
        (segment, index) =>
          (/^\{[^}]+\}$/.test(segment) && concreteSegments[index]?.length !== 0) ||
          segment === concreteSegments[index],
      )
    );
  });
  if (!route) {
    throw new Error(`Missing route inventory mapping for ${method} ${pathname}`);
  }
  return route;
};
const routeInventoryFrom = (captured: Captured[]) => {
  const routes = new Set<string>();
  for (const request of captured) {
    routes.add(routeTemplateFor(request.method, request.pathname));
  }
  routes.add("GET /v1/deployments/{deploymentId}/logs");
  routes.add("GET /v1/builds/{buildId}/logs");
  return [...routes].sort();
};

const fixtureResponse = (request: Captured) => {
  if (request.pathname === "/v1/projects" && request.method === "GET") {
    return request.search.includes("cursor=cursor-2")
      ? page([{ id: "project-2", type: "project", name: "Two" }])
      : page([{ id: "project-1", type: "project", name: "One" }], true, "cursor-2");
  }

  if (request.pathname === "/v1/projects/project-1/databases" && request.method === "POST") {
    return data({ id: "database-1", type: "database", name: "main" });
  }

  if (request.pathname === "/v1/databases/database-1/backups" && request.method === "GET") {
    return json({
      data: [
        {
          id: "backup-1",
          type: "backup",
          backupType: "full",
          createdAt: "2026-01-01T00:00:00Z",
          status: "completed",
        },
      ],
      meta: {
        backupRetentionDays: 7,
      },
      pagination: {
        hasMore: false,
        limit: 1,
      },
    });
  }

  if (request.pathname === "/v1/workspaces/workspace-1/integrations" && request.method === "GET") {
    return page([{ id: "integration-1", url: "https://example.test" }]);
  }

  if (request.pathname === "/v1/domains/domain-1" && request.method === "GET") {
    return data({
      id: "domain-1",
      type: "custom-domain",
      url: "https://api.prisma.test/v1/domains/domain-1",
      hostname: "api.example.com",
      appId: "app-1",
      status: "pending_dns",
      foundryStatus: "pending",
      failureReason: null,
      failureCategory: null,
      certExpiresAt: null,
      createdAt: "2026-01-01T00:00:00Z",
      updatedAt: "2026-01-01T00:00:00Z",
      dnsRecords: [],
    });
  }

  if (request.pathname.startsWith("/v1/regions") && request.method === "GET") {
    return json({
      data: [
        {
          id: "us-east-1",
          type: "region",
          name: "US East",
          product: "postgres",
          status: "available",
        },
      ],
    });
  }

  return json(
    {
      error: {
        message: `Unhandled fixture request ${request.method} ${request.pathname}${request.search}`,
      },
    },
    { status: 500 },
  );
};

const layerForHttp = (client: HttpClient.HttpClient, baseUrl = "https://api.prisma.test") =>
  PrismaClientLive.pipe(
    Layer.provide(
      Layer.mergeAll(
        Layer.succeed(HttpClient.HttpClient, client),
        Layer.succeed(PrismaEnvironment, {
          type: "serviceToken" as const,
          serviceToken: Redacted.make("test-token"),
          source: { type: "stored" as const },
          baseUrl,
        }),
      ),
    ),
  );

const harness = (baseUrl = "https://api.prisma.test") => {
  const captured: Captured[] = [];
  const client = HttpClient.make((request) =>
    Effect.sync(() => {
      const url = new URL(request.url);
      const body = request.body as HttpBody.HttpBody;
      const bodyText = body._tag === "Uint8Array" ? new TextDecoder().decode(body.body) : "";
      const entry: Captured = {
        url: request.url,
        method: request.method,
        pathname: url.pathname,
        search: url.search,
        authorization: request.headers.authorization,
        bodyJson: bodyText ? JSON.parse(bodyText) : undefined,
      };
      captured.push(entry);
      return HttpClientResponse.fromWeb(request, fixtureResponse(entry));
    }),
  );
  const layer = layerForHttp(client, baseUrl);
  return { layer, captured };
};

const withClient = <A>(f: (client: PrismaManagementClient) => Effect.Effect<A, any, any>) =>
  Effect.gen(function* () {
    const client = yield* PrismaClient;
    return yield* f(client);
  });

const routeCoverageHarness = () => {
  const captured: Captured[] = [];
  const client = HttpClient.make((request) =>
    Effect.sync(() => {
      const url = new URL(request.url);
      const body = request.body as HttpBody.HttpBody;
      const bodyText = body._tag === "Uint8Array" ? new TextDecoder().decode(body.body) : "";
      const entry: Captured = {
        url: request.url,
        method: request.method,
        pathname: url.pathname,
        search: url.search,
        authorization: request.headers.authorization,
        bodyJson: bodyText ? JSON.parse(bodyText) : undefined,
      };
      captured.push(entry);

      if (entry.pathname.endsWith("/usage")) {
        return HttpClientResponse.fromWeb(
          request,
          json({
            period: { start: "2026-01-01", end: "2026-01-02" },
            metrics: {
              operations: { used: 0, unit: "ops" },
              storage: { used: 0, unit: "GiB" },
            },
            generatedAt: "2026-01-02T00:00:00Z",
          }),
        );
      }

      if (entry.pathname.startsWith("/v1/regions") && entry.method === "GET") {
        return HttpClientResponse.fromWeb(request, json({ data: [] }));
      }

      if (entry.method === "GET") {
        return HttpClientResponse.fromWeb(request, page([]));
      }

      if (
        entry.method === "DELETE" ||
        entry.pathname.endsWith("/stop") ||
        entry.pathname.endsWith("/transfer")
      ) {
        return HttpClientResponse.fromWeb(request, empty());
      }

      return HttpClientResponse.fromWeb(
        request,
        data({
          id: "resource-1",
          type: "resource",
          foundryVersionId: "foundry-1",
          uploadUrl: "https://upload.example.test/artifact.tar.gz",
          previewDomain: "version-1.example.test",
          appEndpointDomain: "app-1.example.test",
        }),
      );
    }),
  );
  const layer = PrismaClientLive.pipe(
    Layer.provide(
      Layer.mergeAll(
        Layer.succeed(HttpClient.HttpClient, client),
        Layer.succeed(PrismaEnvironment, {
          type: "serviceToken" as const,
          serviceToken: Redacted.make("test-token"),
          source: { type: "stored" as const },
          baseUrl: "https://api.prisma.test",
        }),
      ),
    ),
  );
  return { layer, captured };
};

describe("PrismaClient", { tags: ["unit", "provider:prisma", "local"] }, () => {
  it("extracts canonical endpoint secrets and parses direct credentials", () => {
    const secrets = extractConnectionSecrets({
      id: "connection-1",
      type: "connection",
      url: "https://api.prisma.test/v1/connections/connection-1",
      name: "api",
      createdAt: "2026-01-01T00:00:00Z",
      kind: "postgres",
      endpoints: {
        direct: {
          host: "direct.prisma.test",
          port: 5432,
          connectionString:
            "postgres://api:p%40ss@direct.prisma.test:5432/postgres?sslmode=require",
        },
        pooled: {
          host: "pooled.prisma.test",
          port: 5432,
          connectionString: "postgres://pooled",
        },
      },
      database: {
        id: "database-1",
        url: "https://api.prisma.test/v1/databases/database-1",
        name: "main",
      },
    } as unknown as Parameters<typeof extractConnectionSecrets>[0]);

    expect(Redacted.value(secrets.directConnectionString!)).toContain("direct.prisma.test");
    expect(Redacted.value(secrets.pooledConnectionString!)).toBe("postgres://pooled");
    expect(secrets.host).toBe("direct.prisma.test");
    expect(secrets.user).toBe("api");
    expect(Redacted.value(secrets.password!)).toBe("p@ss");
  });

  it.effect("paginates list endpoints and sends bearer auth", () => {
    const { layer, captured } = harness();

    return withClient((client) =>
      Effect.gen(function* () {
        const projects = yield* client.listProjects({ limit: 1 });

        expect(projects.map((project: { id: string }) => project.id)).toEqual([
          "project-1",
          "project-2",
        ]);
        expect(captured.map((request) => request.pathname)).toEqual([
          "/v1/projects",
          "/v1/projects",
        ]);
        expect(captured[0]?.search).toBe("?limit=1");
        expect(captured[1]?.search).toBe("?limit=1&cursor=cursor-2");
        expect(captured.every((request) => request.authorization === "Bearer test-token")).toBe(
          true,
        );
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("starts pagination from an explicit cursor", () => {
    const { layer, captured } = harness();

    return withClient((client) =>
      Effect.gen(function* () {
        const projects = yield* client.listProjects({
          limit: 1,
          cursor: "cursor-2",
        });

        expect(projects.map((project: { id: string }) => project.id)).toEqual(["project-2"]);
        expect(captured.map((request) => request.pathname)).toEqual(["/v1/projects"]);
        expect(captured[0]?.search).toBe("?limit=1&cursor=cursor-2");
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("rejects pagination that omits a required next cursor", () => {
    const http = HttpClient.make((request) =>
      Effect.succeed(HttpClientResponse.fromWeb(request, page([], true, null))),
    );

    return withClient((client) => client.listProjects()).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiDecodeError);
        expect(error.message).toContain("hasMore was true without a non-empty nextCursor");
      }),
    );
  });

  it.effect("rejects pagination that repeats a cursor", () => {
    let attempts = 0;
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        attempts += 1;
        return HttpClientResponse.fromWeb(request, page([], true, "repeated-cursor"));
      }),
    );

    return withClient((client) => client.listProjects()).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiDecodeError);
        expect(error.message).toContain("nextCursor repeated");
        expect(attempts).toBe(2);
      }),
    );
  });

  it.effect("bounds aggregate pagination response bytes", () => {
    let attempts = 0;
    const payload = "x".repeat(4 * 1024 * 1024 - 1_024);
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        attempts += 1;
        return HttpClientResponse.fromWeb(
          request,
          page([{ id: `project-${attempts}`, payload }], true, `cursor-${attempts}`),
        );
      }),
    );

    return withClient((client) => client.listProjects()).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiDecodeError);
        expect(error.message).toContain("67108864 aggregate response byte safety limit");
        if (error instanceof PrismaApiDecodeError) {
          expect(error.bodyLength).toBeGreaterThan(64 * 1024 * 1024);
        }
        expect(attempts).toBe(17);
      }),
    );
  });

  it.effect("uses the configured Prisma API base URL", () => {
    const { layer, captured } = harness("https://control-plane.prisma.test");

    return withClient((client) =>
      Effect.gen(function* () {
        yield* client.listProjects({ limit: 1 });

        expect(captured[0]?.url).toBe("https://control-plane.prisma.test/v1/projects?limit=1");
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("preserves current custom-domain wire fields", () => {
    const { layer } = harness();

    return withClient((client) =>
      Effect.gen(function* () {
        const domain = yield* client.getCustomDomain("domain-1");
        expect(domain.appId).toBe("app-1");
        expect(domain.foundryStatus).toBe("pending");
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("preserves 200 versus 201 custom-domain create outcomes", () => {
    const statuses = [200, 201] as const;
    let requestIndex = 0;
    const domain = {
      id: "domain-1",
      type: "custom-domain" as const,
      url: "https://api.prisma.test/v1/domains/domain-1",
      hostname: "api.example.com",
      appId: "app-1",
      status: "pending_dns" as const,
      foundryStatus: "pending",
      failureReason: null,
      failureCategory: null,
      certExpiresAt: null,
      createdAt: "2026-01-01T00:00:00Z",
      updatedAt: "2026-01-01T00:00:00Z",
      dnsRecords: [],
    };
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        const status = statuses[requestIndex++];
        return HttpClientResponse.fromWeb(request, json({ data: domain }, { status }));
      }),
    );

    return withClient((client) =>
      Effect.gen(function* () {
        const existing = yield* client.createAppDomain("app-1", {
          hostname: domain.hostname,
        });
        const created = yield* client.createAppDomain("app-1", {
          hostname: domain.hostname,
        });

        expect(existing).toEqual({ status: 200, domain });
        expect(created).toEqual({ status: 201, domain });
      }),
    ).pipe(Effect.provide(layerForHttp(http)));
  });

  it.effect("accepts the full flat database-create response contract", () => {
    const database = {
      id: "database-1",
      type: "database" as const,
      url: "https://api.prisma.test/v1/databases/database-1",
      name: "main",
      status: "failure" as const,
      createdAt: "2026-01-01T00:00:00Z",
      isDefault: false,
      defaultConnectionId: null,
      connections: [],
      project: {
        id: "project-1",
        url: "https://api.prisma.test/v1/projects/project-1",
        name: "app",
      },
      region: null,
      source: null,
      branchId: null,
    };
    const http = HttpClient.make((request) =>
      Effect.succeed(
        HttpClientResponse.fromWeb(request, json({ data: database }, { status: 201 })),
      ),
    );

    return withClient((client) =>
      Effect.gen(function* () {
        const result = yield* client.createDatabase({
          projectId: "project-1",
        });
        expect(result.status).toBe("failure");
        expect(result.region).toBeNull();
      }),
    ).pipe(Effect.provide(layerForHttp(http)));
  });

  it.effect("does not retain secret-bearing malformed response bodies", () => {
    const secret = "postgres://admin:super-secret@db.prisma.test/postgres";
    const http = HttpClient.make((request) =>
      Effect.succeed(
        HttpClientResponse.fromWeb(
          request,
          new Response(`{"data":{"connectionString":"${secret}"}`, {
            status: 201,
            headers: { "content-type": "application/json" },
          }),
        ),
      ),
    );
    const layer = PrismaClientLive.pipe(
      Layer.provide(
        Layer.mergeAll(
          Layer.succeed(HttpClient.HttpClient, http),
          Layer.succeed(PrismaEnvironment, {
            type: "serviceToken" as const,
            serviceToken: Redacted.make("test-token"),
            source: { type: "stored" as const },
            baseUrl: "https://api.prisma.test",
          }),
        ),
      ),
    );

    return withClient((client) =>
      Effect.gen(function* () {
        const error = yield* client
          .createConnection({ databaseId: "database-1", name: "api" })
          .pipe(Effect.flip);
        expect(error).toBeInstanceOf(PrismaApiDecodeError);
        expect(JSON.stringify(error)).not.toContain(secret);
        if (error instanceof PrismaApiDecodeError) {
          expect(error.bodyLength).toBeGreaterThan(0);
          expect("body" in error).toBe(false);
          expect("cause" in error).toBe(false);
        }
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("rejects a missing data response envelope", () => {
    const http = HttpClient.make((request) =>
      Effect.succeed(HttpClientResponse.fromWeb(request, json({ project: {} }))),
    );

    return withClient((client) => client.getProject("project-1")).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiDecodeError);
        expect(error.message).toContain("did not contain a data envelope");
      }),
    );
  });

  it.effect("rejects path-confusing resource IDs before sending auth", () => {
    const { layer, captured } = harness();

    return withClient((client) =>
      Effect.gen(function* () {
        const traversal = yield* client.getProject("../workspaces").pipe(Effect.flip);
        const embeddedRoute = yield* client.getProject("project-1/databases").pipe(Effect.flip);
        const deploymentLog = yield* client
          .getDeploymentLogsRequest("deployment-1/../../projects")
          .pipe(Effect.flip);
        const buildLog = yield* client.getBuildLogsRequest("build-1?token=leak").pipe(Effect.flip);

        for (const error of [traversal, embeddedRoute, deploymentLog, buildLog]) {
          expect(error).toBeInstanceOf(PrismaApiError);
          expect(error.message).toContain("invalid Prisma Management API");
        }
        expect(captured).toEqual([]);
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("times out an unresponsive management API request", () => {
    const http = HttpClient.make(() => Effect.never);
    const layer = layerForHttp(http);

    return Effect.gen(function* () {
      const fiber = yield* withClient((client) => client.getProject("project-1")).pipe(
        Effect.provide(layer),
        Effect.flip,
        Effect.forkChild({ startImmediately: true }),
      );
      yield* TestClock.adjust("11 seconds");
      const error = yield* Fiber.join(fiber);

      expect(error).toBeInstanceOf(PrismaApiError);
      if (error instanceof PrismaApiError) {
        expect(error.status).toBe(0);
        expect(error.message).toContain("timed out after 10 seconds");
      }
    }).pipe(Effect.provide(TestClock.layer()));
  });

  it.effect("times out while reading a streaming response body", () => {
    const http = HttpClient.make((request) =>
      Effect.succeed(
        HttpClientResponse.fromWeb(
          request,
          new Response(
            new ReadableStream<Uint8Array>({
              start(controller) {
                controller.enqueue(new TextEncoder().encode('{"data":'));
              },
            }),
            {
              status: 201,
              headers: { "content-type": "application/json" },
            },
          ),
        ),
      ),
    );
    const layer = layerForHttp(http);

    return Effect.gen(function* () {
      const fiber = yield* withClient((client) => client.getProject("project-1")).pipe(
        Effect.provide(layer),
        Effect.flip,
        Effect.forkChild({ startImmediately: true }),
      );
      yield* TestClock.adjust("11 seconds");
      const error = yield* Fiber.join(fiber);

      expect(error).toBeInstanceOf(PrismaApiError);
      if (error instanceof PrismaApiError) {
        expect(error.status).toBe(0);
        expect(error.message).toContain("timed out after 10 seconds");
      }
    }).pipe(Effect.provide(TestClock.layer()));
  });

  it.effect("rejects oversized successful response bodies", () => {
    const http = HttpClient.make((request) =>
      Effect.succeed(
        HttpClientResponse.fromWeb(
          request,
          new Response("x".repeat(4 * 1024 * 1024 + 1), {
            status: 201,
            headers: { "content-type": "application/json" },
          }),
        ),
      ),
    );

    return withClient((client) => client.createProject({ name: "api" })).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiDecodeError);
        expect(error.message).toContain("4194304 byte safety limit");
      }),
    );
  });

  it.effect("bounds and redacts oversized API error bodies", () => {
    const secret = "do-not-retain-this-error-body";
    const http = HttpClient.make((request) =>
      Effect.succeed(
        HttpClientResponse.fromWeb(
          request,
          new Response(secret.repeat(3_000), {
            status: 400,
            headers: { "content-type": "text/plain" },
          }),
        ),
      ),
    );

    return withClient((client) => client.createProject({ name: "api" })).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiError);
        expect(error.message).toContain("65536 byte safety limit");
        expect(JSON.stringify(error)).not.toContain(secret);
        if (error instanceof PrismaApiError) {
          expect(error.status).toBe(400);
          expect(error.body).toBeUndefined();
        }
      }),
    );
  });

  it.effect("does not expose plain-text API error bodies in messages", () => {
    const secret = "postgres://admin:plain-text-secret@db.example.test/main";
    const http = HttpClient.make((request) =>
      Effect.succeed(
        HttpClientResponse.fromWeb(
          request,
          new Response(secret, {
            status: 400,
            headers: { "content-type": "text/plain" },
          }),
        ),
      ),
    );

    return withClient((client) => client.createProject({ name: "api" })).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiError);
        expect(error.message).toBe("HTTP 400");
        expect(String(error)).not.toContain(secret);
        expect(JSON.stringify(error)).not.toContain(secret);
        if (error instanceof PrismaApiError) {
          expect(Redacted.value(error.body!)).toBe(secret);
        }
      }),
    );
  });

  it.effect("exposes only safe codes from structured API errors", () => {
    const secret = "postgres://admin:structured-secret@db.example.test/main";
    const responseBody = {
      error: {
        code: "state:not_found",
        message: secret,
        hint: secret,
      },
    };
    const http = HttpClient.make((request) =>
      Effect.succeed(HttpClientResponse.fromWeb(request, json(responseBody, { status: 404 }))),
    );

    return withClient((client) => client.createProject({ name: "api" })).pipe(
      Effect.provide(layerForHttp(http)),
      Effect.flip,
      Effect.map((error) => {
        expect(error).toBeInstanceOf(PrismaApiError);
        expect(error.message).toBe("Prisma Management API request failed (state:not_found)");
        expect(String(error)).not.toContain(secret);
        expect(JSON.stringify(error)).not.toContain(secret);
      }),
    );
  });

  it.effect("uses canonical app and deployment management routes", () => {
    const { layer, captured } = routeCoverageHarness();

    return withClient((client) =>
      Effect.gen(function* () {
        yield* client.createProjectDatabase("project-1", {
          name: "main",
          region: "us-east-1",
        });
        yield* client.createApp({
          projectId: "project-1",
          displayName: "api",
          regionId: "us-east-1",
        });
        yield* client.createAppDeployment("app-1", {
          portMapping: { http: 3000 },
        });
        yield* client.getDeployment("deployment-1");
        yield* client.startDeployment("deployment-1");
        yield* client.stopDeployment("deployment-1");
        yield* client.deleteDeployment("deployment-1");
        yield* client.listWorkspaceIntegrations("workspace-1", { limit: 10 });

        expect(
          captured.map((request) => [request.method, `${request.pathname}${request.search}`]),
        ).toEqual([
          ["POST", "/v1/projects/project-1/databases"],
          ["POST", "/v1/apps"],
          ["POST", "/v1/apps/app-1/deployments"],
          ["GET", "/v1/deployments/deployment-1"],
          ["POST", "/v1/deployments/deployment-1/start"],
          ["POST", "/v1/deployments/deployment-1/stop"],
          ["DELETE", "/v1/deployments/deployment-1"],
          ["GET", "/v1/workspaces/workspace-1/integrations?limit=10"],
        ]);
        expect(captured[0]?.bodyJson).toEqual({
          name: "main",
          region: "us-east-1",
        });
        expect(captured[2]?.bodyJson).toEqual({
          portMapping: { http: 3000 },
        });
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("retries transient API failures for destructive requests", () => {
    const captured: Captured[] = [];
    let attempts = 0;
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        attempts += 1;
        const url = new URL(request.url);
        captured.push({
          url: request.url,
          method: request.method,
          pathname: url.pathname,
          search: url.search,
          authorization: request.headers.authorization,
          bodyJson: undefined,
        });
        return HttpClientResponse.fromWeb(
          request,
          attempts < 3
            ? json(
                {
                  error: {
                    message: "transient platform failure",
                  },
                },
                { status: 500 },
              )
            : empty(),
        );
      }),
    );
    const layer = PrismaClientLive.pipe(
      Layer.provide(
        Layer.mergeAll(
          Layer.succeed(HttpClient.HttpClient, http),
          Layer.succeed(PrismaEnvironment, {
            type: "serviceToken" as const,
            serviceToken: Redacted.make("test-token"),
            source: { type: "stored" as const },
            baseUrl: "https://api.prisma.test",
          }),
        ),
      ),
    );

    return Effect.gen(function* () {
      const fiber = yield* withClient((client) => client.deleteDeployment("deployment-1")).pipe(
        Effect.provide(layer),
        Effect.forkChild({ startImmediately: true }),
      );
      yield* TestClock.adjust("1 second");
      yield* Fiber.join(fiber);

      expect(attempts).toBe(3);
      expect(captured.map((request) => request.method)).toEqual(["DELETE", "DELETE", "DELETE"]);
      expect(captured.map((request) => request.pathname)).toEqual([
        "/v1/deployments/deployment-1",
        "/v1/deployments/deployment-1",
        "/v1/deployments/deployment-1",
      ]);
    }).pipe(Effect.provide(TestClock.layer()));
  });

  it.effect("retries transient API failures for safe lifecycle posts", () => {
    const captured: Captured[] = [];
    let attempts = 0;
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        attempts += 1;
        const url = new URL(request.url);
        captured.push({
          url: request.url,
          method: request.method,
          pathname: url.pathname,
          search: url.search,
          authorization: request.headers.authorization,
          bodyJson: undefined,
        });
        return HttpClientResponse.fromWeb(
          request,
          attempts < 3
            ? json(
                {
                  error: {
                    message: "transient platform failure",
                  },
                },
                { status: 500 },
              )
            : data({
                id: "deployment-1",
                type: "deployment",
                url: "https://api.prisma.test/v1/deployments/deployment-1",
                foundryVersionId: "foundry-1",
                status: "running",
                previewDomain: "version-1.prisma.test",
              }),
        );
      }),
    );
    const layer = PrismaClientLive.pipe(
      Layer.provide(
        Layer.mergeAll(
          Layer.succeed(HttpClient.HttpClient, http),
          Layer.succeed(PrismaEnvironment, {
            type: "serviceToken" as const,
            serviceToken: Redacted.make("test-token"),
            source: { type: "stored" as const },
            baseUrl: "https://api.prisma.test",
          }),
        ),
      ),
    );

    return Effect.gen(function* () {
      const fiber = yield* withClient((client) => client.startDeployment("deployment-1")).pipe(
        Effect.provide(layer),
        Effect.forkChild({ startImmediately: true }),
      );
      yield* TestClock.adjust("1 second");
      const version = yield* Fiber.join(fiber);

      expect(attempts).toBe(3);
      expect(version.previewDomain).toBe("version-1.prisma.test");
      expect(captured.map((request) => request.method)).toEqual(["POST", "POST", "POST"]);
      expect(captured.map((request) => request.pathname)).toEqual([
        "/v1/deployments/deployment-1/start",
        "/v1/deployments/deployment-1/start",
        "/v1/deployments/deployment-1/start",
      ]);
    }).pipe(Effect.provide(TestClock.layer()));
  });

  it.effect("does not retry transient API failures for create requests", () => {
    const captured: Captured[] = [];
    let attempts = 0;
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        attempts += 1;
        const url = new URL(request.url);
        captured.push({
          url: request.url,
          method: request.method,
          pathname: url.pathname,
          search: url.search,
          authorization: request.headers.authorization,
          bodyJson: undefined,
        });
        return HttpClientResponse.fromWeb(
          request,
          json(
            {
              error: {
                message: "transient platform failure",
              },
            },
            { status: 500 },
          ),
        );
      }),
    );
    const layer = PrismaClientLive.pipe(
      Layer.provide(
        Layer.mergeAll(
          Layer.succeed(HttpClient.HttpClient, http),
          Layer.succeed(PrismaEnvironment, {
            type: "serviceToken" as const,
            serviceToken: Redacted.make("test-token"),
            source: { type: "stored" as const },
            baseUrl: "https://api.prisma.test",
          }),
        ),
      ),
    );

    return Effect.gen(function* () {
      const error = yield* withClient((client) =>
        client.createAppDeployment("app-1", {
          portMapping: { http: 3000 },
        }),
      ).pipe(Effect.provide(layer), Effect.flip);

      expect(error).toBeInstanceOf(PrismaApiError);
      expect(attempts).toBe(1);
      expect(captured.map((request) => request.method)).toEqual(["POST"]);
      expect(captured.map((request) => request.pathname)).toEqual(["/v1/apps/app-1/deployments"]);
    });
  });

  it.effect("does not retry transient API failures for transfer requests", () => {
    const captured: Captured[] = [];
    let attempts = 0;
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        attempts += 1;
        const url = new URL(request.url);
        captured.push({
          url: request.url,
          method: request.method,
          pathname: url.pathname,
          search: url.search,
          authorization: request.headers.authorization,
          bodyJson: undefined,
        });
        return HttpClientResponse.fromWeb(
          request,
          json(
            {
              error: {
                message: "transient platform failure",
              },
            },
            { status: 500 },
          ),
        );
      }),
    );
    const layer = PrismaClientLive.pipe(
      Layer.provide(
        Layer.mergeAll(
          Layer.succeed(HttpClient.HttpClient, http),
          Layer.succeed(PrismaEnvironment, {
            type: "serviceToken" as const,
            serviceToken: Redacted.make("test-token"),
            source: { type: "stored" as const },
            baseUrl: "https://api.prisma.test",
          }),
        ),
      ),
    );

    return Effect.gen(function* () {
      const error = yield* withClient((client) =>
        client.transferProject("project-1", {
          recipientAccessToken: "recipient-token",
        }),
      ).pipe(Effect.provide(layer), Effect.flip);

      expect(error).toBeInstanceOf(PrismaApiError);
      expect(attempts).toBe(1);
      expect(captured.map((request) => request.method)).toEqual(["POST"]);
      expect(captured.map((request) => request.pathname)).toEqual([
        "/v1/projects/project-1/transfer",
      ]);
    });
  });

  it.effect("retries transient transport failures", () => {
    let attempts = 0;
    const http = HttpClient.make((request) =>
      Effect.sync(() => {
        attempts += 1;
        return attempts < 3
          ? new HttpClientError.HttpClientError({
              reason: new HttpClientError.TransportError({
                request,
                cause: new Error("connection reset"),
                description: "test transport failure",
              }),
            })
          : undefined;
      }).pipe(
        Effect.flatMap((error) =>
          error
            ? Effect.fail(error)
            : Effect.succeed(HttpClientResponse.fromWeb(request, page([{ id: "project-1" }]))),
        ),
      ),
    );
    const layer = PrismaClientLive.pipe(
      Layer.provide(
        Layer.mergeAll(
          Layer.succeed(HttpClient.HttpClient, http),
          Layer.succeed(PrismaEnvironment, {
            type: "serviceToken" as const,
            serviceToken: Redacted.make("test-token"),
            source: { type: "stored" as const },
            baseUrl: "https://api.prisma.test",
          }),
        ),
      ),
    );

    return Effect.gen(function* () {
      const fiber = yield* withClient((client) => client.listProjects()).pipe(
        Effect.provide(layer),
        Effect.forkChild({ startImmediately: true }),
      );
      yield* TestClock.adjust("1 second");
      const projects = yield* Fiber.join(fiber);

      expect(attempts).toBe(3);
      expect(projects.map((project) => project.id)).toEqual(["project-1"]);
    }).pipe(Effect.provide(TestClock.layer()));
  });

  it.effect("preserves backup list metadata", () => {
    const { layer, captured } = harness();

    return withClient((client) =>
      Effect.gen(function* () {
        const backups = yield* client.listBackups("database-1", { limit: 1 });

        expect(backups).toEqual({
          data: [
            {
              id: "backup-1",
              type: "backup",
              backupType: "full",
              createdAt: "2026-01-01T00:00:00Z",
              status: "completed",
            },
          ],
          meta: {
            backupRetentionDays: 7,
          },
          pagination: {
            hasMore: false,
            limit: 1,
          },
        });
        expect(captured.map((request) => request.pathname)).toEqual([
          "/v1/databases/database-1/backups",
        ]);
        expect(captured[0]?.search).toBe("?limit=1");
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("reads non-paginated region endpoints", () => {
    const { layer } = harness();

    return withClient((client) =>
      Effect.gen(function* () {
        const regions = yield* client.listRegions({ product: "postgres" });
        const postgresRegions = yield* client.listPostgresRegions();
        const accelerateRegions = yield* client.listAccelerateRegions();

        expect(regions.map((region) => region.id)).toEqual(["us-east-1"]);
        expect(postgresRegions.map((region) => region.id)).toEqual(["us-east-1"]);
        expect(accelerateRegions.map((region) => region.id)).toEqual(["us-east-1"]);
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("builds authenticated deployment log stream requests", () => {
    const { layer, captured } = harness("https://api.prisma.test");

    return withClient((client) =>
      Effect.gen(function* () {
        const request = yield* client.getDeploymentLogsRequest("deployment-1", {
          tail: 100,
          fromStart: true,
          cursor: "byte-42",
        });
        expect(request.url).toBe(
          "wss://api.prisma.test/v1/deployments/deployment-1/logs?tail=100&cursor=byte-42&from_start=true",
        );
        expect(Redacted.value(request.headers.Authorization)).toBe("Bearer test-token");
        expect(captured).toEqual([]);
      }),
    ).pipe(Effect.provide(layer));
  });

  it.effect("maps every supported Management API operation to its route", () => {
    const { layer, captured } = routeCoverageHarness();

    return withClient((client) =>
      Effect.gen(function* () {
        yield* client.listWorkspaces({ limit: 1 });
        yield* client.getWorkspace("workspace-1");
        yield* client.getCurrentPrincipal();
        yield* client.listRegions({ product: "postgres" });
        yield* client.listPostgresRegions();
        yield* client.listAccelerateRegions();

        yield* client.listProjects({ limit: 1 });
        yield* client.getProject("project-1");
        yield* client.createProject({ name: "app", region: "us-east-1" });
        yield* client.updateProject("project-1", { name: "renamed" });
        yield* client.deleteProject("project-1");
        yield* client.transferProject("project-1", {
          recipientAccessToken: "recipient-token",
        });

        yield* client.listDatabases({
          projectId: "project-1",
          branchGitName: "main",
        });
        yield* client.listProjectDatabases("project-1", { limit: 1 });
        yield* client.getDatabase("database-1");
        yield* client.createDatabase({
          projectId: "project-1",
          name: "main",
        });
        yield* client.createProjectDatabase("project-1", {
          name: "main",
          source: {
            type: "backup",
            databaseId: "database-source",
            backupId: "backup-1",
          },
        });
        yield* client.updateDatabase("database-1", { name: "main-2" });
        yield* client.deleteDatabase("database-1");
        yield* client.listBackups("database-1", { limit: 1 });
        yield* client.restoreDatabase("database-1", {
          source: {
            type: "backup",
            databaseId: "database-source",
            backupId: "backup-1",
          },
        });
        yield* client.getDatabaseUsage("database-1", {
          startDate: "2026-01-01",
        });

        yield* client.listConnections({ databaseId: "database-1" });
        yield* client.listDatabaseConnections("database-1", { limit: 1 });
        yield* client.getConnection("connection-1");
        yield* client.createConnection({
          databaseId: "database-1",
          name: "direct",
        });
        yield* client.createDatabaseConnection("database-1", {
          name: "direct",
        });
        yield* client.deleteConnection("connection-1");
        yield* client.rotateConnection("connection-1");

        yield* client.listBranches("project-1", { gitName: "main" });
        yield* client.getBranch("branch-1");
        yield* client.createBranch("project-1", { gitName: "main" });
        yield* client.updateBranch("branch-1", { isDefault: true });
        yield* client.deleteBranch("branch-1");

        yield* client.listBuckets({ projectId: "project-1" });
        yield* client.getBucket("bucket-1");
        yield* client.createBucket({
          projectId: "project-1",
          name: "uploads",
        });
        yield* client.deleteBucket("bucket-1");
        yield* client.listBucketKeys("bucket-1", { limit: 1 });
        yield* client.createBucketKey("bucket-1", { role: "read_write" });
        yield* client.deleteBucketKey("bucket-1", "key-1");

        yield* client.getCustomDomain("domain-1");
        yield* client.deleteCustomDomain("domain-1");
        yield* client.retryCustomDomain("domain-1");

        yield* client.listEnvironmentVariables({
          projectId: "project-1",
          class: "production",
          key: "TOKEN",
        });
        yield* client.getEnvironmentVariable("env-1");
        yield* client.createEnvironmentVariable({
          projectId: "project-1",
          class: "production",
          key: "TOKEN",
          value: "secret",
        });
        yield* client.updateEnvironmentVariable("env-1", {
          value: "secret-2",
        });
        yield* client.deleteEnvironmentVariable("env-1");

        yield* client.listIntegrations({ workspaceId: "workspace-1" });
        yield* client.listWorkspaceIntegrations("workspace-1", { limit: 1 });
        yield* client.getIntegration("integration-1");
        yield* client.deleteIntegration("integration-1");
        yield* client.revokeWorkspaceIntegration("workspace-1", "client-1");

        yield* client.listScmInstallations({ workspaceId: "workspace-1" });
        yield* client.createScmInstallIntent({
          provider: "github",
          workspaceId: "workspace-1",
        });
        yield* client.listScmInstallationRepositories("scminstall-1", {
          limit: 10,
        });

        yield* client.listSourceRepositories({ projectId: "project-1" });
        yield* client.getSourceRepository("repo-1");
        yield* client.createSourceRepository({
          projectId: "project-1",
          provider: "github",
          providerRepositoryId: 123,
          installationId: "scminstall-1",
        });
        yield* client.deleteSourceRepository("repo-1");

        yield* client.listApps({
          projectId: "project-1",
          branchGitName: "main",
        });
        yield* client.getApp("app-1");
        yield* client.createApp({
          projectId: "project-1",
          displayName: "web",
        });
        yield* client.updateApp("app-1", { displayName: "web-2" });
        yield* client.deleteApp("app-1");
        yield* client.promoteApp("app-1", { deploymentId: "deployment-1" });
        yield* client.rollbackApp("app-1", { deploymentId: "deployment-1" });
        yield* client.listAppDomains("app-1");
        yield* client.createAppDomain("app-1", {
          hostname: "web.example.com",
        });
        yield* client.listAppDeployments("app-1", { limit: 1 });
        yield* client.createAppDeployment("app-1", {
          skipCodeUpload: true,
        });
        yield* client.getDeployment("deployment-1");
        yield* client.deleteDeployment("deployment-1");
        yield* client.startDeployment("deployment-1");
        yield* client.stopDeployment("deployment-1");
        const deploymentLogsRequest = yield* client.getDeploymentLogsRequest("deployment-1", {
          tail: 10,
        });
        expect(deploymentLogsRequest.url).toBe(
          "wss://api.prisma.test/v1/deployments/deployment-1/logs?tail=10",
        );
        expect(Redacted.value(deploymentLogsRequest.headers.Authorization)).toBe(
          "Bearer test-token",
        );
        const buildLogsRequest = yield* client.getBuildLogsRequest("build-1", {
          follow: true,
          cursor: "cursor-1",
        });
        expect(buildLogsRequest.url).toBe(
          "https://api.prisma.test/v1/builds/build-1/logs?follow=true&cursor=cursor-1",
        );
        expect(Redacted.value(buildLogsRequest.headers.Authorization)).toBe("Bearer test-token");
        expect(buildLogsRequest.headers.Accept).toBe("application/x-ndjson");

        expect(
          captured.map((request) => [request.method, `${request.pathname}${request.search}`]),
        ).toEqual([
          ["GET", "/v1/workspaces?limit=1"],
          ["GET", "/v1/workspaces/workspace-1"],
          ["GET", "/v1/me"],
          ["GET", "/v1/regions?product=postgres"],
          ["GET", "/v1/regions/postgres"],
          ["GET", "/v1/regions/accelerate"],
          ["GET", "/v1/projects?limit=1"],
          ["GET", "/v1/projects/project-1"],
          ["POST", "/v1/projects"],
          ["PATCH", "/v1/projects/project-1"],
          ["DELETE", "/v1/projects/project-1"],
          ["POST", "/v1/projects/project-1/transfer"],
          ["GET", "/v1/databases?projectId=project-1&branchGitName=main"],
          ["GET", "/v1/projects/project-1/databases?limit=1"],
          ["GET", "/v1/databases/database-1"],
          ["POST", "/v1/databases"],
          ["POST", "/v1/projects/project-1/databases"],
          ["PATCH", "/v1/databases/database-1"],
          ["DELETE", "/v1/databases/database-1"],
          ["GET", "/v1/databases/database-1/backups?limit=1"],
          ["POST", "/v1/databases/database-1/restore"],
          ["GET", "/v1/databases/database-1/usage?startDate=2026-01-01"],
          ["GET", "/v1/connections?databaseId=database-1"],
          ["GET", "/v1/databases/database-1/connections?limit=1"],
          ["GET", "/v1/connections/connection-1"],
          ["POST", "/v1/connections"],
          ["POST", "/v1/databases/database-1/connections"],
          ["DELETE", "/v1/connections/connection-1"],
          ["POST", "/v1/connections/connection-1/rotate"],
          ["GET", "/v1/projects/project-1/branches?gitName=main"],
          ["GET", "/v1/branches/branch-1"],
          ["POST", "/v1/projects/project-1/branches"],
          ["PATCH", "/v1/branches/branch-1"],
          ["DELETE", "/v1/branches/branch-1"],
          ["GET", "/v1/buckets?projectId=project-1"],
          ["GET", "/v1/buckets/bucket-1"],
          ["POST", "/v1/buckets"],
          ["DELETE", "/v1/buckets/bucket-1"],
          ["GET", "/v1/buckets/bucket-1/keys?limit=1"],
          ["POST", "/v1/buckets/bucket-1/keys"],
          ["DELETE", "/v1/buckets/bucket-1/keys/key-1"],
          ["GET", "/v1/domains/domain-1"],
          ["DELETE", "/v1/domains/domain-1"],
          ["POST", "/v1/domains/domain-1/retry"],
          ["GET", "/v1/environment-variables?projectId=project-1&class=production&key=TOKEN"],
          ["GET", "/v1/environment-variables/env-1"],
          ["POST", "/v1/environment-variables"],
          ["PATCH", "/v1/environment-variables/env-1"],
          ["DELETE", "/v1/environment-variables/env-1"],
          ["GET", "/v1/integrations?workspaceId=workspace-1"],
          ["GET", "/v1/workspaces/workspace-1/integrations?limit=1"],
          ["GET", "/v1/integrations/integration-1"],
          ["DELETE", "/v1/integrations/integration-1"],
          ["DELETE", "/v1/workspaces/workspace-1/integrations/client-1"],
          ["GET", "/v1/scm-installations?workspaceId=workspace-1"],
          ["POST", "/v1/scm-installations/install-intents"],
          ["GET", "/v1/scm-installations/scminstall-1/repositories?limit=10"],
          ["GET", "/v1/source-repositories?projectId=project-1"],
          ["GET", "/v1/source-repositories/repo-1"],
          ["POST", "/v1/source-repositories"],
          ["DELETE", "/v1/source-repositories/repo-1"],
          ["GET", "/v1/apps?projectId=project-1&branchGitName=main"],
          ["GET", "/v1/apps/app-1"],
          ["POST", "/v1/apps"],
          ["PATCH", "/v1/apps/app-1"],
          ["DELETE", "/v1/apps/app-1"],
          ["POST", "/v1/apps/app-1/promote"],
          ["POST", "/v1/apps/app-1/rollback"],
          ["GET", "/v1/apps/app-1/domains"],
          ["POST", "/v1/apps/app-1/domains"],
          ["GET", "/v1/apps/app-1/deployments?limit=1"],
          ["POST", "/v1/apps/app-1/deployments"],
          ["GET", "/v1/deployments/deployment-1"],
          ["DELETE", "/v1/deployments/deployment-1"],
          ["POST", "/v1/deployments/deployment-1/start"],
          ["POST", "/v1/deployments/deployment-1/stop"],
        ]);
        expect(routeInventoryFrom(captured)).toEqual(expectedManagementApiRoutes);
        expect(expectedManagementApiRoutes).toHaveLength(78);
        expect(captured[11]?.bodyJson).toEqual({
          recipientAccessToken: "recipient-token",
        });
        const restoreRequest = captured.find(
          (request) =>
            request.method === "POST" && request.pathname === "/v1/databases/database-1/restore",
        );
        expect(restoreRequest?.bodyJson).toEqual({
          source: {
            type: "backup",
            databaseId: "database-source",
            backupId: "backup-1",
          },
        });
        const projectDatabaseRequest = captured.find(
          (request) =>
            request.method === "POST" && request.pathname === "/v1/projects/project-1/databases",
        );
        expect(projectDatabaseRequest?.bodyJson).toEqual({
          name: "main",
          source: {
            type: "backup",
            databaseId: "database-source",
            backupId: "backup-1",
          },
        });

        const createEnvRequest = captured.find(
          (request) =>
            request.method === "POST" && request.pathname === "/v1/environment-variables",
        );
        expect(createEnvRequest?.bodyJson).toEqual({
          projectId: "project-1",
          class: "production",
          key: "TOKEN",
          value: "secret",
        });

        const updateEnvRequest = captured.find(
          (request) =>
            request.method === "PATCH" && request.pathname === "/v1/environment-variables/env-1",
        );
        expect(updateEnvRequest?.bodyJson).toEqual({
          value: "secret-2",
        });

        const sourceRepositoryRequest = captured.find(
          (request) => request.method === "POST" && request.pathname === "/v1/source-repositories",
        );
        expect(sourceRepositoryRequest?.bodyJson).toEqual({
          projectId: "project-1",
          provider: "github",
          providerRepositoryId: 123,
          installationId: "scminstall-1",
        });

        const installIntentRequest = captured.find(
          (request) =>
            request.method === "POST" &&
            request.pathname === "/v1/scm-installations/install-intents",
        );
        expect(installIntentRequest?.bodyJson).toEqual({
          provider: "github",
          workspaceId: "workspace-1",
        });
      }),
    ).pipe(Effect.provide(layer));
  });

  it("matches the pinned Management API route contract", () => {
    expect(expectedManagementApiRoutes).toEqual([...productionManagementApiRoutes].sort());
  });
});