@prisma/orm-toolchain 8.0.0-rc.1-dev.24 → 8.0.0-rc.1-dev.26

package/dist/cli.mjs

@@ -1,24 +1,37 @@
 import { i as loadConfig } from "./exports-BZLNbtkY.mjs";
+import { F as requireLiveDatabase, N as errorUnexpected, a as errorConfigValidation$1, b as errorNoMigrations, d as errorFileNotFound, h as errorLegendHumanOnly, j as errorTargetMigrationNotSupported, s as errorContractValidationFailed, v as errorMigrationPackageNotFound } from "./cli-errors-CihMAEVj-C1uUYBop.mjs";
 import { r as getEmittedArtifactPaths } from "./exports-BCLg4CiV-05kuwcb0.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-Ci-8sP-b-QzQXK2xQ.mjs";
-import { t as createFormatCommand } from "./format-Ddhz7xFW-Bo1nhay8.mjs";
-import { r as buildReadAggregate } from "./contract-space-aggregate-loader-DOzo1sk9-CCPCubsg.mjs";
-import { n as migrationSpaceListEntriesFromAggregate, r as runMigrationList } from "./migration-list-Bkase_ZM-D-bErpSr.mjs";
+import { p as renderMigrationShowLines } from "./terminal-ui-DQNCDg2u-B3PFqjB8.mjs";
+import { c as spaceMigrationDirectory } from "./verify-contract-spaces-WvjSiWcB-DZPPCwWO.mjs";
+import { S as targetSupportsMigrations, f as maskConnectionUrl, n as closeQuietly } from "./command-helpers-DutQjYgy-CDfFwtAa.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-BJDLPMxp-qaGmQUQr.mjs";
+import { t as createFormatCommand } from "./format-SYdHyutg-IqXk-tDV.mjs";
+import { a as loadContractSpaceAggregateForCli, r as buildReadAggregate } from "./contract-space-aggregate-loader-sF0OJ6oz-jRjdZoyZ.mjs";
+import { t as createControlClient } from "./client-CaIWFVnh-PVaTEvdx.mjs";
+import { t as mapCaughtMigrationError } from "./caught-errors-B_oGFiYw-BqX49eW0.mjs";
+import { n as migrationSpaceListEntriesFromAggregate, r as runMigrationList } from "./migration-list-AKRIIovW-Cr39jOaI.mjs";
+import { n as resolveMigrationRef } from "./ref-resolution-Bi4lpxM8-BX-7sl0f.mjs";
 import { g as renderMigrationGraphLegend, l as createAnsiMigrationListStyler, v as renderMigrationListWithStyle } from "./migration-graph-command-render-BKrg6BPv-BP8Pfj4J.mjs";
+import { n as looksLikePath, r as resolveAppTargetPath, t as findPackageByDirPath } from "./migration-path-target-yA4h5Zc6-DlzBblBG.mjs";
+import { t as buildMigrationSpaceGraphEntries } from "./migration-graph-BtP1Va3T-CMOZgqVW.mjs";
+import { n as renderMigrationGraphDot, r as renderMigrationGraphSections, t as buildMigrationGraphTreeSections } from "./migration-graph-sections-BVqyqBHg-DAwWjIIf.mjs";
+import { n as renderMigrationLogTable, r as serializeLedgerEntriesForJson, t as MIGRATION_LOG_EMPTY_MESSAGE } from "./migration-log-table-C0dSMG9T-BhBYrdka.mjs";
 import { CliStructuredError } from "@prisma/orm-framework/errors/control";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { join, normalize, resolve } from "pathe";
+import { 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 } from "@prisma/orm-framework/utils/casts";
+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 { 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 { defineCommand, defineCommandFamily, defineConfigSection, flag } from "@prisma/cli-engine";
+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-Aw9VS_dF.mjs
+//#region ../../../1-framework/3-tooling/cli/dist/load-config-Bj0g_Kv6.mjs
 const MISSING_CONFIG_ACTION = {
 	kind: "run-command",
 	label: "Create a configuration file",
@@ -165,11 +178,14 @@ function toUnexpected(error) {
 }
 /**
 * Both classes name themselves `CliStructuredError`, so the engine's duck test
-* accepts prisma/prisma's too. What actually separates them is `nextActions`:
-* the engine's constructor always sets it, prisma/prisma's never does.
+* accepts prisma/prisma's too, and a CLI factory carrying typed actions looks
+* conformant without being one — its `toEnvelope` still writes `fix` and no
+* `nextActions`. Only an error the engine itself built is already in protocol
+* shape, and `@prisma/cli-engine` is an exact-pinned, unbundled dependency, so
+* there is one module instance and identity holds.
 */
 function conformsToProtocol(error) {
-	return CliStructuredError$1.is(error) && Array.isArray(error.nextActions);
+	return error instanceof CliStructuredError$1;
 }
 /**
 * Turns the transitional `fix` prose into typed actions. A multi-line fix is
@@ -191,7 +207,7 @@ function toEngineDiagnostic(error) {
 		severity: error.severity ?? "error",
 		summary: error.message,
 		...ifDefined("why", error.why),
-		nextActions: actionsFromFix(error.fix),
+		nextActions: error.nextActions ?? actionsFromFix(error.fix),
 		...ifDefined("where", error.where),
 		...ifDefined("meta", error.meta),
 		...ifDefined("docsUrl", error.docsUrl)
@@ -246,6 +262,121 @@ function defineOrmCommand(def) {
 function migrationsDirFor(config, cwd) {
 	return resolve(cwd, config.migrations?.dir ?? "migrations");
 }
+/** The app subspace under {@link migrationsDirFor}. */
+function appMigrationsDirFor(config, cwd) {
+	return spaceMigrationDirectory(migrationsDirFor(config, cwd), APP_SPACE_ID);
+}
+/**
+* The emitted contract. The config loader has already resolved
+* `contract.output` against the config file's directory, so this only has an
+* effect for a config handed in raw, as tests do.
+*/
+function contractPathFor(config, cwd) {
+	const output = config.contract?.output;
+	return output === void 0 ? void 0 : resolve(cwd, output);
+}
+/**
+* The header's rendering of a path: relative to where the user invoked the
+* CLI, as the commander shell rendered it against the config file.
+*/
+function displayPath(path, cwd) {
+	return relative(cwd, path);
+}
+function graphPresentations(inputs) {
+	return {
+		human: () => [{
+			kind: "fields",
+			rows: [{
+				label: "migrations",
+				value: inputs.migrationsDir
+			}, ...inputs.space === void 0 ? [] : [{
+				label: "space",
+				value: inputs.space
+			}]]
+		}, ...inputs.legendLines.length === 0 ? [] : [{
+			kind: "list",
+			items: [...inputs.legendLines]
+		}]],
+		stdout: () => inputs.lines,
+		json: () => inputs.document
+	};
+}
+function graphSummary(spaces) {
+	const contracts = spaces.reduce((count, space) => count + space.contracts.length, 0);
+	const migrations = spaces.reduce((count, space) => count + space.migrations.length, 0);
+	return `${spaces.length} space(s), ${contracts} contract(s), ${migrations} migration(s)`;
+}
+const migrationGraphCommand = defineOrmCommand({
+	help: {
+		summary: "Show the migration graph topology",
+		description: "Renders the migration graph topology. Offline — does not consult the\ndatabase. --ascii swaps box-drawing for pipe-friendly ASCII glyphs.\n--dot emits Graphviz DOT for the app graph instead of the tree, and\nignores --space; in json mode the result carries the DOT text alongside\nthe graph document.",
+		examples: [
+			"migration graph",
+			"migration graph --json",
+			"migration graph --dot",
+			"migration graph --ascii",
+			"migration graph --legend",
+			"migration graph --space app"
+		]
+	},
+	args: { flags: {
+		space: flag.string({
+			brief: "Narrow output to a single contract space",
+			placeholder: "id"
+		}),
+		dot: flag.boolean({ brief: "Emit Graphviz DOT for the app graph" }),
+		ascii: flag.boolean({ brief: "Use ASCII glyphs (pipe-friendly)" }),
+		legend: flag.boolean({ brief: "Print a key for the tree glyphs and lane colors" })
+	} },
+	needs: { config: ormConfigSection },
+	handler: async (args, ctx) => {
+		if (args.flags.legend && args.flags.dot) return notOk(normalizeError(errorLegendHumanOnly("--dot")));
+		const migrationsDir = migrationsDirFor(ctx.config, ctx.cwd);
+		const loaded = await buildReadAggregate(ctx.config, { migrationsDir });
+		if (!loaded.ok) return notOk(normalizeError(loaded.failure));
+		const { aggregate, contractHash: liveContractHash } = loaded.value;
+		const listed = runMigrationList({
+			spaces: await migrationSpaceListEntriesFromAggregate(aggregate, migrationsDir),
+			...ifDefined("spaceFilter", args.flags.space)
+		});
+		if (!listed.ok) return notOk(normalizeError(listed.failure));
+		const scopedSpaces = listed.value.spaces;
+		const glyphMode = args.flags.ascii ? "ascii" : "unicode";
+		const graphSpaces = [...buildMigrationSpaceGraphEntries({
+			aggregate,
+			scopedSpaces
+		})];
+		const summary = graphSummary(graphSpaces);
+		const graphDocument = {
+			ok: true,
+			spaces: graphSpaces,
+			summary
+		};
+		const dot = args.flags.dot ? renderMigrationGraphDot(aggregate.app.graph()) : void 0;
+		const document = dot === void 0 ? graphDocument : {
+			...graphDocument,
+			dot
+		};
+		const lines = dot === void 0 ? renderMigrationGraphSections(buildMigrationGraphTreeSections({
+			aggregate,
+			scopedSpaces,
+			liveContractHash,
+			glyphMode,
+			colorize: false
+		}), summary).split("\n") : dot.split("\n");
+		const legendLines = args.flags.legend ? renderMigrationGraphLegend({
+			colorize: false,
+			glyphMode
+		}).split("\n") : [];
+		return ok(ctx.present({ data: document }, graphPresentations({
+			document,
+			lines,
+			migrationsDir: displayPath(migrationsDir, ctx.cwd),
+			space: args.flags.space,
+			legendLines
+		})));
+	}
+});
 function listPresentations(inputs) {
 	return {
 		human: () => [{
@@ -310,13 +441,246 @@ const migrationListCommand = defineOrmCommand({
 		return ok(ctx.present({ data: listed.value }, listPresentations({
 			list: listed.value,
 			lines,
-			migrationsDir,
+			migrationsDir: displayPath(migrationsDir, ctx.cwd),
 			space: args.flags.space,
 			legendLines
 		})));
 	}
 });
 /**
+* 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"
+});
+function logPresentations(inputs) {
+	return {
+		human: () => inputs.database === void 0 ? [] : [{
+			kind: "fields",
+			rows: [{
+				label: "database",
+				value: inputs.database
+			}]
+		}],
+		stdout: () => inputs.lines,
+		json: () => inputs.document
+	};
+}
+function logLines(entries, options) {
+	if (entries.length === 0) return [MIGRATION_LOG_EMPTY_MESSAGE];
+	return renderMigrationLogTable(entries, {
+		utc: options.utc,
+		styler: createAnsiMigrationListStyler({ useColor: false }),
+		glyphMode: options.glyphMode
+	}).split("\n");
+}
+const migrationLogCommand = defineOrmCommand({
+	help: {
+		summary: "Show executed migration history",
+		description: "Reads the database ledger and displays every applied migration edge in\nchronological order, including rollbacks and re-applies, merged across\nall contract spaces. Requires a database connection.",
+		examples: [
+			"migration log",
+			"migration log --db $DATABASE_URL",
+			"migration log --utc",
+			"migration log --json"
+		]
+	},
+	args: { flags: {
+		db: dbFlag,
+		utc: flag.boolean({ brief: "Render human timestamps in UTC instead of local time" }),
+		ascii: flag.boolean({ brief: "Use ASCII glyphs (pipe-friendly)" })
+	} },
+	needs: { config: ormConfigSection },
+	handler: async (args, ctx) => {
+		const dbConnection = args.flags.db ?? ctx.config.db?.connection;
+		const missingDb = requireLiveDatabase({
+			dbConnection,
+			hasDriver: ctx.config.driver !== void 0,
+			why: "migration log needs a database connection and driver to read the ledger (set db.connection in prisma-next.config.ts, or pass --db <url>)",
+			commandName: "migration log"
+		});
+		if (missingDb !== null) return notOk(normalizeError(missingDb));
+		if (!targetSupportsMigrations(ctx.config.target)) return notOk(normalizeError(errorTargetMigrationNotSupported({ why: "migration log reads the ledger a migration runner writes, and the configured target provides no runner." })));
+		const client = createControlClient({
+			family: ctx.config.family,
+			target: ctx.config.target,
+			adapter: ctx.config.adapter,
+			...ifDefined("driver", ctx.config.driver),
+			extensions: ctx.config.extensions ?? []
+		});
+		let entries;
+		try {
+			await client.connect(dbConnection);
+			entries = await client.readLedger();
+		} catch (error) {
+			return notOk(normalizeError(mapCaughtMigrationError(error) ?? errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read migration log: ${error instanceof Error ? error.message : String(error)}` })));
+		} finally {
+			await closeQuietly(client);
+		}
+		const records = serializeLedgerEntriesForJson(entries);
+		const document = {
+			ok: true,
+			records,
+			summary: `${records.length} migration(s) applied`
+		};
+		const glyphMode = args.flags.ascii ? "ascii" : "unicode";
+		return ok(ctx.present({ data: document }, logPresentations({
+			document,
+			lines: logLines(entries, {
+				utc: args.flags.utc,
+				glyphMode
+			}),
+			database: typeof dbConnection === "string" ? maskConnectionUrl(dbConnection) : void 0
+		})));
+	}
+});
+function showPresentations(inputs) {
+	return {
+		human: () => [{
+			kind: "fields",
+			rows: [
+				{
+					label: "contract",
+					value: inputs.contractPath
+				},
+				{
+					label: "migrations",
+					value: inputs.appMigrationsRelative
+				},
+				{
+					label: "target",
+					value: inputs.target
+				}
+			]
+		}],
+		stdout: () => renderMigrationShowLines(inputs.document.migration, { colorize: false }),
+		json: () => inputs.document
+	};
+}
+/**
+* A path-looking target must land inside `migrations/app/`; anything else is a
+* migration reference resolved against the app graph and refs. Both routes are
+* app-space only, as they are today.
+*/
+function resolvePackage(inputs) {
+	if (looksLikePath(inputs.target)) {
+		const path = resolveAppTargetPath(inputs.cwd, inputs.target, inputs.appMigrationsDir, inputs.appMigrationsRelative);
+		if (!path.ok) return notOk(normalizeError(path.failure));
+		const matched = findPackageByDirPath(inputs.packages, path.value);
+		return matched === void 0 ? notOk(normalizeError(errorMigrationPackageNotFound(`No loaded migration package at ${relative(inputs.cwd, path.value)}`))) : ok(matched);
+	}
+	if (inputs.packages.length === 0) return notOk(normalizeError(errorNoMigrations(inputs.appMigrationsRelative)));
+	const ref = resolveMigrationRef(inputs.target, {
+		graph: inputs.graph,
+		refs: inputs.refs
+	});
+	if (!ref.ok) return notOk(normalizeError(ref.failure));
+	const matched = inputs.packages.find((candidate) => candidate.metadata.migrationHash === ref.value.migrationHash);
+	return matched === void 0 ? notOk(normalizeError(errorMigrationPackageNotFound(`Resolved migration "${ref.value.dirName}" but the package was not loaded`))) : ok(matched);
+}
+const migrationShowCommand = defineOrmCommand({
+	help: {
+		summary: "Display migration package contents",
+		description: "Shows the operations, statement preview, and metadata for one app-space\nmigration. Accepts a directory path, directory name, or hash prefix.\nOffline — does not consult the database.",
+		examples: [
+			"migration show 20260101_100000_add_user",
+			"migration show a1b2c3",
+			"migration show migrations/app/20260101_100000_add_user",
+			"migration show 20260101_100000_add_user --json"
+		]
+	},
+	args: { positionals: { target: positional.string({
+		brief: "Migration reference: directory name, hash/prefix, ref, or path",
+		placeholder: "target"
+	}) } },
+	needs: { config: ormConfigSection },
+	handler: async (args, ctx) => {
+		const { target } = args.positionals;
+		const contractPath = contractPathFor(ctx.config, ctx.cwd);
+		if (contractPath === void 0) return notOk(normalizeError(errorConfigValidation$1("contract.output", {
+			why: "migration show reads the emitted contract from config.contract.output; the config has no value to read.",
+			section: "contract"
+		})));
+		const migrationsDir = migrationsDirFor(ctx.config, ctx.cwd);
+		const appMigrationsDir = appMigrationsDirFor(ctx.config, ctx.cwd);
+		const appMigrationsRelative = displayPath(appMigrationsDir, ctx.cwd);
+		let contractJson;
+		try {
+			contractJson = await readFile(contractPath, "utf-8");
+		} catch (error) {
+			return notOk(normalizeError(Reflect.get(Object(error), "code") === "ENOENT" ? errorFileNotFound(contractPath, {
+				why: `Contract file not found at ${contractPath}`,
+				fix: `Run \`prisma-next contract emit\` to generate ${relative(ctx.cwd, contractPath)}`
+			}) : errorUnexpected(error instanceof Error ? error.message : String(error), { why: "Failed to read contract file" })));
+		}
+		const familyInstance = ctx.config.family.create(createControlStack(ctx.config));
+		let appContract;
+		try {
+			appContract = familyInstance.deserializeContract(castAs(JSON.parse(contractJson)));
+		} catch (error) {
+			return notOk(normalizeError(errorContractValidationFailed(`Contract at ${contractPath} failed to deserialize: ${error instanceof Error ? error.message : String(error)}`, { where: { path: contractPath } })));
+		}
+		const loaded = await loadContractSpaceAggregateForCli({
+			targetId: ctx.config.target.targetId,
+			migrationsDir,
+			appContract,
+			extensions: [],
+			deserializeContract: (json) => familyInstance.deserializeContract(json)
+		});
+		if (!loaded.ok) return notOk(normalizeError(loaded.failure));
+		const aggregate = loaded.value;
+		const resolved = resolvePackage({
+			target,
+			cwd: ctx.cwd,
+			appMigrationsDir,
+			appMigrationsRelative,
+			packages: aggregate.app.packages,
+			graph: aggregate.app.graph(),
+			refs: aggregate.app.refs
+		});
+		if (!resolved.ok) return notOk(resolved.failure);
+		const pkg = resolved.value;
+		const client = createControlClient({
+			family: ctx.config.family,
+			target: ctx.config.target,
+			adapter: ctx.config.adapter,
+			...ifDefined("driver", ctx.config.driver),
+			extensions: ctx.config.extensions ?? []
+		});
+		const ops = castAs(pkg.ops);
+		const preview = client.toOperationPreview(ops) ?? { statements: [] };
+		const migration = {
+			space: APP_SPACE_ID,
+			name: pkg.dirName,
+			hash: pkg.metadata.migrationHash,
+			fromContract: pkg.metadata.from,
+			toContract: pkg.metadata.to,
+			createdAt: pkg.metadata.createdAt,
+			operations: ops.map((op) => ({
+				id: op.id,
+				label: op.label,
+				operationClass: op.operationClass
+			})),
+			preview: { statements: [...preview.statements] }
+		};
+		const document = {
+			ok: true,
+			summary: `Migration ${migration.name} in ${migration.space}: ${migration.operations.length} operation(s)`,
+			migration
+		};
+		return ok(ctx.present({ data: document }, showPresentations({
+			document,
+			contractPath: displayPath(contractPath, ctx.cwd),
+			appMigrationsRelative,
+			target
+		})));
+	}
+});
+/**
 * The engine derives each diagnostic's docs link from this base plus the
 * dotted code.
 */
@@ -328,7 +692,12 @@ const DOCS_BASE_URL = `${DOCS_BASE}/`;
 */
 const ormCommandFamily = defineCommandFamily({
 	configSection: ormConfigSection,
-	commands: { "migration list": migrationListCommand },
+	commands: {
+		"migration graph": migrationGraphCommand,
+		"migration list": migrationListCommand,
+		"migration log": migrationLogCommand,
+		"migration show": migrationShowCommand
+	},
 	docsBaseUrl: DOCS_BASE_URL
 });
 /**