@prisma-next/target-postgres 0.12.0-dev.62 → 0.12.0-dev.63

package/dist/op-factory-call-q9Tpw6wc.mjs

@@ -0,0 +1,1217 @@
+import { i as quoteIdentifier, n as escapeLiteral, r as qualifyName } from "./sql-utils-DcfMz4MQ.mjs";
+import { n as createTable, t as createSchema } from "./ddl-77SyXgFt.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, d as toRegclassLiteral, n as columnDefaultExistsCheck, o as columnTypeCheck, r as columnExistsCheck, s as constraintExistsCheck } from "./planner-sql-checks-DAdhnI2c.mjs";
+import { FunctionColumnDefault, LiteralColumnDefault } from "@prisma-next/sql-relational-core/ast";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { blindCast } from "@prisma-next/utils/casts";
+import { errorUnfilledPlaceholder } from "@prisma-next/errors/migration";
+import { TsExpression, jsonToTsSource } from "@prisma-next/ts-render";
+import { REFERENTIAL_ACTION_SQL } from "@prisma-next/sql-contract/referential-action-sql";
+//#region src/core/migrations/operations/shared.ts
+function step(description, sql) {
+	return {
+		description,
+		sql
+	};
+}
+function targetDetails(objectType, name, schema, table) {
+	return {
+		id: "postgres",
+		details: {
+			schema,
+			objectType,
+			name,
+			...ifDefined("table", table)
+		}
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/columns.ts
+function addColumn(schemaName, tableName, column) {
+	const addSql = [
+		`ALTER TABLE ${qualifyTableName(schemaName, tableName)}`,
+		`ADD COLUMN ${quoteIdentifier(column.name)} ${column.typeSql}`,
+		column.defaultSql,
+		column.nullable ? "" : "NOT NULL"
+	].filter(Boolean).join(" ");
+	return {
+		id: `column.${tableName}.${column.name}`,
+		label: `Add column "${column.name}" to "${tableName}"`,
+		operationClass: "additive",
+		target: targetDetails("column", column.name, schemaName, tableName),
+		precheck: [step(`ensure column "${column.name}" is missing`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: column.name,
+			exists: false
+		}))],
+		execute: [step(`add column "${column.name}"`, addSql)],
+		postcheck: [step(`verify column "${column.name}" exists`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: column.name
+		}))]
+	};
+}
+function dropColumn(schemaName, tableName, columnName) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `dropColumn.${tableName}.${columnName}`,
+		label: `Drop column "${columnName}" from "${tableName}"`,
+		operationClass: "destructive",
+		target: targetDetails("column", columnName, schemaName, tableName),
+		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName
+		}))],
+		execute: [step(`drop column "${columnName}"`, `ALTER TABLE ${qualified} DROP COLUMN ${quoteIdentifier(columnName)}`)],
+		postcheck: [step(`verify column "${columnName}" does not exist`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName,
+			exists: false
+		}))]
+	};
+}
+/**
+* `qualifiedTargetType` is the new column type as it appears in the
+* `ALTER COLUMN TYPE` clause (schema-qualified for user-defined types, raw
+* native name for built-ins). `formatTypeExpected` is the unqualified
+* `format_type` form used in the postcheck. `rawTargetTypeForLabel` is the
+* string appearing in the human-readable label (typically `toType` when
+* explicit, else the column's native type).
+*/
+function alterColumnType(schemaName, tableName, columnName, options) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	const usingClause = options.using ? ` USING ${options.using}` : ` USING ${quoteIdentifier(columnName)}::${options.qualifiedTargetType}`;
+	return {
+		id: `alterType.${tableName}.${columnName}`,
+		label: `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`,
+		operationClass: "destructive",
+		target: targetDetails("column", columnName, schemaName, tableName),
+		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName
+		}))],
+		execute: [step(`alter type of "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} TYPE ${options.qualifiedTargetType}${usingClause}`)],
+		postcheck: [step(`verify column "${columnName}" has type "${options.formatTypeExpected}"`, columnTypeCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName,
+			expectedType: options.formatTypeExpected
+		}))],
+		meta: { warning: "TABLE_REWRITE" }
+	};
+}
+function setNotNull(schemaName, tableName, columnName) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `alterNullability.setNotNull.${tableName}.${columnName}`,
+		label: `Set NOT NULL on "${tableName}"."${columnName}"`,
+		operationClass: "destructive",
+		target: targetDetails("column", columnName, schemaName, tableName),
+		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName
+		})), step(`ensure no NULL values in "${columnName}"`, `SELECT NOT EXISTS (SELECT 1 FROM ${qualified} WHERE ${quoteIdentifier(columnName)} IS NULL)`)],
+		execute: [step(`set NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET NOT NULL`)],
+		postcheck: [step(`verify column "${columnName}" is NOT NULL`, columnNullabilityCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName,
+			nullable: false
+		}))]
+	};
+}
+function dropNotNull(schemaName, tableName, columnName) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `alterNullability.dropNotNull.${tableName}.${columnName}`,
+		label: `Drop NOT NULL on "${tableName}"."${columnName}"`,
+		operationClass: "widening",
+		target: targetDetails("column", columnName, schemaName, tableName),
+		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName
+		}))],
+		execute: [step(`drop NOT NULL on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP NOT NULL`)],
+		postcheck: [step(`verify column "${columnName}" is nullable`, columnNullabilityCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName,
+			nullable: true
+		}))]
+	};
+}
+/**
+* `defaultSql` is the full `DEFAULT …` clause as produced by
+* `buildColumnDefaultSql` — e.g. `"DEFAULT 42"`,
+* `"DEFAULT (CURRENT_TIMESTAMP)"`, or `"DEFAULT nextval('seq'::regclass)"`.
+*
+* `operationClass` defaults to `'additive'` (setting a default on a column
+* that currently has none). The reconciliation planner passes `'widening'`
+* when the column already has a different default — policy enforcement
+* treats that as a widening change rather than an additive one.
+*/
+function setDefault(schemaName, tableName, columnName, defaultSql, operationClass = "additive") {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `setDefault.${tableName}.${columnName}`,
+		label: `Set default on "${tableName}"."${columnName}"`,
+		operationClass,
+		target: targetDetails("column", columnName, schemaName, tableName),
+		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName
+		}))],
+		execute: [step(`set default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} SET ${defaultSql}`)],
+		postcheck: [step(`verify column "${columnName}" has a default`, columnDefaultExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName,
+			exists: true
+		}))]
+	};
+}
+function dropDefault(schemaName, tableName, columnName) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `dropDefault.${tableName}.${columnName}`,
+		label: `Drop default on "${tableName}"."${columnName}"`,
+		operationClass: "destructive",
+		target: targetDetails("column", columnName, schemaName, tableName),
+		precheck: [step(`ensure column "${columnName}" exists`, columnExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName
+		}))],
+		execute: [step(`drop default on "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`)],
+		postcheck: [step(`verify column "${columnName}" has no default`, columnDefaultExistsCheck({
+			schema: schemaName,
+			table: tableName,
+			column: columnName,
+			exists: false
+		}))]
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/constraints.ts
+function renderForeignKeySql(schemaName, tableName, fk) {
+	let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(fk.name)}
+FOREIGN KEY (${fk.columns.map(quoteIdentifier).join(", ")})
+REFERENCES ${qualifyTableName(fk.references.schema, fk.references.table)} (${fk.references.columns.map(quoteIdentifier).join(", ")})`;
+	if (fk.onDelete !== void 0) {
+		const action = REFERENTIAL_ACTION_SQL[fk.onDelete];
+		if (!action) throw new Error(`Unknown referential action for onDelete: ${String(fk.onDelete)}`);
+		sql += `\nON DELETE ${action}`;
+	}
+	if (fk.onUpdate !== void 0) {
+		const action = REFERENTIAL_ACTION_SQL[fk.onUpdate];
+		if (!action) throw new Error(`Unknown referential action for onUpdate: ${String(fk.onUpdate)}`);
+		sql += `\nON UPDATE ${action}`;
+	}
+	return sql;
+}
+function addPrimaryKey(schemaName, tableName, constraintName, columns) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	const columnList = columns.map(quoteIdentifier).join(", ");
+	return {
+		id: `primaryKey.${tableName}.${constraintName}`,
+		label: `Add primary key on "${tableName}"`,
+		operationClass: "additive",
+		target: targetDetails("primaryKey", constraintName, schemaName, tableName),
+		precheck: [step(`ensure primary key "${constraintName}" does not exist`, constraintExistsCheck({
+			constraintName,
+			schema: schemaName,
+			table: tableName,
+			exists: false
+		}))],
+		execute: [step(`add primary key "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} PRIMARY KEY (${columnList})`)],
+		postcheck: [step(`verify primary key "${constraintName}" exists`, constraintExistsCheck({
+			constraintName,
+			schema: schemaName,
+			table: tableName
+		}))]
+	};
+}
+function addUnique(schemaName, tableName, constraintName, columns) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	const columnList = columns.map(quoteIdentifier).join(", ");
+	return {
+		id: `unique.${tableName}.${constraintName}`,
+		label: `Add unique constraint on "${tableName}" (${columns.join(", ")})`,
+		operationClass: "additive",
+		target: targetDetails("unique", constraintName, schemaName, tableName),
+		precheck: [step(`ensure constraint "${constraintName}" does not exist`, constraintExistsCheck({
+			constraintName,
+			schema: schemaName,
+			table: tableName,
+			exists: false
+		}))],
+		execute: [step(`add unique constraint "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} UNIQUE (${columnList})`)],
+		postcheck: [step(`verify constraint "${constraintName}" exists`, constraintExistsCheck({
+			constraintName,
+			schema: schemaName,
+			table: tableName
+		}))]
+	};
+}
+function addForeignKey(schemaName, tableName, fk) {
+	return {
+		id: `foreignKey.${tableName}.${fk.name}`,
+		label: `Add foreign key "${fk.name}" on "${tableName}"`,
+		operationClass: "additive",
+		target: targetDetails("foreignKey", fk.name, schemaName, tableName),
+		precheck: [step(`ensure FK "${fk.name}" does not exist`, constraintExistsCheck({
+			constraintName: fk.name,
+			schema: schemaName,
+			table: tableName,
+			exists: false
+		}))],
+		execute: [step(`add FK "${fk.name}"`, renderForeignKeySql(schemaName, tableName, fk))],
+		postcheck: [step(`verify FK "${fk.name}" exists`, constraintExistsCheck({
+			constraintName: fk.name,
+			schema: schemaName,
+			table: tableName
+		}))]
+	};
+}
+/**
+* `kind` feeds the operation's `target.details.objectType`. Descriptor-flow
+* does not carry kind information in its drop-constraint descriptor, so the
+* default is `'unique'`. The reconciliation planner passes the correct kind
+* (`'foreignKey'`, `'primaryKey'`, or `'unique'`) based on the `SchemaIssue`
+* that produced the drop.
+*/
+function dropConstraint(schemaName, tableName, constraintName, kind = "unique") {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `dropConstraint.${tableName}.${constraintName}`,
+		label: `Drop constraint "${constraintName}" on "${tableName}"`,
+		operationClass: "destructive",
+		target: targetDetails(kind, constraintName, schemaName, tableName),
+		precheck: [step(`ensure constraint "${constraintName}" exists`, constraintExistsCheck({
+			constraintName,
+			schema: schemaName,
+			table: tableName
+		}))],
+		execute: [step(`drop constraint "${constraintName}"`, `ALTER TABLE ${qualified} DROP CONSTRAINT ${quoteIdentifier(constraintName)}`)],
+		postcheck: [step(`verify constraint "${constraintName}" does not exist`, constraintExistsCheck({
+			constraintName,
+			schema: schemaName,
+			table: tableName,
+			exists: false
+		}))]
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/dependencies.ts
+function createExtension(extensionName) {
+	return {
+		id: `extension.${extensionName}`,
+		label: `Create extension "${extensionName}"`,
+		operationClass: "additive",
+		target: { id: "postgres" },
+		precheck: [],
+		execute: [step(`Create extension "${extensionName}"`, `CREATE EXTENSION IF NOT EXISTS ${quoteIdentifier(extensionName)}`)],
+		postcheck: []
+	};
+}
+/**
+* Install a Postgres extension as the baseline op for an extension-pack
+* contract space. Layered on top of {@link createExtension}: stamps an
+* `invariantId` (required so the per-space marker records the install),
+* scopes the op `id` under a caller-chosen namespace (e.g. `pgvector.`),
+* and emits pre- and postcheck SQL probing `pg_extension`. The richer
+* shape lets the runner's idempotency probe skip the install on re-run
+* (postcheck-pre-satisfied) without firing the precheck.
+*
+* Use this for hand-rolled baseline migrations in contract-space
+* extension packages (e.g. `extension-pgvector`, `extension-paradedb`);
+* use the bare {@link createExtension} for planner-emitted ops where the
+* caller already controls idempotency through the surrounding plan.
+*/
+function installExtension(options) {
+	const { extensionName, invariantId, id } = options;
+	return {
+		id,
+		label: options.label ?? `Enable extension "${extensionName}"`,
+		operationClass: "additive",
+		invariantId,
+		target: {
+			id: "postgres",
+			details: {
+				schema: "public",
+				objectType: "dependency",
+				name: extensionName
+			}
+		},
+		precheck: [step(`verify extension "${extensionName}" is not already enabled`, `SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`)],
+		execute: [step(`create extension "${extensionName}"`, `CREATE EXTENSION IF NOT EXISTS ${extensionName}`)],
+		postcheck: [step(`confirm extension "${extensionName}" is enabled`, `SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = '${extensionName}')`)]
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/enums.ts
+function enumTypeExistsCheck(schemaName, nativeType, exists = true) {
+	return `SELECT ${exists ? "EXISTS" : "NOT EXISTS"} (
+  SELECT 1
+  FROM pg_type t
+  JOIN pg_namespace n ON t.typnamespace = n.oid
+  WHERE n.nspname = '${escapeLiteral(schemaName)}'
+    AND t.typname = '${escapeLiteral(nativeType)}'
+)`;
+}
+function createEnumType(schemaName, typeName, values, nativeType = typeName) {
+	const qualifiedType = qualifyName(schemaName, nativeType);
+	const literalValues = values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
+	return {
+		id: `type.${typeName}`,
+		label: `Create enum type "${typeName}"`,
+		operationClass: "additive",
+		target: targetDetails("type", typeName, schemaName),
+		precheck: [step(`ensure type "${nativeType}" does not exist`, enumTypeExistsCheck(schemaName, nativeType, false))],
+		execute: [step(`create enum type "${typeName}"`, `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`)],
+		postcheck: [step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))]
+	};
+}
+/**
+* `typeName` is the contract-facing type name (used for id/label).
+* `nativeType` is the Postgres type name to mutate (may differ for external types).
+*/
+function addEnumValues(schemaName, typeName, nativeType, values) {
+	const qualifiedType = qualifyName(schemaName, nativeType);
+	return {
+		id: `type.${typeName}.addValues`,
+		label: `Add values to enum type "${typeName}": ${values.join(", ")}`,
+		operationClass: "additive",
+		target: targetDetails("type", typeName, schemaName),
+		precheck: [step(`ensure type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))],
+		execute: values.map((value) => step(`add value '${value}' to enum "${nativeType}"`, `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`)),
+		postcheck: [step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType))]
+	};
+}
+function dropEnumType(schemaName, typeName) {
+	const qualified = qualifyName(schemaName, typeName);
+	return {
+		id: `type.${typeName}.drop`,
+		label: `Drop enum type "${typeName}"`,
+		operationClass: "destructive",
+		target: targetDetails("type", typeName, schemaName),
+		precheck: [step(`ensure type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName))],
+		execute: [step(`drop enum type "${typeName}"`, `DROP TYPE ${qualified}`)],
+		postcheck: [step(`verify type "${typeName}" removed`, enumTypeExistsCheck(schemaName, typeName, false))]
+	};
+}
+function renameType(schemaName, fromName, toName) {
+	const qualifiedFrom = qualifyName(schemaName, fromName);
+	return {
+		id: `type.${fromName}.rename`,
+		label: `Rename type "${fromName}" to "${toName}"`,
+		operationClass: "destructive",
+		target: targetDetails("type", fromName, schemaName),
+		precheck: [step(`ensure type "${fromName}" exists`, enumTypeExistsCheck(schemaName, fromName)), step(`ensure type "${toName}" does not already exist`, enumTypeExistsCheck(schemaName, toName, false))],
+		execute: [step(`rename type "${fromName}" to "${toName}"`, `ALTER TYPE ${qualifiedFrom} RENAME TO ${quoteIdentifier(toName)}`)],
+		postcheck: [step(`verify type "${toName}" exists`, enumTypeExistsCheck(schemaName, toName))]
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/indexes.ts
+function renderIndexOptionValue(key, value) {
+	if (typeof value === "string") return `'${escapeLiteral(value)}'`;
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value === "boolean") return value ? "true" : "false";
+	throw new Error(`Index option "${key}" must be a string, finite number, or boolean; got ${typeof value}`);
+}
+function renderIndexOptions(options) {
+	return Object.entries(options).map(([key, value]) => `${quoteIdentifier(key)} = ${renderIndexOptionValue(key, value)}`).join(", ");
+}
+function createIndex(schemaName, tableName, indexName, columns, extras) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	const columnList = columns.map(quoteIdentifier).join(", ");
+	const using = extras?.type ? ` USING ${quoteIdentifier(extras.type)}` : "";
+	const options = extras?.options;
+	const withClause = options && Object.keys(options).length > 0 ? ` WITH (${renderIndexOptions(options)})` : "";
+	return {
+		id: `index.${tableName}.${indexName}`,
+		label: `Create index "${indexName}" on "${tableName}"`,
+		operationClass: "additive",
+		target: targetDetails("index", indexName, schemaName, tableName),
+		precheck: [step(`ensure index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)],
+		execute: [step(`create index "${indexName}"`, `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualified}${using} (${columnList})${withClause}`)],
+		postcheck: [step(`verify index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)]
+	};
+}
+function dropIndex(schemaName, tableName, indexName) {
+	return {
+		id: `dropIndex.${tableName}.${indexName}`,
+		label: `Drop index "${indexName}"`,
+		operationClass: "destructive",
+		target: targetDetails("index", indexName, schemaName, tableName),
+		precheck: [step(`ensure index "${indexName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`)],
+		execute: [step(`drop index "${indexName}"`, `DROP INDEX ${qualifyTableName(schemaName, indexName)}`)],
+		postcheck: [step(`verify index "${indexName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`)]
+	};
+}
+//#endregion
+//#region src/core/migrations/operations/tables.ts
+function dropTable(schemaName, tableName) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `dropTable.${tableName}`,
+		label: `Drop table "${tableName}"`,
+		operationClass: "destructive",
+		target: targetDetails("table", tableName, schemaName),
+		precheck: [step(`ensure table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)],
+		execute: [step(`drop table "${tableName}"`, `DROP TABLE ${qualified}`)],
+		postcheck: [step(`verify table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)]
+	};
+}
+//#endregion
+//#region src/core/migrations/op-factory-call.ts
+/**
+* Postgres migration IR: one concrete `*Call` class per pure factory under
+* `operations/`, plus a shared `PostgresOpFactoryCallNode` abstract base.
+*
+* Every call class carries the literal arguments its backing factory would
+* receive, computes a human-readable `label` in its constructor, and
+* implements two polymorphic hooks:
+*
+* - `toOp()` — converts the IR node to a runtime
+*   `SqlMigrationPlanOperation` by delegating to the matching pure factory
+*   under `operations/`. `DataTransformCall.toOp()` always throws
+*   `PN-MIG-2001` because a planner-generated data transform is an
+*   unfilled authoring stub by construction.
+* - `renderTypeScript()` / `importRequirements()` — inherited from
+*   `TsExpression`. Used by `renderCallsToTypeScript` to emit the call as
+*   a TypeScript expression inside the scaffolded `migration.ts`.
+*
+* The abstract base and all concrete classes are package-private. External
+* consumers see only the framework-level `OpFactoryCall` interface and the
+* `PostgresOpFactoryCall` union.
+*/
+const TARGET_MIGRATION_MODULE = "@prisma-next/postgres/migration";
+const RELATIONAL_CORE_CONTRACT_FREE = "@prisma-next/sql-relational-core/contract-free";
+var PostgresOpFactoryCallNode = class extends TsExpression {
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: this.factoryName
+		}];
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+};
+function postgresDefaultToDdlColumnDefault(columnDefault) {
+	if (!columnDefault) return void 0;
+	switch (columnDefault.kind) {
+		case "literal": return new LiteralColumnDefault(columnDefault.value);
+		case "function":
+			if (columnDefault.expression === "autoincrement()") return void 0;
+			return new FunctionColumnDefault(columnDefault.expression);
+		case "sequence": return new FunctionColumnDefault(`nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`);
+		default: throw new Error(`postgresDefaultToDdlColumnDefault: unhandled kind "${blindCast(columnDefault).kind}"`);
+	}
+}
+function renderDdlColumnDefault(def) {
+	if (!def) return "";
+	if (def.kind === "literal") return `lit(${jsonToTsSource(def.value)})`;
+	return `fn(${jsonToTsSource(def.expression)})`;
+}
+function renderDdlColumnAsTsCall(col) {
+	const opts = [];
+	if (col.notNull) opts.push("notNull: true");
+	if (col.primaryKey) opts.push("primaryKey: true");
+	if (col.default) opts.push(`default: ${renderDdlColumnDefault(col.default)}`);
+	const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
+	return `col(${jsonToTsSource(col.name)}, ${jsonToTsSource(col.type)}${optsStr})`;
+}
+function renderDdlConstraintAsTsCall(constraint) {
+	switch (constraint.kind) {
+		case "primary-key": {
+			const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : "";
+			return `primaryKey(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+		}
+		case "foreign-key": {
+			const opts = [];
+			if (constraint.name) opts.push(`name: ${jsonToTsSource(constraint.name)}`);
+			if (constraint.onDelete) opts.push(`onDelete: ${jsonToTsSource(constraint.onDelete)}`);
+			if (constraint.onUpdate) opts.push(`onUpdate: ${jsonToTsSource(constraint.onUpdate)}`);
+			const optsStr = opts.length > 0 ? `, { ${opts.join(", ")} }` : "";
+			return `foreignKey(${jsonToTsSource(constraint.columns)}, ${jsonToTsSource(constraint.refTable)}, ${jsonToTsSource(constraint.refColumns)}${optsStr})`;
+		}
+		case "unique": {
+			const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : "";
+			return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+		}
+	}
+}
+function needsColOrConstraintImport(columns) {
+	return columns.length > 0;
+}
+function constraintImportSymbols(constraints) {
+	if (!constraints || constraints.length === 0) return [];
+	const symbols = /* @__PURE__ */ new Set();
+	for (const c of constraints) if (c.kind === "primary-key") symbols.add("primaryKey");
+	else if (c.kind === "foreign-key") symbols.add("foreignKey");
+	else if (c.kind === "unique") symbols.add("unique");
+	return [...symbols];
+}
+function defaultImportSymbols(columns) {
+	const symbols = /* @__PURE__ */ new Set();
+	for (const col of columns) if (col.default?.kind === "literal") symbols.add("lit");
+	else if (col.default?.kind === "function") symbols.add("fn");
+	return [...symbols];
+}
+var CreateTableCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createTable";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	columns;
+	constraints;
+	label;
+	constructor(schemaName, tableName, columns, constraints) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columns = Object.freeze([...columns]);
+		this.constraints = constraints ? Object.freeze([...constraints]) : void 0;
+		this.label = `Create table "${tableName}"`;
+		this.freeze();
+	}
+	toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`CreateTableCall.toOp: a DDL lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		const ddlNode = createTable({
+			...this.schemaName !== UNBOUND_NAMESPACE_ID ? { schema: this.schemaName } : {},
+			table: this.tableName,
+			columns: this.columns,
+			...this.constraints ? { constraints: this.constraints } : {}
+		});
+		const { sql } = lowerer.lower(ddlNode, { contract: {} });
+		const schemaName = this.schemaName;
+		const tableName = this.tableName;
+		return {
+			id: `table.${tableName}`,
+			label: `Create table "${tableName}"`,
+			summary: `Creates table "${tableName}"`,
+			operationClass: "additive",
+			target: targetDetails("table", tableName, schemaName),
+			precheck: [step(`ensure table "${tableName}" does not exist`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`)],
+			execute: [step(`create table "${tableName}"`, sql)],
+			postcheck: [step(`verify table "${tableName}" exists`, `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`)]
+		};
+	}
+	renderTypeScript() {
+		const columnsList = this.columns.map(renderDdlColumnAsTsCall).join(", ");
+		const constraintsList = this.constraints ? this.constraints.map(renderDdlConstraintAsTsCall).join(", ") : void 0;
+		const opts = [];
+		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`columns: [${columnsList}]`);
+		if (constraintsList) opts.push(`constraints: [${constraintsList}]`);
+		return `this.createTable({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		const req = [];
+		if (needsColOrConstraintImport(this.columns)) {
+			req.push({
+				moduleSpecifier: RELATIONAL_CORE_CONTRACT_FREE,
+				symbol: "col"
+			});
+			for (const sym of defaultImportSymbols(this.columns)) req.push({
+				moduleSpecifier: RELATIONAL_CORE_CONTRACT_FREE,
+				symbol: sym
+			});
+		}
+		for (const sym of constraintImportSymbols(this.constraints)) req.push({
+			moduleSpecifier: RELATIONAL_CORE_CONTRACT_FREE,
+			symbol: sym
+		});
+		return req;
+	}
+};
+var DropTableCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropTable";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	label;
+	constructor(schemaName, tableName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.label = `Drop table "${tableName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return dropTable(this.schemaName, this.tableName);
+	}
+	renderTypeScript() {
+		return `dropTable(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)})`;
+	}
+};
+var AddColumnCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addColumn";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	column;
+	label;
+	constructor(schemaName, tableName, column) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.column = column;
+		this.label = `Add column "${column.name}" to "${tableName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return addColumn(this.schemaName, this.tableName, this.column);
+	}
+	renderTypeScript() {
+		return `addColumn(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.column)})`;
+	}
+};
+var DropColumnCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropColumn";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop column "${columnName}" from "${tableName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return dropColumn(this.schemaName, this.tableName, this.columnName);
+	}
+	renderTypeScript() {
+		return `dropColumn(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+	}
+};
+var AlterColumnTypeCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "alterColumnType";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	options;
+	label;
+	constructor(schemaName, tableName, columnName, options) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.options = options;
+		this.label = `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`;
+		this.freeze();
+	}
+	toOp() {
+		return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options);
+	}
+	renderTypeScript() {
+		return `alterColumnType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)}, ${jsonToTsSource(this.options)})`;
+	}
+};
+var SetNotNullCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "setNotNull";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Set NOT NULL on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return setNotNull(this.schemaName, this.tableName, this.columnName);
+	}
+	renderTypeScript() {
+		return `setNotNull(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+	}
+};
+var DropNotNullCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropNotNull";
+	operationClass = "widening";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop NOT NULL on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return dropNotNull(this.schemaName, this.tableName, this.columnName);
+	}
+	renderTypeScript() {
+		return `dropNotNull(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+	}
+};
+var SetDefaultCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "setDefault";
+	operationClass;
+	schemaName;
+	tableName;
+	columnName;
+	defaultSql;
+	label;
+	constructor(schemaName, tableName, columnName, defaultSql, operationClass = "additive") {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.defaultSql = defaultSql;
+		this.operationClass = operationClass;
+		this.label = `Set default on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return setDefault(this.schemaName, this.tableName, this.columnName, this.defaultSql, this.operationClass);
+	}
+	renderTypeScript() {
+		const args = [
+			jsonToTsSource(this.schemaName),
+			jsonToTsSource(this.tableName),
+			jsonToTsSource(this.columnName),
+			jsonToTsSource(this.defaultSql)
+		];
+		if (this.operationClass !== "additive") args.push(jsonToTsSource(this.operationClass));
+		return `setDefault(${args.join(", ")})`;
+	}
+};
+var DropDefaultCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropDefault";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	columnName;
+	label;
+	constructor(schemaName, tableName, columnName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.label = `Drop default on "${tableName}"."${columnName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return dropDefault(this.schemaName, this.tableName, this.columnName);
+	}
+	renderTypeScript() {
+		return `dropDefault(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.columnName)})`;
+	}
+};
+var AddPrimaryKeyCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addPrimaryKey";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	constraintName;
+	columns;
+	label;
+	constructor(schemaName, tableName, constraintName, columns) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.columns = columns;
+		this.label = `Add primary key on "${tableName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return addPrimaryKey(this.schemaName, this.tableName, this.constraintName, this.columns);
+	}
+	renderTypeScript() {
+		return `addPrimaryKey(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.columns)})`;
+	}
+};
+var AddUniqueCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addUnique";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	constraintName;
+	columns;
+	label;
+	constructor(schemaName, tableName, constraintName, columns) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.columns = columns;
+		this.label = `Add unique constraint on "${tableName}" (${columns.join(", ")})`;
+		this.freeze();
+	}
+	toOp() {
+		return addUnique(this.schemaName, this.tableName, this.constraintName, this.columns);
+	}
+	renderTypeScript() {
+		return `addUnique(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.columns)})`;
+	}
+};
+var AddForeignKeyCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addForeignKey";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	fk;
+	label;
+	constructor(schemaName, tableName, fk) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.fk = fk;
+		this.label = `Add foreign key "${fk.name}" on "${tableName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return addForeignKey(this.schemaName, this.tableName, this.fk);
+	}
+	renderTypeScript() {
+		return `addForeignKey(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.fk)})`;
+	}
+};
+var DropConstraintCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropConstraint";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	constraintName;
+	kind;
+	label;
+	constructor(schemaName, tableName, constraintName, kind = "unique") {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.constraintName = constraintName;
+		this.kind = kind;
+		this.label = `Drop constraint "${constraintName}" on "${tableName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return dropConstraint(this.schemaName, this.tableName, this.constraintName, this.kind);
+	}
+	renderTypeScript() {
+		const args = [
+			jsonToTsSource(this.schemaName),
+			jsonToTsSource(this.tableName),
+			jsonToTsSource(this.constraintName)
+		];
+		if (this.kind !== "unique") args.push(jsonToTsSource(this.kind));
+		return `dropConstraint(${args.join(", ")})`;
+	}
+};
+var CreateIndexCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createIndex";
+	operationClass = "additive";
+	schemaName;
+	tableName;
+	indexName;
+	columns;
+	indexType;
+	options;
+	label;
+	constructor(schemaName, tableName, indexName, columns, extras) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.columns = columns;
+		this.indexType = extras?.type;
+		this.options = extras?.options;
+		this.label = `Create index "${indexName}" on "${tableName}"`;
+		this.freeze();
+	}
+	toOp() {
+		const extras = {};
+		if (this.indexType !== void 0) extras.type = this.indexType;
+		if (this.options !== void 0) extras.options = this.options;
+		return createIndex(this.schemaName, this.tableName, this.indexName, this.columns, extras);
+	}
+	renderTypeScript() {
+		const args = [
+			jsonToTsSource(this.schemaName),
+			jsonToTsSource(this.tableName),
+			jsonToTsSource(this.indexName),
+			jsonToTsSource(this.columns)
+		];
+		if (this.indexType !== void 0 || this.options !== void 0) {
+			const extrasParts = [];
+			if (this.indexType !== void 0) extrasParts.push(`type: ${jsonToTsSource(this.indexType)}`);
+			if (this.options !== void 0) extrasParts.push(`options: ${jsonToTsSource(this.options)}`);
+			args.push(`{ ${extrasParts.join(", ")} }`);
+		}
+		return `createIndex(${args.join(", ")})`;
+	}
+};
+var DropIndexCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropIndex";
+	operationClass = "destructive";
+	schemaName;
+	tableName;
+	indexName;
+	label;
+	constructor(schemaName, tableName, indexName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.indexName = indexName;
+		this.label = `Drop index "${indexName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return dropIndex(this.schemaName, this.tableName, this.indexName);
+	}
+	renderTypeScript() {
+		return `dropIndex(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.indexName)})`;
+	}
+};
+var CreateEnumTypeCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createEnumType";
+	operationClass = "additive";
+	schemaName;
+	typeName;
+	nativeType;
+	values;
+	label;
+	constructor(schemaName, typeName, values, nativeType = typeName) {
+		super();
+		this.schemaName = schemaName;
+		this.typeName = typeName;
+		this.nativeType = nativeType;
+		this.values = values;
+		this.label = `Create enum type "${typeName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return createEnumType(this.schemaName, this.typeName, this.values, this.nativeType);
+	}
+	renderTypeScript() {
+		const nativeArg = this.nativeType === this.typeName ? "" : `, ${jsonToTsSource(this.nativeType)}`;
+		return `createEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.values)}${nativeArg})`;
+	}
+};
+var AddEnumValuesCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addEnumValues";
+	operationClass = "additive";
+	schemaName;
+	typeName;
+	nativeType;
+	values;
+	label;
+	constructor(schemaName, typeName, nativeType, values) {
+		super();
+		this.schemaName = schemaName;
+		this.typeName = typeName;
+		this.nativeType = nativeType;
+		this.values = values;
+		this.label = `Add values to enum type "${typeName}": ${values.join(", ")}`;
+		this.freeze();
+	}
+	toOp() {
+		return addEnumValues(this.schemaName, this.typeName, this.nativeType, this.values);
+	}
+	renderTypeScript() {
+		return `addEnumValues(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.nativeType)}, ${jsonToTsSource(this.values)})`;
+	}
+};
+var DropEnumTypeCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dropEnumType";
+	operationClass = "destructive";
+	schemaName;
+	typeName;
+	label;
+	constructor(schemaName, typeName) {
+		super();
+		this.schemaName = schemaName;
+		this.typeName = typeName;
+		this.label = `Drop enum type "${typeName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return dropEnumType(this.schemaName, this.typeName);
+	}
+	renderTypeScript() {
+		return `dropEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)})`;
+	}
+};
+var RenameTypeCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "renameType";
+	operationClass = "destructive";
+	schemaName;
+	fromName;
+	toName;
+	label;
+	constructor(schemaName, fromName, toName) {
+		super();
+		this.schemaName = schemaName;
+		this.fromName = fromName;
+		this.toName = toName;
+		this.label = `Rename type "${fromName}" to "${toName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return renameType(this.schemaName, this.fromName, this.toName);
+	}
+	renderTypeScript() {
+		return `renameType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.fromName)}, ${jsonToTsSource(this.toName)})`;
+	}
+};
+/**
+* Laundered pre-built operation.
+*
+* Wraps an already-materialized `SqlMigrationPlanOperation` — typically one
+* produced by a SQL-family method or a codec control hook — so the planner
+* can carry it alongside IR nodes without reverse-engineering it into a
+* structured call class. Doubles as the user-facing escape hatch for raw
+* migrations: authors can pass a full op shape to `rawSql({...})`.
+*
+* `toOp()` returns the stored op unchanged. `renderTypeScript()` emits
+* `rawSql({...})` with the op serialized as a JSON literal — round-tripping
+* requires every field on the op to be JSON-serializable (no closures).
+*/
+var RawSqlCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "rawSql";
+	operationClass;
+	label;
+	op;
+	constructor(op) {
+		super();
+		this.op = op;
+		this.label = op.label;
+		this.operationClass = op.operationClass;
+		this.freeze();
+	}
+	toOp() {
+		return this.op;
+	}
+	renderTypeScript() {
+		return `rawSql(${jsonToTsSource(this.op)})`;
+	}
+};
+var CreateExtensionCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createExtension";
+	operationClass = "additive";
+	extensionName;
+	label;
+	constructor(extensionName) {
+		super();
+		this.extensionName = extensionName;
+		this.label = `Create extension "${extensionName}"`;
+		this.freeze();
+	}
+	toOp() {
+		return createExtension(this.extensionName);
+	}
+	renderTypeScript() {
+		return `createExtension(${jsonToTsSource(this.extensionName)})`;
+	}
+};
+var CreateSchemaCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "createSchema";
+	operationClass = "additive";
+	schemaName;
+	label;
+	constructor(schemaName) {
+		super();
+		this.schemaName = schemaName;
+		this.label = `Create schema "${schemaName}"`;
+		this.freeze();
+	}
+	toOp(lowerer) {
+		if (lowerer === void 0) throw new Error(`CreateSchemaCall.toOp: a DDL lowerer is required on the Postgres planner path (schema "${this.schemaName}"). Pass the control adapter to createPostgresMigrationPlanner.`);
+		const ddlNode = createSchema({
+			schema: this.schemaName,
+			ifNotExists: true
+		});
+		const { sql } = lowerer.lower(ddlNode, { contract: {} });
+		const schemaName = this.schemaName;
+		return {
+			id: `schema.${schemaName}`,
+			label: `Create schema "${schemaName}"`,
+			operationClass: "additive",
+			target: { id: "postgres" },
+			precheck: [],
+			execute: [step(`Create schema "${schemaName}"`, sql)],
+			postcheck: []
+		};
+	}
+	renderTypeScript() {
+		return `this.createSchema({ schema: ${jsonToTsSource(this.schemaName)} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
+/**
+* A planner-generated data-transform stub. `checkSlot` and `runSlot` name
+* the unfilled authoring slots that the rendered `migration.ts` will expose
+* to the user via `placeholder("…")` calls. `toOp()` always throws
+* `PN-MIG-2001`: the planner cannot lower a stubbed transform to a runtime
+* op — the user must fill the rendered `migration.ts` and re-emit.
+*/
+var DataTransformCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "dataTransform";
+	operationClass;
+	label;
+	checkSlot;
+	runSlot;
+	constructor(label, checkSlot, runSlot, operationClass = "data") {
+		super();
+		this.label = label;
+		this.checkSlot = checkSlot;
+		this.runSlot = runSlot;
+		this.operationClass = operationClass;
+		this.freeze();
+	}
+	toOp() {
+		throw errorUnfilledPlaceholder(this.label);
+	}
+	renderTypeScript() {
+		return [
+			`this.dataTransform(endContract, ${jsonToTsSource(this.label)}, {`,
+			`  check: () => placeholder(${jsonToTsSource(this.checkSlot)}),`,
+			`  run: () => placeholder(${jsonToTsSource(this.runSlot)}),`,
+			"})"
+		].join("\n");
+	}
+	importRequirements() {
+		return [{
+			moduleSpecifier: TARGET_MIGRATION_MODULE,
+			symbol: "placeholder"
+		}, {
+			moduleSpecifier: "./end-contract.json",
+			symbol: "endContract",
+			kind: "default",
+			attributes: { type: "json" }
+		}];
+	}
+};
+//#endregion
+export { dropEnumType as A, dropColumn as B, SetNotNullCall as C, dropIndex as D, createIndex as E, addPrimaryKey as F, dropNotNull as H, addUnique as I, dropConstraint as L, createExtension as M, installExtension as N, addEnumValues as O, addForeignKey as P, addColumn as R, SetDefaultCall as S, dropTable as T, setDefault as U, dropDefault as V, setNotNull as W, DropIndexCall as _, AddUniqueCall as a, RawSqlCall as b, CreateExtensionCall as c, CreateTableCall as d, DataTransformCall as f, DropEnumTypeCall as g, DropDefaultCall as h, AddPrimaryKeyCall as i, renameType as j, createEnumType as k, CreateIndexCall as l, DropConstraintCall as m, AddEnumValuesCall as n, AlterColumnTypeCall as o, DropColumnCall as p, AddForeignKeyCall as r, CreateEnumTypeCall as s, AddColumnCall as t, CreateSchemaCall as u, DropNotNullCall as v, postgresDefaultToDdlColumnDefault as w, RenameTypeCall as x, DropTableCall as y, alterColumnType as z };
+
+//# sourceMappingURL=op-factory-call-q9Tpw6wc.mjs.map