@prisma-next/cli 0.3.0-dev.53 → 0.3.0-dev.54

package/dist/{client-BSZKpZTF.mjs → client-B7f4PZZ1.mjs}

@@ -1,4 +1,4 @@
-import { CliStructuredError, errorConfigValidation, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorHashMismatch, errorJsonFormatNotSupported, errorMarkerMissing, errorMigrationPlanningFailed, errorRuntime, errorTargetMigrationNotSupported, errorTargetMismatch, errorUnexpected as errorUnexpected$1 } from "@prisma-next/core-control-plane/errors";
+import { CliStructuredError, errorConfigValidation, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDestructiveChanges, errorDriverRequired, errorFileNotFound, errorHashMismatch, errorJsonFormatNotSupported, errorMarkerMissing, errorMigrationPlanningFailed, errorRunnerFailed, errorRuntime, errorTargetMigrationNotSupported, errorTargetMismatch, errorUnexpected as errorUnexpected$1 } from "@prisma-next/core-control-plane/errors";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { createControlPlaneStack } from "@prisma-next/core-control-plane/stack";
 import { ifDefined } from "@prisma-next/utils/defined";
@@ -57,6 +57,81 @@ function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId,
 	return frameworkComponents;
 }
 
+//#endregion
+//#region src/control-api/errors.ts
+var ContractValidationError = class extends Error {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.name = "ContractValidationError";
+		this.cause = cause;
+	}
+};
+
+//#endregion
+//#region src/control-api/operations/extract-sql-ddl.ts
+function isDdlStatement(sqlStatement) {
+	const trimmed = sqlStatement.trim().toLowerCase();
+	return trimmed.startsWith("create ") || trimmed.startsWith("alter ") || trimmed.startsWith("drop ");
+}
+function hasExecuteSteps(operation) {
+	const candidate = operation;
+	if (!("execute" in candidate) || !Array.isArray(candidate["execute"])) return false;
+	return candidate["execute"].every((step) => typeof step === "object" && step !== null && "sql" in step);
+}
+/**
+* Extracts a best-effort SQL DDL preview for CLI plan output.
+* This helper is presentation-only and is never used to decide migration correctness.
+*/
+function extractSqlDdl(operations) {
+	const statements = [];
+	for (const operation of operations) {
+		if (!hasExecuteSteps(operation)) continue;
+		for (const step of operation.execute) if (typeof step.sql === "string" && isDdlStatement(step.sql)) statements.push(step.sql.trim());
+	}
+	return statements;
+}
+
+//#endregion
+//#region src/control-api/operations/migration-helpers.ts
+/**
+* Strips operation objects to their public shape (id, label, operationClass).
+* Used at the API boundary to avoid leaking internal fields (precheck, execute, postcheck, etc.).
+*/
+function stripOperations(operations) {
+	return operations.map((op) => ({
+		id: op.id,
+		label: op.label,
+		operationClass: op.operationClass
+	}));
+}
+/**
+* Creates per-operation progress callbacks for the runner.
+* Returns undefined when no onProgress callback is provided.
+*/
+function createOperationCallbacks(onProgress, action, parentSpanId) {
+	if (!onProgress) return;
+	return {
+		onOperationStart: (op) => {
+			onProgress({
+				action,
+				kind: "spanStart",
+				spanId: `operation:${op.id}`,
+				parentSpanId,
+				label: op.label
+			});
+		},
+		onOperationComplete: (op) => {
+			onProgress({
+				action,
+				kind: "spanEnd",
+				spanId: `operation:${op.id}`,
+				outcome: "ok"
+			});
+		}
+	};
+}
+
 //#endregion
 //#region src/control-api/operations/db-init.ts
 /**
@@ -128,7 +203,7 @@ async function executeDbInit(options) {
 		action: "dbInit",
 		kind: "spanStart",
 		spanId: checkMarkerSpanId,
-		label: "Checking contract marker"
+		label: "Checking database signature"
 	});
 	const existingMarker = await familyInstance.readMarker({ driver });
 	if (existingMarker) {
@@ -142,16 +217,18 @@ async function executeDbInit(options) {
 			return ok({
 				mode,
 				plan: { operations: [] },
-				...mode === "apply" ? {
-					execution: {
-						operationsPlanned: 0,
-						operationsExecuted: 0
-					},
-					marker: {
-						storageHash: existingMarker.storageHash,
-						profileHash: existingMarker.profileHash
-					}
-				} : {},
+				destination: {
+					storageHash: migrationPlan.destination.storageHash,
+					...ifDefined("profileHash", migrationPlan.destination.profileHash)
+				},
+				...ifDefined("execution", mode === "apply" ? {
+					operationsPlanned: 0,
+					operationsExecuted: 0
+				} : void 0),
+				...ifDefined("marker", mode === "apply" ? {
+					storageHash: existingMarker.storageHash,
+					profileHash: existingMarker.profileHash
+				} : void 0),
 				summary: "Database already at target contract state"
 			});
 		}
@@ -183,11 +260,21 @@ async function executeDbInit(options) {
 		spanId: checkMarkerSpanId,
 		outcome: "ok"
 	});
-	if (mode === "plan") return ok({
-		mode: "plan",
-		plan: { operations: migrationPlan.operations },
-		summary: `Planned ${migrationPlan.operations.length} operation(s)`
-	});
+	if (mode === "plan") {
+		const planSql = familyInstance.familyId === "sql" ? extractSqlDdl(migrationPlan.operations) : void 0;
+		return ok({
+			mode: "plan",
+			plan: {
+				operations: stripOperations(migrationPlan.operations),
+				...ifDefined("sql", planSql)
+			},
+			destination: {
+				storageHash: migrationPlan.destination.storageHash,
+				...ifDefined("profileHash", migrationPlan.destination.profileHash)
+			},
+			summary: `Planned ${migrationPlan.operations.length} operation(s)`
+		});
+	}
 	const applySpanId = "apply";
 	onProgress?.({
 		action: "dbInit",
@@ -195,31 +282,13 @@ async function executeDbInit(options) {
 		spanId: applySpanId,
 		label: "Applying migration plan"
 	});
-	const callbacks = onProgress ? {
-		onOperationStart: (op) => {
-			onProgress({
-				action: "dbInit",
-				kind: "spanStart",
-				spanId: `operation:${op.id}`,
-				parentSpanId: applySpanId,
-				label: op.label
-			});
-		},
-		onOperationComplete: (op) => {
-			onProgress({
-				action: "dbInit",
-				kind: "spanEnd",
-				spanId: `operation:${op.id}`,
-				outcome: "ok"
-			});
-		}
-	} : void 0;
+	const callbacks = createOperationCallbacks(onProgress, "dbInit", applySpanId);
 	const runnerResult = await runner.execute({
 		plan: migrationPlan,
 		driver,
 		destinationContract: contractIR,
 		policy,
-		...callbacks ? { callbacks } : {},
+		...ifDefined("callbacks", callbacks),
 		executionChecks: {
 			prechecks: false,
 			postchecks: false,
@@ -251,7 +320,170 @@ async function executeDbInit(options) {
 	});
 	return ok({
 		mode: "apply",
-		plan: { operations: migrationPlan.operations },
+		plan: { operations: stripOperations(migrationPlan.operations) },
+		destination: {
+			storageHash: migrationPlan.destination.storageHash,
+			...ifDefined("profileHash", migrationPlan.destination.profileHash)
+		},
+		execution: {
+			operationsPlanned: execution.operationsPlanned,
+			operationsExecuted: execution.operationsExecuted
+		},
+		marker: migrationPlan.destination.profileHash ? {
+			storageHash: migrationPlan.destination.storageHash,
+			profileHash: migrationPlan.destination.profileHash
+		} : { storageHash: migrationPlan.destination.storageHash },
+		summary: `Applied ${execution.operationsExecuted} operation(s), database signed`
+	});
+}
+
+//#endregion
+//#region src/control-api/operations/db-update.ts
+const DB_UPDATE_POLICY = { allowedOperationClasses: [
+	"additive",
+	"widening",
+	"destructive"
+] };
+/**
+* Executes the db update operation: introspect → plan → (optionally) apply → marker.
+*
+* db update is a pure reconciliation command: it introspects the live schema, plans the diff
+* to the destination contract, and applies operations. The marker is bookkeeping only — written
+* after apply so that `verify` and `db init` can reference it, but never read or validated
+* by db update itself. The runner creates the marker table if it does not exist.
+*/
+async function executeDbUpdate(options) {
+	const { driver, familyInstance, contractIR, mode, migrations, frameworkComponents, onProgress } = options;
+	const planner = migrations.createPlanner(familyInstance);
+	const runner = migrations.createRunner(familyInstance);
+	const introspectSpanId = "introspect";
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanStart",
+		spanId: introspectSpanId,
+		label: "Introspecting database schema"
+	});
+	const schemaIR = await familyInstance.introspect({ driver });
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanEnd",
+		spanId: introspectSpanId,
+		outcome: "ok"
+	});
+	const policy = DB_UPDATE_POLICY;
+	const planSpanId = "plan";
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanStart",
+		spanId: planSpanId,
+		label: "Planning migration"
+	});
+	const plannerResult = await planner.plan({
+		contract: contractIR,
+		schema: schemaIR,
+		policy,
+		frameworkComponents
+	});
+	if (plannerResult.kind === "failure") {
+		onProgress?.({
+			action: "dbUpdate",
+			kind: "spanEnd",
+			spanId: planSpanId,
+			outcome: "error"
+		});
+		return notOk({
+			code: "PLANNING_FAILED",
+			summary: "Migration planning failed due to conflicts",
+			conflicts: plannerResult.conflicts,
+			why: void 0,
+			meta: void 0
+		});
+	}
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanEnd",
+		spanId: planSpanId,
+		outcome: "ok"
+	});
+	const migrationPlan = plannerResult.plan;
+	if (mode === "plan") {
+		const planSql = familyInstance.familyId === "sql" ? extractSqlDdl(migrationPlan.operations) : void 0;
+		return ok({
+			mode: "plan",
+			plan: {
+				operations: stripOperations(migrationPlan.operations),
+				...planSql !== void 0 ? { sql: planSql } : {}
+			},
+			destination: {
+				storageHash: migrationPlan.destination.storageHash,
+				...ifDefined("profileHash", migrationPlan.destination.profileHash)
+			},
+			summary: `Planned ${migrationPlan.operations.length} operation(s)`
+		});
+	}
+	if (!options.acceptDataLoss) {
+		const destructiveOps = migrationPlan.operations.filter((op) => op.operationClass === "destructive").map((op) => ({
+			id: op.id,
+			label: op.label
+		}));
+		if (destructiveOps.length > 0) return notOk({
+			code: "DESTRUCTIVE_CHANGES",
+			summary: `Planned ${destructiveOps.length} destructive operation(s) that require confirmation`,
+			why: "Use --plan to preview destructive operations, then re-run with --accept-data-loss to apply",
+			conflicts: void 0,
+			meta: { destructiveOperations: destructiveOps }
+		});
+	}
+	const applySpanId = "apply";
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanStart",
+		spanId: applySpanId,
+		label: "Applying migration plan"
+	});
+	const callbacks = createOperationCallbacks(onProgress, "dbUpdate", applySpanId);
+	const runnerResult = await runner.execute({
+		plan: migrationPlan,
+		driver,
+		destinationContract: contractIR,
+		policy,
+		...callbacks ? { callbacks } : {},
+		executionChecks: {
+			prechecks: false,
+			postchecks: false,
+			idempotencyChecks: false
+		},
+		frameworkComponents
+	});
+	if (!runnerResult.ok) {
+		onProgress?.({
+			action: "dbUpdate",
+			kind: "spanEnd",
+			spanId: applySpanId,
+			outcome: "error"
+		});
+		return notOk({
+			code: "RUNNER_FAILED",
+			summary: runnerResult.failure.summary,
+			why: runnerResult.failure.why,
+			meta: runnerResult.failure.meta,
+			conflicts: void 0
+		});
+	}
+	const execution = runnerResult.value;
+	onProgress?.({
+		action: "dbUpdate",
+		kind: "spanEnd",
+		spanId: applySpanId,
+		outcome: "ok"
+	});
+	return ok({
+		mode: "apply",
+		plan: { operations: stripOperations(migrationPlan.operations) },
+		destination: {
+			storageHash: migrationPlan.destination.storageHash,
+			...ifDefined("profileHash", migrationPlan.destination.profileHash)
+		},
 		execution: {
 			operationsPlanned: execution.operationsPlanned,
 			operationsExecuted: execution.operationsExecuted
@@ -260,7 +492,7 @@ async function executeDbInit(options) {
 			storageHash: migrationPlan.destination.storageHash,
 			profileHash: migrationPlan.destination.profileHash
 		} : { storageHash: migrationPlan.destination.storageHash },
-		summary: `Applied ${execution.operationsExecuted} operation(s), marker written`
+		summary: execution.operationsExecuted === 0 ? "Database already matches contract, signature updated" : `Applied ${execution.operationsExecuted} operation(s), signature updated`
 	});
 }
 
@@ -336,40 +568,47 @@ var ControlClientImpl = class {
 			frameworkComponents: this.frameworkComponents
 		};
 	}
-	async verify(options) {
-		const { onProgress } = options;
-		if (options.connection !== void 0) {
+	async connectWithProgress(connection, action, onProgress) {
+		if (connection === void 0) return;
+		onProgress?.({
+			action,
+			kind: "spanStart",
+			spanId: "connect",
+			label: "Connecting to database..."
+		});
+		try {
+			await this.connect(connection);
 			onProgress?.({
-				action: "verify",
-				kind: "spanStart",
+				action,
+				kind: "spanEnd",
 				spanId: "connect",
-				label: "Connecting to database..."
+				outcome: "ok"
 			});
-			try {
-				await this.connect(options.connection);
-				onProgress?.({
-					action: "verify",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "ok"
-				});
-			} catch (error) {
-				onProgress?.({
-					action: "verify",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "error"
-				});
-				throw error;
-			}
+		} catch (error) {
+			onProgress?.({
+				action,
+				kind: "spanEnd",
+				spanId: "connect",
+				outcome: "error"
+			});
+			throw error;
 		}
+	}
+	async verify(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "verify", onProgress);
 		const { driver, familyInstance } = await this.ensureConnected();
-		const contractIR = familyInstance.validateContractIR(options.contractIR);
+		let contractIR;
+		try {
+			contractIR = familyInstance.validateContractIR(options.contractIR);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
 		onProgress?.({
 			action: "verify",
 			kind: "spanStart",
 			spanId: "verify",
-			label: "Verifying contract marker..."
+			label: "Verifying database signature..."
 		});
 		try {
 			const result = await familyInstance.verify({
@@ -397,33 +636,14 @@ var ControlClientImpl = class {
 	}
 	async schemaVerify(options) {
 		const { onProgress } = options;
-		if (options.connection !== void 0) {
-			onProgress?.({
-				action: "schemaVerify",
-				kind: "spanStart",
-				spanId: "connect",
-				label: "Connecting to database..."
-			});
-			try {
-				await this.connect(options.connection);
-				onProgress?.({
-					action: "schemaVerify",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "ok"
-				});
-			} catch (error) {
-				onProgress?.({
-					action: "schemaVerify",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "error"
-				});
-				throw error;
-			}
-		}
+		await this.connectWithProgress(options.connection, "schemaVerify", onProgress);
 		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
-		const contractIR = familyInstance.validateContractIR(options.contractIR);
+		let contractIR;
+		try {
+			contractIR = familyInstance.validateContractIR(options.contractIR);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
 		onProgress?.({
 			action: "schemaVerify",
 			kind: "spanStart",
@@ -457,33 +677,14 @@ var ControlClientImpl = class {
 	}
 	async sign(options) {
 		const { onProgress } = options;
-		if (options.connection !== void 0) {
-			onProgress?.({
-				action: "sign",
-				kind: "spanStart",
-				spanId: "connect",
-				label: "Connecting to database..."
-			});
-			try {
-				await this.connect(options.connection);
-				onProgress?.({
-					action: "sign",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "ok"
-				});
-			} catch (error) {
-				onProgress?.({
-					action: "sign",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "error"
-				});
-				throw error;
-			}
-		}
+		await this.connectWithProgress(options.connection, "sign", onProgress);
 		const { driver, familyInstance } = await this.ensureConnected();
-		const contractIR = familyInstance.validateContractIR(options.contractIR);
+		let contractIR;
+		try {
+			contractIR = familyInstance.validateContractIR(options.contractIR);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
 		onProgress?.({
 			action: "sign",
 			kind: "spanStart",
@@ -516,70 +717,50 @@ var ControlClientImpl = class {
 	}
 	async dbInit(options) {
 		const { onProgress } = options;
-		if (options.connection !== void 0) {
-			onProgress?.({
-				action: "dbInit",
-				kind: "spanStart",
-				spanId: "connect",
-				label: "Connecting to database..."
-			});
-			try {
-				await this.connect(options.connection);
-				onProgress?.({
-					action: "dbInit",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "ok"
-				});
-			} catch (error) {
-				onProgress?.({
-					action: "dbInit",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "error"
-				});
-				throw error;
-			}
-		}
+		await this.connectWithProgress(options.connection, "dbInit", onProgress);
 		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
 		if (!this.options.target.migrations) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
+		let contractIR;
+		try {
+			contractIR = familyInstance.validateContractIR(options.contractIR);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
 		return executeDbInit({
 			driver,
 			familyInstance,
-			contractIR: familyInstance.validateContractIR(options.contractIR),
+			contractIR,
+			mode: options.mode,
+			migrations: this.options.target.migrations,
+			frameworkComponents,
+			...ifDefined("onProgress", onProgress)
+		});
+	}
+	async dbUpdate(options) {
+		const { onProgress } = options;
+		await this.connectWithProgress(options.connection, "dbUpdate", onProgress);
+		const { driver, familyInstance, frameworkComponents } = await this.ensureConnected();
+		if (!this.options.target.migrations) throw new Error(`Target "${this.options.target.targetId}" does not support migrations`);
+		let contractIR;
+		try {
+			contractIR = familyInstance.validateContractIR(options.contractIR);
+		} catch (error) {
+			throw new ContractValidationError(error instanceof Error ? error.message : String(error), error);
+		}
+		return executeDbUpdate({
+			driver,
+			familyInstance,
+			contractIR,
 			mode: options.mode,
 			migrations: this.options.target.migrations,
 			frameworkComponents,
-			...onProgress ? { onProgress } : {}
+			...ifDefined("acceptDataLoss", options.acceptDataLoss),
+			...ifDefined("onProgress", onProgress)
 		});
 	}
 	async introspect(options) {
 		const onProgress = options?.onProgress;
-		if (options?.connection !== void 0) {
-			onProgress?.({
-				action: "introspect",
-				kind: "spanStart",
-				spanId: "connect",
-				label: "Connecting to database..."
-			});
-			try {
-				await this.connect(options.connection);
-				onProgress?.({
-					action: "introspect",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "ok"
-				});
-			} catch (error) {
-				onProgress?.({
-					action: "introspect",
-					kind: "spanEnd",
-					spanId: "connect",
-					outcome: "error"
-				});
-				throw error;
-			}
-		}
+		await this.connectWithProgress(options?.connection, "introspect", onProgress);
 		const { driver, familyInstance } = await this.ensureConnected();
 		options?.schema;
 		onProgress?.({
@@ -675,6 +856,22 @@ var ControlClientImpl = class {
 			label: "Emitting contract..."
 		});
 		try {
+			try {
+				this.familyInstance.validateContractIR(contractRaw);
+			} catch (error) {
+				onProgress?.({
+					action: "emit",
+					kind: "spanEnd",
+					spanId: "emit",
+					outcome: "error"
+				});
+				return notOk({
+					code: "CONTRACT_VALIDATION_FAILED",
+					summary: "Contract validation failed",
+					why: error instanceof Error ? error.message : String(error),
+					meta: void 0
+				});
+			}
 			const emitResult = await this.familyInstance.emitContract({ contractIR: contractRaw });
 			onProgress?.({
 				action: "emit",
@@ -707,5 +904,5 @@ var ControlClientImpl = class {
 };
 
 //#endregion
-export { errorDatabaseConnectionRequired as a, errorHashMismatch as c, errorMigrationPlanningFailed as d, errorRuntime as f, errorUnexpected$1 as h, errorContractValidationFailed as i, errorJsonFormatNotSupported as l, errorTargetMismatch as m, CliStructuredError as n, errorDriverRequired as o, errorTargetMigrationNotSupported as p, errorContractConfigMissing$1 as r, errorFileNotFound as s, createControlClient as t, errorMarkerMissing as u };
-//# sourceMappingURL=client-BSZKpZTF.mjs.map
+export { errorTargetMismatch as _, errorContractValidationFailed as a, errorDriverRequired as c, errorJsonFormatNotSupported as d, errorMarkerMissing as f, errorTargetMigrationNotSupported as g, errorRuntime as h, errorContractConfigMissing$1 as i, errorFileNotFound as l, errorRunnerFailed as m, ContractValidationError as n, errorDatabaseConnectionRequired as o, errorMigrationPlanningFailed as p, CliStructuredError as r, errorDestructiveChanges as s, createControlClient as t, errorHashMismatch as u, errorUnexpected$1 as v };
+//# sourceMappingURL=client-B7f4PZZ1.mjs.map