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

import { PrismaClient, type PrismaManagementClient } from "@alchemy.run/prisma/Client";
import * as Prisma from "@alchemy.run/prisma/Operations";
import { describe, expect, it } from "@alchemy.run/test";
import * as Effect from "effect/Effect";
import * as Redacted from "effect/Redacted";
import { Credentials } from "../../../prisma/src/internal/Credentials.ts";

type AssertNever<T extends never> = T;
type ClientOperation = Exclude<keyof PrismaManagementClient, "request" | "paginate">;
export type PrismaOperationCoverage = [
  AssertNever<Exclude<ClientOperation, keyof typeof Prisma>>,
  AssertNever<Exclude<keyof typeof Prisma, ClientOperation>>,
];

const expectedOperationHelpers = [
  "listWorkspaces",
  "getWorkspace",
  "getCurrentPrincipal",
  "listRegions",
  "listPostgresRegions",
  "listAccelerateRegions",
  "listProjects",
  "getProject",
  "createProject",
  "updateProject",
  "deleteProject",
  "transferProject",
  "listDatabases",
  "listProjectDatabases",
  "getDatabase",
  "createDatabase",
  "createProjectDatabase",
  "updateDatabase",
  "deleteDatabase",
  "listBackups",
  "restoreDatabase",
  "getDatabaseUsage",
  "listConnections",
  "listDatabaseConnections",
  "getConnection",
  "createConnection",
  "createDatabaseConnection",
  "deleteConnection",
  "rotateConnection",
  "listBranches",
  "getBranch",
  "createBranch",
  "updateBranch",
  "deleteBranch",
  "listBuckets",
  "getBucket",
  "createBucket",
  "deleteBucket",
  "listBucketKeys",
  "createBucketKey",
  "deleteBucketKey",
  "getCustomDomain",
  "deleteCustomDomain",
  "retryCustomDomain",
  "listApps",
  "getApp",
  "createApp",
  "updateApp",
  "deleteApp",
  "promoteApp",
  "rollbackApp",
  "listAppDomains",
  "createAppDomain",
  "listAppDeployments",
  "createAppDeployment",
  "getDeployment",
  "deleteDeployment",
  "startDeployment",
  "stopDeployment",
  "getDeploymentLogsRequest",
  "getBuildLogsRequest",
  "listEnvironmentVariables",
  "getEnvironmentVariable",
  "createEnvironmentVariable",
  "updateEnvironmentVariable",
  "deleteEnvironmentVariable",
  "listIntegrations",
  "listWorkspaceIntegrations",
  "getIntegration",
  "deleteIntegration",
  "revokeWorkspaceIntegration",
  "listScmInstallations",
  "createScmInstallIntent",
  "listScmInstallationRepositories",
  "listSourceRepositories",
  "getSourceRepository",
  "createSourceRepository",
  "deleteSourceRepository",
];

describe("Prisma operation helpers", { tags: ["unit", "provider:prisma", "local"] }, () => {
  it.effect("delegate every public operation helper to PrismaClient", () => {
    const calls: Array<[string, unknown[]]> = [];
    const client = new Proxy(
      {},
      {
        get:
          (_target, prop) =>
          (...args: unknown[]) =>
            Effect.sync(() => {
              calls.push([String(prop), args]);
              return { ok: true };
            }),
      },
    ) as unknown as PrismaManagementClient;

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

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

      yield* Prisma.listDatabases({ projectId: "project-1" });
      yield* Prisma.listProjectDatabases("project-1", { limit: 1 });
      yield* Prisma.getDatabase("database-1");
      yield* Prisma.createDatabase({ projectId: "project-1" });
      yield* Prisma.createProjectDatabase("project-1", {
        region: "us-east-1",
        source: { type: "backup", databaseId: "database-source", backupId: "backup-1" },
      });
      yield* Prisma.updateDatabase("database-1", { name: "renamed" });
      yield* Prisma.deleteDatabase("database-1");
      yield* Prisma.listBackups("database-1", { limit: 1 });
      yield* Prisma.restoreDatabase("database-1", {
        source: { type: "backup", databaseId: "source-database", backupId: "backup-1" },
      });
      yield* Prisma.getDatabaseUsage("database-1", {
        startDate: "2026-01-01",
        endDate: "2026-01-02",
      });

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

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

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

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

      yield* Prisma.listApps({ projectId: "project-1" });
      yield* Prisma.getApp("app-1");
      yield* Prisma.createApp({ projectId: "project-1", displayName: "web" });
      yield* Prisma.updateApp("app-1", { displayName: "renamed" });
      yield* Prisma.deleteApp("app-1");
      yield* Prisma.promoteApp("app-1", { deploymentId: "deployment-1" });
      yield* Prisma.rollbackApp("app-1", { deploymentId: "deployment-1" });
      yield* Prisma.listAppDomains("app-1");
      yield* Prisma.createAppDomain("app-1", { hostname: "web.example.com" });
      yield* Prisma.listAppDeployments("app-1", { limit: 1 });
      yield* Prisma.createAppDeployment("app-1", { skipCodeUpload: true });
      yield* Prisma.getDeployment("deployment-1");
      yield* Prisma.deleteDeployment("deployment-1");
      yield* Prisma.startDeployment("deployment-1");
      yield* Prisma.stopDeployment("deployment-1");
      yield* Prisma.getDeploymentLogsRequest("deployment-1", { tail: 10 });
      yield* Prisma.getBuildLogsRequest("build-1", { follow: true });

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

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

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

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

      expect(Object.keys(Prisma).sort()).toEqual([...expectedOperationHelpers].sort());
      // The log-request builders resolve the distilled Credentials service
      // directly instead of delegating to the client, so they never appear in
      // `calls`.
      expect(calls.map(([name]) => name)).toEqual(
        expectedOperationHelpers.filter(
          (name) => name !== "getDeploymentLogsRequest" && name !== "getBuildLogsRequest",
        ),
      );
    }).pipe(
      Effect.provideService(PrismaClient, client),
      Effect.provideService(
        Credentials,
        Effect.succeed({
          apiToken: Redacted.make("test-token"),
          apiBaseUrl: "https://api.prisma.test",
        }),
      ),
    );
  });
});