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

package/dist/cli.mjs

@@ -1,36 +1,37 @@
 import { i as loadConfig } from "./exports-BZLNbtkY.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 { 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-Dp1pe06_-Cdpvh5DH.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-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 { 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 { 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 { 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";
@@ -40,7 +41,7 @@ import { defineCommand, defineCommandFamily, defineConfigSection, flag, position
 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-Db2bTG_C.mjs
+//#region ../../../1-framework/3-tooling/cli/dist/load-config-pL46nF5F.mjs
 const MISSING_CONFIG_ACTION = {
 	kind: "run-command",
 	label: "Create a config file",
@@ -637,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;
@@ -657,6 +674,7 @@ function planBlocks(result) {
 			status: "ok",
 			text: planSummaryText(result)
 		},
+		...plannerWarningBlocks(result),
 		...operationBlocks$1(result),
 		{
 			kind: "fields",
@@ -717,6 +735,7 @@ function applyBlocks(result) {
 			status: "ok",
 			text: applySummaryText(result)
 		},
+		...plannerWarningBlocks(result),
 		...operationBlocks$1(result),
 		...fallbackMarkerBlocks(result),
 		...advanced === null || advanced === void 0 ? [] : [{
@@ -1157,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;
@@ -2224,6 +2507,7 @@ const ormCommandFamily = defineCommandFamily({
 		"contract infer": contractInferCommand,
 		"db init": dbInitCommand,
 		"db schema": dbSchemaCommand,
+		"db update": dbUpdateCommand,
 		format: formatCommand,
 		migrate: migrateCommand,
 		"migration graph": migrationGraphCommand,