@prisma/orm-target-postgres 8.0.0-rc.17-dev.37 → 8.0.0-rc.17-dev.38

package/dist/{op-factory-call-DiwaNQVO-NSekrcmI.mjs → op-factory-call-ltgiEZ8g-CX6WX57X.mjs}

@@ -1,22 +1,23 @@
 import { s as postgresError } from "./errors-DYyzTYzE-39CV_aMo.mjs";
-import { a as quoteQualifiedName, o as validateEnumValueLength, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-CVsvXiX4-C7xD0Bgv.mjs";
+import { i as quoteIdentifier, n as escapeLiteral, o as quoteQualifiedName, s as validateEnumValueLength, t as POSTGRES_QUOTING } from "./sql-utils-Df-nf6eM-Ov1KgjWm.mjs";
 import { t as DEFAULT_NAMESPACE_ID } from "./namespace-ids-xtp_ZY86-Cpp8PTxD.mjs";
-import { A as tableIsEmptyAst, C as nativeEnumTypeExistsAst, D as rlsPolicyExistsAst, E as rlsEnabledAst, O as sequenceNameAvailableAst, S as indexExistsAst, T as noNullValuesAst, _ as dropDefaultAction, a as columnDefaultAst, b as dropType, c as columnNullabilityAst, d as createIndex$1, f as createPolicy, g as disableRowLevelSecurity$1, h as createType, i as alterTable, k as tableExistsAst, l as columnTypeAst, m as createTable, n as alterIndexRename, o as columnDefaultSequenceAst, p as createSchema, r as alterPolicyRename, s as columnExistsAst, t as addColumnAction, u as constraintExistsAst, v as dropIndex$1, w as nativeEnumValueExistsAst, x as extensionExistsAst, y as dropPolicy } from "./ddl-CFWv3VOT-Ad-I5p22.mjs";
-import { n as buildColumnTypeSql, t as autoincrementWidth } from "./planner-ddl-builders-Y0_96xpe-BzugdEDO.mjs";
+import { A as tableIsEmptyAst, C as nativeEnumTypeExistsAst, D as rlsPolicyExistsAst, E as rlsEnabledAst, O as sequenceNameAvailableAst, S as indexExistsAst, T as noNullValuesAst, _ as dropDefaultAction, a as columnDefaultAst, b as dropType, c as columnNullabilityAst, d as createIndex$1, f as createPolicy, g as disableRowLevelSecurity$1, h as createType, i as alterTable, k as tableExistsAst, l as columnTypeAst, m as createTable, n as alterIndexRename, o as columnDefaultSequenceAst, p as createSchema, r as alterPolicyRename, s as columnExistsAst, t as addColumnAction, u as constraintExistsAst, v as dropIndex$1, w as nativeEnumValueExistsAst, x as extensionExistsAst, y as dropPolicy } from "./ddl-BKqbtVN3-CPHiYaCY.mjs";
+import { t as autoincrementWidth } from "./autoincrement-widths-DbyXRo5B-BUVCYb_V.mjs";
 import { t as postgresObjectName } from "./postgres-object-name-FPikIvOw-BNs44hTu.mjs";
-import { n as qualifyTableName } from "./planner-sql-checks-Bt_KuSiH-CdGZDp7M.mjs";
+import { r as qualifyTableName, t as alterTypeCheckText } from "./planner-sql-checks-CX37qDix-Gkq38UQQ.mjs";
+import { t as buildTargetDetails } from "./planner-target-details-CUEF0s90-COTks5yz.mjs";
 import { DdlColumn, FunctionColumnDefault, LiteralColumnDefault, opaqueSql, renderOpaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
 import { namingOf } from "@prisma/orm-family-sql/schema-ir/naming";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { col } from "@prisma/orm-family-sql/relational-core/contract-free";
-import { createSqlTextSources } from "@prisma/orm-family-sql/family/control";
+import { checkSqlDefaultText, checkSqlExpressionText, convertedColumnMeta, createSqlTextSources, isUnfilledSlot, requiredColumnMeta, slotSource, sqlOfSlot } from "@prisma/orm-family-sql/family/control";
 import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
 import { unfilledPlaceholderOperation } from "@prisma/orm-framework/errors/migration";
 import { TsExpression, jsonToTsSource, tsObjectSource } from "@prisma/orm-framework/ts-render";
 import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
-//#region ../../../3-targets/3-targets/postgres/dist/op-factory-call-DiwaNQVO.mjs
+//#region ../../../3-targets/3-targets/postgres/dist/op-factory-call-ltgiEZ8g.mjs
 /**
 * Maps a planner schema name to the contract-free DDL builder's optional
 * `schema` field: the unbound sentinel becomes `undefined` (the builder omits
@@ -101,16 +102,12 @@ async function renameColumn(schemaName, tableName, fromName, toName, lowerer) {
 	};
 }
 /**
-* `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).
+* `type` is the new column type as a migration writes it, into the `ALTER COLUMN TYPE` clause.
+* `checkType` is the type `format_type` prints for it, which the postcheck compares.
 */
 async function alterColumnType(schemaName, tableName, columnName, options, lowerer, operationClass = "destructive") {
 	const qualified = qualifyTableName(schemaName, tableName);
-	const usingClause = options.using ? ` USING ${renderOpaqueSql(opaqueSql(options.using))}` : ` USING ${quoteIdentifier(columnName)}::${options.qualifiedTargetType}`;
+	const usingClause = options.using ? ` USING ${renderOpaqueSql(opaqueSql(options.using))}` : ` USING ${quoteIdentifier(columnName)}::${options.type}`;
 	const { present } = await columnExistsSteps(lowerer, {
 		schema: schemaName,
 		table: tableName,
@@ -120,16 +117,19 @@ async function alterColumnType(schemaName, tableName, columnName, options, lower
 		schema: schemaName,
 		table: tableName,
 		column: columnName,
-		expectedType: options.formatTypeExpected
+		expectedType: options.checkType
 	}));
 	return {
 		id: `alterType.${tableName}.${columnName}`,
-		label: `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`,
+		label: `Alter type of "${tableName}"."${columnName}" to ${options.type}`,
 		operationClass,
 		target: targetDetails("column", columnName, schemaName, tableName),
 		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params)],
-		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}"`, typeCheck.sql, typeCheck.params)],
+		execute: [{
+			...step(`alter type of "${columnName}"`, `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} TYPE ${options.type}${usingClause}`),
+			...options.using !== void 0 ? { meta: convertedColumnMeta(tableName, columnName, "conversion") } : operationClass === "destructive" ? { meta: convertedColumnMeta(tableName, columnName, "cast") } : {}
+		}],
+		postcheck: [step(`verify column "${columnName}" has type "${options.checkType}"`, typeCheck.sql, typeCheck.params)],
 		meta: { warning: "TABLE_REWRITE" }
 	};
 }
@@ -156,7 +156,10 @@ async function setNotNull(schemaName, tableName, columnName, lowerer) {
 		label: `Set NOT NULL on "${tableName}"."${columnName}"`,
 		operationClass: "widening",
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params), step(`ensure no NULL values in "${columnName}"`, noNulls.sql, noNulls.params)],
+		precheck: [step(`ensure column "${columnName}" exists`, present.sql, present.params), {
+			...step(`ensure no NULL values in "${columnName}"`, noNulls.sql, noNulls.params),
+			meta: requiredColumnMeta(tableName, columnName, "nullValues")
+		}],
 		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`, notNullable.sql, notNullable.params)]
 	};
@@ -312,7 +315,7 @@ async function dropDefault(schemaName, tableName, columnName, lowerer) {
 * empty; the execute step lowers the typed `AddColumn` DDL node through the
 * adapter; postchecks assert the column exists and is NOT NULL.
 */
-async function addNotNullColumnDirect(schemaName, tableName, column, lowerer) {
+async function addRequiredColumnToEmptyTable(schemaName, tableName, column, lowerer) {
 	const columnName = column.name;
 	const addColumn = await lowerer.lowerToExecuteRequest(alterTable({
 		...ifDefined("schema", boundSchema(schemaName)),
@@ -342,7 +345,10 @@ async function addNotNullColumnDirect(schemaName, tableName, column, lowerer) {
 		summary: `Adds column ${columnName} to table ${tableName}`,
 		operationClass: "additive",
 		target: targetDetails("column", columnName, schemaName, tableName),
-		precheck: [step(`ensure column "${columnName}" is missing`, absent.sql, absent.params), step(`ensure table "${tableName}" is empty before adding NOT NULL column without default`, tableEmpty.sql, tableEmpty.params)],
+		precheck: [step(`ensure column "${columnName}" is missing`, absent.sql, absent.params), {
+			...step(`ensure table "${tableName}" is empty before adding NOT NULL column without default`, tableEmpty.sql, tableEmpty.params),
+			meta: requiredColumnMeta(tableName, columnName, "newField")
+		}],
 		execute: [step(`add column "${columnName}"`, addColumn.sql)],
 		postcheck: [step(`verify column "${columnName}" exists`, present.sql, present.params), step(`verify column "${columnName}" is NOT NULL`, notNullable.sql, notNullable.params)]
 	};
@@ -847,14 +853,6 @@ async function renameTable(schemaName, fromName, toName, lowerer) {
 		postcheck: [step(`verify table "${toName}" exists`, toPresent.sql, toPresent.params), step(`verify table "${fromName}" no longer exists`, fromAbsent.sql, fromAbsent.params)]
 	};
 }
-function buildTargetDetails(objectType, name, schema, table) {
-	return {
-		schema,
-		objectType,
-		name,
-		...ifDefined("table", table)
-	};
-}
 function buildAddColumnOperationIdentity(schema, tableName, columnName) {
 	return {
 		id: `column.${tableName}.${columnName}`,
@@ -867,8 +865,8 @@ function buildAddColumnOperationIdentity(schema, tableName, columnName) {
 	};
 }
 async function buildAddNotNullColumnWithTemporaryDefaultOperation(options) {
-	const { schema, tableName, columnName, column, types, storageTypes, temporaryDefault, lowerer } = options;
-	const ddlColumn = col(columnName, buildColumnTypeSql(column, types, storageTypes), {
+	const { schema, tableName, columnName, type, temporaryDefault, lowerer } = options;
+	const ddlColumn = col(columnName, type, {
 		notNull: true,
 		default: new FunctionColumnDefault(opaqueSql(temporaryDefault))
 	});
@@ -1322,39 +1320,87 @@ var DropColumnCall = class extends PostgresOpFactoryCallNode {
 		return [];
 	}
 };
+/** An `alterColumnType` call named by the column it alters, as its errors name it. */
+function alterColumnTypeCallText(schema, table, column) {
+	return `alterColumnType({ ${columnCallLocation(schema, table, column).join(", ")} })`;
+}
 var AlterColumnTypeCall = class extends PostgresOpFactoryCallNode {
 	factoryName = "alterColumnType";
 	operationClass;
 	schemaName;
 	tableName;
 	columnName;
-	options;
+	/** The new type as a migration writes it. */
+	type;
+	using;
+	/** The type `format_type` prints once the alter has run, which the postcheck compares. */
+	checkType;
 	label;
-	constructor(schemaName, tableName, columnName, options, operationClass = "destructive") {
+	constructor(input) {
 		super();
-		this.schemaName = schemaName;
-		this.tableName = tableName;
-		this.columnName = columnName;
-		this.options = options;
-		this.operationClass = operationClass;
-		this.label = `Alter type of "${tableName}"."${columnName}" to ${options.rawTargetTypeForLabel}`;
+		this.schemaName = input.schemaName;
+		this.tableName = input.tableName;
+		this.columnName = input.columnName;
+		this.type = input.type;
+		this.using = input.using;
+		this.operationClass = input.operationClass ?? this.#defaultClass();
+		this.#refuseUnsafeUsing();
+		this.checkType = alterTypeCheckText(input.type, input.dataTypes, this.#callText());
+		this.label = `Alter type of "${input.tableName}"."${input.columnName}" to ${input.type}`;
 		this.freeze();
 	}
+	#refuseUnsafeUsing() {
+		if (this.using?.kind !== "sql") return;
+		const refused = checkSqlExpressionText(this.using.sql, POSTGRES_QUOTING);
+		if (refused === void 0) return;
+		const call = this.#callText();
+		throw postgresError("MIGRATION.SQL_EXPRESSION_INVALID", `${call}: using ${JSON.stringify(this.using.sql)} holds ${refused}, which could end or extend the ALTER COLUMN … TYPE statement it is written into`, {
+			why: "The conversion is written into the USING clause of ALTER COLUMN … TYPE. The check refuses a semicolon, a SQL comment, dollar quoting, and a comma or a statement keyword outside parentheses, since each could end or extend that statement; it does not check that the text is valid SQL.",
+			fix: `Write using as one SQL expression over the column, such as "${this.columnName}"::${this.type}. If it holds a comma or a keyword such as FROM outside parentheses, wrap it in parentheses.`,
+			meta: {
+				call,
+				field: "using",
+				expression: this.using.sql,
+				refused
+			}
+		});
+	}
+	#defaultClass() {
+		return this.using === void 0 ? "destructive" : "data";
+	}
+	#callText() {
+		return alterColumnTypeCallText(this.schemaName, this.tableName, this.columnName);
+	}
 	async toOp(lowerer) {
+		if (isUnfilledSlot(this.using)) return unfilledPlaceholderOperation(this.label);
 		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AlterColumnTypeCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AlterColumnTypeCall" } });
-		return alterColumnType(this.schemaName, this.tableName, this.columnName, this.options, lowerer, this.operationClass);
+		return alterColumnType(this.schemaName, this.tableName, this.columnName, {
+			type: this.type,
+			checkType: this.checkType,
+			...ifDefined("using", sqlOfSlot(this.using))
+		}, lowerer, this.operationClass);
 	}
 	renderTypeScript() {
-		const opts = [];
-		if (this.schemaName !== UNBOUND_NAMESPACE_ID) opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
-		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
-		opts.push(`column: ${jsonToTsSource(this.columnName)}`);
-		opts.push(`options: ${jsonToTsSource(this.options)}`);
-		if (this.operationClass !== "destructive") opts.push(`operationClass: ${jsonToTsSource(this.operationClass)}`);
-		return `this.alterColumnType({ ${opts.join(", ")} })`;
+		return this.#written().source;
 	}
 	importRequirements() {
-		return [];
+		return [...isUnfilledSlot(this.using) ? [{
+			moduleSpecifier: POSTGRES_MIGRATION_FACADE,
+			symbol: "placeholder"
+		}] : [], ...this.#written().imports];
+	}
+	#written() {
+		const sql = createSqlTextSources(POSTGRES_MIGRATION_FACADE);
+		const using = this.using === void 0 ? [] : [`using: ${slotSource(this.using, sql)}`];
+		return {
+			source: `this.alterColumnType({ ${[
+				...columnCallLocation(this.schemaName, this.tableName, this.columnName),
+				`type: ${jsonToTsSource(this.type)}`,
+				...using,
+				...this.operationClass === this.#defaultClass() ? [] : [`operationClass: ${jsonToTsSource(this.operationClass)}`]
+			].join(", ")} })`,
+			imports: sql.imports()
+		};
 	}
 };
 var SetNotNullCall = class extends PostgresOpFactoryCallNode {
@@ -1497,95 +1543,110 @@ var DropDefaultCall = class extends PostgresOpFactoryCallNode {
 		return [];
 	}
 };
+function columnCallLocation(schemaName, tableName, columnName) {
+	return [
+		...schemaName === UNBOUND_NAMESPACE_ID ? [] : [`schema: ${jsonToTsSource(schemaName)}`],
+		`table: ${jsonToTsSource(tableName)}`,
+		`column: ${jsonToTsSource(columnName)}`
+	];
+}
 /**
-* Planner-internal call for adding a NOT NULL column (no contract default) to
-* a table that must be empty at migration time. Carries the typed `DdlColumn`
-* and lowers it to an ADD COLUMN execute step via the adapter at `toOp` time.
-*
-* No authored `PostgresMigration` method: this call is only emitted by the
-* planner, never hand-written by migration authors.
+* Adds a required column with no default to a table that must be empty when the migration runs:
+* a column in a new primary key, unique constraint or foreign key, where one temporary value in
+* every row would break the constraint.
 */
-var AddNotNullColumnDirectCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "rawSql";
+var AddRequiredColumnToEmptyTableCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addRequiredColumnToEmptyTable";
 	operationClass = "additive";
 	schemaName;
 	tableName;
 	columnName;
-	column;
+	/** The column's type as a migration writes it. */
+	type;
 	label;
-	constructor(schemaName, tableName, columnName, column) {
+	constructor(schemaName, tableName, columnName, type) {
 		super();
 		this.schemaName = schemaName;
 		this.tableName = tableName;
 		this.columnName = columnName;
-		this.column = column;
+		this.type = type;
 		this.label = `Add column ${columnName} to ${tableName}`;
 		this.freeze();
 	}
 	async toOp(lowerer) {
-		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddNotNullColumnDirectCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddNotNullColumnDirectCall" } });
-		return addNotNullColumnDirect(this.schemaName, this.tableName, this.column, lowerer);
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddRequiredColumnToEmptyTableCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddRequiredColumnToEmptyTableCall" } });
+		return addRequiredColumnToEmptyTable(this.schemaName, this.tableName, col(this.columnName, this.type, { notNull: true }), lowerer);
 	}
 	renderTypeScript() {
-		return `rawSql(${jsonToTsSource({
-			id: `column.${this.tableName}.${this.columnName}`,
-			label: this.label,
-			operationClass: "additive"
-		})})`;
+		return `this.addRequiredColumnToEmptyTable({ ${[...columnCallLocation(this.schemaName, this.tableName, this.columnName), `type: ${jsonToTsSource(this.type)}`].join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
 	}
 };
 /**
-* Planner-internal call for adding a NOT NULL column (no contract default)
-* using a temporary default value for non-empty tables. Carries all parameters
-* needed for `buildAddNotNullColumnWithTemporaryDefaultOperation`; both the
-* typed ADD COLUMN execute step and the pre/postchecks are lowered via the
-* adapter at `toOp` time.
-*
-* No authored `PostgresMigration` method: this call is only emitted by the
-* planner, never hand-written by migration authors.
+* Adds a required column with no default to a table that may have rows: the column is added with
+* `temporaryDefault`, a SQL value every existing row takes, and the default is then dropped.
 */
-var AddNotNullColumnWithTempDefaultCall = class extends PostgresOpFactoryCallNode {
-	factoryName = "rawSql";
+var AddColumnWithTemporaryDefaultCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "addColumnWithTemporaryDefault";
 	operationClass = "additive";
 	schemaName;
 	tableName;
 	columnName;
-	column;
-	types;
-	storageTypes;
+	/** The column's type as a migration writes it. */
+	type;
+	/** SQL for the value existing rows take, such as `''` or `0`. */
 	temporaryDefault;
 	label;
-	constructor(options) {
+	constructor(schemaName, tableName, columnName, type, temporaryDefault) {
 		super();
-		this.schemaName = options.schemaName;
-		this.tableName = options.tableName;
-		this.columnName = options.columnName;
-		this.column = options.column;
-		this.types = options.types;
-		this.storageTypes = options.storageTypes;
-		this.temporaryDefault = options.temporaryDefault;
-		this.label = `Add column ${options.columnName} to ${options.tableName}`;
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.columnName = columnName;
+		this.type = type;
+		this.temporaryDefault = temporaryDefault;
+		const refused = checkSqlDefaultText(temporaryDefault);
+		if (refused !== void 0) {
+			const call = `addColumnWithTemporaryDefault({ ${columnCallLocation(schemaName, tableName, columnName).join(", ")} })`;
+			throw postgresError("CONTRACT.DEFAULT_INVALID", `${call}: temporaryDefault ${JSON.stringify(temporaryDefault)} is not a value: ${refused}`, {
+				fix: "Write temporaryDefault as one SQL value, such as '' or 0.",
+				meta: {
+					expression: temporaryDefault,
+					where: call
+				}
+			});
+		}
+		this.label = `Add column ${columnName} to ${tableName}`;
 		this.freeze();
 	}
 	async toOp(lowerer) {
-		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddNotNullColumnWithTempDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddNotNullColumnWithTempDefaultCall" } });
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddColumnWithTemporaryDefaultCall.toOp: a lowerer is required on the Postgres planner path (column "${this.columnName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddColumnWithTemporaryDefaultCall" } });
 		return buildAddNotNullColumnWithTemporaryDefaultOperation({
 			schema: this.schemaName,
 			tableName: this.tableName,
 			columnName: this.columnName,
-			column: this.column,
-			types: this.types,
-			storageTypes: this.storageTypes,
+			type: this.type,
 			temporaryDefault: this.temporaryDefault,
 			lowerer
 		});
 	}
 	renderTypeScript() {
-		return `rawSql(${jsonToTsSource({
-			id: `column.${this.tableName}.${this.columnName}`,
-			label: this.label,
-			operationClass: "additive"
-		})})`;
+		return this.#written().source;
+	}
+	importRequirements() {
+		return this.#written().imports;
+	}
+	#written() {
+		const sql = createSqlTextSources(POSTGRES_MIGRATION_FACADE);
+		return {
+			source: `this.addColumnWithTemporaryDefault({ ${[
+				...columnCallLocation(this.schemaName, this.tableName, this.columnName),
+				`type: ${jsonToTsSource(this.type)}`,
+				`temporaryDefault: ${sql.source(this.temporaryDefault)}`
+			].join(", ")} })`,
+			imports: sql.imports()
+		};
 	}
 };
 function constraintCallOptions(schemaName, tableName, constraintName) {
@@ -2164,12 +2225,14 @@ var DataTransformCall = class extends PostgresOpFactoryCallNode {
 	label;
 	checkSlot;
 	runSlot;
-	constructor(label, checkSlot, runSlot, operationClass = "data") {
+	backfillsColumn;
+	constructor(label, checkSlot, runSlot, operationClass = "data", backfillsColumn) {
 		super();
 		this.label = label;
 		this.checkSlot = checkSlot;
 		this.runSlot = runSlot;
 		this.operationClass = operationClass;
+		this.backfillsColumn = backfillsColumn;
 		this.freeze();
 	}
 	toOp() {
@@ -2178,6 +2241,7 @@ var DataTransformCall = class extends PostgresOpFactoryCallNode {
 	renderTypeScript() {
 		return [
 			`this.dataTransform(endContract, ${jsonToTsSource(this.label)}, {`,
+			...this.backfillsColumn === void 0 ? [] : [`  backfillsColumn: ${jsonToTsSource(this.backfillsColumn).replaceAll("\n", "\n  ")},`],
 			`  check: () => placeholder(${jsonToTsSource(this.checkSlot)}),`,
 			`  run: () => placeholder(${jsonToTsSource(this.runSlot)}),`,
 			"})"
@@ -2353,6 +2417,6 @@ function columnNameOfCall(call) {
 	if ("column" in call && call.column instanceof DdlColumn) return call.column.name;
 }
 //#endregion
-export { RenameConstraintCall as A, isPostgresOpFactoryCall as B, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, SetNotNullCall as F, renameTableStatement as H, buildTargetDetails as I, columnNameOfCall as L, RenamePostgresRlsPolicyCall as M, RenameTableCall as N, RawSqlCall as O, SetDefaultCall as P, createExtension as R, DropIndexCall as S, DropPostgresRlsPolicyCall as T, postgresDefaultToDdlColumnDefault as V, DisableRowLevelSecurityCall as _, AddNotNullColumnDirectCall as a, DropConstraintCall as b, AddUniqueCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddNativeEnumValueCall as i, RenameIndexCall as j, RenameColumnCall as k, AlterColumnTypeCall as l, CreateSchemaCall as m, AddColumnCall as n, AddNotNullColumnWithTempDefaultCall as o, CreatePostgresRlsPolicyCall as p, AddForeignKeyCall as r, AddPrimaryKeyCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y, installExtension as z };
+export { RenameConstraintCall as A, isPostgresOpFactoryCall as B, DropNativeEnumTypeCall as C, EnableRowLevelSecurityCall as D, DropTableCall as E, SetNotNullCall as F, renameTableStatement as H, alterColumnTypeCallText as I, columnNameOfCall as L, RenamePostgresRlsPolicyCall as M, RenameTableCall as N, RawSqlCall as O, SetDefaultCall as P, createExtension as R, DropIndexCall as S, DropPostgresRlsPolicyCall as T, postgresDefaultToDdlColumnDefault as V, DisableRowLevelSecurityCall as _, AddNativeEnumValueCall as a, DropConstraintCall as b, AddUniqueCall as c, CreateIndexCall as d, CreateNativeEnumTypeCall as f, DataTransformCall as g, CreateTableCall as h, AddForeignKeyCall as i, RenameIndexCall as j, RenameColumnCall as k, AlterColumnTypeCall as l, CreateSchemaCall as m, AddColumnCall as n, AddPrimaryKeyCall as o, CreatePostgresRlsPolicyCall as p, AddColumnWithTemporaryDefaultCall as r, AddRequiredColumnToEmptyTableCall as s, AddCheckConstraintCall as t, CreateExtensionCall as u, DropCheckConstraintCall as v, DropNotNullCall as w, DropDefaultCall as x, DropColumnCall as y, installExtension as z };
 
-//# sourceMappingURL=op-factory-call-DiwaNQVO-NSekrcmI.mjs.map
+//# sourceMappingURL=op-factory-call-ltgiEZ8g-CX6WX57X.mjs.map