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);