@prisma/orm-target-postgres 8.0.0-rc.16-dev.6 → 8.0.0-rc.16-dev.7

package/dist/postgres-migration-DmczQSHT-DsWlow8L.mjs

@@ -0,0 +1,1075 @@
+import { t as errorPostgresMigrationStackMissing } from "./errors-DYyzTYzE-39CV_aMo.mjs";
+import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
+import { i as PostgresRlsPolicy } from "./postgres-schema-COkaqci7-C6JpiSha.mjs";
+import { n as PostgresSchemaNodeKind, r as PostgresTableSchemaNode } from "./postgres-table-schema-node-BBkitBQh-DT1T5VWU.mjs";
+import { n as PostgresNamespaceSchemaNode, r as PostgresPolicySchemaNode, t as PostgresDatabaseSchemaNode } from "./postgres-role-schema-node-B8Z5i5D--PObwlU2Z.mjs";
+import { n as postgresResolveDefault } from "./default-normalizer-Bf_Fhv4v-CugGfLAe.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-DD69Bwve-e-BpAfFa.mjs";
+import { a as renderDefaultLiteral } from "./planner-ddl-builders-Y0_96xpe-BzugdEDO.mjs";
+import { A as RenameConstraintCall, C as DropNativeEnumTypeCall, D as EnableRowLevelSecurityCall, E as DropTableCall, F as SetNotNullCall, H as renameTableStatement, M as RenamePostgresRlsPolicyCall, N as RenameTableCall, P as SetDefaultCall, S as DropIndexCall, T as DropPostgresRlsPolicyCall, _ as DisableRowLevelSecurityCall, b as DropConstraintCall, c as AddUniqueCall, d as CreateIndexCall, f as CreateNativeEnumTypeCall, h as CreateTableCall, i as AddNativeEnumValueCall, j as RenameIndexCall, k as RenameColumnCall, l as AlterColumnTypeCall, m as CreateSchemaCall, n as AddColumnCall, p as CreatePostgresRlsPolicyCall, r as AddForeignKeyCall, s as AddPrimaryKeyCall, t as AddCheckConstraintCall, v as DropCheckConstraintCall, w as DropNotNullCall, x as DropDefaultCall, y as DropColumnCall, z as installExtension } from "./op-factory-call-BbTtrII--CbCFZfSd.mjs";
+import { n as defaultPrimaryKeyName, r as defaultUniqueName, t as defaultForeignKeyName } from "./default-constraint-names-CtcRXhV8-nz3ff6b8.mjs";
+import { l as resolveNamespaceIdForDdlSchema, r as issueNode } from "./control-policy-DMOu5nnt-DslefUx9.mjs";
+import { n as contractToPostgresDatabaseSchemaNode, t as buildPostgresPlanDiff } from "./diff-database-schema-DgAMDjHF-YATlptWC.mjs";
+import { n as PostgresContractView } from "./postgres-contract-view-CL-YTH_3-Diah6i2a.mjs";
+import { t as dataTransform } from "./data-transform-Bo32KRbq-BLn1_UG-.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { issueOutcome } from "@prisma/orm-framework/components/control";
+import { namingOf, namingOfLiveName, parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
+import { assertDefined } from "@prisma/orm-framework/utils/assertions";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { resolveColumnRenameAgainst, resolveTableRenameAgainst, sqlTypeLookupsOf, unmatchedColumnRename, unmatchedTableRename } from "@prisma/orm-family-sql/family/control";
+import { PrimaryKey, RelationalSchemaNodeKind, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlUniqueIR } from "@prisma/orm-family-sql/schema-ir/types";
+import { isArrayEqual } from "@prisma/orm-framework/utils/array-equal";
+import { errorMigrationOperationOptionRemoved } from "@prisma/orm-framework/errors/migration";
+import { Migration } from "@prisma/orm-family-sql/family/migration";
+import { MigrationContractViews } from "@prisma/orm-toolchain/migration-tools/migration";
+//#region ../../../3-targets/3-targets/postgres/dist/postgres-migration-DmczQSHT.mjs
+function postgresRenderDefault(def, column, type) {
+	if (def.kind === "function") return def.expression;
+	return renderDefaultLiteral(def.value, {
+		many: column.many,
+		...type
+	});
+}
+/**
+* The Postgres schema tree a contract describes, as the planner's "from" side:
+* the target descriptor's `migrations.contractToSchema` hook and the trees
+* `renameTable` compares to find its companion renames both go through here,
+* so they are built with the same type lookups, default renderer and default resolver.
+*/
+function postgresContractToSchema(contract, frameworkComponents) {
+	const types = sqlTypeLookupsOf(frameworkComponents);
+	return contractToPostgresDatabaseSchemaNode(blindCast(contract), {
+		annotationNamespace: "pg",
+		dataTypeLookup: types.dataTypeLookup,
+		codecLookup: types.codecLookup,
+		renderDefault: postgresRenderDefault,
+		resolveDefault: postgresResolveDefault
+	});
+}
+/**
+* Rename post-pass for indexes, per `(schema, table)`, widening-only,
+* deterministic by sorted names — the same structure as the policy pass
+* below (which stays untouched: policies pair by hash only).
+*
+* Hash pairing (prefix-only renames): extras whose live names parse as
+* wire names, grouped by `(schema, table, hash)`; missing nodes iterated
+* in sorted-name order consume the sorted-name-first candidate.
+*
+* Content pairing (exact→wire convergence), after hash pairing has
+* consumed its matches: the remaining wire-named-missing nodes
+* (`prefix` defined) against the remaining extras of any name shape,
+* paired iff content-equal (columns ordered-strict both-defined-or-
+* both-undefined, `unique`/`type` strict, `options` loose, bodies
+* byte-equal).
+*
+* Leftovers proceed as create/drop exactly as before; without the
+* widening allowance the pass is skipped and pairing degrades to the
+* additive half, like the policy pass.
+*/
+function pairIndexRenames(options, issues) {
+	const consumed = /* @__PURE__ */ new Set();
+	const calls = [];
+	if (!options.policy.allowedOperationClasses.includes("widening")) return {
+		calls,
+		consumed
+	};
+	const missing = [];
+	const extra = [];
+	for (const issue of issues) {
+		const node = issueNode(issue);
+		if (node === void 0 || !SqlIndexIR.is(node)) continue;
+		const ddlSchema = issue.path[1];
+		const tableName = issue.path[2];
+		if (ddlSchema === void 0 || tableName === void 0) continue;
+		if (issueOutcome(issue) === "not-found") missing.push({
+			issue,
+			node,
+			ddlSchema,
+			tableName
+		});
+		else if (issueOutcome(issue) === "not-expected") extra.push({
+			issue,
+			node,
+			ddlSchema,
+			tableName
+		});
+	}
+	if (missing.length === 0 || extra.length === 0) return {
+		calls,
+		consumed
+	};
+	const byName = (a, b) => a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0;
+	const emissionSchema = (ddlSchema) => resolveNamespaceIdForDdlSchema(options.contract, ddlSchema) === UNBOUND_NAMESPACE_ID ? UNBOUND_NAMESPACE_ID : ddlSchema;
+	const pairingKey = (finding, hash) => JSON.stringify([
+		finding.ddlSchema,
+		finding.tableName,
+		hash
+	]);
+	const rename = (missingFinding, candidate) => {
+		consumed.add(missingFinding.issue);
+		consumed.add(candidate.issue);
+		calls.push(new RenameIndexCall(emissionSchema(missingFinding.ddlSchema), missingFinding.tableName, candidate.node.name, missingFinding.node.name));
+	};
+	const sortedMissing = [...missing].sort(byName);
+	const extrasByHash = /* @__PURE__ */ new Map();
+	for (const finding of extra) {
+		const parsed = parseWireName(finding.node.name);
+		if (parsed === void 0) continue;
+		const key = pairingKey(finding, parsed.hash);
+		const group = extrasByHash.get(key) ?? [];
+		group.push(finding);
+		extrasByHash.set(key, group);
+	}
+	for (const group of extrasByHash.values()) group.sort(byName);
+	for (const missingFinding of sortedMissing) {
+		const parsed = parseWireName(missingFinding.node.name);
+		if (parsed === void 0) continue;
+		const candidate = extrasByHash.get(pairingKey(missingFinding, parsed.hash))?.shift();
+		if (candidate === void 0) continue;
+		rename(missingFinding, candidate);
+	}
+	const sortedExtras = [...extra].sort(byName);
+	for (const missingFinding of sortedMissing) {
+		if (consumed.has(missingFinding.issue)) continue;
+		if (missingFinding.node.prefix === void 0) continue;
+		const candidate = sortedExtras.find((extraFinding) => !consumed.has(extraFinding.issue) && extraFinding.ddlSchema === missingFinding.ddlSchema && extraFinding.tableName === missingFinding.tableName && missingFinding.node.contentEquals(extraFinding.node, {
+			columnPresence: "matching",
+			bodies: "verbatim"
+		}));
+		if (candidate === void 0) continue;
+		rename(missingFinding, candidate);
+	}
+	return {
+		calls,
+		consumed
+	};
+}
+/**
+* Check-constraint rename post-pass: a `not-found` and a `not-expected`
+* check on the same table whose wire-name content hashes match but whose
+* prefixes differ is a prefix-only rename, and collapses into one
+* `ALTER TABLE … RENAME CONSTRAINT`.
+*
+* This is the index pass's hash-pairing phase and nothing else. There is
+* deliberately no content-pairing phase: a live check body is whatever
+* Postgres reprinted, so it never byte-matches the authored text, and
+* pairing an exact-named live check by content would bless whatever
+* predicate is actually live. Adoption of an old exact-named check stays
+* drop + add.
+*
+* Runs only when the policy allows `widening` (rename's class). Without it
+* the pass no-ops and the pair degrades to an add and a drop, and the drop,
+* which is `widening` too, is refused as a conflict.
+*/
+function pairCheckRenames(options, issues) {
+	const consumed = /* @__PURE__ */ new Set();
+	const calls = [];
+	if (!options.policy.allowedOperationClasses.includes("widening")) return {
+		calls,
+		consumed
+	};
+	const missing = [];
+	const extra = [];
+	for (const issue of issues) {
+		const node = issueNode(issue);
+		if (node === void 0 || !SqlCheckConstraintIR.is(node)) continue;
+		const ddlSchema = issue.path[1];
+		const tableName = issue.path[2];
+		if (ddlSchema === void 0 || tableName === void 0) continue;
+		if (issueOutcome(issue) === "not-found") missing.push({
+			issue,
+			node,
+			ddlSchema,
+			tableName
+		});
+		else if (issueOutcome(issue) === "not-expected") extra.push({
+			issue,
+			node,
+			ddlSchema,
+			tableName
+		});
+	}
+	if (missing.length === 0 || extra.length === 0) return {
+		calls,
+		consumed
+	};
+	const byName = (a, b) => a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0;
+	const emissionSchema = (ddlSchema) => resolveNamespaceIdForDdlSchema(options.contract, ddlSchema) === UNBOUND_NAMESPACE_ID ? UNBOUND_NAMESPACE_ID : ddlSchema;
+	const pairingKey = (finding, hash) => JSON.stringify([
+		finding.ddlSchema,
+		finding.tableName,
+		hash
+	]);
+	const sortedMissing = [...missing].sort(byName);
+	const extrasByHash = /* @__PURE__ */ new Map();
+	for (const finding of extra) {
+		const parsed = parseWireName(finding.node.name);
+		if (parsed === void 0) continue;
+		const key = pairingKey(finding, parsed.hash);
+		const group = extrasByHash.get(key) ?? [];
+		group.push(finding);
+		extrasByHash.set(key, group);
+	}
+	for (const group of extrasByHash.values()) group.sort(byName);
+	for (const missingFinding of sortedMissing) {
+		const parsed = parseWireName(missingFinding.node.name);
+		if (parsed === void 0) continue;
+		const candidate = extrasByHash.get(pairingKey(missingFinding, parsed.hash))?.shift();
+		if (candidate === void 0) continue;
+		consumed.add(missingFinding.issue);
+		consumed.add(candidate.issue);
+		calls.push(new RenameConstraintCall(emissionSchema(missingFinding.ddlSchema), missingFinding.tableName, "checkConstraint", candidate.node.name, missingFinding.node.name));
+	}
+	return {
+		calls,
+		consumed
+	};
+}
+/**
+* The tables of a Postgres schema, addressed by `contract`'s namespace ids, each mapped to its DDL
+* schema.
+*/
+function postgresSchemaTables(schema, contract) {
+	const tableIn = (namespaceId, table) => schema.namespaces[resolveDdlSchemaForNamespaceStorage(contract.storage, namespaceId)]?.tables[table];
+	const hasTable = (namespaceId, table) => tableIn(namespaceId, table) !== void 0;
+	return {
+		hasTable,
+		hasColumn: (namespaceId, table, column) => Object.hasOwn(tableIn(namespaceId, table)?.columns ?? {}, column),
+		tablesNamed: (namespaceId, table) => hasTable(namespaceId, table) ? [table] : [],
+		columnsNamed: (namespaceId, table, column) => Object.hasOwn(tableIn(namespaceId, table)?.columns ?? {}, column) ? [column] : [],
+		namespacesWithTable: (table) => Object.keys(contract.storage.namespaces).filter((namespaceId) => hasTable(namespaceId, table))
+	};
+}
+/**
+* The constraint renames that follow a table rename. Each primary key, unique constraint and
+* foreign key of the renamed table is paired with the destination constraint of the same kind on
+* the same columns, and for a foreign key the same referenced columns. Foreign keys pair first
+* with destination keys to the same referenced table, and the rest then pair with keys to another
+* table, because a later rename in the same plan may change that table and a foreign key's derived
+* name never depends on it. A paired constraint is renamed to the destination's explicit name, or else
+* to the name the planner derives from the new table name, when that differs from its name in the
+* database. Each destination constraint pairs with at most one constraint, in order. An unpaired
+* constraint is being dropped or changed and keeps its name. Indexes and checks are not handled
+* here: their wire names pair by content hash in the index and check rename passes.
+*/
+function constraintRenamesForTableRename(input) {
+	return pairedConstraintRenames(input, {
+		primaryKey: true,
+		onColumns: () => true
+	});
+}
+/**
+* The renames of the constraints in `scope` that pair with a destination constraint of the same
+* kind on the same columns, to the destination's explicit name or else the derived one.
+*/
+function pairedConstraintRenames(input, scope) {
+	const { schemaName, previous, next } = input;
+	const table = next.name;
+	const rename = (kind, actualName, target) => {
+		assertDefined(actualName, `the table "${previous.name}" has a ${kind} that has no name; the working schema names every primary key, unique and foreign key a rename can change`);
+		return target === void 0 || target === actualName ? [] : [new RenameConstraintCall(schemaName, table, kind, actualName, target)];
+	};
+	const nextPrimaryKey = next.primaryKey;
+	const primaryKey = previous.primaryKey === void 0 || !scope.primaryKey ? [] : rename("primaryKey", previous.primaryKey.name, nextPrimaryKey !== void 0 && isArrayEqual(previous.primaryKey.columns, nextPrimaryKey.columns) ? nextPrimaryKey.name ?? defaultPrimaryKeyName(table) : void 0);
+	const pairedUniques = /* @__PURE__ */ new Set();
+	const uniques = previous.uniques.filter((unique) => scope.onColumns(unique.columns)).flatMap((unique) => {
+		const paired = next.uniques.find((candidate) => !pairedUniques.has(candidate) && isArrayEqual(candidate.columns, unique.columns));
+		if (paired !== void 0) pairedUniques.add(paired);
+		return rename("unique", unique.name, paired === void 0 ? void 0 : paired.name ?? defaultUniqueName(table, paired.columns));
+	});
+	const previousForeignKeys = previous.foreignKeys.filter((fk) => scope.onColumns(fk.columns));
+	const pairing = pairForeignKeys(previousForeignKeys, next.foreignKeys);
+	const foreignKeys = previousForeignKeys.flatMap((fk) => {
+		const paired = pairing.get(fk);
+		return rename("foreignKey", fk.name, paired === void 0 ? void 0 : paired.name ?? defaultForeignKeyName(table, fk.columns));
+	});
+	return [
+		...primaryKey,
+		...uniques,
+		...foreignKeys
+	];
+}
+/**
+* Pairs old foreign keys with destination keys on the same columns and referenced columns. Every
+* key to the same referenced table pairs first, so an old key with no such match cannot take the
+* destination key another old key keeps; the remaining keys then pair in order.
+*/
+function pairForeignKeys(previous, next) {
+	const pairs = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	const pass = (accepts) => {
+		for (const fk of previous) {
+			if (pairs.has(fk)) continue;
+			const paired = next.find((candidate) => !taken.has(candidate) && isArrayEqual(candidate.columns, fk.columns) && isArrayEqual(candidate.referencedColumns, fk.referencedColumns) && accepts(fk, candidate));
+			if (paired === void 0) continue;
+			pairs.set(fk, paired);
+			taken.add(paired);
+		}
+	};
+	pass((fk, candidate) => candidate.referencedTable === fk.referencedTable && candidate.resolvedReferencedNamespace === fk.resolvedReferencedNamespace);
+	pass(() => true);
+	return pairs;
+}
+/**
+* The constraint renames that follow a column rename. Each unique constraint and foreign key on
+* the renamed column is paired with the destination constraint of the same kind on the same
+* columns, and renamed to the destination's explicit name, or else to the name the planner derives
+* from the table and the new column names, when that differs from its name in the database. The
+* primary key's derived name does not depend on its columns, so it is left alone. `previous` is
+* the table after the column rename, its constraint names as they are in the database.
+*/
+function constraintRenamesForColumnRename(input) {
+	return pairedConstraintRenames(input, {
+		primaryKey: false,
+		onColumns: (columns) => columns.includes(input.column)
+	});
+}
+function ddlSchemaOf(callSchemaName) {
+	return callSchemaName === UNBOUND_NAMESPACE_ID ? DEFAULT_NAMESPACE_ID : callSchemaName;
+}
+function rewriteRefs(refs, rewrite) {
+	return refs?.map(rewrite);
+}
+/**
+* Rewrites the step of `kind` and `id` in a ref that runs through the given table, and the table
+* step itself when `kind` is the table kind.
+*/
+function stepRewrite(schemaName, tableName, kind, fromId, toId) {
+	return (ref) => {
+		const namespaceStep = ref[1];
+		const tableStep = ref[2];
+		if (namespaceStep?.nodeKind !== PostgresSchemaNodeKind.namespace || namespaceStep.id !== schemaName || tableStep?.nodeKind !== PostgresSchemaNodeKind.table || tableStep.id !== tableName) return ref;
+		return ref.map((step, index) => index >= 2 && step.nodeKind === kind && step.id === fromId ? {
+			nodeKind: kind,
+			id: toId
+		} : step);
+	};
+}
+function withColumnName(column, name) {
+	return new SqlColumnIR({
+		name,
+		nativeType: column.nativeType,
+		nullable: column.nullable,
+		...ifDefined("default", column.default),
+		...ifDefined("annotations", column.annotations),
+		...ifDefined("many", column.many),
+		...ifDefined("resolvedNativeType", column.resolvedNativeType),
+		...ifDefined("resolvedDefault", column.resolvedDefault),
+		...ifDefined("authoredDefault", column.authoredDefault),
+		...ifDefined("codecRef", column.codecRef),
+		...ifDefined("codecBaseNativeType", column.codecBaseNativeType),
+		...ifDefined("dataType", column.dataType),
+		...ifDefined("toCanonicalForm", column.toCanonicalForm)
+	});
+}
+function withPrimaryKey(primaryKey, name, rewrite, columnName) {
+	return new PrimaryKey({
+		columns: primaryKey.columns.map(columnName),
+		...ifDefined("name", name),
+		...ifDefined("dependsOn", rewriteRefs(primaryKey.dependsOn, rewrite))
+	});
+}
+function withUnique(unique, name, rewrite, columnName) {
+	return new SqlUniqueIR({
+		columns: unique.columns.map(columnName),
+		...ifDefined("name", name),
+		...ifDefined("annotations", unique.annotations),
+		...ifDefined("dependsOn", rewriteRefs(unique.dependsOn, rewrite))
+	});
+}
+function withForeignKey(fk, overrides, rewrite, columnName) {
+	return new SqlForeignKeyIR({
+		columns: fk.columns.map(columnName),
+		referencedTable: overrides.referencedTable,
+		referencedColumns: overrides.referencedColumns ?? fk.referencedColumns,
+		...ifDefined("referencedSchema", fk.referencedSchema),
+		...ifDefined("name", overrides.name),
+		...ifDefined("onDelete", fk.onDelete),
+		...ifDefined("onUpdate", fk.onUpdate),
+		...ifDefined("annotations", fk.annotations),
+		...ifDefined("resolvedReferencedNamespace", fk.resolvedReferencedNamespace),
+		...ifDefined("dependsOn", rewriteRefs(fk.dependsOn, rewrite))
+	});
+}
+/**
+* An index whose definition carries SQL text, an expression or a predicate, keeps its columns as
+* they are: a column named inside the text cannot be renamed here, so the diff plans the index.
+*/
+function withIndex(index, naming, rewrite, columnName) {
+	const columnsFollow = index.expression === void 0 && index.where === void 0;
+	const base = {
+		naming,
+		where: index.where,
+		unique: index.unique,
+		partial: index.partial,
+		type: index.type,
+		options: index.options,
+		annotations: index.annotations,
+		dependsOn: rewriteRefs(index.dependsOn, rewrite)
+	};
+	return new SqlIndexIR(index.expression !== void 0 ? {
+		...base,
+		expression: index.expression
+	} : {
+		...base,
+		columns: (index.columns ?? []).map(columnsFollow ? columnName : (c) => c)
+	});
+}
+function withCheck(check, naming, rewrite) {
+	return new SqlCheckConstraintIR({
+		naming,
+		expression: check.expression,
+		dependsOn: rewriteRefs(check.dependsOn, rewrite)
+	});
+}
+function withPolicy(policy, overrides, rewrite) {
+	return new PostgresPolicySchemaNode({
+		naming: overrides.naming,
+		tableName: overrides.tableName,
+		namespaceId: policy.namespaceId,
+		operation: policy.operation,
+		roles: policy.roles,
+		using: policy.using,
+		withCheck: policy.withCheck,
+		permissive: policy.permissive,
+		dependsOn: rewriteRefs(policy.dependsOn, rewrite)
+	});
+}
+function unchangedEdit(table) {
+	return {
+		name: table.name,
+		primaryKeyName: (primaryKey) => primaryKey.name,
+		uniqueName: (unique) => unique.name,
+		foreignKey: (fk) => ({
+			name: fk.name,
+			referencedTable: fk.referencedTable
+		}),
+		columnName: (column) => column,
+		indexNaming: (index) => namingOf(index.name, index.prefix),
+		checkNaming: (check) => namingOf(check.name, check.prefix),
+		policy: (policy) => ({
+			naming: namingOf(policy.name, policy.prefix),
+			tableName: policy.tableName
+		})
+	};
+}
+function rebuildTable(table, edit, rewrite) {
+	const { columnName } = edit;
+	return new PostgresTableSchemaNode({
+		name: edit.name,
+		columns: Object.fromEntries(Object.values(table.columns).map((column) => {
+			const name = columnName(column.name);
+			return [name, name === column.name ? column : withColumnName(column, name)];
+		})),
+		...ifDefined("primaryKey", table.primaryKey === void 0 ? void 0 : withPrimaryKey(table.primaryKey, edit.primaryKeyName(table.primaryKey), rewrite, columnName)),
+		uniques: table.uniques.map((unique) => withUnique(unique, edit.uniqueName(unique), rewrite, columnName)),
+		foreignKeys: table.foreignKeys.map((fk) => withForeignKey(fk, edit.foreignKey(fk), rewrite, columnName)),
+		indexes: table.indexes.map((index) => withIndex(index, edit.indexNaming(index), rewrite, columnName)),
+		...ifDefined("checks", table.checks?.map((check) => withCheck(check, edit.checkNaming(check), rewrite))),
+		...ifDefined("annotations", table.annotations),
+		policies: table.policies.map((policy) => withPolicy(policy, edit.policy(policy), rewrite)),
+		rlsEnabled: table.rlsEnabled
+	});
+}
+/**
+* Rebuilds every table of the schema: `editFor` returns the edit for a table, or `undefined` to
+* only rewrite its dependencies.
+*/
+function mapTables(schema, rewrite, editFor) {
+	return new PostgresDatabaseSchemaNode({
+		namespaces: Object.fromEntries(Object.entries(schema.namespaces).map(([key, namespace]) => [key, new PostgresNamespaceSchemaNode({
+			schemaName: namespace.schemaName,
+			nativeEnums: namespace.nativeEnums,
+			tables: Object.fromEntries(Object.values(namespace.tables).map((table) => {
+				const rebuilt = rebuildTable(table, editFor(namespace.schemaName, table) ?? unchangedEdit(table), rewrite);
+				return [rebuilt.name, rebuilt];
+			}))
+		})])),
+		roles: schema.roles,
+		existingSchemas: schema.existingSchemas,
+		pgVersion: schema.pgVersion
+	});
+}
+/**
+* The schema with one table under its new name. Foreign keys anywhere that reference the table
+* follow it, its policies and every dependency that names it move with it, and row-level security
+* is carried. Constraint, index, check and policy names do not change: a primary key, unique
+* constraint or foreign key whose name was derived from the old table name gets that name spelled
+* out, since it no longer derives from the table it is on.
+*/
+function renameTableInPostgresSchema(schema, rename) {
+	const { schemaName, from, to } = rename;
+	const rewrite = stepRewrite(schemaName, from, PostgresSchemaNodeKind.table, from, to);
+	const referencesRenamed = (ownSchema, fk) => (fk.resolvedReferencedNamespace ?? ownSchema) === schemaName && fk.referencedTable === from;
+	return mapTables(schema, rewrite, (tableSchema, table) => {
+		const unchanged = unchangedEdit(table);
+		const followReference = (fk) => ({
+			name: fk.name,
+			referencedTable: referencesRenamed(tableSchema, fk) ? to : fk.referencedTable
+		});
+		if (tableSchema !== schemaName || table.name !== from) return {
+			...unchanged,
+			foreignKey: followReference
+		};
+		return {
+			...unchanged,
+			name: to,
+			primaryKeyName: (primaryKey) => primaryKey.name ?? defaultPrimaryKeyName(from),
+			uniqueName: (unique) => unique.name ?? defaultUniqueName(from, unique.columns),
+			foreignKey: (fk) => ({
+				...followReference(fk),
+				name: fk.name ?? defaultForeignKeyName(from, fk.columns)
+			}),
+			policy: (policy) => ({
+				...unchanged.policy(policy),
+				tableName: to
+			})
+		};
+	});
+}
+/**
+* The schema with one column under its new name. The table's primary key, unique constraints,
+* foreign keys and plain column indexes name it under the new name, foreign keys anywhere that
+* reference it follow it, and every dependency that names it moves with it. An index with an
+* expression or a predicate, and a check, keep their SQL text. Constraint and index names do not
+* change: a unique constraint or foreign key on the column whose name was derived from the old
+* column name gets that name spelled out.
+*/
+function renameColumnInPostgresSchema(schema, rename) {
+	const { schemaName, table: tableName, from, to } = rename;
+	const rewrite = stepRewrite(schemaName, tableName, RelationalSchemaNodeKind.column, `column:${from}`, `column:${to}`);
+	const renamed = (column) => column === from ? to : column;
+	const referencesTable = (ownSchema, fk) => (fk.resolvedReferencedNamespace ?? ownSchema) === schemaName && fk.referencedTable === tableName;
+	return mapTables(schema, rewrite, (tableSchema, table) => {
+		const unchanged = unchangedEdit(table);
+		const followReference = (fk) => ({
+			name: fk.name,
+			referencedTable: fk.referencedTable,
+			referencedColumns: referencesTable(tableSchema, fk) ? fk.referencedColumns.map(renamed) : fk.referencedColumns
+		});
+		if (tableSchema !== schemaName || table.name !== tableName) return {
+			...unchanged,
+			foreignKey: followReference
+		};
+		return {
+			...unchanged,
+			columnName: renamed,
+			uniqueName: (unique) => unique.name ?? (unique.columns.includes(from) ? defaultUniqueName(tableName, unique.columns) : void 0),
+			foreignKey: (fk) => ({
+				...followReference(fk),
+				name: fk.name ?? (fk.columns.includes(from) ? defaultForeignKeyName(tableName, fk.columns) : void 0)
+			})
+		};
+	});
+}
+function renamedNaming(previous, name) {
+	return previous.prefix === void 0 ? namingOf(name, void 0) : namingOfLiveName(name);
+}
+function renameConstraint(schema, call) {
+	const schemaName = ddlSchemaOf(call.schemaName);
+	const { tableName, oldConstraintName, newConstraintName } = call;
+	const renamed = (name, derived) => (name ?? derived) === oldConstraintName ? newConstraintName : name;
+	return mapTables(schema, stepRewrite(schemaName, tableName, RelationalSchemaNodeKind.check, `check:${oldConstraintName}`, `check:${newConstraintName}`), (tableSchema, table) => {
+		if (tableSchema !== schemaName || table.name !== tableName) return void 0;
+		const unchanged = unchangedEdit(table);
+		switch (call.kind) {
+			case "primaryKey": return {
+				...unchanged,
+				primaryKeyName: (primaryKey) => renamed(primaryKey.name, defaultPrimaryKeyName(tableName))
+			};
+			case "unique": return {
+				...unchanged,
+				uniqueName: (unique) => renamed(unique.name, defaultUniqueName(tableName, unique.columns))
+			};
+			case "foreignKey": return {
+				...unchanged,
+				foreignKey: (fk) => ({
+					referencedTable: fk.referencedTable,
+					name: renamed(fk.name, defaultForeignKeyName(tableName, fk.columns))
+				})
+			};
+			case "checkConstraint": return {
+				...unchanged,
+				checkNaming: (check) => check.name === oldConstraintName ? renamedNaming(check, newConstraintName) : unchanged.checkNaming(check)
+			};
+		}
+	});
+}
+function renameIndex(schema, call) {
+	const schemaName = ddlSchemaOf(call.schemaName);
+	const { tableName, oldIndexName, newIndexName } = call;
+	return mapTables(schema, stepRewrite(schemaName, tableName, RelationalSchemaNodeKind.index, `index:${oldIndexName}`, `index:${newIndexName}`), (tableSchema, table) => {
+		if (tableSchema !== schemaName || table.name !== tableName) return void 0;
+		const unchanged = unchangedEdit(table);
+		return {
+			...unchanged,
+			indexNaming: (index) => index.name === oldIndexName ? renamedNaming(index, newIndexName) : unchanged.indexNaming(index)
+		};
+	});
+}
+function renamePolicy(schema, call) {
+	const schemaName = ddlSchemaOf(call.schemaName);
+	const { tableName, oldPolicyName, newPolicyName } = call;
+	return mapTables(schema, stepRewrite(schemaName, tableName, PostgresSchemaNodeKind.policy, oldPolicyName, newPolicyName), (tableSchema, table) => {
+		if (tableSchema !== schemaName || table.name !== tableName) return void 0;
+		const unchanged = unchangedEdit(table);
+		return {
+			...unchanged,
+			policy: (policy) => policy.name === oldPolicyName ? {
+				naming: renamedNaming(policy, newPolicyName),
+				tableName: policy.tableName
+			} : unchanged.policy(policy)
+		};
+	});
+}
+function applied(schema, call) {
+	if (call instanceof RenameTableCall) {
+		const renamed = renameTableInPostgresSchema(schema, {
+			schemaName: ddlSchemaOf(call.schemaName),
+			from: call.oldTableName,
+			to: call.tableName
+		});
+		return call.companions.reduce(applied, renamed);
+	}
+	if (call instanceof RenameColumnCall) {
+		const renamed = renameColumnInPostgresSchema(schema, {
+			schemaName: ddlSchemaOf(call.schemaName),
+			table: call.tableName,
+			from: call.oldColumnName,
+			to: call.columnName
+		});
+		return call.companions.reduce(applied, renamed);
+	}
+	if (call instanceof RenameConstraintCall) return renameConstraint(schema, call);
+	if (call instanceof RenameIndexCall) return renameIndex(schema, call);
+	return renamePolicy(schema, call);
+}
+/** The working schema of a plan or a migration, starting from `initial`. */
+function createWorkingSchema(initial) {
+	return new WorkingSchemaImpl(initial);
+}
+var WorkingSchemaImpl = class {
+	#current;
+	constructor(initial) {
+		this.#current = initial;
+	}
+	get current() {
+		return this.#current;
+	}
+	apply(call) {
+		this.#current = applied(this.#current, call);
+	}
+};
+const RENAME_POLICY = { allowedOperationClasses: ["widening"] };
+function emissionSchemaForNamespace(contract, namespaceId) {
+	return namespaceId === UNBOUND_NAMESPACE_ID ? UNBOUND_NAMESPACE_ID : resolveDdlSchemaForNamespaceStorage(contract.storage, namespaceId);
+}
+/**
+* The `renameTable` call a user writes in `migration.ts` for `rename`. `schema` names the namespace
+* the facade resolves the table in, and is left out for the unbound namespace or when not given.
+*/
+function renderRenameTableCall(rename) {
+	return new RenameTableCall(rename.namespaceId ?? UNBOUND_NAMESPACE_ID, rename.from, rename.to, []).renderTypeScript();
+}
+/** The SQL a user runs against the database to rename the table by hand. */
+function renameTableByHandStatements(contract, rename) {
+	return [renameTableStatement(emissionSchemaForNamespace(contract, rename.namespaceId), rename.from, rename.to)];
+}
+function tableNode(schema, ddlSchema, tableName) {
+	const table = schema.namespaces[ddlSchema]?.tables[tableName];
+	assertDefined(table, `a resolved rename names table "${tableName}" in schema "${ddlSchema}"`);
+	return table;
+}
+/**
+* The call that renames a table, carrying as companions the renames of the objects on the table
+* whose names derive from the table name: each primary key, unique constraint and foreign key the
+* destination keeps, named as the destination names it, and each wire-named index and check whose
+* prefix changes. `previous` is the schema before the rename; the renamed copy is diffed against
+* the destination built from `contract`.
+*/
+function postgresTableRenameCall(input) {
+	const { contract, rename } = input;
+	const schemaName = emissionSchemaForNamespace(contract, rename.namespaceId);
+	const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, rename.namespaceId);
+	const renamed = renameTableInPostgresSchema(input.previous, {
+		schemaName: ddlSchema,
+		from: rename.from,
+		to: rename.to
+	});
+	const { expected, issues } = buildPostgresPlanDiff({
+		contract,
+		actualSchema: renamed,
+		frameworkComponents: input.frameworkComponents
+	});
+	const onRenamedTable = (call) => call.schemaName === schemaName && call.tableName === rename.to;
+	const pairing = {
+		contract,
+		policy: RENAME_POLICY
+	};
+	return new RenameTableCall(schemaName, rename.from, rename.to, [
+		...constraintRenamesForTableRename({
+			schemaName,
+			previous: tableNode(renamed, ddlSchema, rename.to),
+			next: tableNode(expected, ddlSchema, rename.to)
+		}),
+		...pairIndexRenames(pairing, issues).calls.filter(onRenamedTable),
+		...pairCheckRenames(pairing, issues).calls.filter(onRenamedTable)
+	]);
+}
+/**
+* The call that renames a column, carrying as companions the renames of the objects on its table
+* whose names derive from the column name: each unique constraint and foreign key on the column
+* the destination keeps, named as the destination names it, and each index on the column renamed
+* to the destination's wire name. `previous` is the schema before the rename; the renamed copy is
+* diffed against the destination built from `contract`. A check on the column keeps its name: its
+* expression names the column, so the diff replaces it.
+*/
+function postgresColumnRenameCall(input) {
+	const { contract, rename } = input;
+	const schemaName = emissionSchemaForNamespace(contract, rename.namespaceId);
+	const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, rename.namespaceId);
+	const renamed = renameColumnInPostgresSchema(input.previous, {
+		schemaName: ddlSchema,
+		table: rename.table,
+		from: rename.from,
+		to: rename.to
+	});
+	const { expected, issues } = buildPostgresPlanDiff({
+		contract,
+		actualSchema: renamed,
+		frameworkComponents: input.frameworkComponents
+	});
+	const table = tableNode(renamed, ddlSchema, rename.table);
+	const destination = expected.namespaces[ddlSchema]?.tables[rename.table];
+	const indexesOnColumn = new Set(table.indexes.filter((index) => index.columns?.includes(rename.to)).map((index) => index.name));
+	const indexRenames = pairIndexRenames({
+		contract,
+		policy: RENAME_POLICY
+	}, issues).calls.filter((call) => call.schemaName === schemaName && call.tableName === rename.table && indexesOnColumn.has(call.oldIndexName));
+	return new RenameColumnCall(schemaName, rename.table, rename.from, rename.to, [...destination === void 0 ? [] : constraintRenamesForColumnRename({
+		schemaName,
+		column: rename.to,
+		previous: table,
+		next: destination
+	}), ...indexRenames]);
+}
+/**
+* Target-owned base class for Postgres migrations.
+*
+* Fixes the `SqlMigration` generic to `PostgresPlanTargetDetails` and the
+* abstract `targetId` to the Postgres target-id string literal, so both
+* user-authored migrations and renderer-generated scaffolds (the output of
+* `renderCallsToTypeScript`) can extend `PostgresMigration` directly without
+* redeclaring target-local identity.
+*
+* Mirrors `MongoMigration` in `@internal/family-mongo`: the renderer
+* emits `extends Migration` against a facade re-export of this class
+* from `@internal/postgres/migration`, keeping the authoring surface
+* target-scoped rather than family-scoped.
+*
+* The constructor materializes a single Postgres `SqlControlAdapter` from
+* `stack.adapter.create(stack)` and stores it; the protected `dataTransform`
+* instance method forwards to the free `dataTransform` factory with that
+* stored adapter, so user migrations can write `this.dataTransform(...)`
+* without threading the adapter through every call.
+*
+* Every method requires an explicit `schema`. Postgres migrations name their
+* schema deliberately — there is no default and no `search_path`-relative
+* option. A migration that left the schema unspecified would resolve against
+* whatever `search_path` the connection happened to carry, and that ambiguity
+* is an antipattern in a migration. (The unbound/unspecified namespace concept
+* remains for SQLite, which has no schemas, and for Mongo's connection `db`.)
+*/
+var PostgresMigration = class extends Migration {
+	targetId = "postgres";
+	/**
+	* Materialized Postgres control adapter, created once per migration
+	* instance from the injected stack. `undefined` only when the migration
+	* was instantiated without a stack (test fixtures); `controlAdapterFor`
+	* throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING in that case to surface the misuse.
+	*/
+	controlAdapter;
+	/** The rename calls this read of `operations` has made so far, in order. */
+	#renames = [];
+	#endView = new MigrationContractViews(this, "PostgresMigration", (json) => PostgresContractView.fromJson(json));
+	#startView = new MigrationContractViews(this, "PostgresMigration", (json) => PostgresContractView.fromJson(json));
+	constructor(stack) {
+		super(stack);
+		this.controlAdapter = stack?.adapter ? blindCast(stack.adapter.create(stack)) : void 0;
+	}
+	frameworkComponents() {
+		const stack = this.stack;
+		if (stack === void 0) return [];
+		return [
+			stack.target,
+			...stack.adapter === void 0 ? [] : [stack.adapter],
+			...stack.extensions
+		];
+	}
+	/**
+	* Returns the materialized control adapter, or throws a MIGRATION.POSTGRES_CONTROL_STACK_MISSING naming
+	* `operation` when the migration was constructed without a `ControlStack`.
+	* Single home for the null-check that every DDL/DML method shares.
+	*/
+	controlAdapterFor(operation) {
+		if (!this.controlAdapter) throw errorPostgresMigrationStackMissing(operation);
+		return this.controlAdapter;
+	}
+	/**
+	* The typed, schema-qualified Postgres view over this migration's end-state
+	* contract — `this.endContract.namespace.<schema>.table.<name>`, etc. Throws
+	* if no `endContractJson` was provided.
+	*/
+	get endContract() {
+		return this.#endView.endContract;
+	}
+	/**
+	* The typed Postgres view over this migration's start-state contract, or
+	* `null` for a baseline migration (no `startContractJson`).
+	*/
+	get startContract() {
+		return this.#startView.startContract;
+	}
+	/**
+	* Instance-method wrapper around the free `dataTransform` factory that
+	* supplies the stored control adapter. Authors call this from inside
+	* `get operations()`; the adapter argument is hidden from the call site.
+	*/
+	dataTransform(contract, name, options) {
+		return dataTransform(contract, name, options, this.controlAdapterFor("dataTransform"));
+	}
+	/**
+	* Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+	* the supplied options and lowers it through the stored control adapter.
+	* Throws if no adapter is present (i.e. migration instantiated without a stack).
+	*/
+	createTable(options) {
+		return new CreateTableCall(options.schema, options.table, options.columns, options.constraints).toOp(this.controlAdapterFor("createTable"));
+	}
+	/**
+	* Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
+	* the supplied options and lowers it through the stored control adapter.
+	* Throws if no adapter is present (i.e. migration instantiated without a stack).
+	*/
+	createSchema(options) {
+		return new CreateSchemaCall(options.schema).toOp(this.controlAdapterFor("createSchema"));
+	}
+	/**
+	* Emit a `CREATE TYPE ... AS ENUM (...)` migration operation for a managed
+	* native enum. Builds a typed DDL node and lowers it through the stored
+	* control adapter (members render in declaration order). Throws if no adapter
+	* is present.
+	*/
+	createNativeEnumType(options) {
+		return new CreateNativeEnumTypeCall(options.schema, options.typeName, options.members).toOp(this.controlAdapterFor("createNativeEnumType"));
+	}
+	/**
+	* Emit a `DROP TYPE` migration operation for a managed native enum, lowered
+	* through the stored control adapter. Throws if no adapter is present.
+	*/
+	dropNativeEnumType(options) {
+		return new DropNativeEnumTypeCall(options.schema, options.typeName).toOp(this.controlAdapterFor("dropNativeEnumType"));
+	}
+	/**
+	* Emit an `ALTER TYPE ... ADD VALUE` migration operation appending one
+	* member to a managed native enum, lowered through the stored control
+	* adapter. Throws if no adapter is present. Every appended value is its
+	* own operation — call this once per value to append more than one.
+	*/
+	addNativeEnumValue(options) {
+		return new AddNativeEnumValueCall(options.schema, options.typeName, options.value).toOp(this.controlAdapterFor("addNativeEnumValue"));
+	}
+	addColumn(options) {
+		return new AddColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("addColumn"));
+	}
+	addPrimaryKey(options) {
+		return new AddPrimaryKeyCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapterFor("addPrimaryKey"));
+	}
+	addUnique(options) {
+		return new AddUniqueCall(options.schema, options.table, options.constraint, options.columns).toOp(this.controlAdapterFor("addUnique"));
+	}
+	addForeignKey(options) {
+		return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(this.controlAdapterFor("addForeignKey"));
+	}
+	addCheckConstraint(options) {
+		return new AddCheckConstraintCall(options.schema, options.table, options.constraint, options.expression).toOp(this.controlAdapterFor("addCheckConstraint"));
+	}
+	renameCheckConstraint(options) {
+		return this.renameConstraint({
+			...options,
+			kind: "checkConstraint"
+		});
+	}
+	renameConstraint(options) {
+		const call = new RenameConstraintCall(options.schema ?? UNBOUND_NAMESPACE_ID, options.table, options.kind, options.from, options.to);
+		const adapter = this.controlAdapterFor("renameConstraint");
+		this.#renames.push(call);
+		return call.toOp(adapter);
+	}
+	dropCheckConstraint(options) {
+		return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(this.controlAdapterFor("dropCheckConstraint"));
+	}
+	dropConstraint(options) {
+		return new DropConstraintCall(options.schema, options.table, options.constraint, options.kind ?? "unique").toOp(this.controlAdapterFor("dropConstraint"));
+	}
+	/**
+	* Emit the operations that rename a table: the table rename, then a rename of each primary key,
+	* unique constraint, foreign key, index and check whose name was derived from the old table name.
+	* The old name is resolved against the schema as this migration's earlier rename calls
+	* (`renameTable`, `renameIndex`, `renameConstraint`, `renameRlsPolicy`) leave it, and the new
+	* name against the end contract, so the companions start from names an earlier rename gave.
+	* Spread the result into `operations`:
+	* `...this.renameTable({ table: 'userProfile', to: 'UserProfile' })`. `schema` names the table's
+	* namespace when more than one declares the table. Throws `MIGRATION.TABLE_RENAME_UNMATCHED` when
+	* the table does not exist at that point of the migration or the end contract lacks the new name.
+	*/
+	renameTable(options) {
+		const adapter = this.controlAdapterFor("renameTable");
+		const rename = {
+			namespaceId: options.schema,
+			from: options.table,
+			to: options.to
+		};
+		const startContract = this.startContract;
+		if (startContract === null) throw unmatchedTableRename(rename, "the migration has no start contract");
+		const current = this.schemaAfterRenames(startContract);
+		const endContract = this.endContract;
+		const resolved = resolveTableRenameAgainst(postgresSchemaTables(current, startContract), endContract, rename);
+		if (!resolved.ok) throw resolved.failure;
+		const call = postgresTableRenameCall({
+			previous: current,
+			contract: endContract,
+			rename: resolved.value,
+			frameworkComponents: this.frameworkComponents()
+		});
+		this.#renames.push(call);
+		return call.toOps(adapter).map(async (op) => op);
+	}
+	/**
+	* Emit the operations that rename a column: the column rename, then a rename of each unique
+	* constraint, foreign key and index on the column whose name was derived from the old column
+	* name, to the name the end contract gives it. The column is resolved against the schema as this
+	* migration's earlier rename calls leave it, so a column of a table an earlier `renameTable`
+	* renamed is named on the table's new name. Spread the result into `operations`:
+	* `...this.renameColumn({ table: 'User', column: 'name', to: 'fullName' })`. `schema` names the
+	* table's namespace when more than one declares the table. Throws
+	* `MIGRATION.COLUMN_RENAME_UNMATCHED` when the table or column does not exist at that point of
+	* the migration, the table already has the new column, or the end contract lacks it.
+	*/
+	renameColumn(options) {
+		const adapter = this.controlAdapterFor("renameColumn");
+		const rename = {
+			namespaceId: options.schema,
+			table: options.table,
+			from: options.column,
+			to: options.to
+		};
+		const startContract = this.startContract;
+		if (startContract === null) throw unmatchedColumnRename(rename, "the migration has no start contract");
+		const current = this.schemaAfterRenames(startContract);
+		const endContract = this.endContract;
+		const resolved = resolveColumnRenameAgainst(postgresSchemaTables(current, startContract), endContract, rename);
+		if (!resolved.ok) throw resolved.failure;
+		const call = postgresColumnRenameCall({
+			previous: current,
+			contract: endContract,
+			rename: resolved.value,
+			frameworkComponents: this.frameworkComponents()
+		});
+		this.#renames.push(call);
+		return call.toOps(adapter).map(async (op) => op);
+	}
+	/**
+	* The start contract's schema with this read's rename calls applied in order. It is built only
+	* when a `renameTable` needs it, so a migration that renames no table never reads its start
+	* contract.
+	*/
+	schemaAfterRenames(startContract) {
+		const working = createWorkingSchema(postgresContractToSchema(startContract, this.frameworkComponents()));
+		for (const call of this.#renames) working.apply(call);
+		return working.current;
+	}
+	beginOperationsRead() {
+		this.#renames = [];
+	}
+	dropTable(options) {
+		return new DropTableCall(options.schema, options.table).toOp(this.controlAdapterFor("dropTable"));
+	}
+	dropColumn(options) {
+		return new DropColumnCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("dropColumn"));
+	}
+	alterColumnType(options) {
+		return new AlterColumnTypeCall(options.schema, options.table, options.column, options.options).toOp(this.controlAdapterFor("alterColumnType"));
+	}
+	setNotNull(options) {
+		return new SetNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("setNotNull"));
+	}
+	dropNotNull(options) {
+		return new DropNotNullCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("dropNotNull"));
+	}
+	setDefault(options) {
+		refuseEarlierSetDefaultOptions(options);
+		return new SetDefaultCall(options.schema, options.table, options.column, options.operationClass).toOp(this.controlAdapterFor("setDefault"));
+	}
+	dropDefault(options) {
+		return new DropDefaultCall(options.schema, options.table, options.column).toOp(this.controlAdapterFor("dropDefault"));
+	}
+	createIndex(options) {
+		return new CreateIndexCall(options.schema, options.table, options.index, options.columns !== void 0 ? { columns: options.columns } : { expression: options.expression }, options.extras).toOp(this.controlAdapterFor("createIndex"));
+	}
+	renameIndex(options) {
+		const call = new RenameIndexCall(options.schema, options.table, options.from, options.to);
+		const adapter = this.controlAdapterFor("renameIndex");
+		this.#renames.push(call);
+		return call.toOp(adapter);
+	}
+	dropIndex(options) {
+		return new DropIndexCall(options.schema, options.table, options.index).toOp(this.controlAdapterFor("dropIndex"));
+	}
+	installExtension(options) {
+		return installExtension(options, this.controlAdapterFor("installExtension"));
+	}
+	enableRowLevelSecurity(options) {
+		return new EnableRowLevelSecurityCall(options.schema, options.table).toOp(this.controlAdapterFor("enableRowLevelSecurity"));
+	}
+	disableRowLevelSecurity(options) {
+		return new DisableRowLevelSecurityCall(options.schema, options.table).toOp(this.controlAdapterFor("disableRowLevelSecurity"));
+	}
+	createRlsPolicy(options) {
+		return new CreatePostgresRlsPolicyCall(options.schema, options.table, new PostgresRlsPolicy({
+			...options.policy,
+			using: options.policy.using,
+			withCheck: options.policy.withCheck
+		})).toOp(this.controlAdapterFor("createRlsPolicy"));
+	}
+	dropRlsPolicy(options) {
+		return new DropPostgresRlsPolicyCall(options.schema, options.table, options.policy).toOp(this.controlAdapterFor("dropRlsPolicy"));
+	}
+	renameRlsPolicy(options) {
+		const call = new RenamePostgresRlsPolicyCall(options.schema, options.table, options.from, options.to);
+		const adapter = this.controlAdapterFor("renameRlsPolicy");
+		this.#renames.push(call);
+		return call.toOp(adapter);
+	}
+};
+/**
+* `setDefault` options an earlier version wrote carry the column's name in `column` and its default as SQL text in `defaultSql`.
+*/
+function refuseEarlierSetDefaultOptions(options) {
+	const column = options.column;
+	const columnIsName = typeof column === "string";
+	if (!columnIsName && !Object.hasOwn(options, "defaultSql")) return;
+	throw errorMigrationOperationOptionRemoved({
+		operation: "setDefault",
+		option: "defaultSql",
+		subject: `column ${JSON.stringify(columnIsName ? column : options.column.name)} of table ${JSON.stringify(options.table)}`,
+		rewrite: "Pass the column as `col(name, type, { default, codecRef })`, with its default written as `lit(value)` or `fn(expression)`, in place of its name and `defaultSql`.",
+		upgradeEntry: "migration-ts-column-defaults"
+	});
+}
+//#endregion
+export { postgresColumnRenameCall as a, postgresSchemaTables as c, renderRenameTableCall as d, pairIndexRenames as i, postgresTableRenameCall as l, createWorkingSchema as n, postgresContractToSchema as o, pairCheckRenames as r, postgresRenderDefault as s, PostgresMigration as t, renameTableByHandStatements as u };
+
+//# sourceMappingURL=postgres-migration-DmczQSHT-DsWlow8L.mjs.map