@prisma/orm-toolchain 8.0.0-rc.1-dev.35 → 8.0.0-rc.1-dev.37

package/dist/cli.mjs

@@ -1,11 +1,12 @@
 import { i as loadConfig } from "./exports-BZLNbtkY.mjs";
-import { F as requireLiveDatabase, I as runCommandAction, N as errorUnexpected, a as errorConfigValidation$1, b as errorNoMigrations, c as errorDatabaseConnectionRequired, d as errorFileNotFound, h as errorLegendHumanOnly, j as errorTargetMigrationNotSupported, s as errorContractValidationFailed, t as CliStructuredError$1$1, u as errorDriverRequired, v as errorMigrationPackageNotFound } from "./cli-errors-C6_pH59O-CzD4SYcJ.mjs";
+import { F as requireLiveDatabase, I as runCommandAction, N as errorUnexpected, O as errorRuntime$1, a as errorConfigValidation$1, b as errorNoMigrations, c as errorDatabaseConnectionRequired, d as errorFileNotFound, h as errorLegendHumanOnly, j as errorTargetMigrationNotSupported, s as errorContractValidationFailed, t as CliStructuredError$1$1, u as errorDriverRequired, v as errorMigrationPackageNotFound } from "./cli-errors-C6_pH59O-CzD4SYcJ.mjs";
 import { r as getEmittedArtifactPaths } from "./exports-BCLg4CiV-05kuwcb0.mjs";
+import { n as executeContractEmit } from "./contract-emit-Dp1pe06_-Cdpvh5DH.mjs";
 import { h as renderPreviewStatement, m as previewBlockHeader } from "./terminal-ui-Cqz4LVL7-B0mcVdLy.mjs";
 import { c as spaceMigrationDirectory } from "./verify-contract-spaces-DhJTb0zM-_oh6W6lp.mjs";
 import { S as targetSupportsMigrations, f as maskConnectionUrl, n as closeQuietly, v as sanitizeErrorMessage } from "./command-helpers-kD9CO1hd-BPhnkBin.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-BlvUNMHM-BEioUVR5.mjs";
-import { t as createFormatCommand } from "./format-D5x0jz7q-xalz6Fkn.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-Cpj5Qz7z-BXt3HGPC.mjs";
+import { n as executeFormat, t as createFormatCommand } from "./format-DceifGAK-BJhTdkcO.mjs";
 import { a as loadContractSpaceAggregateForCli, r as buildReadAggregate, s as refuseContractSpaceIntegrity, u as toDeclaredExtensionsFromRaw } from "./contract-space-aggregate-loader-BpdB-mHG-BiU0IUeb.mjs";
 import { t as createControlClient } from "./client-BqhVohc5-DFRVWFps.mjs";
 import { a as readContractIR, o as resolveRefAdvancementFields, t as advanceRefSafely } from "./ref-advancement-DaZBzm7m-WoqnFAyr.mjs";
@@ -22,25 +23,27 @@ import { n as looksLikePath, r as resolveAppTargetPath, t as findPackageByDirPat
 import { t as buildMigrationSpaceGraphEntries } from "./migration-graph-DmdVVJoZ-DDBKjUMz.mjs";
 import { n as renderMigrationGraphDot, r as renderMigrationGraphSections, t as buildMigrationGraphTreeSections } from "./migration-graph-sections-BWcFCOL6-_G0Wb4QR.mjs";
 import { a as sortLedgerEntries, i as serializeLedgerEntriesForJson, n as formatLedgerAppliedAt, o as styleHashTransition, t as MIGRATION_LOG_EMPTY_MESSAGE } from "./migration-log-table-DRiOnvzf-zTQBThqe.mjs";
+import { n as executeRefListCommand, r as executeRefSetCommand, t as executeRefDeleteCommand } from "./ref-CVD6j3jA-BAgpZLNM.mjs";
 import { CliStructuredError } from "@prisma/orm-framework/errors/control";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { join, normalize, relative, resolve } from "pathe";
+import { basename, dirname, join, normalize, relative, resolve } from "pathe";
 import { existsSync, unlinkSync, writeFileSync } from "node:fs";
 import { DOCS_BASE, isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { APP_SPACE_ID, createControlStack } from "@prisma/orm-framework/components/control";
 import { collectConfigIssues } from "@prisma/orm-framework/config/config-validation";
 import { tmpdir } from "node:os";
+import { printPsl } from "@prisma/orm-framework/psl-printer";
 import { defineCommand, defineCommandFamily, defineConfigSection, flag, positional } from "@prisma/cli-engine";
 import { CliStructuredError as CliStructuredError$1, notOk, ok } from "@prisma/cli-engine/protocol";
 import { pathToFileURL } from "node:url";
 import { build } from "esbuild";
-//#region ../../../1-framework/3-tooling/cli/dist/load-config-BQgwPvgu.mjs
+//#region ../../../1-framework/3-tooling/cli/dist/load-config-Db2bTG_C.mjs
 const MISSING_CONFIG_ACTION = {
 	kind: "run-command",
-	label: "Create a configuration file",
+	label: "Create a config file",
 	command: "prisma-next init"
 };
 function editConfigAction(field) {
@@ -260,16 +263,6 @@ function defineOrmCommand(def) {
 		}
 	});
 }
-/**
-* The database connection override, declared from here by every command that
-* accepts one so its brief and placeholder cannot drift apart. Resolution
-* order is the flag, then `config.db.connection`, then
-* `CONFIG.DB_CONNECTION_REQUIRED`.
-*/
-const dbFlag = flag.string({
-	brief: "Database connection string",
-	placeholder: "url"
-});
 const OUTCOMES = {
 	ok: "ok",
 	skipped: "skipped",
@@ -302,6 +295,267 @@ function controlProgressReporter(report) {
 		});
 	};
 }
+function hashRows(document) {
+	return {
+		kind: "fields",
+		rows: [
+			{
+				label: "storageHash",
+				value: [{
+					text: document.storageHash,
+					tone: "identifier"
+				}]
+			},
+			...document.executionHash === void 0 ? [] : [{
+				label: "executionHash",
+				value: [{
+					text: document.executionHash,
+					tone: "identifier"
+				}]
+			}],
+			{
+				label: "profileHash",
+				value: [{
+					text: document.profileHash,
+					tone: "identifier"
+				}]
+			}
+		]
+	};
+}
+function emitPresentations(inputs) {
+	const { document, cwd } = inputs;
+	return {
+		human: () => [
+			{
+				kind: "fields",
+				rail: true,
+				rows: [{
+					label: "contract",
+					value: relative(cwd, document.files.json)
+				}, {
+					label: "types",
+					value: relative(cwd, document.files.dts)
+				}]
+			},
+			{
+				kind: "summary",
+				status: "ok",
+				text: "Emitted contract.json and contract.d.ts"
+			},
+			hashRows(document)
+		],
+		stdout: () => [document.files.json, document.files.dts],
+		json: () => document
+	};
+}
+function createContractEmitCommand$1({ executeContractEmit }) {
+	return defineOrmCommand({
+		help: {
+			summary: "Emit your contract artifacts",
+			description: "Reads your contract source (TypeScript or Prisma schema) and emits\ncontract.json and contract.d.ts. The contract.json contains the canonical\ncontract structure, and contract.d.ts provides TypeScript types for\ntype-safe query building. Offline — does not consult the database.",
+			examples: [
+				"contract emit",
+				"contract emit --output-path ./generated",
+				"contract emit --json"
+			]
+		},
+		args: { flags: { outputPath: flag.string({
+			brief: "Directory to write contract.json and contract.d.ts into",
+			placeholder: "dir"
+		}) } },
+		needs: { config: ormConfigSection },
+		handler: async (args, ctx) => {
+			const startedAt = Date.now();
+			const outputPath = args.flags.outputPath === void 0 ? void 0 : resolve(ctx.cwd, args.flags.outputPath);
+			const result = await executeContractEmit({
+				config: ctx.config,
+				cwd: ctx.cwd,
+				onProgress: controlProgressReporter(ctx.report),
+				signal: ctx.signal,
+				...ifDefined("outputPath", outputPath)
+			});
+			if (result.validationWarning !== void 0) ctx.report({
+				kind: "message",
+				severity: "warn",
+				text: result.validationWarning
+			});
+			const document = {
+				ok: true,
+				storageHash: result.storageHash,
+				...ifDefined("executionHash", result.executionHash),
+				profileHash: result.profileHash,
+				outDir: dirname(result.files.json),
+				files: result.files,
+				timings: { total: Date.now() - startedAt }
+			};
+			ctx.report({
+				kind: "message",
+				severity: "verbose",
+				text: `Total time: ${document.timings.total}ms`
+			});
+			return ok(ctx.present({ data: document }, emitPresentations({
+				document,
+				cwd: ctx.cwd
+			})));
+		}
+	});
+}
+const contractEmitCommand = createContractEmitCommand$1({ executeContractEmit });
+/**
+* Writes a generated file the way `contract emit` publishes its pair: the
+* bytes land in a temporary file beside the target and are renamed over it, so
+* a run interrupted mid-write leaves the previous file intact rather than a
+* truncated one.
+*/
+async function publishTextArtifact(inputs) {
+	const directory = dirname(inputs.path);
+	const tempPath = join(directory, `.${basename(inputs.path)}.${process.pid}.${inputs.publicationToken}.next.tmp`);
+	await mkdir(directory, { recursive: true });
+	try {
+		await writeFile(tempPath, inputs.content, "utf-8");
+		await rename(tempPath, inputs.path);
+	} finally {
+		await rm(tempPath, { force: true });
+	}
+}
+/**
+* The database connection override, declared from here by every command that
+* accepts one so its brief and placeholder cannot drift apart. Resolution
+* order is the flag, then `config.db.connection`, then
+* `CONFIG.DB_CONNECTION_REQUIRED`.
+*/
+const dbFlag = flag.string({
+	brief: "Database connection string",
+	placeholder: "url"
+});
+/** The file `contract infer` writes when nothing names another. */
+const INFERRED_CONTRACT_FILENAME = "contract.prisma";
+/**
+* Where `contract infer` writes the PSL it inferred: `--output`, else
+* `contract.prisma` beside the emitted contract, else `contract.prisma` in the
+* invocation directory.
+*/
+function inferredContractPathFor(inputs) {
+	if (inputs.output !== void 0) return resolve(inputs.cwd, inputs.output);
+	const contractOutput = inputs.config.contract?.output;
+	if (contractOutput !== void 0) return join(dirname(resolve(inputs.cwd, contractOutput)), INFERRED_CONTRACT_FILENAME);
+	return join(inputs.cwd, INFERRED_CONTRACT_FILENAME);
+}
+function inferPresentations(inputs) {
+	const { document, database } = inputs;
+	return {
+		human: () => [...database === void 0 ? [] : [{
+			kind: "fields",
+			rail: true,
+			rows: [{
+				label: "database",
+				value: database
+			}]
+		}], {
+			kind: "summary",
+			status: "ok",
+			text: [{ text: "Contract written to " }, {
+				text: document.psl.path,
+				tone: "identifier"
+			}]
+		}],
+		json: () => document
+	};
+}
+function createContractInferCommand({ createControlClient, printPsl }) {
+	return defineOrmCommand({
+		help: {
+			summary: "Infer a PSL contract from the live database schema",
+			description: "Reads the live database schema and writes an inferred PSL contract to\ndisk. This command stops at contract.prisma; follow it with\n`contract emit` and `db sign` as separate steps. An existing file at the\noutput path is overwritten, with a warning.",
+			examples: [
+				"contract infer --db $DATABASE_URL",
+				"contract infer --db $DATABASE_URL --output ./src/prisma/contract.prisma",
+				"contract infer --json"
+			]
+		},
+		args: { flags: {
+			db: dbFlag,
+			output: flag.string({
+				brief: "Write the inferred PSL contract to the specified path",
+				placeholder: "path"
+			})
+		} },
+		needs: { config: ormConfigSection },
+		handler: async (args, ctx) => {
+			const startedAt = Date.now();
+			const dbConnection = args.flags.db ?? ctx.config.db?.connection;
+			if (dbConnection === void 0) return notOk(normalizeError(errorDatabaseConnectionRequired({
+				why: "Database connection is required for contract infer (set db.connection in prisma-next.config.ts, or pass --db <url>)",
+				commandName: "contract infer",
+				missingFlags: ["--db"]
+			})));
+			if (ctx.config.driver === void 0) return notOk(normalizeError(errorDriverRequired({ why: "Config.driver is required for contract infer" })));
+			const client = createControlClient({
+				family: ctx.config.family,
+				target: ctx.config.target,
+				adapter: ctx.config.adapter,
+				driver: ctx.config.driver,
+				extensions: ctx.config.extensions ?? []
+			});
+			let pslContent;
+			try {
+				const schema = await client.introspect({
+					connection: dbConnection,
+					onProgress: controlProgressReporter(ctx.report)
+				});
+				const pslContractAst = client.inferPslContract(schema);
+				if (pslContractAst === void 0) return notOk(normalizeError(errorRuntime$1("CONTRACT.INFER_UNSUPPORTED", "contract infer is not supported for this family", {
+					why: "The configured family does not implement the PslContractInferCapable capability, so an inferred PSL contract cannot be produced from the live database schema.",
+					fix: "Use a family that supports contract inference (e.g. SQL/Postgres)."
+				})));
+				pslContent = printPsl(pslContractAst, { pslBlockDescriptors: client.getPslBlockDescriptors() });
+			} catch (error) {
+				if (CliStructuredError$1$1.is(error)) return notOk(normalizeError(error));
+				const safeMessage = sanitizeErrorMessage(error instanceof Error ? error.message : String(error), typeof dbConnection === "string" ? dbConnection : void 0);
+				return notOk(normalizeError(errorUnexpected(safeMessage, { why: `Unexpected error during contract infer: ${safeMessage}` })));
+			} finally {
+				await closeQuietly(client);
+			}
+			const outputPath = inferredContractPathFor({
+				config: ctx.config,
+				cwd: ctx.cwd,
+				output: args.flags.output
+			});
+			const displayPath = relative(ctx.cwd, outputPath);
+			if (existsSync(outputPath)) ctx.report({
+				kind: "message",
+				severity: "warn",
+				text: `Overwriting existing file: ${displayPath}`
+			});
+			await publishTextArtifact({
+				path: outputPath,
+				content: pslContent,
+				publicationToken: String(process.hrtime.bigint())
+			});
+			const database = typeof dbConnection === "string" ? maskConnectionUrl(dbConnection) : void 0;
+			const document = {
+				ok: true,
+				summary: "Contract inferred successfully",
+				target: {
+					familyId: ctx.config.family.familyId,
+					id: ctx.config.target.targetId
+				},
+				psl: { path: displayPath },
+				meta: { ...ifDefined("dbUrl", database) },
+				timings: { total: Date.now() - startedAt }
+			};
+			return ok(ctx.present({ data: document }, inferPresentations({
+				document,
+				database
+			})));
+		}
+	});
+}
+const contractInferCommand = createContractInferCommand({
+	createControlClient,
+	printPsl
+});
 function operationNode(operation) {
 	return operation.operationClass === "destructive" ? {
 		label: operation.label,
@@ -903,6 +1157,44 @@ function createDbSchemaCommand(createClient) {
 	});
 }
 const dbSchemaCommand = createDbSchemaCommand(createControlClient);
+const NOTHING_TO_FORMAT = "Nothing to format (contract source is not PSL).";
+function formatPresentations(document, cwd) {
+	const path = document.path;
+	return {
+		human: () => document.formatted && path !== void 0 ? [{
+			kind: "summary",
+			status: "ok",
+			text: [{ text: "Formatted " }, {
+				text: relative(cwd, path),
+				tone: "identifier"
+			}]
+		}] : [{
+			kind: "summary",
+			status: "info",
+			text: NOTHING_TO_FORMAT
+		}],
+		json: () => document
+	};
+}
+function createFormatCommand$1(execute = executeFormat) {
+	return defineOrmCommand({
+		help: {
+			summary: "Format your PSL contract source",
+			description: "Formats the Prisma schema (PSL) contract source declared in your config\n(contract.source.inputs[0]) in place. Only runs when contract.source.format\nis 'psl'; a TypeScript or unset source is left untouched. Indent and newline\nare read from the optional formatter config section, defaulting to two\nspaces and the system newline.",
+			examples: ["format", "format --json"]
+		},
+		needs: { config: ormConfigSection },
+		handler: async (_args, ctx) => {
+			const result = await execute({
+				config: ctx.config,
+				cwd: ctx.cwd
+			});
+			if (!result.ok) return notOk(normalizeError(result.failure));
+			return ok(ctx.present({ data: result.value }, formatPresentations(result.value, ctx.cwd)));
+		}
+	});
+}
+const formatCommand = createFormatCommand$1();
 const STATUS_ACTION = runCommandAction("Check every space against the database", "prisma-next migration status");
 /**
 * The route the migration will take. The graph is a drawing — the engine cannot
@@ -1337,7 +1629,7 @@ const migrationGraphCommand = defineOrmCommand({
 		})));
 	}
 });
-function listPresentations(inputs) {
+function listPresentations$1(inputs) {
 	const legend = inputs.legend;
 	return {
 		human: () => [
@@ -1410,7 +1702,7 @@ const migrationListCommand = defineOrmCommand({
 			styler,
 			palette: TONE_MIGRATION_GRAPH_PALETTE
 		}) : void 0;
-		return ok(ctx.present({ data: listed.value }, listPresentations({
+		return ok(ctx.present({ data: listed.value }, listPresentations$1({
 			list: listed.value,
 			tree,
 			migrationsDir: displayPath(migrationsDir, ctx.cwd),
@@ -1761,6 +2053,160 @@ const migrationShowCommand = defineOrmCommand({
 		})));
 	}
 });
+function deletePresentations(document) {
+	return {
+		human: () => [{
+			kind: "summary",
+			status: "ok",
+			text: [
+				{ text: "Deleted ref \"" },
+				{
+					text: document.ref,
+					tone: "ref"
+				},
+				{ text: "\"" }
+			]
+		}],
+		json: () => document
+	};
+}
+function createRefDeleteCommand(execute = executeRefDeleteCommand) {
+	return defineOrmCommand({
+		help: {
+			summary: "Delete a ref",
+			description: "Removes migrations/app/refs/<name>.json. The contract the ref pointed at\nis untouched: a ref is a pointer, and its target survives the deletion.",
+			examples: ["ref delete staging", "ref delete staging --json"]
+		},
+		args: { positionals: { name: positional.string({
+			brief: "Ref name to delete",
+			placeholder: "name"
+		}) } },
+		needs: { config: ormConfigSection },
+		handler: async (args, ctx) => {
+			const result = await execute(args.positionals.name, {
+				config: ctx.config,
+				cwd: ctx.cwd
+			});
+			if (!result.ok) return notOk(normalizeError(result.failure));
+			return ok(ctx.present({ data: result.value }, deletePresentations(result.value)));
+		}
+	});
+}
+const refDeleteCommand = createRefDeleteCommand();
+const HEADING_REF = "Ref";
+const HEADING_CONTRACT = "Contract";
+const HEADING_INVARIANTS = "Invariants";
+const EMPTY_MESSAGE = "No refs defined";
+/**
+* The refs as a grid the engine sizes. The invariants heading appears only
+* when a ref carries any, as the commander shell appended them only then.
+*/
+function refsGrid(refs) {
+	const entries = Object.entries(refs);
+	const showInvariants = entries.some(([, entry]) => entry.invariants.length > 0);
+	return {
+		kind: "table",
+		columns: showInvariants ? [
+			HEADING_REF,
+			HEADING_CONTRACT,
+			HEADING_INVARIANTS
+		] : [HEADING_REF, HEADING_CONTRACT],
+		rows: entries.map(([name, entry]) => {
+			const cells = [[{
+				text: name,
+				tone: "ref"
+			}], [{
+				text: entry.hash,
+				tone: "identifier"
+			}]];
+			if (showInvariants) cells.push(entry.invariants.join(", "));
+			return cells;
+		})
+	};
+}
+function listPresentations(document) {
+	return {
+		human: () => Object.keys(document.refs).length === 0 ? [{
+			kind: "summary",
+			status: "info",
+			text: EMPTY_MESSAGE
+		}] : [refsGrid(document.refs)],
+		json: () => document
+	};
+}
+function createRefListCommand(execute = executeRefListCommand) {
+	return defineOrmCommand({
+		help: {
+			summary: "List every named ref",
+			description: "Reads migrations/app/refs/ and reports each ref with the contract hash it\npoints at and the invariants recorded against it. Offline — does not\nconsult the database.",
+			examples: ["ref list", "ref list --json"]
+		},
+		needs: { config: ormConfigSection },
+		handler: async (_args, ctx) => {
+			const result = await execute({
+				config: ctx.config,
+				cwd: ctx.cwd
+			});
+			if (!result.ok) return notOk(normalizeError(result.failure));
+			return ok(ctx.present({ data: result.value }, listPresentations(result.value)));
+		}
+	});
+}
+const refListCommand = createRefListCommand();
+function setPresentations(document) {
+	return {
+		human: () => [{
+			kind: "summary",
+			status: "ok",
+			text: [
+				{ text: "Set ref \"" },
+				{
+					text: document.ref,
+					tone: "ref"
+				},
+				{ text: "\" → " },
+				{
+					text: document.hash,
+					tone: "identifier"
+				}
+			]
+		}],
+		json: () => document
+	};
+}
+function createRefSetCommand(execute = executeRefSetCommand) {
+	return defineOrmCommand({
+		help: {
+			summary: "Point a ref at a contract",
+			description: "Writes migrations/app/refs/<name>.json so a logical environment name\nresolves to a contract hash. The contract is given as a hash or prefix,\nanother ref name, a migration directory name, or <dir>^ for that\nmigration's source contract. Offline — the contract must already be a\nnode of the on-disk migration graph, with its snapshot present.",
+			examples: [
+				"ref set staging 4cb4256",
+				"ref set production 20260101T1000_add_user",
+				"ref set staging production --json"
+			]
+		},
+		args: { positionals: {
+			name: positional.string({
+				brief: "Ref name (e.g. staging, production)",
+				placeholder: "name"
+			}),
+			contract: positional.string({
+				brief: "Contract reference: hash, prefix, ref name, migration dir name, or <dir>^",
+				placeholder: "contract"
+			})
+		} },
+		needs: { config: ormConfigSection },
+		handler: async (args, ctx) => {
+			const result = await execute(args.positionals.name, args.positionals.contract, {
+				config: ctx.config,
+				cwd: ctx.cwd
+			});
+			if (!result.ok) return notOk(normalizeError(result.failure));
+			return ok(ctx.present({ data: result.value }, setPresentations(result.value)));
+		}
+	});
+}
+const refSetCommand = createRefSetCommand();
 /**
 * The engine derives each diagnostic's docs link from this base plus the
 * dotted code.
@@ -1774,13 +2220,19 @@ const DOCS_BASE_URL = `${DOCS_BASE}/`;
 const ormCommandFamily = defineCommandFamily({
 	configSection: ormConfigSection,
 	commands: {
+		"contract emit": contractEmitCommand,
+		"contract infer": contractInferCommand,
 		"db init": dbInitCommand,
 		"db schema": dbSchemaCommand,
+		format: formatCommand,
 		migrate: migrateCommand,
 		"migration graph": migrationGraphCommand,
 		"migration list": migrationListCommand,
 		"migration log": migrationLogCommand,
-		"migration show": migrationShowCommand
+		"migration show": migrationShowCommand,
+		"ref delete": refDeleteCommand,
+		"ref list": refListCommand,
+		"ref set": refSetCommand
 	},
 	docsBaseUrl: DOCS_BASE_URL,
 	redirects: [{