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

import * as Prisma from "@alchemy.run/prisma";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as HttpServerResponse from "effect/http/HttpServerResponse";
import * as Path from "effect/Path";
import * as Redacted from "effect/Redacted";
import * as Schedule from "effect/Schedule";

const { test } = Test.make({ providers: Prisma.providers(), dev: true });

test.provider(
  "dev mode returns a local Compute without a token",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const app = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Prisma.Compute("App", {
            project: "project-dev",
            appName: "api",
            port: 8787,
            dev: { url: "http://localhost:8787" },
          });
        }),
      );

      expect(app.local).toBe(true);
      expect(app.url).toBe("http://localhost:8787");
      expect(app.appId).toContain("dev:");

      yield* stack.destroy();
    }),
  { tags: ["provider:prisma", "provider:prisma:compute", "local"] },
);

test.provider(
  "dev mode supports the same stack shape with Project",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const output = yield* stack.deploy(
        Effect.gen(function* () {
          const project = yield* Prisma.Project("Project", {
            name: "local-project",
            createDatabase: false,
          });
          const app = yield* Prisma.Compute("AppWithProject", {
            project,
            appName: "api",
            port: 8787,
            dev: { url: "http://localhost:8787" },
          });
          return { project, app };
        }),
      );

      expect(output.project.projectId).toBe("dev:project:Project");
      expect(output.app.projectId).toBe(output.project.projectId);
      expect(output.app.local).toBe(true);
      expect(output.app.url).toBe("http://localhost:8787");

      yield* stack.destroy();
    }),
  { tags: ["provider:prisma", "provider:prisma:compute", "provider:prisma:project", "local"] },
);

test.provider(
  "dev mode records effect-native Connection.bind env on Compute",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const output = yield* stack.deploy(
        Effect.gen(function* () {
          const project = yield* Prisma.Project("Project", { name: "local-project" });
          const database = yield* Prisma.Database("Database", {
            project,
            name: "main",
            dev: { name: "alchemy-compute-dev-bind-env" },
          });
          const connection = yield* Prisma.Connection("Connection", { database, name: "api" });
          const keys = Prisma.connectEnvKeys(connection);
          const app = yield* Prisma.Compute(
            "App",
            {
              project,
              appName: "api",
              main: import.meta.filename,
              dev: { url: "http://localhost:8787" },
            },
            Effect.gen(function* () {
              const db = yield* Prisma.Connect(connection);

              return {
                fetch: Effect.gen(function* () {
                  const connectionId = yield* db.connectionId;
                  return HttpServerResponse.text(connectionId);
                }),
              };
            }).pipe(Effect.provide(Prisma.ConnectBinding)),
          );

          return { app, keys };
        }),
      );

      expect(output.app.local).toBe(true);
      expect(output.app.environmentKeys).toEqual(
        expect.arrayContaining([
          output.keys.connectionId,
          output.keys.databaseId,
          output.keys.directConnectionString,
          output.keys.pooledConnectionString,
          output.keys.accelerateConnectionString,
          output.keys.host,
          output.keys.user,
          output.keys.password,
        ]),
      );

      yield* stack.destroy();
    }),
  {
    tags: [
      "provider:prisma",
      "provider:prisma:compute",
      "provider:prisma:connect",
      "provider:prisma:connection",
      "provider:prisma:database",
      "provider:prisma:project",
      "local",
    ],
  },
);

test.provider(
  "dev mode resolves all owned Prisma resource shapes without a token",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const output = yield* stack.deploy(
        Effect.gen(function* () {
          const project = yield* Prisma.Project("Project", { name: "local-project" });
          const database = yield* Prisma.Database("Database", {
            project,
            name: "main",
            dev: { name: "alchemy-compute-dev-owned-shapes" },
          });
          const connection = yield* Prisma.Connection("Connection", { database, name: "api" });
          const branch = yield* Prisma.Branch("Branch", {
            project,
            gitName: "main",
            isDefault: true,
          });
          const appResource = yield* Prisma.App("App", {
            project,
            displayName: "api",
            branchId: branch.branchId,
          });
          const deployment = yield* Prisma.Deployment("Deployment", {
            app: appResource,
            portMapping: { http: 3000 },
          });
          const env = yield* Prisma.EnvironmentVariable("Environment", {
            project,
            class: "production",
            key: "TOKEN",
            value: Redacted.make("secret"),
          });
          const repo = yield* Prisma.SourceRepository("SourceRepository", {
            project,
            providerRepositoryId: 123,
          });

          return { project, database, connection, branch, appResource, deployment, env, repo };
        }),
      );

      expect(output.project.projectId).toBe("dev:project:Project");
      expect(output.database.projectId).toBe(output.project.projectId);
      expect(output.database.databaseId).toBe("dev:database:Database");
      expect(output.connection.databaseId).toBe(output.database.databaseId);
      expect(output.branch.projectId).toBe(output.project.projectId);
      expect(output.branch.isDefault).toBe(true);
      expect(output.appResource.projectId).toBe(output.project.projectId);
      expect(output.appResource.branchId).toBe(output.branch.branchId);
      expect(output.deployment.appId).toBe(output.appResource.appId);
      expect(output.env.projectId).toBe(output.project.projectId);
      expect(output.env.key).toBe("TOKEN");
      expect(Redacted.value(output.env.value)).toBe("secret");
      expect(output.repo.projectId).toBe(output.project.projectId);
      expect(output.repo.repoId).toBe(123);

      yield* stack.destroy();
    }),
  {
    tags: [
      "provider:prisma",
      "provider:prisma:app",
      "provider:prisma:branch",
      "provider:prisma:compute",
      "provider:prisma:connection",
      "provider:prisma:database",
      "provider:prisma:deployment",
      "provider:prisma:environmentvariable",
      "provider:prisma:project",
      "provider:prisma:sourcerepository",
      "local",
    ],
    exclusive: "prisma:dev",
  },
);

test.provider(
  "dev mode starts a local command and passes env",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const fs = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const root = yield* fs.makeTempDirectory({ prefix: "alchemy-prisma-dev-" });
      const scriptPath = path.join(root, "dev-server.sh");
      const outputPath = path.join(root, "dev-output.json");
      const stoppedPath = path.join(root, "dev-stopped.txt");

      yield* fs.writeFileString(
        scriptPath,
        [
          "trap 'printf stopped > dev-stopped.txt; exit 0' TERM INT",
          'printf \'{"port":"%s","greeting":"%s","nodeEnv":"%s"}\' "$PORT" "$GREETING" "$NODE_ENV" > dev-output.json',
          "while true; do sleep 1; done",
          "",
        ].join("\n"),
      );

      const app = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Prisma.Compute("AppWithCommand", {
            project: "project-dev",
            appName: "api",
            path: root,
            port: 8788,
            env: { GREETING: "hello-dev" },
            dev: { command: "sh dev-server.sh", cwd: root, port: 8789 },
          });
        }),
      );

      expect(app.local).toBe(true);
      expect(app.url).toBe("http://localhost:8789");

      const output = yield* fs.readFileString(outputPath).pipe(
        Effect.retry({
          schedule: Schedule.max([Schedule.fixed("50 millis"), Schedule.recurs(40)]),
        }),
      );

      expect(JSON.parse(output)).toEqual({
        port: "8789",
        greeting: "hello-dev",
        nodeEnv: "development",
      });

      yield* stack.destroy();

      const stopped = yield* fs.readFileString(stoppedPath).pipe(
        Effect.retry({
          schedule: Schedule.max([Schedule.fixed("50 millis"), Schedule.recurs(40)]),
        }),
      );

      expect(stopped).toBe("stopped");
    }),
  { tags: ["provider:prisma", "provider:prisma:compute", "local"], timeout: 10_000 },
);