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

package/dist/postgres-migration-CeX6vfEU-DsmCRCnD.mjs

@@ -1,596 +0,0 @@
-import { t as errorPostgresMigrationStackMissing } from "./errors-DYyzTYzE-39CV_aMo.mjs";
-import { i as PostgresRlsPolicy, n as PostgresRlsEnablement } from "./postgres-schema-AlEVkXXS-ZfXWYddl.mjs";
-import { 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-BthOWVjF-DuZ9iUh-.mjs";
-import { a as renderDefaultLiteral } from "./planner-ddl-builders-Y0_96xpe-BzugdEDO.mjs";
-import { A as RenameIndexCall, C as DropNativeEnumTypeCall, D as EnableRowLevelSecurityCall, E as DropTableCall, M as RenameTableCall, N as SetDefaultCall, P as SetNotNullCall, R as installExtension, 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 RenamePostgresRlsPolicyCall, k as RenameConstraintCall, 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 } from "./op-factory-call-BAgAln5R-BTkhp29z.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-B7t5CB1S-CotIwNO4.mjs";
-import { n as contractToPostgresDatabaseSchemaNode, t as buildPostgresPlanDiff } from "./diff-database-schema-KGNaKzKp-Bt2yYSIt.mjs";
-import { n as PostgresContractView } from "./postgres-contract-view-C1bi3x4v-BAfk6euQ.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, parseWireName } from "@prisma/orm-family-sql/schema-ir/naming";
-import { assertDefined } from "@prisma/orm-framework/utils/assertions";
-import { applyTableRename, sqlTypeLookupsOf } from "@prisma/orm-family-sql/family/control";
-import { SqlCheckConstraintIR, SqlIndexIR } from "@prisma/orm-family-sql/schema-ir/types";
-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-CeX6vfEU.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
-	});
-}
-/** The constraint of `nextNodes` the diff pairs with `node` and finds unchanged. */
-function unchangedIn(node, nextNodes) {
-	return nextNodes.find((next) => next.id === node.id && next.isEqualTo(node));
-}
-/**
-* The renames of the primary key, unique constraints and foreign keys of one table that the end tree keeps otherwise unchanged but names differently. A constraint's name is its stated name, or the one the planner derives from its table; a start tree read from the database states every name. A constraint whose start and end names differ is renamed to the end name. The diff never compares constraint names, so without these the database keeps the old name. A database may already have the new name, as when Prisma 7 created it and the contract only now states it; the rename's postcheck then holds before it runs, and the runner skips it.
-*/
-function constraintNameRenames(input) {
-	const { schemaName, from, to, previous, next } = input;
-	const rename = (kind, oldName, unchanged, derivedName) => {
-		if (unchanged === void 0) return [];
-		const newName = unchanged.name ?? derivedName;
-		return oldName === newName ? [] : [new RenameConstraintCall(schemaName, to, kind, oldName, newName)];
-	};
-	const primaryKey = previous.primaryKey === void 0 ? [] : rename("primaryKey", previous.primaryKey.name ?? defaultPrimaryKeyName(from), unchangedIn(previous.primaryKey, next.primaryKey === void 0 ? [] : [next.primaryKey]), defaultPrimaryKeyName(to));
-	const uniques = previous.uniques.flatMap((unique) => rename("unique", unique.name ?? defaultUniqueName(from, unique.columns), unchangedIn(unique, next.uniques), defaultUniqueName(to, unique.columns)));
-	const foreignKeys = previous.foreignKeys.flatMap((fk) => rename("foreignKey", fk.name ?? defaultForeignKeyName(from, fk.columns), unchangedIn(fk, next.foreignKeys), defaultForeignKeyName(to, fk.columns)));
-	return [
-		...primaryKey,
-		...uniques,
-		...foreignKeys
-	];
-}
-/**
-* The constraint renames of a plan: {@link constraintNameRenames} for every table the start tree the planner was given and the end contract both have. The start tree comes from the start contract for `migration plan` and from the database for `db update`, so a database Prisma 8 created under derived names is renamed too once the contract states other names.
-*/
-function plannedConstraintNameRenames(options) {
-	if (!options.policy.allowedOperationClasses.includes("widening")) return [];
-	PostgresDatabaseSchemaNode.assert(options.schema);
-	const startTablesBySchema = new Map(Object.values(options.schema.namespaces).map((namespace) => [namespace.schemaName, namespace.tables]));
-	const contract = options.contract;
-	const end = postgresContractToSchema(contract, options.frameworkComponents);
-	return Object.values(end.namespaces).flatMap((namespace) => {
-		const startTables = startTablesBySchema.get(namespace.schemaName) ?? {};
-		const schemaName = resolveNamespaceIdForDdlSchema(contract, namespace.schemaName) === UNBOUND_NAMESPACE_ID ? UNBOUND_NAMESPACE_ID : namespace.schemaName;
-		return Object.entries(namespace.tables).flatMap(([tableName, next]) => {
-			const previous = startTables[tableName];
-			return previous === void 0 ? [] : constraintNameRenames({
-				schemaName,
-				from: tableName,
-				to: tableName,
-				previous,
-				next
-			});
-		});
-	});
-}
-/**
-* 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 the slice-1 behavior: an add,
-* plus a drop when `destructive` is allowed too.
-*/
-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
-	};
-}
-function renamedMarker(marker, rename) {
-	if (!(marker instanceof PostgresRlsEnablement) || marker.tableName !== rename.from) return marker;
-	return new PostgresRlsEnablement({
-		tableName: rename.to,
-		namespaceId: marker.namespaceId
-	});
-}
-function renamedPolicy(policy, rename) {
-	if (!(policy instanceof PostgresRlsPolicy) || policy.tableName !== rename.from) return policy;
-	return new PostgresRlsPolicy({
-		naming: namingOf(policy.name, policy.prefix),
-		tableName: rename.to,
-		namespaceId: policy.namespaceId,
-		operation: policy.operation,
-		roles: policy.roles,
-		using: policy.using,
-		withCheck: policy.withCheck,
-		permissive: policy.permissive
-	});
-}
-/**
-* Moves the RLS marker and the policies of a renamed table onto its new name. The marker is keyed by table name; policies are keyed by their own name and only their `tableName` changes. Policy names do not derive from the table name, so none is renamed.
-*/
-function renameRlsReferences(entries, rename) {
-	const markers = entries["rls"];
-	const policies = entries["policy"];
-	return {
-		...entries,
-		...markers === void 0 ? {} : { rls: Object.fromEntries(Object.entries(markers).map(([tableName, marker]) => [tableName === rename.from ? rename.to : tableName, renamedMarker(marker, rename)])) },
-		...policies === void 0 ? {} : { policy: Object.fromEntries(Object.entries(policies).map(([name, policy]) => [name, renamedPolicy(policy, rename)])) }
-	};
-}
-const RENAME_POLICY = { allowedOperationClasses: ["widening"] };
-function emissionSchemaForNamespace(contract, namespaceId) {
-	return namespaceId === UNBOUND_NAMESPACE_ID ? UNBOUND_NAMESPACE_ID : resolveDdlSchemaForNamespaceStorage(contract.storage, namespaceId);
-}
-function renamedTableNode(schema, contract, rename) {
-	const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, rename.namespaceId);
-	const table = Object.values(schema.namespaces).find((namespace) => namespace.schemaName === ddlSchema)?.tables[rename.to];
-	assertDefined(table, `a resolved rename names table "${rename.to}" in schema "${ddlSchema}"`);
-	return table;
-}
-/**
-* The calls a migration's `renameTable` emits: the table rename, then a rename of each primary key, unique constraint and foreign key the start contract left unnamed, and of each wire-named index and check whose prefix derives from the table name. Only objects the end contract leaves otherwise unchanged are renamed; a constraint takes the end contract's stated name, or the name derived from the new table name. Throws `MIGRATION.TABLE_RENAME_UNMATCHED` when the start contract lacks the table or the end contract lacks the new name.
-*/
-function postgresTableRenameCalls(input) {
-	const applied = applyTableRename({
-		startContract: input.startContract,
-		endContract: input.endContract,
-		rename: input.rename,
-		renameTableReferences: renameRlsReferences
-	});
-	if (!applied.ok) throw applied.failure;
-	const { rename } = applied.value;
-	const contract = input.endContract;
-	const schemaName = emissionSchemaForNamespace(contract, rename.namespaceId);
-	const previousSchema = postgresContractToSchema(applied.value.contract, input.frameworkComponents);
-	const nextSchema = postgresContractToSchema(contract, input.frameworkComponents);
-	const { issues } = buildPostgresPlanDiff({
-		contract,
-		actualSchema: previousSchema,
-		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),
-		...constraintNameRenames({
-			schemaName,
-			from: rename.from,
-			to: rename.to,
-			previous: renamedTableNode(previousSchema, contract, rename),
-			next: renamedTableNode(nextSchema, contract, rename)
-		}),
-		...pairIndexRenames(pairing, issues).calls.filter(onRenamedTable),
-		...pairCheckRenames(pairing, issues).calls.filter(onRenamedTable)
-	];
-}
-/**
-* 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;
-	#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) {
-		return new RenameConstraintCall(options.schema ?? UNBOUND_NAMESPACE_ID, options.table, options.kind, options.from, options.to).toOp(this.controlAdapterFor("renameConstraint"));
-	}
-	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, read from this migration's start and end contracts. 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 start contract lacks the table or the end contract lacks the new name.
-	*/
-	renameTable(options) {
-		const adapter = this.controlAdapterFor("renameTable");
-		return postgresTableRenameCalls({
-			startContract: this.startContract,
-			endContract: this.endContract,
-			rename: {
-				namespaceId: options.schema,
-				from: options.table,
-				to: options.to
-			},
-			frameworkComponents: this.frameworkComponents()
-		}).map(async (call) => call.toOp(adapter));
-	}
-	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) {
-		return new RenameIndexCall(options.schema, options.table, options.from, options.to).toOp(this.controlAdapterFor("renameIndex"));
-	}
-	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) {
-		return new RenamePostgresRlsPolicyCall(options.schema, options.table, options.from, options.to).toOp(this.controlAdapterFor("renameRlsPolicy"));
-	}
-};
-/**
-* `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 { plannedConstraintNameRenames as a, pairIndexRenames as i, emissionSchemaForNamespace as n, postgresContractToSchema as o, pairCheckRenames as r, postgresRenderDefault as s, PostgresMigration as t };
-
-//# sourceMappingURL=postgres-migration-CeX6vfEU-DsmCRCnD.mjs.map