@prisma/orm-family-sql 8.0.0-rc.16-dev.5 → 8.0.0-rc.16-dev.7

package/dist/{control-0kB6FkCn.mjs → control-C4VZIU-L.mjs}

@@ -1,14 +1,14 @@
 import { u as namingOf } from "./naming-DkG_OegU-DpENNdZX.mjs";
 import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-dmXkOR4a.mjs";
 import { a as renderSqlTypeName, l as sqlDataTypeOfCodec, t as dataTypeParams, u as unquotedSqlBaseName } from "./data-type-CAPmGXg9.mjs";
-import { c as StorageTable, n as ForeignKey } from "./storage-table-CyL4CNMi-ByGZXmzd.mjs";
+import { c as StorageTable } from "./storage-table-CyL4CNMi-ByGZXmzd.mjs";
 import { a as sqlExpressionAuthoringEntry, o as sqlExpressionDataType, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-D7GsLgDM.mjs";
-import { c as isMaterializedSqlNamespace, o as SqlStorage, u as isStorageTypeInstance } from "./types-DDHgx581.mjs";
+import { u as isStorageTypeInstance } from "./types-DDHgx581.mjs";
 import { m as valueObjectStorageTypeMissingMessage } from "./validators-Xx-TKcx3.mjs";
 import { c as SqlSchemaIR, n as RelationalSchemaNodeKind, u as SqlTableIR } from "./types-Cz_bcUWN-CC3lFQOi.mjs";
-import { a as describeUnsupportedSqlAttribute, b as sqlAttributeSpecs } from "./psl-field-resolution-DUCrDnuq-BYapcETh.mjs";
+import { a as describeUnsupportedSqlAttribute, b as sqlAttributeSpecs } from "./psl-field-resolution-DUCrDnuq-DSxPrd-4.mjs";
 import { t as sqlEmission } from "./dist-7hmkNQGd.mjs";
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-dihiQslc-S4oVeeaO.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-0Iv2zdwS-CVl4womm.mjs";
 import { c as verifySqlSchemaByDiff, n as classifyDiffSubjectGranularity, o as enforceSqlDataTypeInvariants, t as classifyDiffEntityKind } from "./schema-verify-DIfHSB4I-CjYnmUuD.mjs";
 import { t as sqlFamilyError } from "./errors-B5g0xWro-mWH2C07F.mjs";
 import { t as SqlContractSerializer } from "./sql-contract-serializer-DDaAVCQr-CLDkZLXO.mjs";
@@ -22,7 +22,7 @@ import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
-import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions, extractCodecLookup, issueOutcome, sameMarkerHashes } from "@prisma/orm-framework/components/control";
+import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions, describeMigrationStatement, extractCodecLookup, issueOutcome, modelDisplayName, sameMarkerHashes } from "@prisma/orm-framework/components/control";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { assertDescriptorSelfConsistency } from "@prisma/orm-toolchain/migration-tools/spaces";
 //#region ../../../2-sql/9-family/dist/control.mjs
@@ -652,118 +652,6 @@ var SqlFamilyDescriptor = class {
 		return createSqlFamilyInstance(stack);
 	}
 };
-const TABLE_RENAME_UNMATCHED_CODE = "MIGRATION.TABLE_RENAME_UNMATCHED";
-function tableLabel(namespaceId, tableName) {
-	return namespaceId === void 0 || namespaceId === UNBOUND_NAMESPACE_ID ? tableName : `${namespaceId}.${tableName}`;
-}
-function namespacesDeclaring(contract, tableName) {
-	return Object.values(contract.storage.namespaces).filter((namespace) => Object.hasOwn(namespace.entries.table ?? {}, tableName)).map((namespace) => namespace.id);
-}
-function declares(contract, namespaceId, tableName) {
-	return Object.hasOwn(contract.storage.namespaces[namespaceId]?.entries.table ?? {}, tableName);
-}
-function unmatched(rename, reason) {
-	return sqlFamilyError(TABLE_RENAME_UNMATCHED_CODE, `renameTable "${tableLabel(rename.namespaceId, rename.from)}" to "${rename.to}" does not match the migration's contracts: ${reason}.`, {
-		why: "renameTable must name a table of the migration's start contract and a new name that the end contract has and the start contract does not. Make the rename its own schema change, so the migration's start contract is the schema before the rename and its end contract the schema after it, and check the spelling and the namespace.",
-		meta: {
-			from: rename.from,
-			to: rename.to
-		}
-	});
-}
-function resolveTableRename(rename, startContract, endContract) {
-	const namespaceIds = rename.namespaceId === void 0 ? namespacesDeclaring(startContract, rename.from) : declares(startContract, rename.namespaceId, rename.from) ? [rename.namespaceId] : [];
-	const [namespaceId, ...others] = namespaceIds;
-	if (namespaceId === void 0) return notOk(unmatched(rename, `table "${tableLabel(rename.namespaceId, rename.from)}" does not exist in the start contract`));
-	if (others.length > 0) return notOk(unmatched(rename, `table "${rename.from}" is declared in more than one namespace (${namespaceIds.join(", ")}); name its namespace`));
-	if (declares(startContract, namespaceId, rename.to)) return notOk(unmatched(rename, `table "${tableLabel(namespaceId, rename.to)}" already exists in the start contract`));
-	if (!declares(endContract, namespaceId, rename.to)) return notOk(unmatched(rename, `table "${tableLabel(namespaceId, rename.to)}" does not exist in the end contract`));
-	return ok({
-		namespaceId,
-		from: rename.from,
-		to: rename.to
-	});
-}
-function renamedReference(reference, rename) {
-	if (!(reference.spaceId === void 0) || reference.namespaceId !== rename.namespaceId || reference.tableName !== rename.from) return reference;
-	return {
-		...reference,
-		tableName: rename.to
-	};
-}
-function renameForeignKeys(table, rename) {
-	if (!table.foreignKeys.some((fk) => renamedReference(fk.source, rename) !== fk.source || renamedReference(fk.target, rename) !== fk.target)) return table;
-	return new StorageTable({
-		...table,
-		foreignKeys: table.foreignKeys.map((fk) => new ForeignKey({
-			...fk,
-			source: renamedReference(fk.source, rename),
-			target: renamedReference(fk.target, rename)
-		}))
-	});
-}
-/**
-* The same namespace instance with only `entries` replaced: every own
-* property, including the non-enumerable `kind`, is carried over onto the
-* same prototype, so the target's namespace class (its `qualifyTable`,
-* `ddlSchemaName`, entity getters) keeps working on the copy. This is the
-* one place a frozen contract node is rebuilt without its constructor: the
-* constructors re-hydrate `entries` from raw input, which the already
-* hydrated entities here do not need.
-*/
-function withEntries(namespace, entries) {
-	const copy = Object.create(Object.getPrototypeOf(namespace), {
-		...Object.getOwnPropertyDescriptors(namespace),
-		entries: {
-			value: Object.freeze(entries),
-			enumerable: true,
-			writable: false,
-			configurable: false
-		}
-	});
-	return Object.freeze(copy);
-}
-function renameTableInNamespace(namespace, rename, renameTableReferences) {
-	const ownsTable = rename.namespaceId === namespace.id;
-	const tables = Object.entries(namespace.entries.table ?? {}).map(([name, table]) => [ownsTable && name === rename.from ? rename.to : name, renameForeignKeys(table, rename)]);
-	if (tables.every(([name, table]) => namespace.entries.table?.[name] === table)) return namespace;
-	if (!isMaterializedSqlNamespace(namespace)) throw new InternalError(`applyTableRename: namespace "${namespace.id}" is not a materialized SQL namespace`);
-	const renamedTables = {
-		...namespace.entries,
-		table: Object.fromEntries(tables)
-	};
-	return withEntries(namespace, renameTableReferences === void 0 || !ownsTable ? renamedTables : renameTableReferences(renamedTables, rename));
-}
-function renameTableInContract(contract, rename, renameTableReferences) {
-	const namespaces = Object.fromEntries(Object.entries(contract.storage.namespaces).map(([id, namespace]) => [id, renameTableInNamespace(namespace, rename, renameTableReferences)]));
-	const materialized = {};
-	for (const [id, namespace] of Object.entries(namespaces)) {
-		if (!isMaterializedSqlNamespace(namespace)) throw new InternalError(`applyTableRename: namespace "${id}" is not a materialized SQL namespace`);
-		materialized[id] = namespace;
-	}
-	return {
-		...contract,
-		storage: new SqlStorage({
-			storageHash: contract.storage.storageHash,
-			...contract.storage.types === void 0 ? {} : { types: contract.storage.types },
-			namespaces: materialized
-		})
-	};
-}
-/**
-* Resolves the table a migration renames against its start and end contracts and returns the start contract with that table under its new name, so a diff against the end contract sees the table under one name. The table must exist in the start contract (in exactly one namespace when the namespace is not given), and the new name must exist in the end contract and not in the start contract; otherwise the rename is refused with `MIGRATION.TABLE_RENAME_UNMATCHED`.
-*
-* Foreign keys that name the renamed table on either side are retargeted. Index, unique, check and primary-key names are carried unchanged. Target entity kinds that name the table are renamed by the target's `renameTableReferences`.
-*/
-function applyTableRename(input) {
-	if (input.startContract === null) return notOk(unmatched(input.rename, "the migration has no start contract"));
-	const resolved = resolveTableRename(input.rename, input.startContract, input.endContract);
-	if (!resolved.ok) return resolved;
-	return ok({
-		contract: renameTableInContract(input.startContract, resolved.value, input.renameTableReferences),
-		rename: resolved.value
-	});
-}
 function convertColumn(name, column, storageTypes, types, renderDefault, resolveDefault) {
 	const resolved = resolveColumnTypeMetadata(column, storageTypes);
 	const dataType = sqlDataTypeOfCodec(resolved.codecId, types);
@@ -1207,6 +1095,9 @@ function subjectKey(subject) {
 function planFieldEventOperations(options) {
 	const priorContract = options.priorContract;
 	const newContract = options.newContract;
+	const renamedTo = new Map(options.tableRenames.map((rename) => [renameKey(rename.namespaceId, rename.from), rename.to]));
+	const newNameOf = (namespaceId, tableName) => renamedTo.get(renameKey(namespaceId, tableName));
+	const columnRenamedTo = new Map(options.columnRenames.map((rename) => [renameKey(rename.namespaceId, rename.table, rename.from), rename.to]));
 	const added = [];
 	const dropped = [];
 	const altered = [];
@@ -1214,7 +1105,7 @@ function planFieldEventOperations(options) {
 	for (const namespaceId of namespaceIds) {
 		const priorNs = priorContract?.storage.namespaces[namespaceId];
 		const newNs = newContract.storage.namespaces[namespaceId];
-		const priorTables = priorNs?.entries.table;
+		const priorTables = underNewNames(priorNs?.entries.table, (tableName) => newNameOf(namespaceId, tableName));
 		const newTables = newNs?.entries.table;
 		const tableNames = unionSorted(priorTables ? Object.keys(priorTables) : [], newTables ? Object.keys(newTables) : []);
 		for (const tableName of tableNames) {
@@ -1222,9 +1113,10 @@ function planFieldEventOperations(options) {
 			const newTableRaw = newTables?.[tableName];
 			const priorTable = StorageTable.is(priorTableRaw) ? priorTableRaw : void 0;
 			const newTable = StorageTable.is(newTableRaw) ? newTableRaw : void 0;
-			const fieldNames = unionSorted(priorTable ? Object.keys(priorTable.columns) : [], newTable ? Object.keys(newTable.columns) : []);
+			const priorColumns = underNewNames(priorTable?.columns, (columnName) => columnRenamedTo.get(renameKey(namespaceId, tableName, columnName)));
+			const fieldNames = unionSorted(priorColumns ? Object.keys(priorColumns) : [], newTable ? Object.keys(newTable.columns) : []);
 			for (const fieldName of fieldNames) {
-				const priorField = priorTable?.columns[fieldName];
+				const priorField = priorColumns?.[fieldName];
 				const newField = newTable?.columns[fieldName];
 				const entry = {
 					namespaceId,
@@ -1249,6 +1141,13 @@ function planFieldEventOperations(options) {
 	appendCalls("altered", altered, options.codecHooks, calls, (e) => e.newField?.codecId);
 	return calls;
 }
+function renameKey(...parts) {
+	return JSON.stringify(parts);
+}
+function underNewNames(tables, newNameOf) {
+	if (tables === void 0) return void 0;
+	return Object.fromEntries(Object.entries(tables).map(([tableName, table]) => [newNameOf(tableName) ?? tableName, table]));
+}
 function appendCalls(event, entries, codecHooks, calls, pickCodecId) {
 	for (const entry of entries) {
 		const codecId = pickCodecId(entry);
@@ -1381,15 +1280,18 @@ function createMigrationPlan(options) {
 		...options.meta ? { meta: cloneRecord(options.meta) } : {}
 	});
 }
-function plannerSuccess(plan, warnings) {
+function plannerSuccess(plan, appliedStatements, warnings) {
 	return Object.freeze({
 		kind: "success",
 		plan,
+		appliedStatements: Object.freeze([...appliedStatements]),
 		...warnings && warnings.length > 0 ? { warnings: Object.freeze(warnings.map((conflict) => Object.freeze({
 			kind: conflict.kind,
 			summary: conflict.summary,
 			...conflict.why ? { why: conflict.why } : {},
 			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.refusedStatement ? { refusedStatement: conflict.refusedStatement } : {},
+			...conflict.refusedOperationClass ? { refusedOperationClass: conflict.refusedOperationClass } : {},
 			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
 		}))) } : {}
 	});
@@ -1402,6 +1304,8 @@ function plannerFailure(conflicts) {
 			summary: conflict.summary,
 			...conflict.why ? { why: conflict.why } : {},
 			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.refusedStatement ? { refusedStatement: conflict.refusedStatement } : {},
+			...conflict.refusedOperationClass ? { refusedOperationClass: conflict.refusedOperationClass } : {},
 			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
 		})))
 	});
@@ -1430,6 +1334,150 @@ function runnerFailure(code, summary, options) {
 * Policy used by `db init`: additive-only operations, no widening/destructive steps.
 */
 const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.freeze(["additive"]) });
+const COLUMN_RENAME_UNMATCHED_CODE = "MIGRATION.COLUMN_RENAME_UNMATCHED";
+function tableLabel$1(namespaceId, table) {
+	return namespaceId === void 0 || namespaceId === UNBOUND_NAMESPACE_ID ? table : `${namespaceId}.${table}`;
+}
+function columnLabel(namespaceId, table, column) {
+	return `"${tableLabel$1(namespaceId, table)}"."${column}"`;
+}
+function declaresColumn(contract, namespaceId, table, column) {
+	const columns = contract.storage.namespaces[namespaceId]?.entries.table?.[table]?.columns;
+	return columns !== void 0 && Object.hasOwn(columns, column);
+}
+/**
+* Refuses a `renameColumn` call that does not match the migration's contracts, with
+* `MIGRATION.COLUMN_RENAME_UNMATCHED`.
+*/
+function unmatchedColumnRename(rename, reason) {
+	return sqlFamilyError(COLUMN_RENAME_UNMATCHED_CODE, `renameColumn ${columnLabel(rename.namespaceId, rename.table, rename.from)} to "${rename.to}" does not match the migration's contracts: ${reason}.`, {
+		why: "renameColumn must name a table and a column as the migration's earlier rename operations leave them, and a new column name that the end contract has on that table and that the table does not have yet. Order the rename calls in the sequence the renames happen, and check the names of the table, the column and the namespace.",
+		meta: {
+			table: rename.table,
+			from: rename.from,
+			to: rename.to
+		}
+	});
+}
+/**
+* Checks a column rename: the table must exist in `previous` (in exactly one namespace when the
+* namespace is not given) with the old column and without the new one, and the end contract must
+* have the new column on that table.
+*/
+function checkColumnRename(previous, endContract, rename) {
+	const namespaceIds = rename.namespaceId === void 0 ? previous.namespacesWithTable(rename.table) : previous.hasTable(rename.namespaceId, rename.table) ? [rename.namespaceId] : [];
+	const [namespaceId, ...others] = namespaceIds;
+	if (namespaceId === void 0) return notOk({ kind: "tableMissing" });
+	if (others.length > 0) return notOk({
+		kind: "tableInManyNamespaces",
+		namespaceIds
+	});
+	if (!previous.hasColumn(namespaceId, rename.table, rename.from)) return notOk({
+		kind: "columnMissing",
+		namespaceId
+	});
+	const [taken] = previous.columnsNamed(namespaceId, rename.table, rename.to).filter((column) => column !== rename.from);
+	if (taken !== void 0) return notOk({
+		kind: "nameTaken",
+		namespaceId,
+		taken
+	});
+	if (!declaresColumn(endContract, namespaceId, rename.table, rename.to)) return notOk({
+		kind: "notInEndContract",
+		namespaceId
+	});
+	return ok({
+		namespaceId,
+		table: rename.table,
+		from: rename.from,
+		to: rename.to
+	});
+}
+/** The reason `MIGRATION.COLUMN_RENAME_UNMATCHED` gives for a mismatch. */
+function columnRenameMismatchReason(rename, mismatch) {
+	switch (mismatch.kind) {
+		case "tableMissing": return `table "${tableLabel$1(rename.namespaceId, rename.table)}" does not exist at this point of the migration`;
+		case "tableInManyNamespaces": return `table "${rename.table}" is declared in more than one namespace (${mismatch.namespaceIds.join(", ")}); name its namespace`;
+		case "columnMissing": return `column ${columnLabel(mismatch.namespaceId, rename.table, rename.from)} does not exist at this point of the migration`;
+		case "nameTaken": return `column ${columnLabel(mismatch.namespaceId, rename.table, rename.to)} already exists at this point of the migration${mismatch.taken === rename.to ? "" : ` as "${mismatch.taken}"`}`;
+		case "notInEndContract": return `column ${columnLabel(mismatch.namespaceId, rename.table, rename.to)} does not exist in the end contract`;
+	}
+}
+/**
+* Resolves a column a migration renames with {@link checkColumnRename}, refusing a mismatch with
+* `MIGRATION.COLUMN_RENAME_UNMATCHED`.
+*/
+function resolveColumnRenameAgainst(previous, endContract, rename) {
+	const checked = checkColumnRename(previous, endContract, rename);
+	if (!checked.ok) return notOk(unmatchedColumnRename(rename, columnRenameMismatchReason(rename, checked.failure)));
+	return ok(checked.value);
+}
+const TABLE_RENAME_UNMATCHED_CODE = "MIGRATION.TABLE_RENAME_UNMATCHED";
+function tableLabel(namespaceId, tableName) {
+	return namespaceId === void 0 || namespaceId === UNBOUND_NAMESPACE_ID ? tableName : `${namespaceId}.${tableName}`;
+}
+function declares(contract, namespaceId, tableName) {
+	return Object.hasOwn(contract.storage.namespaces[namespaceId]?.entries.table ?? {}, tableName);
+}
+/**
+* Refuses a `renameTable` call that does not match the migration's contracts, with
+* `MIGRATION.TABLE_RENAME_UNMATCHED`.
+*/
+function unmatchedTableRename(rename, reason) {
+	return sqlFamilyError(TABLE_RENAME_UNMATCHED_CODE, `renameTable "${tableLabel(rename.namespaceId, rename.from)}" to "${rename.to}" does not match the migration's contracts: ${reason}.`, {
+		why: "renameTable must name a table as the migration's earlier rename operations leave it, and a new name that the end contract has and that no earlier rename operation has already produced. Order the renameTable calls in the sequence the renames happen, make the rename its own schema change, and check the spelling, the table and the namespace.",
+		meta: {
+			from: rename.from,
+			to: rename.to
+		}
+	});
+}
+/**
+* Checks a table rename: the table must exist in `previous` (in exactly one namespace when the
+* namespace is not given), and the new name must exist in the end contract and not in `previous`.
+*/
+function checkTableRename(previous, endContract, rename) {
+	const namespaceIds = rename.namespaceId === void 0 ? previous.namespacesWithTable(rename.from) : previous.hasTable(rename.namespaceId, rename.from) ? [rename.namespaceId] : [];
+	const [namespaceId, ...others] = namespaceIds;
+	if (namespaceId === void 0) return notOk({ kind: "tableMissing" });
+	if (others.length > 0) return notOk({
+		kind: "tableInManyNamespaces",
+		namespaceIds
+	});
+	const [taken] = previous.tablesNamed(namespaceId, rename.to).filter((table) => table !== rename.from);
+	if (taken !== void 0) return notOk({
+		kind: "nameTaken",
+		namespaceId,
+		taken
+	});
+	if (!declares(endContract, namespaceId, rename.to)) return notOk({
+		kind: "notInEndContract",
+		namespaceId
+	});
+	return ok({
+		namespaceId,
+		from: rename.from,
+		to: rename.to
+	});
+}
+/** The reason `MIGRATION.TABLE_RENAME_UNMATCHED` gives for a mismatch. */
+function tableRenameMismatchReason(rename, mismatch) {
+	switch (mismatch.kind) {
+		case "tableMissing": return `table "${tableLabel(rename.namespaceId, rename.from)}" does not exist at this point of the migration`;
+		case "tableInManyNamespaces": return `table "${rename.from}" is declared in more than one namespace (${mismatch.namespaceIds.join(", ")}); name its namespace`;
+		case "nameTaken": return `table "${tableLabel(mismatch.namespaceId, rename.to)}" already exists at this point of the migration${mismatch.taken === rename.to ? "" : ` as "${mismatch.taken}"`}`;
+		case "notInEndContract": return `table "${tableLabel(mismatch.namespaceId, rename.to)}" does not exist in the end contract`;
+	}
+}
+/**
+* Resolves a table a migration renames with {@link checkTableRename}, refusing a mismatch with
+* `MIGRATION.TABLE_RENAME_UNMATCHED`.
+*/
+function resolveTableRenameAgainst(previous, endContract, rename) {
+	const checked = checkTableRename(previous, endContract, rename);
+	if (!checked.ok) return notOk(unmatchedTableRename(rename, tableRenameMismatchReason(rename, checked.failure)));
+	return ok(checked.value);
+}
 /** The codecs and data types a set of composed components registers. */
 function sqlTypeLookupsOf(frameworkComponents) {
 	return {
@@ -1437,6 +1485,292 @@ function sqlTypeLookupsOf(frameworkComponents) {
 		dataTypeLookup: assembleDataTypes(frameworkComponents).lookup
 	};
 }
+function isSqlModelStorage(storage) {
+	return typeof storage["table"] === "string" && typeof storage["namespaceId"] === "string" && typeof storage["fields"] === "object" && storage["fields"] !== null;
+}
+/** The storage of a model the contract stores in a table, or `undefined` for any other model. */
+function sqlModelStorage(contract, coordinate) {
+	const storage = contract.domain.namespaces[coordinate.namespaceId]?.models[coordinate.model]?.storage;
+	return storage !== void 0 && isSqlModelStorage(storage) ? storage : void 0;
+}
+function modelTable(contract, coordinate) {
+	const storage = sqlModelStorage(contract, coordinate);
+	return storage === void 0 ? void 0 : {
+		namespaceId: storage.namespaceId,
+		table: storage.table
+	};
+}
+/**
+* The storage effect of a model rename: the origin model's table compared with the destination
+* model's. Equal tables mean the rename needs no storage change.
+*/
+function modelRenameStorageEffect(statement, fromContract, contract) {
+	const from = modelTable(fromContract, statement.from);
+	if (from === void 0) return notOk({
+		kind: "noTable",
+		model: statement.from
+	});
+	const to = modelTable(contract, statement.to);
+	if (to === void 0) return notOk({
+		kind: "noTable",
+		model: statement.to
+	});
+	if (from.namespaceId !== to.namespaceId) return ok({
+		kind: "moveNamespace",
+		from,
+		to
+	});
+	if (from.table === to.table) return ok({ kind: "unchanged" });
+	return ok({
+		kind: "renameTable",
+		rename: {
+			namespaceId: from.namespaceId,
+			from: from.table,
+			to: to.table
+		}
+	});
+}
+function fieldColumn(contract, coordinate) {
+	const fields = sqlModelStorage(contract, coordinate)?.fields;
+	return fields !== void 0 && Object.hasOwn(fields, coordinate.field) ? fields[coordinate.field]?.column : void 0;
+}
+/**
+* The storage effect of a field rename: the origin field's column compared with the destination
+* field's. A relation field has no column on either side, and equal columns need no change.
+*/
+function fieldRenameStorageEffect(statement, fromContract, contract) {
+	const table = modelTable(fromContract, statement.from);
+	if (table === void 0) return notOk({
+		kind: "noTable",
+		model: statement.from
+	});
+	const from = fieldColumn(fromContract, statement.from);
+	const to = fieldColumn(contract, statement.to);
+	if (from === void 0 && to === void 0) return ok({ kind: "unchanged" });
+	if (from === void 0 || to === void 0) return notOk({ kind: "columnOnOneSide" });
+	if (from === to) return ok({ kind: "unchanged" });
+	return ok({
+		kind: "renameColumn",
+		table,
+		from,
+		to
+	});
+}
+function operationsOf(call) {
+	return [call, ...call.companions];
+}
+const DRIFTED = "so the database has drifted from that contract. Inspect it with prisma db schema, or leave out this statement.";
+const UNMATCHED = "A statement plans the rename a hand-written rename call makes, and that call does not match the contracts. Leave out this statement.";
+function statementRefused(statement, summary, why, location, refusedOperationClass) {
+	return {
+		kind: "statementRefused",
+		summary,
+		why,
+		refusedStatement: statement,
+		...refusedOperationClass === void 0 ? {} : { refusedOperationClass },
+		...location === void 0 ? {} : { location: {
+			namespaceId: location.namespaceId,
+			entityKind: "table",
+			entityName: location.table,
+			...location.column === void 0 ? {} : { column: location.column }
+		} }
+	};
+}
+function tableControlPolicy(contract, table) {
+	const node = contract.storage.namespaces[table.namespaceId]?.entries.table?.[table.table];
+	return controlPolicyForCall({
+		namespaceId: table.namespaceId,
+		entityKind: "table",
+		entityName: table.table,
+		...StorageTable.is(node) && node.control !== void 0 ? { explicitNodeControlPolicy: node.control } : {},
+		createsNewObject: false
+	}, contract.defaultControlPolicy);
+}
+function tableKey(table) {
+	return JSON.stringify([table.namespaceId, table.table]);
+}
+function tableRenameRefused(statement, label, rename, mismatch) {
+	switch (mismatch.kind) {
+		case "tableMissing": return statementRefused(statement, `${label}: the schema being planned from has no table "${rename.from}"`, `The database has no table "${rename.from}", although the contract it was last updated to names it, ${DRIFTED}`, {
+			namespaceId: rename.namespaceId,
+			table: rename.from
+		});
+		case "nameTaken": return statementRefused(statement, `${label}: the schema being planned from already has a table "${rename.to}"${mismatch.taken === rename.to ? "" : `, as "${mismatch.taken}"`}`, `A rename cannot replace a table that already exists. Rename or drop table "${mismatch.taken}" first, or leave out this statement.`, {
+			namespaceId: rename.namespaceId,
+			table: rename.to
+		});
+		case "tableInManyNamespaces":
+		case "notInEndContract": return statementRefused(statement, `${label}: ${tableRenameMismatchReason(rename, mismatch)}`, UNMATCHED, {
+			namespaceId: rename.namespaceId,
+			table: rename.from
+		});
+	}
+}
+function columnRenameRefused(statement, label, rename, mismatch) {
+	const table = {
+		namespaceId: rename.namespaceId,
+		table: rename.table
+	};
+	switch (mismatch.kind) {
+		case "tableMissing": return statementRefused(statement, `${label}: the schema being planned from has no table "${rename.table}"`, `The database has no table "${rename.table}", although the contract it was last updated to names it, ${DRIFTED}`, table);
+		case "columnMissing": return statementRefused(statement, `${label}: the schema being planned from has no column "${rename.from}" on table "${rename.table}"`, `The database has no column "${rename.from}" on table "${rename.table}", although the contract it was last updated to names it, ${DRIFTED}`, {
+			...table,
+			column: rename.from
+		});
+		case "nameTaken": return statementRefused(statement, `${label}: the schema being planned from already has a column "${mismatch.taken}" on table "${rename.table}"`, `A rename cannot replace a column that already exists. Rename or drop column "${mismatch.taken}" of table "${rename.table}" first, or leave out this statement.`, {
+			...table,
+			column: rename.to
+		});
+		case "tableInManyNamespaces":
+		case "notInEndContract": return statementRefused(statement, `${label}: ${columnRenameMismatchReason(rename, mismatch)}`, UNMATCHED, {
+			...table,
+			column: rename.from
+		});
+	}
+}
+var StatementPlanner = class {
+	#fromContract;
+	#contract;
+	#policy;
+	#target;
+	/** The name each table renamed so far has in the working schema, keyed by its origin name. */
+	#renamedTables = /* @__PURE__ */ new Map();
+	calls = [];
+	/** How many operations the calls planned so far lower to. */
+	#operationCount = 0;
+	tableRenames = [];
+	columnRenames = [];
+	constructor(input) {
+		this.#fromContract = input.fromContract;
+		this.#contract = input.contract;
+		this.#policy = input.policy;
+		this.#target = input.target;
+	}
+	/** Plans one statement; the result is the positions of the operations it accounts for. */
+	plan(statement) {
+		return statement.entity === "model" ? this.#planModel(statement) : this.#planField(statement);
+	}
+	#controlPolicyRefusal(statement, label, destinationTable) {
+		const controlPolicy = tableControlPolicy(this.#contract, destinationTable);
+		if (controlPolicy === "managed") return void 0;
+		return statementRefused(statement, `${label}: the table's control policy is "${controlPolicy}"`, `Statements rename only tables, and columns of tables, whose control policy is "managed"; table "${destinationTable.table}" is "${controlPolicy}". Make the change in the database yourself and leave out this statement.`, destinationTable);
+	}
+	#emit(statement, label, location, call) {
+		const refused = operationsOf(call).map((operation) => operation.operationClass).find((operationClass) => !this.#policy.allowedOperationClasses.includes(operationClass));
+		if (refused !== void 0) return notOk(statementRefused(statement, `${label}: the plan does not allow "${refused}" operations`, `The rename produces a "${refused}" operation, and this command plans only ${this.#policy.allowedOperationClasses.map((c) => `"${c}"`).join(", ")} operations. Leave out this statement, or make the change with a command that allows "${refused}" operations, such as migration plan.`, location, refused));
+		this.#target.apply(call);
+		this.calls.push(call);
+		const first = this.#operationCount;
+		this.#operationCount += operationsOf(call).length;
+		return ok(operationsOf(call).map((_, offset) => first + offset));
+	}
+	#planModel(statement) {
+		const worked = modelRenameStorageEffect(statement, this.#fromContract, this.#contract);
+		if (!worked.ok) return notOk(statementRefused(statement, `Model "${modelDisplayName(worked.failure.model)}" has no table in its contract`, `A model rename renames the model's table, and model "${modelDisplayName(worked.failure.model)}" has none in its contract. Leave out this statement.`, void 0));
+		const effect = worked.value;
+		if (effect.kind === "unchanged") return ok([]);
+		if (effect.kind === "moveNamespace") return notOk(statementRefused(statement, `Moving a model to another namespace is not supported in this release: "${modelDisplayName(statement.from)}" to "${modelDisplayName(statement.to)}"`, `The model's table would move from namespace "${effect.from.namespaceId}" to namespace "${effect.to.namespaceId}". Leave out this statement and move the table yourself in a hand-written migration, or keep the model in namespace "${effect.from.namespaceId}".`, effect.from));
+		const { rename } = effect;
+		const destinationTable = {
+			namespaceId: rename.namespaceId,
+			table: rename.to
+		};
+		const label = `Cannot rename table "${rename.from}" to "${rename.to}"`;
+		const policyRefusal = this.#controlPolicyRefusal(statement, label, destinationTable);
+		if (policyRefusal !== void 0) return notOk(policyRefusal);
+		const checked = checkTableRename(this.#target.tables(), this.#contract, rename);
+		if (!checked.ok) return notOk(tableRenameRefused(statement, label, rename, checked.failure));
+		const planned = this.#emit(statement, label, destinationTable, this.#target.renameTableCall(rename));
+		if (planned.ok) {
+			this.tableRenames.push(rename);
+			this.#renamedTables.set(tableKey({
+				namespaceId: rename.namespaceId,
+				table: rename.from
+			}), rename.to);
+		}
+		return planned;
+	}
+	#planField(statement) {
+		const worked = fieldRenameStorageEffect(statement, this.#fromContract, this.#contract);
+		if (!worked.ok && worked.failure.kind === "noTable") return notOk(statementRefused(statement, `Model "${modelDisplayName(worked.failure.model)}" has no table in its contract`, `A field rename renames the field's column, and model "${modelDisplayName(worked.failure.model)}" has no table in its contract. Leave out this statement.`, void 0));
+		if (!worked.ok) return notOk(statementRefused(statement, `Field "${modelDisplayName(statement.from)}.${statement.from.field}" has a column on one side only of ${describeMigrationStatement(statement, this.#fromContract, this.#contract)}`, "A field rename renames a column or changes nothing in storage, and this field gains or loses its column. Leave out this statement and plan the change without it.", void 0));
+		const effect = worked.value;
+		if (effect.kind === "unchanged") return ok([]);
+		const table = this.#renamedTables.get(tableKey(effect.table)) ?? effect.table.table;
+		const destinationTable = modelTable(this.#contract, statement.to);
+		if (destinationTable !== void 0 && (destinationTable.namespaceId !== effect.table.namespaceId || destinationTable.table !== table)) {
+			const tableRename = {
+				namespaceId: effect.table.namespaceId,
+				from: table,
+				to: destinationTable.table
+			};
+			const model = modelDisplayName(statement.to);
+			const fieldText = `${model}.${statement.from.field}:${model}.${statement.to.field}`;
+			return notOk(statementRefused(statement, `Cannot rename column "${table}"."${effect.from}": the model's table changes from "${table}" to "${destinationTable.table}", and no statement renames the table`, `The column would be renamed on a table the plan then drops and creates under the new name, and a migration that only changes the table name is planned the same way. With migration plan, rename the table by hand in its own migration first. Change the contract so that only the table name changes, and run prisma contract emit. Run prisma migration new --name <name> --from <hash of the migration the database is at>, add ${this.#target.renderTableRename(tableRename)} to the operations of its migration.ts, and run node on that migration.ts to write its ops.json. Then change the contract to its final form, emit it, and plan the field rename with --from that migration. With db update, change the contract so that only the table name changes, and run prisma contract emit. Rename the table in the database yourself with ${this.#target.tableRenameByHand(tableRename).join("; ")}, check that prisma db update --dry-run plans no drop of a table or column, and run prisma db update to store that contract. Then emit the final contract and run prisma db update --rename ${fieldText}.`, {
+				namespaceId: effect.table.namespaceId,
+				table,
+				column: effect.from
+			}));
+		}
+		const rename = {
+			namespaceId: effect.table.namespaceId,
+			table,
+			from: effect.from,
+			to: effect.to
+		};
+		const tableLocation = {
+			namespaceId: rename.namespaceId,
+			table
+		};
+		const label = `Cannot rename column "${table}"."${rename.from}" to "${rename.to}"`;
+		const policyRefusal = this.#controlPolicyRefusal(statement, label, tableLocation);
+		if (policyRefusal !== void 0) return notOk(policyRefusal);
+		const checked = checkColumnRename(this.#target.tables(), this.#contract, rename);
+		if (!checked.ok) return notOk(columnRenameRefused(statement, label, rename, checked.failure));
+		const planned = this.#emit(statement, label, {
+			...tableLocation,
+			column: rename.from
+		}, this.#target.renameColumnCall(rename));
+		if (planned.ok) this.columnRenames.push(rename);
+		return planned;
+	}
+};
+/**
+* Plans the statements in order against a target's working schema: each model rename becomes a
+* table rename and each field rename a column rename, computed against the schema earlier
+* statements left, then applied to it. The first statement that cannot be planned fails the whole
+* plan with a `statementRefused` conflict that carries the statement.
+*/
+function planStatements(input) {
+	const { fromContract } = input;
+	const [first] = input.statements;
+	if (first === void 0) return ok({
+		calls: [],
+		tableRenames: [],
+		columnRenames: [],
+		appliedStatements: []
+	});
+	if (fromContract === null) return notOk(statementRefused(first, "Statements need an origin contract, and this plan has none", "A statement names models and fields of the origin contract, and this plan has none. Plan from a contract that has the old names, or leave out the statement.", void 0));
+	const planner = new StatementPlanner({
+		...input,
+		fromContract
+	});
+	const appliedStatements = [];
+	for (const statement of input.statements) {
+		const operationIndexes = planner.plan(statement);
+		if (!operationIndexes.ok) return operationIndexes;
+		appliedStatements.push({
+			statement,
+			operationIndexes: operationIndexes.value
+		});
+	}
+	return ok({
+		calls: planner.calls,
+		tableRenames: planner.tableRenames,
+		columnRenames: planner.columnRenames,
+		appliedStatements
+	});
+}
 const TABLE_NAME_CASE_CHANGED_CODE = "MIGRATION.TABLE_NAME_CASE_CHANGED";
 function lowerFirst(value) {
 	return value.charAt(0).toLowerCase() + value.slice(1);
@@ -1551,6 +1885,6 @@ function temporalCodecPresetWithPrecision(input) {
 }
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { runnerFailure as _, contractNamespaceToSchemaIR as a, temporalCodecPresetWithPrecision as b, control_default as c, detectTableNameCaseChanges as d, partitionCallsByControlPolicy as f, plannerSuccess as g, plannerFailure as h, assembleAuthoringContributions as i, createMigrationPlan as l, planFieldEventOperations as m, TABLE_NAME_CASE_CHANGED_CODE as n, contractToSchemaIR as o, partitionIssuesByControlPolicy as p, applyTableRename as r, controlPolicyForCall as s, INIT_ADDITIVE_POLICY as t, detectDestructiveChanges as u, runnerSuccess as v, temporalStringAuthoringPresets as x, sqlTypeLookupsOf as y };
+export { runnerSuccess as C, unmatchedColumnRename as D, temporalStringAuthoringPresets as E, unmatchedTableRename as O, runnerFailure as S, temporalCodecPresetWithPrecision as T, planStatements as _, contractNamespaceToSchemaIR as a, resolveColumnRenameAgainst as b, control_default as c, detectTableNameCaseChanges as d, fieldRenameStorageEffect as f, planFieldEventOperations as g, partitionIssuesByControlPolicy as h, assembleAuthoringContributions as i, createMigrationPlan as l, partitionCallsByControlPolicy as m, INIT_ADDITIVE_POLICY as n, contractToSchemaIR as o, modelRenameStorageEffect as p, TABLE_NAME_CASE_CHANGED_CODE as r, controlPolicyForCall as s, COLUMN_RENAME_UNMATCHED_CODE as t, detectDestructiveChanges as u, plannerFailure as v, sqlTypeLookupsOf as w, resolveTableRenameAgainst as x, plannerSuccess as y };
 
-//# sourceMappingURL=control-0kB6FkCn.mjs.map
+//# sourceMappingURL=control-C4VZIU-L.mjs.map