@prisma/orm-toolchain 8.0.0-rc.1-dev.36 → 8.0.0-rc.1-dev.38

package/dist/cli.mjs

@@ -1,47 +1,50 @@
 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 { I as requireLiveDatabase, L as runCommandAction, M as errorTargetMigrationNotSupported, O as errorRunnerFailed, P as errorUnexpected, a as errorConfigValidation$1, b as errorMigrationPlanningFailed, c as errorContractValidationFailed, d as errorDriverRequired, f as errorFileNotFound, g as errorLegendHumanOnly, k as errorRuntime$1, l as errorDatabaseConnectionRequired, o as errorConsentPlanMismatch, t as CliStructuredError$1$1, u as errorDestructiveChanges, x as errorNoMigrations, y as errorMigrationPackageNotFound } from "./cli-errors-BG6bItjG-DwdKIeGz.mjs";
 import { r as getEmittedArtifactPaths } from "./exports-BCLg4CiV-05kuwcb0.mjs";
+import { n as executeContractEmit } from "./contract-emit-CZQZ1i4z-p9LSGmmQ.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 { 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 { S as targetSupportsMigrations, f as maskConnectionUrl, n as closeQuietly, v as sanitizeErrorMessage } from "./command-helpers-CwLvFwMB-BWwUQhlT.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-BQFpcb2A-BwT9iVdb.mjs";
+import { n as executeFormat, t as createFormatCommand } from "./format-cbJY7l6v-CjMUDTAs.mjs";
+import { a as loadContractSpaceAggregateForCli, r as buildReadAggregate, s as refuseContractSpaceIntegrity, u as toDeclaredExtensionsFromRaw } from "./contract-space-aggregate-loader-CoLTf3Ce-pQDru2w0.mjs";
+import { t as createControlClient } from "./client-DU9qtBxW-BjVHiKzE.mjs";
 import { a as readContractIR, o as resolveRefAdvancementFields, t as advanceRefSafely } from "./ref-advancement-DaZBzm7m-WoqnFAyr.mjs";
-import { t as mapDbInitFailure } from "./db-init-failure-XYOVL4o7-BitY_JYn.mjs";
-import { t as mapCaughtMigrationError } from "./caught-errors-BZ-9WASe-DH4DaDha.mjs";
-import { t as mapContractAtError } from "./contract-at-errors-CLFX1-Gc-MNPXDx1t.mjs";
-import { i as refuseUnknownInvariants, n as refuseMarkerOutsideGraph } from "./invariants-1L2zfc6--BpedlAbF.mjs";
-import { t as executeMigrateShowPlan } from "./migrate-show-bdXjSFgh-CQxl5yNp.mjs";
-import { n as resolveMigrationRef, t as resolveContractRef } from "./ref-resolution-D4fAdXo8-Dfaky0yw.mjs";
-import { n as migrationSpaceListEntriesFromAggregate, r as runMigrationList } from "./migration-list-W0dqabIj-Dc2NH_LY.mjs";
+import { t as mapDbInitFailure } from "./db-init-failure-BmCcHUfc-BqDxyrJE.mjs";
+import { t as resolveContractRefToSnapshot } from "./contract-snapshot-resolution-DvZvbNcZ-DHFCWe_k.mjs";
+import { t as mapCaughtMigrationError } from "./caught-errors-DLPzfzIW-CQ9BoXD-.mjs";
+import { t as mapContractAtError } from "./contract-at-errors-Dptf8RE_-B5gr04Sc.mjs";
+import { i as refuseUnknownInvariants, n as refuseMarkerOutsideGraph } from "./invariants-1zL5-9Mc-BCeOLxd_.mjs";
+import { t as executeMigrateShowPlan } from "./migrate-show-kVUG1xdo-bVTW8tu4.mjs";
+import { n as resolveMigrationRef, t as resolveContractRef } from "./ref-resolution-DAK4OK3x-B-8ZZc0f.mjs";
+import { n as migrationSpaceListEntriesFromAggregate, r as runMigrationList } from "./migration-list-BQTfSGbT-DoNqbNsu.mjs";
 import { S as toneSpans, b as renderMigrationListWithStyle, d as createToneMigrationListStyler, n as TONE_MIGRATION_GRAPH_PALETTE, v as renderMigrationGraphLegend, x as toneDrawing } from "./migration-graph-command-render-BeuEyf2B-BNH9oUB_.mjs";
-import { n as migrateShowRunListRows, r as renderMigrateShowGraph, t as mapMigrateFailure } from "./migrate-failure-Bdr3AJee-C9yNeQXy.mjs";
-import { n as looksLikePath, r as resolveAppTargetPath, t as findPackageByDirPath } from "./migration-path-target-5r1leSW5-B0EMgvEv.mjs";
-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 { n as migrateShowRunListRows, r as renderMigrateShowGraph, t as mapMigrateFailure } from "./migrate-failure-CnoUcDms-taa9pfd7.mjs";
+import { n as looksLikePath, r as resolveAppTargetPath, t as findPackageByDirPath } from "./migration-path-target-BNTSTPAc-D7dQ4K7x.mjs";
+import { t as buildMigrationSpaceGraphEntries } from "./migration-graph-B30X5398-BH3zB9Mn.mjs";
+import { n as renderMigrationGraphDot, r as renderMigrationGraphSections, t as buildMigrationGraphTreeSections } from "./migration-graph-sections-0lKA5l1b-CTHQquu7.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 { n as executeRefListCommand, r as executeRefSetCommand, t as executeRefDeleteCommand } from "./ref-C8oaaeky-ColNkWpr.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 { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+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-h2VTJG-X.mjs
+//#region ../../../1-framework/3-tooling/cli/dist/load-config-pL46nF5F.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) {
@@ -261,16 +264,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",
@@ -303,6 +296,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,
@@ -384,6 +638,22 @@ function previewBlocks$1(preview) {
 		lines: statements
 	}];
 }
+/**
+* What the planner flagged without refusing to plan it. Only `db update`
+* produces these — the additive-only policies cannot reach the branch.
+*/
+function plannerWarningBlocks(result) {
+	const warnings = result.warnings ?? [];
+	if (warnings.length === 0) return [];
+	return [{
+		kind: "summary",
+		status: "warn",
+		text: "Planner warnings"
+	}, {
+		kind: "list",
+		items: warnings.map((warning) => warning.summary)
+	}];
+}
 function planSummaryText(result) {
 	const operations = result.plan.operations.length;
 	const spaces = result.perSpace?.length ?? 0;
@@ -404,6 +674,7 @@ function planBlocks(result) {
 			status: "ok",
 			text: planSummaryText(result)
 		},
+		...plannerWarningBlocks(result),
 		...operationBlocks$1(result),
 		{
 			kind: "fields",
@@ -464,6 +735,7 @@ function applyBlocks(result) {
 			status: "ok",
 			text: applySummaryText(result)
 		},
+		...plannerWarningBlocks(result),
 		...operationBlocks$1(result),
 		...fallbackMarkerBlocks(result),
 		...advanced === null || advanced === void 0 ? [] : [{
@@ -904,6 +1176,270 @@ function createDbSchemaCommand(createClient) {
 	});
 }
 const dbSchemaCommand = createDbSchemaCommand(createControlClient);
+/**
+* A `db update` failure as the CLI's structured error.
+*
+* `DESTRUCTIVE_CHANGES` is handled by the command, which asks for consent and
+* calls again; it is mapped here for the case the control API returns it from a
+* call that already carried consent, which would otherwise degrade silently.
+*
+* The `assertNever` is deliberate: a control-API failure code this does not
+* handle must stop the command rather than degrade into a generic message.
+*/
+function mapDbUpdateFailure(failure) {
+	if (failure.code === "PLANNING_FAILED") return errorMigrationPlanningFailed({ conflicts: failure.conflicts ?? [] });
+	if (failure.code === "RUNNER_FAILED") {
+		const fix = (typeof failure.meta?.["runnerErrorCode"] === "string" ? failure.meta["runnerErrorCode"] : void 0) === "MIGRATION.LEGACY_MARKER_SHAPE" ? "Legacy marker-table shape detected. Drop `prisma_contract.marker` (Postgres) or `_prisma_marker` (SQLite) and re-run `prisma-next db init` to recreate it with the current per-space schema." : "Inspect the reported conflict, reconcile schema drift if needed, then re-run `prisma-next db update`";
+		return errorRunnerFailed(failure.summary, {
+			why: failure.why ?? "Migration runner failed",
+			fix,
+			meta: {
+				...failure.meta,
+				...failure.warnings && failure.warnings.length > 0 ? { plannerWarnings: failure.warnings } : {}
+			},
+			...ifDefined("cause", failure.cause)
+		});
+	}
+	if (failure.code === "DESTRUCTIVE_CHANGES") return errorDestructiveChanges(failure.summary, {
+		...ifDefined("why", failure.why),
+		fix: "Re-run `prisma-next db update` and type the database name when asked, or pass `--no-interactive --confirm <database>` where there is nobody to ask. Use `--dry-run` to preview the operations first.",
+		...failure.destructiveChanges ? { meta: {
+			destructiveOperations: failure.destructiveChanges.destructiveOperations,
+			databaseName: failure.destructiveChanges.databaseName,
+			planHash: failure.destructiveChanges.planHash
+		} } : {}
+	});
+	if (failure.code === "CONSENT_PLAN_MISMATCH") return errorConsentPlanMismatch({
+		consentedPlanHash: failure.consentPlanMismatch?.consentedPlanHash ?? "",
+		planHash: failure.consentPlanMismatch?.planHash ?? "",
+		...ifDefined("why", failure.why)
+	});
+	const exhaustive = failure.code;
+	return assertNever(exhaustive, `Unhandled DbUpdateFailure code: ${String(exhaustive)}`);
+}
+/**
+* A token nobody can type is not consent: an empty one makes the engine's
+* type-to-confirm accept a bare Enter, and `--confirm ""` grant outright.
+*/
+function errorConsentTokenUnresolved(targetId) {
+	return new CliStructuredError$1("CLI.CONSENT_TOKEN_UNRESOLVED", "The database this run would change has no name to confirm.", {
+		why: `The connected database reports no name, and the target id "${targetId}" yields none either, so the consent prompt has nothing to ask you to type and the destructive operations cannot be authorised.`,
+		nextActions: [{
+			kind: "user-choice",
+			label: "Name the database in `db.connection` (or pass `--db <url>`) and run `prisma-next db update` again."
+		}]
+	});
+}
+/** A prompt that names nothing cannot be consented to knowingly. */
+function errorConsentOperationsMissing() {
+	return new CliStructuredError$1("CLI.CONSENT_OPERATIONS_MISSING", "The plan was refused as destructive but named no operations to confirm.", {
+		why: "The consent prompt has to list what is about to be destroyed, and the refusal carried no operations to list.",
+		nextActions: [{
+			kind: "run-command",
+			label: "Preview the plan",
+			command: "prisma-next db update --dry-run"
+		}]
+	});
+}
+/** The question the user answers before anything is dropped. */
+function destructiveConsentQuestion(operations, token) {
+	const listed = operations.map((operation) => `  - ${operation.label}`).join("\n");
+	return [`Apply ${operations.length} destructive operation(s) to ${token}? Data they remove cannot be recovered:`, listed].join("\n");
+}
+function updatePresentations(inputs) {
+	const { document, database, dryRun } = inputs;
+	return {
+		human: () => [{
+			kind: "fields",
+			rail: true,
+			rows: [
+				{
+					label: "contract",
+					value: inputs.contractPath
+				},
+				...database === void 0 ? [] : [{
+					label: "database",
+					value: database
+				}],
+				...inputs.to === void 0 ? [] : [{
+					label: "to",
+					value: inputs.to
+				}],
+				...dryRun ? [{
+					label: "mode",
+					value: "dry run"
+				}] : []
+			]
+		}, ...migrationResultBlocks(document)],
+		json: () => document,
+		next: () => migrationResultNextActions(document, "prisma-next db update")
+	};
+}
+function updateDocument(inputs) {
+	const { value } = inputs;
+	return {
+		ok: true,
+		mode: value.mode,
+		plan: {
+			targetId: inputs.targetId,
+			destination: {
+				storageHash: value.destination.storageHash,
+				...ifDefined("profileHash", value.destination.profileHash)
+			},
+			operations: value.plan.operations.map((operation) => ({
+				id: operation.id,
+				label: operation.label,
+				operationClass: operation.operationClass
+			})),
+			...ifDefined("preview", value.plan.preview)
+		},
+		...value.execution === void 0 ? {} : { execution: {
+			operationsPlanned: value.execution.operationsPlanned,
+			operationsExecuted: value.execution.operationsExecuted
+		} },
+		...value.marker === void 0 ? {} : { marker: {
+			storageHash: value.marker.storageHash,
+			...ifDefined("profileHash", value.marker.profileHash)
+		} },
+		...ifDefined("perSpace", value.perSpace),
+		...ifDefined("warnings", value.warnings),
+		advancedRef: inputs.advancedRef,
+		plannedAdvanceRef: inputs.plannedAdvanceRef,
+		summary: value.summary,
+		timings: { total: Date.now() - inputs.startedAt }
+	};
+}
+function createDbUpdateCommand(createClient) {
+	return defineOrmCommand({
+		help: {
+			summary: "Update your database schema to match your contract",
+			description: "Compares the database to the emitted contract and applies the changes that\nclose the gap, whether or not the database was bootstrapped with `db init`.\nAn operation that would destroy data is applied only with your consent: the\ncommand asks you to type the database name. A run with nobody to ask — a CI\njob, or `--no-interactive` — takes it from `--confirm <database>` instead.\nUse --dry-run to see the operations without applying them.",
+			examples: [
+				"db update",
+				"db update --dry-run",
+				"db update --no-interactive --confirm appdb",
+				"db update --to production"
+			]
+		},
+		args: { flags: {
+			db: dbFlag,
+			dryRun: flag.boolean({ brief: "Preview the planned operations without applying them" }),
+			to: flag.string({
+				brief: "Contract to update to (hash, prefix, ref name, migration dir name, or ./path)",
+				placeholder: "contract"
+			}),
+			advanceRef: flag.string({
+				brief: "Advance the named ref to the post-command contract hash",
+				placeholder: "name"
+			})
+		} },
+		needs: { config: ormConfigSection },
+		handler: async (args, ctx) => {
+			const startedAt = Date.now();
+			const prepared = await prepareMigrationRun({
+				config: ctx.config,
+				cwd: ctx.cwd,
+				db: args.flags.db,
+				commandName: "db update",
+				createClient
+			});
+			if (!prepared.ok) return notOk(prepared.failure);
+			const { client, contractPath, dbConnection, migrationsDir, refsDir } = prepared.value;
+			let contractJson = prepared.value.contractJson;
+			let snapshotContractPath = contractPath;
+			if (args.flags.to !== void 0) {
+				const resolved = await resolveContractRefToSnapshot({
+					config: ctx.config,
+					migrationsDir,
+					refInput: args.flags.to,
+					contractPathAbsolute: contractPath,
+					fallbackToEmitted: false,
+					missingBundleFlag: "--to"
+				});
+				if (!resolved.ok) return notOk(normalizeError(resolved.failure));
+				contractJson = resolved.value.contractJson;
+				snapshotContractPath = resolved.value.contractJsonPath;
+			}
+			const mode = args.flags.dryRun ? "plan" : "apply";
+			let document;
+			try {
+				await client.connect(dbConnection);
+				const update = (consent) => client.dbUpdate({
+					contract: contractJson,
+					mode,
+					migrationsDir,
+					...consent === void 0 ? {} : { consent },
+					onProgress: controlProgressReporter(ctx.report)
+				});
+				const reported = /* @__PURE__ */ new Set();
+				const reportPlannerWarnings = (warnings) => {
+					for (const warning of warnings) if (!reported.has(warning.summary)) {
+						reported.add(warning.summary);
+						ctx.report({
+							kind: "message",
+							severity: "warn",
+							text: warning.summary
+						});
+					}
+				};
+				let result = await update();
+				if (mode === "apply" && !result.ok && result.failure.code === "DESTRUCTIVE_CHANGES") {
+					reportPlannerWarnings(result.failure.warnings ?? []);
+					const refusal = result.failure.destructiveChanges;
+					if (refusal === void 0 || refusal.destructiveOperations.length === 0) return notOk(normalizeError(errorConsentOperationsMissing()));
+					const token = refusal.databaseName ?? "";
+					if (token.trim().length === 0) return notOk(normalizeError(errorConsentTokenUnresolved(ctx.config.target.targetId)));
+					if (!await ctx.prompt.consent(destructiveConsentQuestion(refusal.destructiveOperations, token), { token })) return notOk(normalizeError(mapDbUpdateFailure(result.failure)));
+					result = await update({ planHash: refusal.planHash });
+				}
+				if (!result.ok) {
+					reportPlannerWarnings(result.failure.warnings ?? []);
+					return notOk(normalizeError(mapDbUpdateFailure(result.failure)));
+				}
+				const advancementHash = result.value.mode === "apply" ? result.value.marker?.storageHash ?? result.value.destination.storageHash : result.value.destination.storageHash;
+				const advancement = await resolveRefAdvancementFields({
+					...ifDefined("advanceRef", args.flags.advanceRef),
+					...ifDefined("db", args.flags.db),
+					refsDir,
+					migrationsDir,
+					contractJson,
+					contractJsonPath: snapshotContractPath,
+					mode: result.value.mode,
+					hash: advancementHash
+				});
+				if (!advancement.ok) return notOk(normalizeError(advancement.failure));
+				document = updateDocument({
+					value: result.value,
+					targetId: ctx.config.target.targetId,
+					advancedRef: advancement.value.advancedRef,
+					plannedAdvanceRef: advancement.value.plannedAdvanceRef,
+					startedAt
+				});
+			} catch (error) {
+				if (error instanceof CliStructuredError$1) throw error;
+				if (CliStructuredError$1$1.is(error)) return notOk(normalizeError(error));
+				if (isStructuredError(error) && error.code === "CONTRACT.VALIDATION_FAILED") return notOk(normalizeError(errorContractValidationFailed(`Contract validation failed: ${error.message}`, { where: { path: contractPath } })));
+				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 db update: ${safeMessage}` })));
+			} finally {
+				await closeQuietly(client);
+			}
+			ctx.report({
+				kind: "message",
+				severity: "verbose",
+				text: `Total time: ${document.timings.total}ms`
+			});
+			return ok(ctx.present({ data: document }, updatePresentations({
+				document,
+				contractPath: prepared.value.contractDisplayPath,
+				database: prepared.value.database,
+				to: args.flags.to,
+				dryRun: args.flags.dryRun
+			})));
+		}
+	});
+}
+const dbUpdateCommand = createDbUpdateCommand(createControlClient);
 const NOTHING_TO_FORMAT = "Nothing to format (contract source is not PSL).";
 function formatPresentations(document, cwd) {
 	const path = document.path;
@@ -1967,8 +2503,11 @@ const DOCS_BASE_URL = `${DOCS_BASE}/`;
 const ormCommandFamily = defineCommandFamily({
 	configSection: ormConfigSection,
 	commands: {
+		"contract emit": contractEmitCommand,
+		"contract infer": contractInferCommand,
 		"db init": dbInitCommand,
 		"db schema": dbSchemaCommand,
+		"db update": dbUpdateCommand,
 		format: formatCommand,
 		migrate: migrateCommand,
 		"migration graph": migrationGraphCommand,