@prisma-next/target-postgres 0.4.0-dev.8 → 0.4.1

package/dist/migration.d.mts

@@ -0,0 +1,164 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-MXb3oeul.mjs";
+import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
+import { placeholder } from "@prisma-next/errors/migration";
+import { Migration } from "@prisma-next/family-sql/migration";
+import { Contract } from "@prisma-next/contract/types";
+import { ReferentialAction, SqlStorage } from "@prisma-next/sql-contract/types";
+import { DataTransformOperation } from "@prisma-next/framework-components/control";
+import { SqlQueryPlan } from "@prisma-next/sql-relational-core/plan";
+
+//#region src/core/migrations/operations/shared.d.ts
+type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
+/**
+ * Literal-args shape for a column definition consumed by `createTable` and
+ * `addColumn`. Fully materialized: codec expansion and default rendering have
+ * already happened in the wrapper.
+ *
+ * - `typeSql` is the column's DDL type string (e.g. `"integer"`, `"SERIAL"`,
+ *   `"varchar(100)"`), already produced by `buildColumnTypeSql` in the
+ *   call-factory wrapper.
+ * - `defaultSql` is the full `DEFAULT …` clause (e.g. `"DEFAULT 42"`) or an
+ *   empty string when the column has no default, matching
+ *   `buildColumnDefaultSql`'s output.
+ */
+interface ColumnSpec {
+  readonly name: string;
+  readonly typeSql: string;
+  readonly defaultSql: string;
+  readonly nullable: boolean;
+}
+/**
+ * Literal-args shape for a foreign key definition. The referenced table is
+ * assumed to live in the same schema as the constrained table.
+ */
+interface ForeignKeySpec {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly references: {
+    readonly table: string;
+    readonly columns: readonly string[];
+  };
+  readonly onDelete?: ReferentialAction;
+  readonly onUpdate?: ReferentialAction;
+}
+//#endregion
+//#region src/core/migrations/operations/columns.d.ts
+declare function addColumn(schemaName: string, tableName: string, column: ColumnSpec): Op;
+declare function dropColumn(schemaName: string, tableName: string, columnName: string): Op;
+/**
+ * `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).
+ */
+declare function alterColumnType(schemaName: string, tableName: string, columnName: string, options: {
+  readonly qualifiedTargetType: string;
+  readonly formatTypeExpected: string;
+  readonly rawTargetTypeForLabel: string;
+  readonly using?: string;
+}): Op;
+declare function setNotNull(schemaName: string, tableName: string, columnName: string): Op;
+declare function dropNotNull(schemaName: string, tableName: string, columnName: string): Op;
+/**
+ * `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.
+ */
+declare function setDefault(schemaName: string, tableName: string, columnName: string, defaultSql: string, operationClass?: 'additive' | 'widening'): Op;
+declare function dropDefault(schemaName: string, tableName: string, columnName: string): Op;
+//#endregion
+//#region src/core/migrations/operations/constraints.d.ts
+declare function addPrimaryKey(schemaName: string, tableName: string, constraintName: string, columns: readonly string[]): Op;
+declare function addUnique(schemaName: string, tableName: string, constraintName: string, columns: readonly string[]): Op;
+declare function addForeignKey(schemaName: string, tableName: string, fk: ForeignKeySpec): Op;
+/**
+ * `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.
+ */
+declare function dropConstraint(schemaName: string, tableName: string, constraintName: string, kind?: 'foreignKey' | 'unique' | 'primaryKey'): Op;
+//#endregion
+//#region src/core/migrations/operations/data-transform.d.ts
+interface Buildable<R = unknown> {
+  build(): SqlQueryPlan<R>;
+}
+/**
+ * A single-closure producer of a SQL query plan. Shared between
+ * `check` and each `run` entry.
+ */
+type DataTransformClosure = () => SqlQueryPlan | Buildable;
+interface DataTransformOptions {
+  /** Optional pre-flight query. `undefined` means "no check". */
+  readonly check?: DataTransformClosure;
+  /** One or more mutation queries to execute. */
+  readonly run: DataTransformClosure | readonly DataTransformClosure[];
+}
+declare function dataTransform<TContract extends Contract<SqlStorage>>(contract: TContract, name: string, options: DataTransformOptions): DataTransformOperation;
+//#endregion
+//#region src/core/migrations/operations/dependencies.d.ts
+declare function createExtension(extensionName: string): Op;
+declare function createSchema(schemaName: string): Op;
+//#endregion
+//#region src/core/migrations/operations/enums.d.ts
+declare function createEnumType(schemaName: string, typeName: string, values: readonly string[]): Op;
+/**
+ * `typeName` is the contract-facing type name (used for id/label).
+ * `nativeType` is the Postgres type name to mutate (may differ for external types).
+ */
+declare function addEnumValues(schemaName: string, typeName: string, nativeType: string, values: readonly string[]): Op;
+declare function dropEnumType(schemaName: string, typeName: string): Op;
+declare function renameType(schemaName: string, fromName: string, toName: string): Op;
+//#endregion
+//#region src/core/migrations/operations/indexes.d.ts
+declare function createIndex(schemaName: string, tableName: string, indexName: string, columns: readonly string[]): Op;
+declare function dropIndex(schemaName: string, tableName: string, indexName: string): Op;
+//#endregion
+//#region src/core/migrations/operations/raw.d.ts
+/**
+ * Identity factory for an already-materialized `SqlMigrationPlanOperation`.
+ *
+ * The planner uses this via `liftOpToCall` to carry ops produced by SQL
+ * family methods, codec control hooks, and component database dependencies
+ * alongside migration IR without reverse-engineering them. Users writing
+ * raw migrations can pass a full op shape directly — typically built by
+ * composing SQL family helpers — to author a migration that bypasses the
+ * structured call classes.
+ */
+declare function rawSql(op: Op): Op;
+//#endregion
+//#region src/core/migrations/operations/tables.d.ts
+declare function createTable(schemaName: string, tableName: string, columns: ReadonlyArray<ColumnSpec>, primaryKey?: {
+  readonly columns: readonly string[];
+}): Op;
+declare function dropTable(schemaName: string, tableName: string): Op;
+//#endregion
+//#region src/core/migrations/postgres-migration.d.ts
+/**
+ * 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 `@prisma-next/family-mongo`: the renderer
+ * emits `extends Migration` against a target-specific re-export of this
+ * class from `@prisma-next/target-postgres/migration`, keeping the
+ * authoring surface target-scoped rather than family-scoped.
+ */
+declare abstract class PostgresMigration extends Migration<PostgresPlanTargetDetails> {
+  readonly targetId: "postgres";
+}
+//#endregion
+export { type DataTransformClosure, type DataTransformOptions, PostgresMigration as Migration, addColumn, addEnumValues, addForeignKey, addPrimaryKey, addUnique, alterColumnType, createEnumType, createExtension, createIndex, createSchema, createTable, dataTransform, dropColumn, dropConstraint, dropDefault, dropEnumType, dropIndex, dropNotNull, dropTable, placeholder, rawSql, renameType, setDefault, setNotNull };
+//# sourceMappingURL=migration.d.mts.map

package/dist/migration.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts","../src/core/migrations/operations/columns.ts","../src/core/migrations/operations/constraints.ts","../src/core/migrations/operations/data-transform.ts","../src/core/migrations/operations/dependencies.ts","../src/core/migrations/operations/enums.ts","../src/core/migrations/operations/indexes.ts","../src/core/migrations/operations/raw.ts","../src/core/migrations/operations/tables.ts","../src/core/migrations/postgres-migration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;KAMY,EAAA,GAAK,0BAA0B;;;;;;;AAA3C;AAcA;AAWA;;;;ACrBgB,UDUC,UAAA,CCVwD;EAoCzD,SAAA,IAAU,EAAA,MAAA;EAyCV,SAAA,OAAA,EAAe,MAAA;EA+Cf,SAAA,UAAU,EAAA,MAA6D;EAqCvE,SAAA,QAAW,EAAA,OAA6D;AA2CxF;AAuCA;;;;ACvNgB,UFPC,cAAA,CEYd;EAkCa,SAAA,IAAS,EAAA,MAAA;EAuCT,SAAA,OAAa,EAAA,SAAA,MAA4C,EAAA;EAsCzD,SAAA,UAAc,EAAA;;;;EC1HpB,SAAA,QAAS,CAAA,EHMG,iBGLX;EAOC,SAAA,QAAA,CAAA,EHDU,iBGCmB;AAEzC;;;iBFhCgB,SAAA,gDAAyD,aAAa;iBAoCtE,UAAA,6DAAuE;;;;;;;;ADxCvF;AAciB,iBCmED,eAAA,CDnEW,UAAA,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,OAAA,EAAA;EAWV,SAAA,mBAAc,EAOT,MAAA;;;;AC5BtB,CAAA,CAAA,EAuFG,EAvFa;AAoCA,iBAwFA,UAAA,CAxFyE,UAAA,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,CAAA,EAwFF,EAxFE;AAyCzE,iBAoFA,WAAA,CA1Eb,UAAE,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,CAAA,EA0EmF,EA1EnF;AAqCL;AAqCA;AA2CA;AAuCA;;;;ACvNA;AAuCA;AAuCA;AAsCgB,iBD4DA,UAAA,CCvDb,UAAE,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,UAAA,EAAA,MAAA,EAAA,cAAA,CAAA,EAAA,UAAA,GAAA,UAAA,CAAA,ED6DF,EC7DE;iBD8FW,WAAA,6DAAwE;;;iBCvNxE,aAAA,6FAKb;iBAkCa,SAAA,6FAKb;iBAkCa,aAAA,4CAAyD,iBAAiB;;;;;;;AF9G1F;AAciB,iBEsID,cAAA,CFtIW,UAAA,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,EAAA,cAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EAAA,YAAA,GAAA,QAAA,GAAA,YAAA,CAAA,EE2IxB,EF3IwB;;;UGYjB;WACC,aAAa;ADKxB;AAuCA;AAuCA;AAsCA;;KClHY,oBAAA,SAA6B,eAAe;UAEvC,oBAAA;EAVP;EAQE,SAAA,KAAA,CAAA,EAIO,oBAJsB;EAExB;EAEE,SAAA,GAAA,EAEH,oBAFG,GAAA,SAE6B,oBAF7B,EAAA;;AAE6B,iBAYhC,aAZgC,CAAA,kBAYA,QAZA,CAYS,UAZT,CAAA,CAAA,CAAA,QAAA,EAapC,SAboC,EAAA,IAAA,EAAA,MAAA,EAAA,OAAA,EAerC,oBAfqC,CAAA,EAgB7C,sBAhB6C;;;iBC3ChC,eAAA,yBAAwC;iBAiBxC,YAAA,sBAAkC;;;iBCNlC,cAAA,mEAIb;;;;;iBA8Ba,aAAA,uFAKb;iBAsBa,YAAA,wCAAoD;iBAepD,UAAA,wDAAkE;;;iBCtFlE,WAAA,wFAKb;iBA6Ba,SAAA,4DAAqE;;;;;;;;;;;;ANhCrF;AAciB,iBORD,MAAA,CPQW,EAAA,EORA,EPQA,CAAA,EORK,EPQL;;;iBQhBX,WAAA,iDAGL,cAAc;;IAEtB;iBAgCa,SAAA,yCAAkD;;;;;;;;;;;ARnClE;AAcA;AAWA;;;;ACrBgB,uBQOM,iBAAA,SAA0B,SRPwC,CQO3B,yBRP2B,CAAA,CAAA;EAoCxE,SAAA,QAAU,EAAA,UAA+D;AAyCzF"}

package/dist/migration.mjs

@@ -0,0 +1,446 @@
+import { F as escapeLiteral, I as quoteIdentifier, M as codecDefinitions, N as PG_JSONB_CODEC_ID, P as PG_JSON_CODEC_ID, S as setNotNull, _ as alterColumnType, a as dropIndex, b as dropNotNull, c as dropEnumType, d as createSchema, f as addForeignKey, g as addColumn, h as dropConstraint, i as createIndex, l as renameType, m as addUnique, n as createTable, o as addEnumValues, p as addPrimaryKey, r as dropTable, s as createEnumType, t as PostgresMigration, u as createExtension, v as dropColumn, x as setDefault, y as dropDefault } from "./postgres-migration-BsHJHV9O.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { LiteralExpr, createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { errorDataTransformContractMismatch, placeholder } from "@prisma-next/errors/migration";
+import { lowerSqlPlan } from "@prisma-next/sql-runtime";
+
+//#region ../../6-adapters/postgres/dist/adapter-Du9Hr9Rl.mjs
+const VECTOR_CODEC_ID = "pg/vector@1";
+function getCodecParamCast(codecId) {
+	if (codecId === VECTOR_CODEC_ID) return "vector";
+	if (codecId === PG_JSON_CODEC_ID) return "json";
+	if (codecId === PG_JSONB_CODEC_ID) return "jsonb";
+}
+function renderTypedParam(index, codecId) {
+	const cast = getCodecParamCast(codecId);
+	return cast ? `$${index}::${cast}` : `$${index}`;
+}
+const defaultCapabilities = Object.freeze({
+	postgres: {
+		orderBy: true,
+		limit: true,
+		lateral: true,
+		jsonAgg: true,
+		returning: true
+	},
+	sql: {
+		enums: true,
+		returning: true,
+		defaultInInsert: true
+	}
+});
+const parameterizedCodecs = Object.values(codecDefinitions).map((definition) => definition.codec).filter((codec$1) => codec$1.paramsSchema !== void 0).map((codec$1) => Object.freeze({
+	codecId: codec$1.id,
+	paramsSchema: codec$1.paramsSchema,
+	...ifDefined("init", codec$1.init)
+}));
+var PostgresAdapterImpl = class {
+	familyId = "sql";
+	targetId = "postgres";
+	profile;
+	codecRegistry = (() => {
+		const registry = createCodecRegistry();
+		for (const definition of Object.values(codecDefinitions)) registry.register(definition.codec);
+		return registry;
+	})();
+	constructor(options) {
+		this.profile = Object.freeze({
+			id: options?.profileId ?? "postgres/default@1",
+			target: "postgres",
+			capabilities: defaultCapabilities,
+			codecs: () => this.codecRegistry,
+			readMarkerStatement: () => ({
+				sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1",
+				params: [1]
+			})
+		});
+	}
+	parameterizedCodecs() {
+		return parameterizedCodecs;
+	}
+	lower(ast, context) {
+		const collectedParamRefs = ast.collectParamRefs();
+		const paramIndexMap = /* @__PURE__ */ new Map();
+		const params = [];
+		for (const ref of collectedParamRefs) {
+			if (paramIndexMap.has(ref)) continue;
+			paramIndexMap.set(ref, params.length + 1);
+			params.push(ref.value);
+		}
+		let sql;
+		const node = ast;
+		switch (node.kind) {
+			case "select":
+				sql = renderSelect(node, context.contract, paramIndexMap);
+				break;
+			case "insert":
+				sql = renderInsert(node, context.contract, paramIndexMap);
+				break;
+			case "update":
+				sql = renderUpdate(node, context.contract, paramIndexMap);
+				break;
+			case "delete":
+				sql = renderDelete(node, context.contract, paramIndexMap);
+				break;
+			default: throw new Error(`Unsupported AST node kind: ${node.kind}`);
+		}
+		return Object.freeze({
+			profileId: this.profile.id,
+			body: Object.freeze({
+				sql,
+				params
+			})
+		});
+	}
+};
+function renderSelect(ast, contract, pim) {
+	return [
+		`SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(ast.projection, contract, pim)}`,
+		`FROM ${renderSource(ast.from, contract, pim)}`,
+		ast.joins?.length ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(" ") : "",
+		ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : "",
+		ast.groupBy?.length ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(", ")}` : "",
+		ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : "",
+		ast.orderBy?.length ? `ORDER BY ${ast.orderBy.map((order) => {
+			return `${renderExpr(order.expr, contract, pim)} ${order.dir.toUpperCase()}`;
+		}).join(", ")}` : "",
+		typeof ast.limit === "number" ? `LIMIT ${ast.limit}` : "",
+		typeof ast.offset === "number" ? `OFFSET ${ast.offset}` : ""
+	].filter((part) => part.length > 0).join(" ").trim();
+}
+function renderProjection(projection, contract, pim) {
+	return projection.map((item) => {
+		const alias = quoteIdentifier(item.alias);
+		if (item.expr.kind === "literal") return `${renderLiteral(item.expr)} AS ${alias}`;
+		return `${renderExpr(item.expr, contract, pim)} AS ${alias}`;
+	}).join(", ");
+}
+function renderDistinctPrefix(distinct, distinctOn, contract, pim) {
+	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(", ")}) `;
+	if (distinct) return "DISTINCT ";
+	return "";
+}
+function renderSource(source, contract, pim) {
+	const node = source;
+	switch (node.kind) {
+		case "table-source": {
+			const table = quoteIdentifier(node.name);
+			if (!node.alias) return table;
+			return `${table} AS ${quoteIdentifier(node.alias)}`;
+		}
+		case "derived-table-source": return `(${renderSelect(node.query, contract, pim)}) AS ${quoteIdentifier(node.alias)}`;
+		default: throw new Error(`Unsupported source node kind: ${node.kind}`);
+	}
+}
+function assertScalarSubquery(query) {
+	if (query.projection.length !== 1) throw new Error("Subquery expressions must project exactly one column");
+}
+function renderSubqueryExpr(expr, contract, pim) {
+	assertScalarSubquery(expr.query);
+	return `(${renderSelect(expr.query, contract, pim)})`;
+}
+function renderWhere(expr, contract, pim) {
+	return renderExpr(expr, contract, pim);
+}
+function renderNullCheck(expr, contract, pim) {
+	const rendered = renderExpr(expr.expr, contract, pim);
+	const renderedExpr = expr.expr.kind === "operation" || expr.expr.kind === "subquery" ? `(${rendered})` : rendered;
+	return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
+}
+function renderBinary(expr, contract, pim) {
+	if (expr.right.kind === "list" && expr.right.values.length === 0) {
+		if (expr.op === "in") return "FALSE";
+		if (expr.op === "notIn") return "TRUE";
+	}
+	const leftExpr = expr.left;
+	const left = renderExpr(leftExpr, contract, pim);
+	const leftRendered = leftExpr.kind === "operation" || leftExpr.kind === "subquery" ? `(${left})` : left;
+	const rightNode = expr.right;
+	let right;
+	switch (rightNode.kind) {
+		case "list":
+			right = renderListLiteral(rightNode, pim);
+			break;
+		case "literal":
+			right = renderLiteral(rightNode);
+			break;
+		case "column-ref":
+			right = renderColumn(rightNode);
+			break;
+		case "param-ref":
+			right = renderParamRef(rightNode, pim);
+			break;
+		default:
+			right = renderExpr(rightNode, contract, pim);
+			break;
+	}
+	return `${leftRendered} ${{
+		eq: "=",
+		neq: "!=",
+		gt: ">",
+		lt: "<",
+		gte: ">=",
+		lte: "<=",
+		like: "LIKE",
+		in: "IN",
+		notIn: "NOT IN"
+	}[expr.op]} ${right}`;
+}
+function renderListLiteral(expr, pim) {
+	if (expr.values.length === 0) return "(NULL)";
+	return `(${expr.values.map((v) => {
+		if (v.kind === "param-ref") return renderParamRef(v, pim);
+		if (v.kind === "literal") return renderLiteral(v);
+		return renderExpr(v, void 0, pim);
+	}).join(", ")})`;
+}
+function renderColumn(ref) {
+	if (ref.table === "excluded") return `excluded.${quoteIdentifier(ref.column)}`;
+	return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
+}
+function renderAggregateExpr(expr, contract, pim) {
+	const fn = expr.fn.toUpperCase();
+	if (!expr.expr) return `${fn}(*)`;
+	return `${fn}(${renderExpr(expr.expr, contract, pim)})`;
+}
+function renderJsonObjectExpr(expr, contract, pim) {
+	return `json_build_object(${expr.entries.flatMap((entry) => {
+		const key = `'${escapeLiteral(entry.key)}'`;
+		if (entry.value.kind === "literal") return [key, renderLiteral(entry.value)];
+		return [key, renderExpr(entry.value, contract, pim)];
+	}).join(", ")})`;
+}
+function renderOrderByItems(items, contract, pim) {
+	return items.map((item) => `${renderExpr(item.expr, contract, pim)} ${item.dir.toUpperCase()}`).join(", ");
+}
+function renderJsonArrayAggExpr(expr, contract, pim) {
+	const aggregateOrderBy = expr.orderBy && expr.orderBy.length > 0 ? ` ORDER BY ${renderOrderByItems(expr.orderBy, contract, pim)}` : "";
+	const aggregated = `json_agg(${renderExpr(expr.expr, contract, pim)}${aggregateOrderBy})`;
+	if (expr.onEmpty === "emptyArray") return `coalesce(${aggregated}, json_build_array())`;
+	return aggregated;
+}
+function renderExpr(expr, contract, pim) {
+	const node = expr;
+	switch (node.kind) {
+		case "column-ref": return renderColumn(node);
+		case "identifier-ref": return quoteIdentifier(node.name);
+		case "operation": return renderOperation(node, contract, pim);
+		case "subquery": return renderSubqueryExpr(node, contract, pim);
+		case "aggregate": return renderAggregateExpr(node, contract, pim);
+		case "json-object": return renderJsonObjectExpr(node, contract, pim);
+		case "json-array-agg": return renderJsonArrayAggExpr(node, contract, pim);
+		case "binary": return renderBinary(node, contract, pim);
+		case "and":
+			if (node.exprs.length === 0) return "TRUE";
+			return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(" AND ")})`;
+		case "or":
+			if (node.exprs.length === 0) return "FALSE";
+			return `(${node.exprs.map((part) => renderExpr(part, contract, pim)).join(" OR ")})`;
+		case "exists": return `${node.notExists ? "NOT " : ""}EXISTS (${renderSelect(node.subquery, contract, pim)})`;
+		case "null-check": return renderNullCheck(node, contract, pim);
+		case "not": return `NOT (${renderExpr(node.expr, contract, pim)})`;
+		case "param-ref": return renderParamRef(node, pim);
+		case "literal": return renderLiteral(node);
+		case "list": return renderListLiteral(node, pim);
+		default: throw new Error(`Unsupported expression node kind: ${node.kind}`);
+	}
+}
+function renderParamRef(ref, pim) {
+	const index = pim?.get(ref);
+	if (index === void 0) throw new Error("ParamRef not found in index map");
+	return renderTypedParam(index, ref.codecId);
+}
+function renderLiteral(expr) {
+	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
+	if (typeof expr.value === "number" || typeof expr.value === "boolean") return String(expr.value);
+	if (typeof expr.value === "bigint") return String(expr.value);
+	if (expr.value === null) return "NULL";
+	if (expr.value === void 0) return "NULL";
+	if (expr.value instanceof Date) return `'${escapeLiteral(expr.value.toISOString())}'`;
+	if (Array.isArray(expr.value)) return `ARRAY[${expr.value.map((v) => renderLiteral(new LiteralExpr(v))).join(", ")}]`;
+	const json = JSON.stringify(expr.value);
+	if (json === void 0) return "NULL";
+	return `'${escapeLiteral(json)}'`;
+}
+function renderOperation(expr, contract, pim) {
+	const self = renderExpr(expr.self, contract, pim);
+	const args = expr.args.map((arg) => {
+		return renderExpr(arg, contract, pim);
+	});
+	let result = expr.lowering.template;
+	result = result.replace(/\{\{self\}\}/g, self);
+	for (let i = 0; i < args.length; i++) result = result.replace(new RegExp(`\\{\\{arg${i}\\}\\}`, "g"), args[i] ?? "");
+	return result;
+}
+function renderJoin(join, contract, pim) {
+	return `${join.joinType.toUpperCase()} JOIN ${join.lateral ? "LATERAL " : ""}${renderSource(join.source, contract, pim)} ON ${renderJoinOn(join.on, contract, pim)}`;
+}
+function renderJoinOn(on, contract, pim) {
+	if (on.kind === "eq-col-join-on") return `${renderColumn(on.left)} = ${renderColumn(on.right)}`;
+	return renderWhere(on, contract, pim);
+}
+function getInsertColumnOrder(rows, contract, tableName) {
+	const orderedColumns = [];
+	const seenColumns = /* @__PURE__ */ new Set();
+	for (const row of rows) for (const column of Object.keys(row)) {
+		if (seenColumns.has(column)) continue;
+		seenColumns.add(column);
+		orderedColumns.push(column);
+	}
+	if (orderedColumns.length > 0) return orderedColumns;
+	return Object.keys(contract.storage.tables[tableName]?.columns ?? {});
+}
+function renderInsertValue(value, pim) {
+	if (!value || value.kind === "default-value") return "DEFAULT";
+	switch (value.kind) {
+		case "param-ref": return renderParamRef(value, pim);
+		case "column-ref": return renderColumn(value);
+		default: throw new Error(`Unsupported value node in INSERT: ${value.kind}`);
+	}
+}
+function renderInsert(ast, contract, pim) {
+	const table = quoteIdentifier(ast.table.name);
+	const rows = ast.rows;
+	if (rows.length === 0) throw new Error("INSERT requires at least one row");
+	const hasExplicitValues = rows.some((row) => Object.keys(row).length > 0);
+	return `${(() => {
+		if (!hasExplicitValues) {
+			if (rows.length === 1) return `INSERT INTO ${table} DEFAULT VALUES`;
+			const defaultColumns = getInsertColumnOrder(rows, contract, ast.table.name);
+			if (defaultColumns.length === 0) return `INSERT INTO ${table} VALUES ${rows.map(() => "()").join(", ")}`;
+			const quotedColumns = defaultColumns.map((column) => quoteIdentifier(column));
+			const defaultRow = `(${defaultColumns.map(() => "DEFAULT").join(", ")})`;
+			return `INSERT INTO ${table} (${quotedColumns.join(", ")}) VALUES ${rows.map(() => defaultRow).join(", ")}`;
+		}
+		const columnOrder = getInsertColumnOrder(rows, contract, ast.table.name);
+		const columns = columnOrder.map((column) => quoteIdentifier(column));
+		const values = rows.map((row) => {
+			return `(${columnOrder.map((column) => renderInsertValue(row[column], pim)).join(", ")})`;
+		}).join(", ");
+		return `INSERT INTO ${table} (${columns.join(", ")}) VALUES ${values}`;
+	})()}${ast.onConflict ? (() => {
+		const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
+		if (conflictColumns.length === 0) throw new Error("INSERT onConflict requires at least one conflict column");
+		const action = ast.onConflict.action;
+		switch (action.kind) {
+			case "do-nothing": return ` ON CONFLICT (${conflictColumns.join(", ")}) DO NOTHING`;
+			case "do-update-set": {
+				const updates = Object.entries(action.set).map(([colName, value]) => {
+					const target = quoteIdentifier(colName);
+					if (value.kind === "param-ref") return `${target} = ${renderParamRef(value, pim)}`;
+					return `${target} = ${renderColumn(value)}`;
+				});
+				return ` ON CONFLICT (${conflictColumns.join(", ")}) DO UPDATE SET ${updates.join(", ")}`;
+			}
+			default: throw new Error(`Unsupported onConflict action: ${action.kind}`);
+		}
+	})() : ""}${ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : ""}`;
+}
+function renderUpdate(ast, contract, pim) {
+	const table = quoteIdentifier(ast.table.name);
+	const setClauses = Object.entries(ast.set).map(([col, val]) => {
+		const column = quoteIdentifier(col);
+		let value;
+		switch (val.kind) {
+			case "param-ref":
+				value = renderParamRef(val, pim);
+				break;
+			case "column-ref":
+				value = renderColumn(val);
+				break;
+			default: throw new Error(`Unsupported value node in UPDATE: ${val.kind}`);
+		}
+		return `${column} = ${value}`;
+	});
+	const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : "";
+	const returningClause = ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : "";
+	return `UPDATE ${table} SET ${setClauses.join(", ")}${whereClause}${returningClause}`;
+}
+function renderDelete(ast, contract, pim) {
+	return `DELETE FROM ${quoteIdentifier(ast.table.name)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(", ")}` : ""}`;
+}
+function createPostgresAdapter(options) {
+	return Object.freeze(new PostgresAdapterImpl(options));
+}
+
+//#endregion
+//#region src/core/migrations/operations/data-transform.ts
+/**
+* User-facing `dataTransform` factory for the Postgres migration authoring
+* surface. Invoked directly inside a `migration.ts` file:
+*
+* ```ts
+* import endContract from './end-contract.json' with { type: 'json' };
+* import { dataTransform } from '@prisma-next/target-postgres/migration';
+*
+* dataTransform(endContract, 'backfill emails', {
+*   check: () => db.users.count().where(({ email }) => email.isNull()),
+*   run:   () => db.users.update({ email: '' }).where(({ email }) => email.isNull()),
+* });
+* ```
+*
+* The factory accepts lazy closures (`() => SqlQueryPlan | Buildable`),
+* invokes each one, asserts that its `meta.storageHash` matches the
+* `contract` it was handed (→ `PN-MIG-2005` on mismatch), and lowers the
+* plan via the Postgres adapter to a serialized `{sql, params}` payload
+* for `ops.json`.
+*/
+/** Single shared adapter for apply/CLI; sufficient for single-threaded migration execution. */
+let adapterSingleton = null;
+function getAdapter() {
+	if (adapterSingleton === null) adapterSingleton = createPostgresAdapter();
+	return adapterSingleton;
+}
+function dataTransform(contract, name, options) {
+	const adapter = getAdapter();
+	const runClosures = Array.isArray(options.run) ? options.run : [options.run];
+	return {
+		id: `data_migration.${name}`,
+		label: `Data transform: ${name}`,
+		operationClass: "data",
+		name,
+		source: "migration.ts",
+		check: options.check ? invokeAndLower(options.check, contract, adapter, name) : null,
+		run: runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name))
+	};
+}
+function invokeAndLower(closure, contract, adapter, name) {
+	const result = closure();
+	const plan = isBuildable(result) ? result.build() : result;
+	assertContractMatches(plan, contract, name);
+	const lowered = lowerSqlPlan(adapter, contract, plan);
+	return {
+		sql: lowered.sql,
+		params: lowered.params
+	};
+}
+function isBuildable(value) {
+	return typeof value === "object" && value !== null && "build" in value && typeof value.build === "function";
+}
+function assertContractMatches(plan, contract, name) {
+	if (plan.meta.storageHash !== contract.storage.storageHash) throw errorDataTransformContractMismatch({
+		dataTransformName: name,
+		expected: contract.storage.storageHash,
+		actual: plan.meta.storageHash
+	});
+}
+
+//#endregion
+//#region src/core/migrations/operations/raw.ts
+/**
+* Identity factory for an already-materialized `SqlMigrationPlanOperation`.
+*
+* The planner uses this via `liftOpToCall` to carry ops produced by SQL
+* family methods, codec control hooks, and component database dependencies
+* alongside migration IR without reverse-engineering them. Users writing
+* raw migrations can pass a full op shape directly — typically built by
+* composing SQL family helpers — to author a migration that bypasses the
+* structured call classes.
+*/
+function rawSql(op) {
+	return op;
+}
+
+//#endregion
+export { PostgresMigration as Migration, addColumn, addEnumValues, addForeignKey, addPrimaryKey, addUnique, alterColumnType, createEnumType, createExtension, createIndex, createSchema, createTable, dataTransform, dropColumn, dropConstraint, dropDefault, dropEnumType, dropIndex, dropNotNull, dropTable, placeholder, rawSql, renameType, setDefault, setNotNull };
+//# sourceMappingURL=migration.mjs.map