@prisma/orm-family-sql 8.0.0-rc.16-dev.6 → 8.0.0-rc.16-dev.8

package/dist/{control-DxvOSmwF.mjs → control-BRbds4vn.mjs}

@@ -1,9 +1,9 @@
 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-DSxPrd-4.mjs";
@@ -21,8 +21,8 @@ import { assembleDataTypes, canonicalFormOf } from "@prisma/orm-framework/compon
 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 { asNamespaceId, 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, 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
@@ -76,6 +76,38 @@ function assertContractMatchesStack(contract, stack) {
 	const problems = [...dataTypeProblems(contract.storage, stack.codecLookup), ...valueObjectProblems(contract, stack.authoringContributions)];
 	if (problems.length > 0) throw new ContractValidationError(problems.join("; "), "storage");
 }
+function isStorageDetails(details) {
+	if (typeof details !== "object" || details === null) return false;
+	const [objectType, name, schema, table] = [
+		"objectType",
+		"name",
+		"schema",
+		"table"
+	].map((key) => Reflect.get(details, key));
+	return typeof objectType === "string" && typeof name === "string" && (schema === void 0 || typeof schema === "string") && (table === void 0 || typeof table === "string");
+}
+function storageDetailsOf(operation) {
+	const target = Reflect.get(operation, "target");
+	if (typeof target !== "object" || target === null) return void 0;
+	const details = Reflect.get(target, "details");
+	return isStorageDetails(details) ? details : void 0;
+}
+/**
+* The name the database knows an operation's object by, read from the operation's target
+* details: `schema.table.column` for a column, `schema.name` for anything else, without the
+* schema in the unbound namespace. An operation without details is named by its id.
+*/
+function storageNameOfOperation(operation) {
+	const details = storageDetailsOf(operation);
+	if (details === void 0) return operation.id;
+	const schema = details.schema === void 0 || details.schema === UNBOUND_NAMESPACE_ID ? [] : [details.schema];
+	const table = details.objectType === "column" && details.table !== void 0 ? [details.table] : [];
+	return [
+		...schema,
+		...table,
+		details.name
+	].join(".");
+}
 function isDdlStatement(sqlStatement) {
 	const trimmed = sqlStatement.trim().toLowerCase();
 	return trimmed.startsWith("create ") || trimmed.startsWith("alter ") || trimmed.startsWith("drop ");
@@ -535,6 +567,9 @@ function createSqlFamilyInstance(stack) {
 		toOperationPreview(operations) {
 			return sqlOperationsToPreview(operations);
 		},
+		storageNameOf(operation) {
+			return storageNameOfOperation(operation);
+		},
 		toSchemaView(schema) {
 			const root = blindCast(schema);
 			const namespaceEntries = root.namespaces !== void 0 ? Object.entries(root.namespaces).map(([namespaceKey, namespace]) => [namespaceKey, namespace.tables]) : [[void 0, root.tables ?? {}]];
@@ -652,118 +687,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);
@@ -1205,8 +1128,15 @@ function subjectKey(subject) {
 	return `${subject.namespaceId}\u0000${subject.entityKind ?? ""}\u0000${subject.entityName ?? ""}\u0000${subject.rlsPolicy ?? ""}`;
 }
 function planFieldEventOperations(options) {
+	return planFieldEventCalls(options).map(({ call }) => call);
+}
+/** The calls the codec hooks return, each with the field event's column. */
+function planFieldEventCalls(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 +1144,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 +1152,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 +1180,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);
@@ -1257,7 +1195,12 @@ function appendCalls(event, entries, codecHooks, calls, pickCodecId) {
 		if (!hook?.onFieldEvent) continue;
 		const ctx = buildContext(event, entry);
 		const emitted = hook.onFieldEvent(event, ctx);
-		for (const call of emitted) calls.push(call);
+		for (const call of emitted) calls.push({
+			call,
+			namespaceId: entry.namespaceId,
+			tableName: entry.tableName,
+			columnName: entry.fieldName
+		});
 	}
 }
 /**
@@ -1326,6 +1269,560 @@ function unionSorted(a, b) {
 	for (const name of b) set.add(name);
 	return [...set].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
 }
+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);
+}
+/** Whether a model's storage names a table, as a model a SQL contract stores in a table does. */
+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
+	});
+}
+/** What a codec hook's call is about: the column of the field event it was returned for. */
+function fieldEventStorage(field) {
+	return {
+		storageName: [
+			...field.namespaceId === UNBOUND_NAMESPACE_ID ? [] : [field.namespaceId],
+			field.tableName,
+			field.columnName
+		].join("."),
+		table: {
+			namespaceId: field.namespaceId,
+			table: field.tableName,
+			column: field.columnName
+		}
+	};
+}
+/**
+* Names for destructive calls a target cannot map to storage: each call's factory name, with a
+* `#n` ordinal when several calls of the plan share it, so each name picks out one call.
+*/
+function unknownCallNames(calls) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const call of calls) counts.set(call.factoryName, (counts.get(call.factoryName) ?? 0) + 1);
+	const seen = /* @__PURE__ */ new Map();
+	return new Map(calls.map((call) => {
+		const ordinal = (seen.get(call.factoryName) ?? 0) + 1;
+		seen.set(call.factoryName, ordinal);
+		return [call, (counts.get(call.factoryName) ?? 0) > 1 ? `${call.factoryName}#${ordinal}` : call.factoryName];
+	}));
+}
+function originTable(context, namespaceId, table) {
+	for (const statement of context.statements) {
+		if (statement.entity !== "model") continue;
+		const effect = modelRenameStorageEffect(statement, context.fromContract, context.contract);
+		if (!effect.ok || effect.value.kind !== "renameTable") continue;
+		const { rename } = effect.value;
+		if (rename.namespaceId === namespaceId && rename.to === table) return rename.from;
+	}
+	return table;
+}
+function originColumn(context, namespaceId, table, column) {
+	for (const statement of context.statements) {
+		if (statement.entity !== "field") continue;
+		const effect = fieldRenameStorageEffect(statement, context.fromContract, context.contract);
+		if (!effect.ok || effect.value.kind !== "renameColumn") continue;
+		const rename = effect.value;
+		if (rename.table.namespaceId === namespaceId && rename.table.table === table && rename.to === column) return rename.from;
+	}
+	return column;
+}
+/** The models of `contract` that store `table`: a model and its variants share one. */
+function modelsStoring(contract, namespaceId, table) {
+	return Object.entries(contract.domain.namespaces).flatMap(([modelNamespace, namespace]) => Object.entries(namespace.models).flatMap(([model, definition]) => {
+		const { storage } = definition;
+		if (!isSqlModelStorage(storage)) return [];
+		if (storage.namespaceId !== namespaceId || storage.table !== table) return [];
+		return [{
+			coordinate: {
+				namespaceId: asNamespaceId(modelNamespace),
+				model
+			},
+			isRoot: definition.base === void 0,
+			fields: storage.fields
+		}];
+	}));
+}
+function subjectOf(target, context) {
+	const storage = {
+		kind: "storage",
+		name: target.storageName
+	};
+	const { fromContract } = context;
+	if (target.table === void 0 || fromContract === null) return storage;
+	const withOrigin = {
+		...context,
+		fromContract
+	};
+	const { namespaceId } = target.table;
+	const table = originTable(withOrigin, namespaceId, target.table.table);
+	const models = modelsStoring(fromContract, namespaceId, table);
+	if (target.table.column === void 0) {
+		const model = models.find(({ isRoot }) => isRoot) ?? models[0];
+		return model === void 0 ? storage : {
+			kind: "model",
+			...model.coordinate
+		};
+	}
+	const column = originColumn(withOrigin, namespaceId, table, target.table.column);
+	for (const model of [...models].sort((a, b) => Number(b.isRoot) - Number(a.isRoot))) {
+		const field = Object.entries(model.fields).find(([, stored]) => stored.column === column)?.[0];
+		if (field !== void 0) return {
+			kind: "field",
+			...model.coordinate,
+			field
+		};
+	}
+	return storage;
+}
+/**
+* The subject of each operation that loses data and each that widens access, at its position in
+* the plan. A subject is a model or a field of the origin contract when one stores it, found under
+* its origin name when a rename statement renamed its table or column earlier in the plan.
+*/
+function subjectsOfCalls(calls, context) {
+	const dataLoss = [];
+	const accessWidening = [];
+	let operationIndex = 0;
+	for (const call of calls) {
+		for (const target of call.dataLoss) dataLoss.push({
+			operationIndex,
+			subject: subjectOf(target, context)
+		});
+		for (const target of call.accessWidening) accessWidening.push({
+			operationIndex,
+			subject: subjectOf(target, context),
+			widens: target.widens
+		});
+		operationIndex += call.operationCount;
+	}
+	return {
+		dataLoss,
+		accessWidening
+	};
+}
 const readOnlyEmptyObject = Object.freeze({});
 function cloneRecord(value) {
 	if (value === readOnlyEmptyObject) return value;
@@ -1381,15 +1878,20 @@ function createMigrationPlan(options) {
 		...options.meta ? { meta: cloneRecord(options.meta) } : {}
 	});
 }
-function plannerSuccess(plan, warnings) {
+function plannerSuccess(plan, appliedStatements, subjects, warnings) {
 	return Object.freeze({
 		kind: "success",
 		plan,
+		appliedStatements: Object.freeze([...appliedStatements]),
+		dataLoss: Object.freeze([...subjects.dataLoss]),
+		accessWidening: Object.freeze([...subjects.accessWidening]),
 		...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 +1904,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) } : {}
 		})))
 	});
@@ -1551,6 +2055,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 { temporalStringAuthoringPresets as A, resolveTableRenameAgainst as C, storageNameOfOperation as D, sqlTypeLookupsOf as E, unmatchedColumnRename as M, unmatchedTableRename as N, subjectsOfCalls as O, resolveColumnRenameAgainst as S, runnerSuccess as T, planFieldEventCalls as _, contractNamespaceToSchemaIR as a, plannerFailure as b, control_default as c, detectTableNameCaseChanges as d, fieldEventStorage as f, partitionIssuesByControlPolicy as g, partitionCallsByControlPolicy as h, assembleAuthoringContributions as i, unknownCallNames as j, temporalCodecPresetWithPrecision as k, createMigrationPlan as l, modelRenameStorageEffect as m, INIT_ADDITIVE_POLICY as n, contractToSchemaIR as o, fieldRenameStorageEffect as p, TABLE_NAME_CASE_CHANGED_CODE as r, controlPolicyForCall as s, COLUMN_RENAME_UNMATCHED_CODE as t, detectDestructiveChanges as u, planFieldEventOperations as v, runnerFailure as w, plannerSuccess as x, planStatements as y };
 
-//# sourceMappingURL=control-DxvOSmwF.mjs.map
+//# sourceMappingURL=control-BRbds4vn.mjs.map