sailfork / t3code-github / .repos/ alchemy-effect/ packages/ prisma/ src/ ORM/ Generate.ts

import type { Contract } from "@prisma/orm-postgres/contract/types";
import type { SqlStorage } from "@prisma/orm-postgres/family-contract/types";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Schema from "effect/Schema";
import { effectGeneratorKey, type EffectGeneratorOptions } from "./generator.ts";
import { CliError, rewriteEmittedTypes, runPrismaCli, type EmitResult } from "./internal.ts";
import { emitSchemas, SchemaError } from "./Schema.ts";

interface GeneratorConfig {
  readonly orm?: {
    readonly [effectGeneratorKey]?: EffectGeneratorOptions;
    readonly contract?: {
      readonly output?: string;
      readonly source?: { readonly inputs?: readonly string[] };
    };
  };
}

/** Load generation settings without running emission or migrations. */
export const loadGeneratorConfig = Effect.fn(function* (configFile: string) {
  const path = yield* Path.Path;
  const absolute = path.resolve(configFile);
  const url = yield* path.toFileUrl(absolute);
  const module = yield* Effect.tryPromise({
    try: () => import(url.href),
    catch: (cause) => new CliError({ message: `Cannot load ${absolute}: ${String(cause)}` }),
  });
  const config = module.default as GeneratorConfig | undefined;
  const options = config?.orm?.[effectGeneratorKey];
  if (!options || !config?.orm?.contract?.output) {
    return yield* new CliError({
      message: `Wrap the orm configuration in ${absolute} with withEffect(ormConfig(...), options) and specify output.`,
    });
  }
  const directory = path.dirname(absolute);
  return {
    absolute,
    directory,
    options,
    output: path.resolve(directory, config.orm.contract.output),
    inputs: [
      absolute,
      ...(config.orm.contract.source?.inputs ?? []).map((input) => path.resolve(directory, input)),
    ],
  };
});

const header = "// Generated by alchemy prisma generate.\n";

/** Emit Prisma contracts and optional Effect bindings; never connect or migrate. */
export const generate = Effect.fn(function* (configFile: string) {
  const fs = yield* FileSystem.FileSystem;
  const path = yield* Path.Path;
  const config = yield* loadGeneratorConfig(configFile);
  const temporary = yield* fs.makeTempDirectoryScoped({
    prefix: "alchemy-prisma-generate-",
  });
  const emitted = yield* runPrismaCli<EmitResult>(
    [
      "contract",
      "emit",
      "--config",
      config.absolute,
      "--output-path",
      path.join(temporary, path.basename(config.output)),
    ],
    { cwd: config.directory },
  ).pipe(
    Effect.catchTag("Prisma.CliError", (error) => {
      const diagnostics = Schema.decodeUnknownOption(
        Schema.Struct({
          diagnostics: Schema.Array(Schema.Struct({ message: Schema.String })),
        }),
      )(error.meta);
      return Effect.fail(
        Option.isSome(diagnostics)
          ? new CliError({
              code: error.code,
              fix: error.fix,
              meta: error.meta,
              message: [
                error.message,
                ...diagnostics.value.diagnostics.map((diagnostic) => diagnostic.message),
              ].join("\n"),
            })
          : error,
      );
    }),
  );
  const json = path.resolve(config.directory, emitted.files.json);
  const dts = path.resolve(config.directory, emitted.files.dts);
  yield* rewriteEmittedTypes(dts);
  const text = yield* fs.readFileString(json);
  const contract = yield* Effect.try({
    try: () => JSON.parse(text) as Contract<SqlStorage>,
    catch: (cause) => new CliError({ message: `Invalid emitted contract: ${String(cause)}` }),
  });
  const directory = path.dirname(config.output);
  const jsonName = `./${path.basename(json)}`;
  const typeName = `./${path.basename(dts)}`;
  const files: Record<string, string> = {};
  if (config.options.client !== false) {
    files["runtime.ts"] =
      `${header}import contractJson from ${JSON.stringify(jsonName)} with { type: "json" };\nexport { contractJson };\n`;
    files["client.ts"] =
      `${header}import type { Contract } from ${JSON.stringify(typeName)};\nimport type * as Effect from "effect/Effect";\nimport type * as Redacted from "effect/Redacted";\nimport { Postgres, type PostgresConfig } from "@alchemy.run/prisma/ORM/Postgres";\nimport { contractJson } from "./runtime.ts";\nexport const makeDatabase = <E = never, R = never>(\n  connectionString: Effect.Effect<Redacted.Redacted<string>, E, R>,\n  options: Omit<PostgresConfig<Contract>, "contract" | "contractJson"> = {},\n) => Postgres<Contract, E, R>(connectionString, { ...options, contractJson });\n`;
  }
  if (config.options.schemas !== false) {
    files["schemas.ts"] = yield* Effect.try({
      try: () => emitSchemas(contract, config.options),
      catch: (cause) =>
        cause instanceof SchemaError
          ? cause
          : new CliError({ message: `Cannot emit schemas: ${String(cause)}` }),
    });
  }
  files["index.ts"] =
    header +
    [
      ...(config.options.client !== false ? ['export { makeDatabase } from "./client.ts";'] : []),
      ...(config.options.schemas !== false ? ['export { schemas } from "./schemas.ts";'] : []),
    ].join("\n") +
    "\n";
  const owned = ["runtime.ts", "client.ts", "schemas.ts", "index.ts"];
  for (const name of owned) {
    const target = path.join(directory, name);
    if (yield* fs.exists(target)) {
      const previous = yield* fs.readFileString(target);
      if (!previous.startsWith(header)) {
        return yield* new CliError({
          message: `Refusing to overwrite non-generated file ${target}`,
        });
      }
    }
  }
  files[path.basename(json)] = text;
  files[path.basename(dts)] = yield* fs.readFileString(dts);
  yield* fs.makeDirectory(directory, { recursive: true });
  for (const name of new Set([...owned, ...Object.keys(files)])) {
    const target = path.join(directory, name);
    const exists = yield* fs.exists(target);
    const previous = exists ? yield* fs.readFileString(target) : undefined;
    const content = files[name];
    if (content === undefined) {
      if (exists) yield* fs.remove(target);
    } else if (content !== previous) {
      yield* fs.writeFileString(target, content);
    }
  }
  return {
    directory,
    files: Object.keys(files).map((name) => path.join(directory, name)),
  };
}, Effect.scoped);