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

import { generate } from "@alchemy.run/prisma/ORM/Generate";
import { expect, layer } from "@alchemy.run/test";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import { ChildProcess } from "effect/process";
import * as Result from "effect/Result";
import * as Schedule from "effect/Schedule";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";

const describe = layer(NodeServices.layer, { excludeTestServices: true });

describe("Effect contract generation", (it) => {
  it.effect(
    "emits deterministic PSL bindings, validates rows, and removes disabled outputs",
    () =>
      Effect.gen(function* () {
        const fs = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const fixtures = yield* path.fromFileUrl(new URL("./fixtures", import.meta.url));
        const directory = yield* fs.makeTempDirectoryScoped({
          directory: fixtures,
          prefix: "generate-",
        });
        const source = yield* fs.readFileString(path.join(fixtures, "psl/contract.psl"));
        yield* fs.writeFileString(path.join(directory, "contract.psl"), source);
        const config = (client: boolean, schemas: boolean) =>
          `import { defineConfig } from "@prisma/orm-postgres/config";\nimport { definePrismaConfig } from "prisma/config";\nimport { withEffect } from "@alchemy.run/prisma/ORM/generator";\nexport default definePrismaConfig({ orm: withEffect(defineConfig({ contract: "./contract.psl", output: "./generated" }), { client: ${client}, schemas: ${schemas} }) });\n`;
        for (const [name, client, schemas] of [
          ["both", true, true],
          ["schemas", false, true],
          ["client", true, false],
        ] as const) {
          yield* fs.writeFileString(
            path.join(directory, `${name}.config.ts`),
            config(client, schemas),
          );
        }
        const result = yield* generate(path.join(directory, "both.config.ts"));
        const before = yield* Effect.forEach(result.files, (file) => fs.readFileString(file));
        yield* generate(path.join(directory, "both.config.ts"));
        expect(yield* Effect.forEach(result.files, (file) => fs.readFileString(file))).toEqual(
          before,
        );
        expect(result.files).toHaveLength(6);
        const schemaUrl = yield* path.toFileUrl(path.join(result.directory, "schemas.ts"));
        const { schemas } = yield* Effect.promise(() => import(schemaUrl.href));
        expect(
          Schema.is(schemas.public.User)({
            id: 1,
            email: "a@example.com",
            name: null,
          }),
        ).toBe(true);
        expect(
          Schema.is(schemas.public.User)({
            id: "bad",
            email: "a@example.com",
            name: null,
          }),
        ).toBe(false);
        const standalone = yield* fs.readFileString(path.join(result.directory, "schemas.ts"));
        expect(standalone).not.toContain('from "alchemy');
        expect(standalone).not.toContain("@prisma");
        yield* generate(path.join(directory, "schemas.config.ts"));
        expect(yield* fs.exists(path.join(result.directory, "client.ts"))).toBe(false);
        expect(yield* fs.exists(path.join(result.directory, "runtime.ts"))).toBe(false);
        expect(yield* fs.readFileString(path.join(result.directory, "index.ts"))).not.toContain(
          "makeDatabase",
        );
        yield* generate(path.join(directory, "client.config.ts"));
        expect(yield* fs.exists(path.join(result.directory, "schemas.ts"))).toBe(false);
        expect(yield* fs.exists(path.join(result.directory, "client.ts"))).toBe(true);
        yield* fs.writeFileString(path.join(result.directory, "schemas.ts"), "// handwritten\n");
        const refused = yield* generate(path.join(directory, "both.config.ts")).pipe(Effect.result);
        expect(Result.isFailure(refused)).toBe(true);
        expect(yield* fs.readFileString(path.join(result.directory, "schemas.ts"))).toBe(
          "// handwritten\n",
        );
        yield* fs.remove(path.join(result.directory, "schemas.ts"));
        yield* fs.writeFileString(path.join(directory, "contract.psl"), "invalid contract");
        const failed = yield* generate(path.join(directory, "both.config.ts")).pipe(Effect.result);
        expect(Result.isFailure(failed)).toBe(true);
        expect(yield* fs.readFileString(path.join(result.directory, "contract.json"))).toBe(
          before[result.files.indexOf(path.join(result.directory, "contract.json"))],
        );
      }).pipe(Effect.scoped),
    {
      tags: ["unit", "provider:prisma", "provider:prisma:orm", "local"],
      timeout: 120_000,
    },
  );

  it.effect(
    "watch regenerates imported TypeScript changes and recovers after invalid source",
    () =>
      Effect.gen(function* () {
        const fs = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const fixtures = yield* path.fromFileUrl(new URL("./fixtures", import.meta.url));
        const directory = yield* fs.makeTempDirectoryScoped({
          directory: fixtures,
          prefix: "watch-",
        });
        const config = path.join(directory, "prisma.config.ts");
        yield* fs.writeFileString(
          config,
          `import { defineConfig } from "@prisma/orm-postgres/config";\nimport { definePrismaConfig } from "prisma/config";\nimport { withEffect } from "@alchemy.run/prisma/ORM/generator";\nexport default definePrismaConfig({ orm: withEffect(defineConfig({ contract: "./contract.ts", output: "./generated" })) });\n`,
        );
        yield* fs.writeFileString(
          path.join(directory, "contract.ts"),
          `import { defineContract, field, model } from "@alchemy.run/prisma/ORM";\nimport { value } from "./fields.ts";\nexport const contract = defineContract({ models: { Item: model("Item", { fields: { id: field.column({ codecId: "pg/int4@1", nativeType: "int4" }).id(), value } }) } });\n`,
        );
        const fieldModule = (codec: "text" | "int4") =>
          `import { field } from "@alchemy.run/prisma/ORM";\nexport const value = field.column({ codecId: "pg/${codec}@1", nativeType: "${codec}" });\n`;
        const fields = path.join(directory, "fields.ts");
        yield* fs.writeFileString(fields, fieldModule("text"));
        const bin = yield* path.fromFileUrl(
          new URL("../../../../alchemy/bin/cli.js", import.meta.url),
        );
        const process = yield* ChildProcess.make(globalThis.process.execPath, [
          bin,
          "provider",
          "prisma",
          "generate",
          "--config",
          config,
          "--watch",
          "--no-input",
        ]);
        let output = "";
        yield* process.stdout.pipe(
          Stream.decodeText(),
          Stream.runForEach((text) =>
            Effect.sync(() => {
              output += text;
            }),
          ),
          Effect.forkScoped,
        );
        yield* process.stderr.pipe(
          Stream.decodeText(),
          Stream.runForEach((text) =>
            Effect.sync(() => {
              output += text;
            }),
          ),
          Effect.forkScoped,
        );
        const wait = (condition: () => boolean) =>
          Effect.sync(condition).pipe(
            Effect.repeat({
              schedule: Schedule.spaced("1 second"),
              until: Boolean,
              times: 10,
            }),
            Effect.flatMap((ready) => Effect.sync(() => expect(ready, output).toBe(true))),
          );
        yield* wait(() => output.includes("Watching"));
        const generated = path.join(directory, "generated/schemas.ts");
        const waitForField = (expression: string) =>
          fs.readFileString(generated).pipe(
            Effect.repeat({
              schedule: Schedule.spaced("1 second"),
              until: (text) => text.includes(expression),
              times: 10,
            }),
            Effect.tap((text) => Effect.sync(() => expect(text).toContain(expression))),
          );
        yield* fs.writeFileString(fields, fieldModule("int4"));
        yield* waitForField('"value": Schema.Int');
        yield* fs.writeFileString(fields, "invalid typescript");
        yield* wait(() => output.includes("Prisma.CliError"));
        yield* fs.writeFileString(fields, fieldModule("text"));
        yield* waitForField('"value": Schema.String');
      }).pipe(Effect.scoped),
    {
      tags: ["unit", "provider:prisma", "provider:prisma:orm", "local"],
      timeout: 120_000,
    },
  );
});