@prisma-next/cli 0.5.0-dev.4 → 0.5.0-dev.41

package/dist/{migration-status-Ry3TnEya.mjs → migration-status-DoPrFIOQ.mjs}

@@ -1,16 +1,16 @@
-import { t as loadConfig } from "./config-loader-_W4T21X1.mjs";
-import { _ as errorUnexpected, m as errorRuntime } from "./cli-errors-DHq6GQGu.mjs";
-import { t as createControlClient } from "./client-TG7rbCWT.mjs";
-import { _ as formatStyledHeader, a as maskConnectionUrl, c as resolveMigrationPaths, d as setCommandExamples, i as loadAllBundles, m as parseGlobalFlags, n as addGlobalOptions, o as readContractEnvelope, p as toPathDecisionResult, t as handleResult, u as setCommandDescriptions } from "./result-handler-BJwA7ufw.mjs";
-import { t as TerminalUI } from "./terminal-ui-C5k88MmW.mjs";
+import { t as loadConfig } from "./config-loader-ih8ViDb_.mjs";
+import { _ as errorUnexpected, m as errorRuntime, v as mapMigrationToolsError } from "./cli-errors-By1iVE3z.mjs";
+import { t as TerminalUI } from "./terminal-ui-u2YgKghu.mjs";
+import { a as loadMigrationPackages, d as setCommandDescriptions, f as setCommandExamples, g as parseGlobalFlags, h as toStructuralEdge, l as resolveMigrationPaths, m as toPathDecisionResult, n as addGlobalOptions, o as maskConnectionUrl, r as collectDeclaredInvariants, s as readContractEnvelope, t as handleResult, y as formatStyledHeader } from "./result-handler-Ch6hVnOo.mjs";
+import { t as createControlClient } from "./client-1JqqkiC7.mjs";
 import { Command } from "commander";
-import { notOk, ok } from "@prisma-next/utils/result";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
-import { findPath, findPathWithDecision, findReachableLeaves } from "@prisma-next/migration-tools/dag";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { findPath, findPathWithDecision, findReachableLeaves } from "@prisma-next/migration-tools/migration-graph";
 import { bold, cyan, dim, magenta, yellow } from "colorette";
+import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
+import { MigrationToolsError, errorNoInvariantPath, errorUnknownInvariant } from "@prisma-next/migration-tools/errors";
 import { readRefs, resolveRef } from "@prisma-next/migration-tools/refs";
-import { MigrationToolsError } from "@prisma-next/migration-tools/types";
 import dagre from "@dagrejs/dagre";
 
 //#region src/utils/formatters/graph-types.ts
@@ -100,7 +100,8 @@ function migrationGraphToRenderInput(input) {
 	for (const [, entries] of graph.forwardChain) for (const entry of entries) {
 		const status = statusByDirName.get(entry.dirName);
 		const icon = status ? STATUS_ICON[status] : "";
-		const label = `${entry.dirName}${icon}`;
+		const invariantsSuffix = entry.invariants.length > 0 ? `  provides [${entry.invariants.map((id) => JSON.stringify(id)).join(", ")}]` : "";
+		const label = `${entry.dirName}${icon}${invariantsSuffix}`;
 		edgeList.push({
 			from: toShortId(entry.from),
 			to: toShortId(entry.to),
@@ -1194,7 +1195,7 @@ function buildMigrationEntries(chain, packages, mode, markerHash, edgeStatuses)
 			dirName: migration.dirName,
 			from: migration.from,
 			to: migration.to,
-			migrationId: migration.migrationId,
+			migrationHash: migration.migrationHash,
 			operationCount: ops.length,
 			operationSummary: summary,
 			hasDestructive,
@@ -1246,30 +1247,25 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 	const hasDriver = !!config.driver;
 	let activeRefName;
 	let activeRefHash;
+	let activeRefEntry;
 	let allRefs = {};
 	try {
 		allRefs = await readRefs(refsDir);
 	} catch (error) {
-		if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
-			why: error.why,
-			fix: error.fix,
-			meta: { code: error.code }
-		}));
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
 		throw error;
 	}
 	if (options.ref) {
 		activeRefName = options.ref;
 		try {
-			activeRefHash = resolveRef(allRefs, activeRefName).hash;
+			activeRefEntry = resolveRef(allRefs, activeRefName);
+			activeRefHash = activeRefEntry.hash;
 		} catch (error) {
-			if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
-				why: error.why,
-				fix: error.fix,
-				meta: { code: error.code }
-			}));
+			if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
 			throw error;
 		}
 	}
+	const requiredInvariants = [...activeRefEntry?.invariants ?? []].sort();
 	const statusRefs = Object.entries(allRefs).map(([name, entry]) => ({
 		name,
 		hash: entry.hash,
@@ -1291,6 +1287,10 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			label: "ref",
 			value: activeRefName
 		});
+		if (activeRefEntry && activeRefEntry.invariants.length > 0) details.push({
+			label: "required",
+			value: formatInvariantList(activeRefEntry.invariants)
+		});
 		const header = formatStyledHeader({
 			command: "migration status",
 			description: "Show migration history and applied status",
@@ -1314,13 +1314,9 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 	let bundles;
 	let graph;
 	try {
-		({bundles, graph} = await loadAllBundles(migrationsDir));
+		({bundles, graph} = await loadMigrationPackages(migrationsDir));
 	} catch (error) {
-		if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
-			why: error.why,
-			fix: error.fix,
-			meta: { code: error.code }
-		}));
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
 		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read migrations directory: ${error instanceof Error ? error.message : String(error)}` }));
 	}
 	if (bundles.length === 0) {
@@ -1337,7 +1333,8 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			targetHash: EMPTY_CONTRACT_HASH,
 			contractHash,
 			summary: "No migrations found",
-			diagnostics
+			diagnostics,
+			requiredInvariants
 		});
 	}
 	let targetHash;
@@ -1354,6 +1351,7 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		});
 	}
 	let markerHash;
+	let markerInvariants = [];
 	let mode = "offline";
 	if (dbConnection && hasDriver) {
 		const client = createControlClient({
@@ -1365,7 +1363,9 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		});
 		try {
 			await client.connect(dbConnection);
-			markerHash = (await client.readMarker())?.storageHash;
+			const marker = await client.readMarker();
+			markerHash = marker?.storageHash;
+			markerInvariants = marker?.invariants ?? [];
 			mode = "online";
 		} catch {
 			if (!flags.json && !flags.quiet) ui.warn("Could not connect to database — showing offline status");
@@ -1373,6 +1373,17 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			await client.close();
 		}
 	}
+	if (activeRefEntry && activeRefEntry.invariants.length > 0) {
+		const declared = collectDeclaredInvariants(graph);
+		const known = new Set(declared);
+		if (mode === "online") for (const id of markerInvariants) known.add(id);
+		const unknown = activeRefEntry.invariants.filter((id) => !known.has(id));
+		if (unknown.length > 0) return notOk(mapMigrationToolsError(errorUnknownInvariant({
+			...ifDefined("refName", activeRefName),
+			unknown,
+			declared: [...declared].sort()
+		})));
+	}
 	if (mode === "online" && markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash !== contractHash) {
 		const hints = [];
 		if (graph.nodes.has(contractHash)) hints.push("Run 'prisma-next db sign' to overwrite the marker if the database already matches the contract", "Run 'prisma-next db update' to push the current contract to the database", "Run 'prisma-next contract infer' to make your contract match the database", "Run 'prisma-next db verify' to inspect the database state");
@@ -1392,6 +1403,7 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			summary: `${bundles.length} migration(s) on disk`,
 			diagnostics,
 			markerHash,
+			requiredInvariants,
 			...statusRefs.length > 0 ? { refs: statusRefs } : {}
 		});
 	}
@@ -1416,6 +1428,7 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		summary: `${bundles.length} migration(s) on disk`,
 		diagnostics,
 		...ifDefined("markerHash", markerHash),
+		requiredInvariants,
 		...statusRefs.length > 0 ? { refs: statusRefs } : {},
 		graph,
 		bundles,
@@ -1430,35 +1443,68 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 	const entries = buildMigrationEntries(chain, bundles, mode, markerHash, edgeStatuses);
 	const pendingCount = edgeStatuses.filter((e) => e.status === "pending").length;
 	const appliedCount = edgeStatuses.filter((e) => e.status === "applied").length;
+	let appliedInvariants;
+	let missingInvariants;
+	let effectiveRequired = /* @__PURE__ */ new Set();
+	if (mode === "online") {
+		const markerSet = new Set(markerInvariants);
+		effectiveRequired = new Set(requiredInvariants.filter((id) => !markerSet.has(id)));
+		appliedInvariants = requiredInvariants.filter((id) => markerSet.has(id));
+		missingInvariants = [...effectiveRequired].sort();
+	}
+	const hasInvariantWork = effectiveRequired.size > 0;
+	const missingList = [...effectiveRequired].sort().join(", ");
 	let summary;
 	if (mode === "online") if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) summary = `${bundles.length} migration(s) on disk`;
-	else if (activeRefHash && markerHash !== void 0) summary = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName);
-	else if (pendingCount === 0) summary = `Database is up to date (${appliedCount} migration${appliedCount !== 1 ? "s" : ""} applied)`;
+	else if (activeRefHash && markerHash !== void 0) {
+		const distance = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName);
+		summary = hasInvariantWork ? `${distance} — missing invariant(s): ${missingList}` : distance;
+	} else if (pendingCount === 0 && !hasInvariantWork) summary = `Database is up to date (${appliedCount} migration${appliedCount !== 1 ? "s" : ""} applied)`;
+	else if (pendingCount === 0 && hasInvariantWork) summary = `Missing invariant(s): ${missingList} — run 'prisma-next migration apply --ref ${activeRefName ?? "<ref>"}' to apply`;
 	else if (markerHash === void 0) summary = `${pendingCount} pending migration(s) — database has no marker`;
 	else summary = `${pendingCount} pending migration(s) — run 'prisma-next migration apply' to apply`;
 	else summary = `${entries.length} migration(s) on disk`;
-	if (mode === "online") if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) diagnostics.push({
-		code: "MIGRATION.MARKER_NOT_IN_HISTORY",
-		severity: "warn",
-		message: "Database matches the current contract but was updated directly (not via migration apply)",
-		hints: ["Run 'prisma-next migration plan' to plan a migration to your current contract"]
-	});
-	else if (pendingCount > 0) diagnostics.push({
-		code: "MIGRATION.DATABASE_BEHIND",
-		severity: "info",
-		message: `${pendingCount} migration(s) pending`,
-		hints: ["Run 'prisma-next migration apply' to apply pending migrations"]
-	});
-	else diagnostics.push({
-		code: "MIGRATION.UP_TO_DATE",
-		severity: "info",
-		message: "Database is up to date",
-		hints: []
-	});
 	let pathDecision;
-	if (mode === "online" && markerHash !== void 0) {
-		const decision = findPathWithDecision(graph, markerHash, targetHash, activeRefName);
-		if (decision) pathDecision = toPathDecisionResult(decision);
+	let routingUnreachable = false;
+	if (mode === "online") {
+		const outcome = findPathWithDecision(graph, markerHash ?? EMPTY_CONTRACT_HASH, targetHash, {
+			...ifDefined("refName", activeRefName),
+			required: effectiveRequired
+		});
+		if (outcome.kind === "ok") pathDecision = toPathDecisionResult(outcome.decision);
+		else if (outcome.kind === "unsatisfiable") return notOk(mapMigrationToolsError(errorNoInvariantPath({
+			...ifDefined("refName", activeRefName),
+			required: [...effectiveRequired].sort(),
+			missing: outcome.missing,
+			structuralPath: outcome.structuralPath.map(toStructuralEdge)
+		})));
+		else routingUnreachable = true;
+	}
+	if (mode === "online") {
+		if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) diagnostics.push({
+			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
+			severity: "warn",
+			message: "Database matches the current contract but was updated directly (not via migration apply)",
+			hints: ["Run 'prisma-next migration plan' to plan a migration to your current contract"]
+		});
+		else if (pendingCount > 0) diagnostics.push({
+			code: "MIGRATION.DATABASE_BEHIND",
+			severity: "info",
+			message: `${pendingCount} migration(s) pending`,
+			hints: ["Run 'prisma-next migration apply' to apply pending migrations"]
+		});
+		else if (hasInvariantWork) diagnostics.push({
+			code: "MIGRATION.INVARIANTS_PENDING",
+			severity: "info",
+			message: `Missing required invariant(s): ${missingList}`,
+			hints: [`Run 'prisma-next migration apply --ref ${activeRefName ?? "<ref>"}' to apply a path that covers the required invariants`]
+		});
+		else if (!routingUnreachable) diagnostics.push({
+			code: "MIGRATION.UP_TO_DATE",
+			severity: "info",
+			message: "Database is up to date",
+			hints: []
+		});
 	}
 	return ok({
 		ok: true,
@@ -1469,6 +1515,9 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		summary,
 		diagnostics,
 		...ifDefined("markerHash", markerHash),
+		requiredInvariants,
+		...ifDefined("appliedInvariants", appliedInvariants),
+		...ifDefined("missingInvariants", missingInvariants),
 		...statusRefs.length > 0 ? { refs: statusRefs } : {},
 		...ifDefined("pathDecision", pathDecision),
 		graph,
@@ -1490,7 +1539,7 @@ function createMigrationStatusCommand() {
 		});
 		const exitCode = handleResult(await executeMigrationStatusCommand(options, flags, ui), flags, ui, (statusResult) => {
 			if (flags.json) {
-				const { graph: _g, bundles: _b, edgeStatuses: _es, activeRefHash: _arh, activeRefName: _arn, diverged: _d, ...jsonResult } = statusResult;
+				const { graph: _graph, bundles: _bundles, edgeStatuses: _edgeStatuses, activeRefHash: _activeRefHash, activeRefName: _activeRefName, diverged: _diverged, ...jsonResult } = statusResult;
 				ui.output(JSON.stringify(jsonResult, null, 2));
 			} else if (!flags.quiet) {
 				const colorize = flags.color !== false;
@@ -1540,10 +1589,15 @@ function formatStatusSummary(result, colorize) {
 	const hasUnknown = result.migrations.some((e) => e.status === "unknown");
 	const pendingCount = result.migrations.filter((e) => e.status === "pending").length;
 	const hasWarnings = result.diagnostics?.some((d) => d.severity === "warn") ?? false;
+	const hasInvariantPending = result.diagnostics?.some((d) => d.code === "MIGRATION.INVARIANTS_PENDING") ?? false;
 	if (result.mode === "online") if (hasUnknown || hasWarnings) lines.push(`${c(yellow, "⚠")} ${result.summary}`);
-	else if (pendingCount === 0) lines.push(`${c(cyan, "✔")} ${result.summary}`);
+	else if (pendingCount === 0 && !hasInvariantPending) lines.push(`${c(cyan, "✔")} ${result.summary}`);
 	else lines.push(`${c(yellow, "⧗")} ${result.summary}`);
 	else lines.push(result.summary);
+	if (result.requiredInvariants.length > 0) if (result.appliedInvariants !== void 0 && result.missingInvariants !== void 0) {
+		lines.push(`${c(dim, "applied  ")}${formatInvariantList(result.appliedInvariants)}`);
+		lines.push(`${c(dim, "missing  ")}${formatInvariantList(result.missingInvariants)}`);
+	} else lines.push(`${c(dim, "applied  ")}(unknown — connect a database to evaluate)`);
 	const warnings = result.diagnostics?.filter((d) => d.severity === "warn") ?? [];
 	for (const diag of warnings) {
 		lines.push(`${c(yellow, "⚠")} ${diag.message}`);
@@ -1551,6 +1605,9 @@ function formatStatusSummary(result, colorize) {
 	}
 	return lines.join("\n");
 }
+function formatInvariantList(ids) {
+	return ids.length === 0 ? "(none)" : ids.join(", ");
+}
 function summarizeRefDistance(graph, markerHash, refHash, refName) {
 	if (markerHash === refHash) return `At ref "${refName}" target`;
 	const pathToRef = findPath(graph, markerHash, refHash);
@@ -1561,5 +1618,5 @@ function summarizeRefDistance(graph, markerHash, refHash, refName) {
 }
 
 //#endregion
-export { deriveEdgeStatuses as n, createMigrationStatusCommand as t };
-//# sourceMappingURL=migration-status-Ry3TnEya.mjs.map
+export { deriveEdgeStatuses as n, formatStatusSummary as r, createMigrationStatusCommand as t };
+//# sourceMappingURL=migration-status-DoPrFIOQ.mjs.map