@prisma-next/target-postgres 0.3.0-dev.53 → 0.3.0-dev.55

package/dist/control.mjs

@@ -1,6 +1,6 @@
 import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-DxB8oZzB.mjs";
 import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/sql-relational-core/ast";
-import { arraysEqual, isIndexSatisfied, isUniqueConstraintSatisfied, verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
+import { arraysEqual, verifySqlSchema } from "@prisma-next/family-sql/schema-verify";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { bigintJsonReplacer, isTaggedBigInt } from "@prisma-next/contract/types";
 import { createMigrationPlan, extractCodecControlHooks, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess } from "@prisma-next/family-sql/control";
@@ -8,31 +8,6 @@ import { readMarker } from "@prisma-next/family-sql/verify";
 import { SqlQueryError } from "@prisma-next/sql-errors";
 import { ok, okVoid } from "@prisma-next/utils/result";
 
-//#region ../../6-adapters/postgres/dist/codec-ids-Bsm9c7ns.mjs
-const PG_TEXT_CODEC_ID = "pg/text@1";
-const PG_ENUM_CODEC_ID = "pg/enum@1";
-const PG_CHAR_CODEC_ID = "pg/char@1";
-const PG_VARCHAR_CODEC_ID = "pg/varchar@1";
-const PG_INT_CODEC_ID = "pg/int@1";
-const PG_INT2_CODEC_ID = "pg/int2@1";
-const PG_INT4_CODEC_ID = "pg/int4@1";
-const PG_INT8_CODEC_ID = "pg/int8@1";
-const PG_FLOAT_CODEC_ID = "pg/float@1";
-const PG_FLOAT4_CODEC_ID = "pg/float4@1";
-const PG_FLOAT8_CODEC_ID = "pg/float8@1";
-const PG_NUMERIC_CODEC_ID = "pg/numeric@1";
-const PG_BOOL_CODEC_ID = "pg/bool@1";
-const PG_BIT_CODEC_ID = "pg/bit@1";
-const PG_VARBIT_CODEC_ID = "pg/varbit@1";
-const PG_TIMESTAMP_CODEC_ID = "pg/timestamp@1";
-const PG_TIMESTAMPTZ_CODEC_ID = "pg/timestamptz@1";
-const PG_TIME_CODEC_ID = "pg/time@1";
-const PG_TIMETZ_CODEC_ID = "pg/timetz@1";
-const PG_INTERVAL_CODEC_ID = "pg/interval@1";
-const PG_JSON_CODEC_ID = "pg/json@1";
-const PG_JSONB_CODEC_ID = "pg/jsonb@1";
-
-//#endregion
 //#region ../../6-adapters/postgres/dist/sql-utils-CSfAGEwF.mjs
 /**
 * Shared SQL utility functions for the Postgres adapter.
@@ -108,6 +83,31 @@ function validateEnumValueLength(value, enumTypeName) {
 	if (value.length > MAX_IDENTIFIER_LENGTH$1) throw new SqlEscapeError(`Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH$1}-character label limit`, value, "literal");
 }
 
+//#endregion
+//#region ../../6-adapters/postgres/dist/codec-ids-Bsm9c7ns.mjs
+const PG_TEXT_CODEC_ID = "pg/text@1";
+const PG_ENUM_CODEC_ID = "pg/enum@1";
+const PG_CHAR_CODEC_ID = "pg/char@1";
+const PG_VARCHAR_CODEC_ID = "pg/varchar@1";
+const PG_INT_CODEC_ID = "pg/int@1";
+const PG_INT2_CODEC_ID = "pg/int2@1";
+const PG_INT4_CODEC_ID = "pg/int4@1";
+const PG_INT8_CODEC_ID = "pg/int8@1";
+const PG_FLOAT_CODEC_ID = "pg/float@1";
+const PG_FLOAT4_CODEC_ID = "pg/float4@1";
+const PG_FLOAT8_CODEC_ID = "pg/float8@1";
+const PG_NUMERIC_CODEC_ID = "pg/numeric@1";
+const PG_BOOL_CODEC_ID = "pg/bool@1";
+const PG_BIT_CODEC_ID = "pg/bit@1";
+const PG_VARBIT_CODEC_ID = "pg/varbit@1";
+const PG_TIMESTAMP_CODEC_ID = "pg/timestamp@1";
+const PG_TIMESTAMPTZ_CODEC_ID = "pg/timestamptz@1";
+const PG_TIME_CODEC_ID = "pg/time@1";
+const PG_TIMETZ_CODEC_ID = "pg/timetz@1";
+const PG_INTERVAL_CODEC_ID = "pg/interval@1";
+const PG_JSON_CODEC_ID = "pg/json@1";
+const PG_JSONB_CODEC_ID = "pg/jsonb@1";
+
 //#endregion
 //#region ../../6-adapters/postgres/dist/descriptor-meta-ilnFI7bx.mjs
 const ENUM_INTROSPECT_QUERY = `
@@ -1463,6 +1463,395 @@ var control_default$1 = {
 	}
 };
 
+//#endregion
+//#region src/core/migrations/planner-reconciliation.ts
+function buildReconciliationPlan(options) {
+	const operations = [];
+	const conflicts = [];
+	const { mode } = options;
+	const seenOperationIds = /* @__PURE__ */ new Set();
+	for (const issue of sortSchemaIssues(options.issues)) {
+		if (isAdditiveIssue(issue)) continue;
+		const operation = buildReconciliationOperationFromIssue({
+			issue,
+			contract: options.contract,
+			schemaName: options.schemaName,
+			mode
+		});
+		if (operation) {
+			if (!seenOperationIds.has(operation.id)) {
+				seenOperationIds.add(operation.id);
+				if (options.policy.allowedOperationClasses.includes(operation.operationClass)) operations.push(operation);
+				else {
+					const conflict = convertIssueToConflict(issue);
+					if (conflict) conflicts.push(conflict);
+				}
+			}
+		} else {
+			const conflict = convertIssueToConflict(issue);
+			if (conflict) conflicts.push(conflict);
+		}
+	}
+	return {
+		operations,
+		conflicts: conflicts.sort(conflictComparator)
+	};
+}
+function isAdditiveIssue(issue) {
+	switch (issue.kind) {
+		case "type_missing":
+		case "type_values_mismatch":
+		case "missing_table":
+		case "missing_column":
+		case "extension_missing": return true;
+		case "primary_key_mismatch": return issue.actual === void 0;
+		case "unique_constraint_mismatch":
+		case "index_mismatch":
+		case "foreign_key_mismatch": return issue.indexOrConstraint === void 0;
+		default: return false;
+	}
+}
+function buildReconciliationOperationFromIssue(options) {
+	const { issue, contract, schemaName, mode } = options;
+	switch (issue.kind) {
+		case "extra_table":
+			if (!mode.allowDestructive || !issue.table) return null;
+			return buildDropTableOperation(schemaName, issue.table);
+		case "extra_column":
+			if (!mode.allowDestructive || !issue.table || !issue.column) return null;
+			return buildDropColumnOperation(schemaName, issue.table, issue.column);
+		case "extra_index":
+			if (!mode.allowDestructive || !issue.table || !issue.indexOrConstraint) return null;
+			return buildDropIndexOperation(schemaName, issue.table, issue.indexOrConstraint);
+		case "extra_foreign_key":
+		case "extra_unique_constraint": {
+			if (!mode.allowDestructive || !issue.table || !issue.indexOrConstraint) return null;
+			const constraintKind = issue.kind === "extra_foreign_key" ? "foreignKey" : "unique";
+			return buildDropConstraintOperation(schemaName, issue.table, issue.indexOrConstraint, constraintKind);
+		}
+		case "extra_primary_key": {
+			if (!mode.allowDestructive || !issue.table) return null;
+			const constraintName = issue.indexOrConstraint ?? `${issue.table}_pkey`;
+			return buildDropConstraintOperation(schemaName, issue.table, constraintName, "primaryKey");
+		}
+		case "nullability_mismatch":
+			if (!issue.table || !issue.column) return null;
+			if (issue.expected === "true") return mode.allowWidening ? buildDropNotNullOperation(schemaName, issue.table, issue.column) : null;
+			return mode.allowDestructive ? buildSetNotNullOperation(schemaName, issue.table, issue.column) : null;
+		case "type_mismatch": {
+			if (!mode.allowDestructive || !issue.table || !issue.column) return null;
+			const contractColumn = getContractColumn(contract, issue.table, issue.column);
+			if (!contractColumn) return null;
+			return buildAlterColumnTypeOperation(schemaName, issue.table, issue.column, contractColumn);
+		}
+		default: return null;
+	}
+}
+function getContractColumn(contract, tableName, columnName) {
+	const table = contract.storage.tables[tableName];
+	if (!table) return null;
+	return table.columns[columnName] ?? null;
+}
+function buildDropTableOperation(schemaName, tableName) {
+	return {
+		id: `dropTable.${tableName}`,
+		label: `Drop table ${tableName}`,
+		summary: `Drops extra table ${tableName}`,
+		operationClass: "destructive",
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("table", tableName, schemaName)
+		},
+		precheck: [{
+			description: `ensure table "${tableName}" exists`,
+			sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`
+		}],
+		execute: [{
+			description: `drop table "${tableName}"`,
+			sql: `DROP TABLE ${qualifyTableName(schemaName, tableName)}`
+		}],
+		postcheck: [{
+			description: `verify table "${tableName}" is removed`,
+			sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`
+		}]
+	};
+}
+function buildDropColumnOperation(schemaName, tableName, columnName) {
+	return {
+		id: `dropColumn.${tableName}.${columnName}`,
+		label: `Drop column ${columnName} from ${tableName}`,
+		summary: `Drops extra column ${columnName} from table ${tableName}`,
+		operationClass: "destructive",
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("column", columnName, schemaName, tableName)
+		},
+		precheck: [{
+			description: `ensure column "${columnName}" exists`,
+			sql: columnExistsCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName
+			})
+		}],
+		execute: [{
+			description: `drop column "${columnName}"`,
+			sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)} DROP COLUMN ${quoteIdentifier(columnName)}`
+		}],
+		postcheck: [{
+			description: `verify column "${columnName}" is removed`,
+			sql: columnExistsCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName,
+				exists: false
+			})
+		}]
+	};
+}
+function buildDropIndexOperation(schemaName, tableName, indexName) {
+	return {
+		id: `dropIndex.${tableName}.${indexName}`,
+		label: `Drop index ${indexName} on ${tableName}`,
+		summary: `Drops extra index ${indexName} on table ${tableName}`,
+		operationClass: "destructive",
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("index", indexName, schemaName, tableName)
+		},
+		precheck: [{
+			description: `ensure index "${indexName}" exists`,
+			sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`
+		}],
+		execute: [{
+			description: `drop index "${indexName}"`,
+			sql: `DROP INDEX ${qualifyTableName(schemaName, indexName)}`
+		}],
+		postcheck: [{
+			description: `verify index "${indexName}" is removed`,
+			sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`
+		}]
+	};
+}
+function buildDropConstraintOperation(schemaName, tableName, constraintName, constraintKind) {
+	return {
+		id: `dropConstraint.${tableName}.${constraintName}`,
+		label: `Drop constraint ${constraintName} on ${tableName}`,
+		summary: `Drops extra constraint ${constraintName} on table ${tableName}`,
+		operationClass: "destructive",
+		target: {
+			id: "postgres",
+			details: buildTargetDetails(constraintKind, constraintName, schemaName, tableName)
+		},
+		precheck: [{
+			description: `ensure constraint "${constraintName}" exists`,
+			sql: constraintExistsCheck({
+				constraintName,
+				schema: schemaName
+			})
+		}],
+		execute: [{
+			description: `drop constraint "${constraintName}"`,
+			sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+DROP CONSTRAINT ${quoteIdentifier(constraintName)}`
+		}],
+		postcheck: [{
+			description: `verify constraint "${constraintName}" is removed`,
+			sql: constraintExistsCheck({
+				constraintName,
+				schema: schemaName,
+				exists: false
+			})
+		}]
+	};
+}
+function buildDropNotNullOperation(schemaName, tableName, columnName) {
+	return {
+		id: `alterNullability.${tableName}.${columnName}`,
+		label: `Relax nullability for ${columnName} on ${tableName}`,
+		summary: `Drops NOT NULL constraint for ${columnName} on table ${tableName}`,
+		operationClass: "widening",
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("column", columnName, schemaName, tableName)
+		},
+		precheck: [{
+			description: `ensure column "${columnName}" exists`,
+			sql: columnExistsCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName
+			})
+		}],
+		execute: [{
+			description: `drop NOT NULL from "${columnName}"`,
+			sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ALTER COLUMN ${quoteIdentifier(columnName)} DROP NOT NULL`
+		}],
+		postcheck: [{
+			description: `verify "${columnName}" is nullable`,
+			sql: columnNullabilityCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName,
+				nullable: true
+			})
+		}]
+	};
+}
+function buildSetNotNullOperation(schemaName, tableName, columnName) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	return {
+		id: `alterNullability.${tableName}.${columnName}`,
+		label: `Enforce NOT NULL for ${columnName} on ${tableName}`,
+		summary: `Sets NOT NULL on ${columnName} for table ${tableName}`,
+		operationClass: "destructive",
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("column", columnName, schemaName, tableName)
+		},
+		precheck: [{
+			description: `ensure column "${columnName}" exists`,
+			sql: columnExistsCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName
+			})
+		}, {
+			description: `ensure "${columnName}" has no NULL values`,
+			sql: `SELECT NOT EXISTS (
+  SELECT 1 FROM ${qualified}
+  WHERE ${quoteIdentifier(columnName)} IS NULL
+  LIMIT 1
+)`
+		}],
+		execute: [{
+			description: `set NOT NULL on "${columnName}"`,
+			sql: `ALTER TABLE ${qualified}
+ALTER COLUMN ${quoteIdentifier(columnName)} SET NOT NULL`
+		}],
+		postcheck: [{
+			description: `verify "${columnName}" is NOT NULL`,
+			sql: columnNullabilityCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName,
+				nullable: false
+			})
+		}]
+	};
+}
+function buildAlterColumnTypeOperation(schemaName, tableName, columnName, column) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	const expectedType = buildColumnTypeSql(column);
+	return {
+		id: `alterType.${tableName}.${columnName}`,
+		label: `Alter type for ${columnName} on ${tableName}`,
+		summary: `Changes type of ${columnName} to ${expectedType}`,
+		operationClass: "destructive",
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("column", columnName, schemaName, tableName)
+		},
+		meta: {
+			warning: "TABLE_REWRITE",
+			detail: "ALTER COLUMN TYPE requires a full table rewrite and acquires an ACCESS EXCLUSIVE lock. On large tables, this can cause significant downtime."
+		},
+		precheck: [{
+			description: `ensure column "${columnName}" exists`,
+			sql: columnExistsCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName
+			})
+		}],
+		execute: [{
+			description: `alter type of "${columnName}"`,
+			sql: `ALTER TABLE ${qualified}
+ALTER COLUMN ${quoteIdentifier(columnName)}
+TYPE ${expectedType}
+USING ${quoteIdentifier(columnName)}::${expectedType}`
+		}],
+		postcheck: [{
+			description: `verify column "${columnName}" exists after type change`,
+			sql: columnExistsCheck({
+				schema: schemaName,
+				table: tableName,
+				column: columnName
+			})
+		}]
+	};
+}
+function convertIssueToConflict(issue) {
+	switch (issue.kind) {
+		case "type_mismatch": return buildConflict("typeMismatch", issue);
+		case "nullability_mismatch": return buildConflict("nullabilityConflict", issue);
+		case "default_missing":
+		case "default_mismatch":
+		case "extra_table":
+		case "extra_column":
+		case "extra_primary_key":
+		case "extra_foreign_key":
+		case "extra_unique_constraint":
+		case "extra_index": return buildConflict("missingButNonAdditive", issue);
+		case "primary_key_mismatch":
+		case "unique_constraint_mismatch":
+		case "index_mismatch": return buildConflict("indexIncompatible", issue);
+		case "foreign_key_mismatch": return buildConflict("foreignKeyConflict", issue);
+		default: return null;
+	}
+}
+function buildConflict(kind, issue) {
+	const location = buildConflictLocation(issue);
+	const meta = issue.expected || issue.actual ? Object.freeze({
+		...ifDefined("expected", issue.expected),
+		...ifDefined("actual", issue.actual)
+	}) : void 0;
+	return {
+		kind,
+		summary: issue.message,
+		...ifDefined("location", location),
+		...ifDefined("meta", meta)
+	};
+}
+function sortSchemaIssues(issues) {
+	return [...issues].sort((a, b) => {
+		const kindCompare = a.kind.localeCompare(b.kind);
+		if (kindCompare !== 0) return kindCompare;
+		const tableCompare = compareStrings(a.table, b.table);
+		if (tableCompare !== 0) return tableCompare;
+		const columnCompare = compareStrings(a.column, b.column);
+		if (columnCompare !== 0) return columnCompare;
+		return compareStrings(a.indexOrConstraint, b.indexOrConstraint);
+	});
+}
+function buildConflictLocation(issue) {
+	const location = {
+		...ifDefined("table", issue.table),
+		...ifDefined("column", issue.column),
+		...ifDefined("constraint", issue.indexOrConstraint)
+	};
+	return Object.keys(location).length > 0 ? location : void 0;
+}
+function conflictComparator(a, b) {
+	if (a.kind !== b.kind) return a.kind < b.kind ? -1 : 1;
+	const aLocation = a.location ?? {};
+	const bLocation = b.location ?? {};
+	const tableCompare = compareStrings(aLocation.table, bLocation.table);
+	if (tableCompare !== 0) return tableCompare;
+	const columnCompare = compareStrings(aLocation.column, bLocation.column);
+	if (columnCompare !== 0) return columnCompare;
+	const constraintCompare = compareStrings(aLocation.constraint, bLocation.constraint);
+	if (constraintCompare !== 0) return constraintCompare;
+	return compareStrings(a.summary, b.summary);
+}
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	if (a === void 0) return -1;
+	if (b === void 0) return 1;
+	return a < b ? -1 : 1;
+}
+
 //#endregion
 //#region src/core/migrations/planner.ts
 const DEFAULT_PLANNER_CONFIG = { defaultSchema: "public" };
@@ -1480,13 +1869,23 @@ var PostgresMigrationPlanner = class {
 		const schemaName = options.schemaName ?? this.config.defaultSchema;
 		const policyResult = this.ensureAdditivePolicy(options.policy);
 		if (policyResult) return policyResult;
-		const classification = this.classifySchema(options);
-		if (classification.kind === "conflict") return plannerFailure(classification.conflicts);
+		const planningMode = this.resolvePlanningMode(options.policy);
+		const schemaIssues = this.collectSchemaIssues(options, planningMode.includeExtraObjects);
 		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
 		const operations = [];
+		const reconciliationPlan = buildReconciliationPlan({
+			contract: options.contract,
+			issues: schemaIssues,
+			schemaName,
+			mode: planningMode,
+			policy: options.policy
+		});
+		if (reconciliationPlan.conflicts.length > 0) return plannerFailure(reconciliationPlan.conflicts);
 		const storageTypePlan = this.buildStorageTypeOperations(options, schemaName, codecHooks);
 		if (storageTypePlan.conflicts.length > 0) return plannerFailure(storageTypePlan.conflicts);
-		operations.push(...this.buildDatabaseDependencyOperations(options), ...storageTypePlan.operations, ...this.buildTableOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildColumnOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildPrimaryKeyOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildUniqueOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildIndexOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildFkBackingIndexOperations(options.contract.storage.tables, options.schema, schemaName), ...this.buildForeignKeyOperations(options.contract.storage.tables, options.schema, schemaName));
+		const sortedTables = sortedEntries(options.contract.storage.tables);
+		const schemaLookups = buildSchemaLookupMap(options.schema);
+		operations.push(...this.buildDatabaseDependencyOperations(options), ...storageTypePlan.operations, ...reconciliationPlan.operations, ...this.buildTableOperations(sortedTables, options.schema, schemaName), ...this.buildColumnOperations(sortedTables, options.schema, schemaName), ...this.buildPrimaryKeyOperations(sortedTables, options.schema, schemaName), ...this.buildUniqueOperations(sortedTables, schemaLookups, schemaName), ...this.buildIndexOperations(sortedTables, schemaLookups, schemaName), ...this.buildFkBackingIndexOperations(sortedTables, schemaLookups, schemaName), ...this.buildForeignKeyOperations(sortedTables, schemaLookups, schemaName));
 		return plannerSuccess(createMigrationPlan({
 			targetId: "postgres",
 			origin: null,
@@ -1500,8 +1899,8 @@ var PostgresMigrationPlanner = class {
 	ensureAdditivePolicy(policy) {
 		if (!policy.allowedOperationClasses.includes("additive")) return plannerFailure([{
 			kind: "unsupportedOperation",
-			summary: "Init planner requires additive operations be allowed",
-			why: "The init planner only emits additive operations. Update the policy to include \"additive\"."
+			summary: "Migration planner requires additive operations be allowed",
+			why: "The planner requires the \"additive\" operation class to be allowed in the policy."
 		}]);
 		return null;
 	}
@@ -1576,7 +1975,7 @@ var PostgresMigrationPlanner = class {
 	}
 	buildTableOperations(tables, schema, schemaName) {
 		const operations = [];
-		for (const [tableName, table] of sortedEntries(tables)) {
+		for (const [tableName, table] of tables) {
 			if (schema.tables[tableName]) continue;
 			const qualified = qualifyTableName(schemaName, tableName);
 			operations.push({
@@ -1606,7 +2005,7 @@ var PostgresMigrationPlanner = class {
 	}
 	buildColumnOperations(tables, schema, schemaName) {
 		const operations = [];
-		for (const [tableName, table] of sortedEntries(tables)) {
+		for (const [tableName, table] of tables) {
 			const schemaTable = schema.tables[tableName];
 			if (!schemaTable) continue;
 			for (const [columnName, column] of sortedEntries(table.columns)) {
@@ -1646,10 +2045,11 @@ var PostgresMigrationPlanner = class {
 			})
 		}, ...notNull ? [{
 			description: `verify column "${columnName}" is NOT NULL`,
-			sql: columnIsNotNullCheck({
+			sql: columnNullabilityCheck({
 				schema,
 				table: tableName,
-				column: columnName
+				column: columnName,
+				nullable: false
 			})
 		}] : []];
 		return {
@@ -1668,7 +2068,7 @@ var PostgresMigrationPlanner = class {
 	}
 	buildPrimaryKeyOperations(tables, schema, schemaName) {
 		const operations = [];
-		for (const [tableName, table] of sortedEntries(tables)) {
+		for (const [tableName, table] of tables) {
 			if (!table.primaryKey) continue;
 			const schemaTable = schema.tables[tableName];
 			if (!schemaTable || schemaTable.primaryKey) continue;
@@ -1700,12 +2100,12 @@ PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(", ")})`
 		}
 		return operations;
 	}
-	buildUniqueOperations(tables, schema, schemaName) {
+	buildUniqueOperations(tables, schemaLookups, schemaName) {
 		const operations = [];
-		for (const [tableName, table] of sortedEntries(tables)) {
-			const schemaTable = schema.tables[tableName];
+		for (const [tableName, table] of tables) {
+			const lookup = schemaLookups.get(tableName);
 			for (const unique of table.uniques) {
-				if (schemaTable && hasUniqueConstraint(schemaTable, unique.columns)) continue;
+				if (lookup && hasUniqueConstraint(lookup, unique.columns)) continue;
 				const constraintName = unique.name ?? `${tableName}_${unique.columns.join("_")}_key`;
 				operations.push({
 					id: `unique.${tableName}.${constraintName}`,
@@ -1742,12 +2142,12 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
 		}
 		return operations;
 	}
-	buildIndexOperations(tables, schema, schemaName) {
+	buildIndexOperations(tables, schemaLookups, schemaName) {
 		const operations = [];
-		for (const [tableName, table] of sortedEntries(tables)) {
-			const schemaTable = schema.tables[tableName];
+		for (const [tableName, table] of tables) {
+			const lookup = schemaLookups.get(tableName);
 			for (const index of table.indexes) {
-				if (schemaTable && hasIndex(schemaTable, index.columns)) continue;
+				if (lookup && hasIndex(lookup, index.columns)) continue;
 				const indexName = index.name ?? `${tableName}_${index.columns.join("_")}_idx`;
 				operations.push({
 					id: `index.${tableName}.${indexName}`,
@@ -1779,15 +2179,15 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
 	* Generates FK-backing index operations for FKs with `index: true`,
 	* but only when no matching user-declared index exists in `contractTable.indexes`.
 	*/
-	buildFkBackingIndexOperations(tables, schema, schemaName) {
+	buildFkBackingIndexOperations(tables, schemaLookups, schemaName) {
 		const operations = [];
-		for (const [tableName, table] of sortedEntries(tables)) {
-			const schemaTable = schema.tables[tableName];
+		for (const [tableName, table] of tables) {
+			const lookup = schemaLookups.get(tableName);
 			const declaredIndexColumns = new Set(table.indexes.map((idx) => idx.columns.join(",")));
 			for (const fk of table.foreignKeys) {
 				if (fk.index === false) continue;
 				if (declaredIndexColumns.has(fk.columns.join(","))) continue;
-				if (schemaTable && hasIndex(schemaTable, fk.columns)) continue;
+				if (lookup && hasIndex(lookup, fk.columns)) continue;
 				const indexName = `${tableName}_${fk.columns.join("_")}_idx`;
 				operations.push({
 					id: `index.${tableName}.${indexName}`,
@@ -1815,13 +2215,13 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
 		}
 		return operations;
 	}
-	buildForeignKeyOperations(tables, schema, schemaName) {
+	buildForeignKeyOperations(tables, schemaLookups, schemaName) {
 		const operations = [];
-		for (const [tableName, table] of sortedEntries(tables)) {
-			const schemaTable = schema.tables[tableName];
+		for (const [tableName, table] of tables) {
+			const lookup = schemaLookups.get(tableName);
 			for (const foreignKey of table.foreignKeys) {
 				if (foreignKey.constraint === false) continue;
-				if (schemaTable && hasForeignKey(schemaTable, foreignKey)) continue;
+				if (lookup && hasForeignKey(lookup, foreignKey)) continue;
 				const fkName = foreignKey.name ?? `${tableName}_${foreignKey.columns.join("_")}_fkey`;
 				operations.push({
 					id: `foreignKey.${tableName}.${fkName}`,
@@ -1857,62 +2257,27 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(", ")})`
 		return operations;
 	}
 	buildTargetDetails(objectType, name, schema, table) {
+		return buildTargetDetails(objectType, name, schema, table);
+	}
+	resolvePlanningMode(policy) {
+		const allowWidening = policy.allowedOperationClasses.includes("widening");
+		const allowDestructive = policy.allowedOperationClasses.includes("destructive");
 		return {
-			schema,
-			objectType,
-			name,
-			...ifDefined("table", table)
+			includeExtraObjects: allowWidening || allowDestructive,
+			allowWidening,
+			allowDestructive
 		};
 	}
-	classifySchema(options) {
-		const verifyResult = verifySqlSchema({
+	collectSchemaIssues(options, strict) {
+		return verifySqlSchema({
 			contract: options.contract,
 			schema: options.schema,
-			strict: false,
+			strict,
 			typeMetadataRegistry: /* @__PURE__ */ new Map(),
 			frameworkComponents: options.frameworkComponents,
 			normalizeDefault: parsePostgresDefault,
 			normalizeNativeType: normalizeSchemaNativeType
-		});
-		const conflicts = this.extractConflicts(verifyResult.schema.issues);
-		if (conflicts.length > 0) return {
-			kind: "conflict",
-			conflicts
-		};
-		return { kind: "ok" };
-	}
-	extractConflicts(issues) {
-		const conflicts = [];
-		for (const issue of issues) {
-			if (isAdditiveIssue(issue)) continue;
-			const conflict = this.convertIssueToConflict(issue);
-			if (conflict) conflicts.push(conflict);
-		}
-		return conflicts.sort(conflictComparator);
-	}
-	convertIssueToConflict(issue) {
-		switch (issue.kind) {
-			case "type_mismatch": return this.buildConflict("typeMismatch", issue);
-			case "nullability_mismatch": return this.buildConflict("nullabilityConflict", issue);
-			case "primary_key_mismatch": return this.buildConflict("indexIncompatible", issue);
-			case "unique_constraint_mismatch": return this.buildConflict("indexIncompatible", issue);
-			case "index_mismatch": return this.buildConflict("indexIncompatible", issue);
-			case "foreign_key_mismatch": return this.buildConflict("foreignKeyConflict", issue);
-			default: return null;
-		}
-	}
-	buildConflict(kind, issue) {
-		const location = buildConflictLocation(issue);
-		const meta = issue.expected || issue.actual ? Object.freeze({
-			...ifDefined("expected", issue.expected),
-			...ifDefined("actual", issue.actual)
-		}) : void 0;
-		return {
-			kind,
-			summary: issue.message,
-			...ifDefined("location", location),
-			...ifDefined("meta", meta)
-		};
+		}).schema.issues;
 	}
 };
 function isSqlDependencyProvider(component) {
@@ -1941,6 +2306,23 @@ function buildCreateTableSql(qualifiedTableName, table) {
 	return `CREATE TABLE ${qualifiedTableName} (\n  ${[...columnDefinitions, ...constraintDefinitions].join(",\n  ")}\n)`;
 }
 /**
+* Pattern for safe PostgreSQL type names.
+* Allows letters, digits, underscores, spaces (for "double precision", "character varying"),
+* and trailing [] for array types.
+*/
+const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\[\])?$/;
+function assertSafeNativeType(nativeType) {
+	if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) throw new Error(`Unsafe native type name in contract: "${nativeType}". Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?\$/`);
+}
+/**
+* Sanity check against accidental SQL injection from malformed contract files.
+* Rejects semicolons, SQL comment tokens, and dollar-quoting.
+* Not a comprehensive security boundary — the contract is developer-authored.
+*/
+function assertSafeDefaultExpression(expression) {
+	if (expression.includes(";") || /--|\/\*|\$\$|\bSELECT\b/i.test(expression)) throw new Error(`Unsafe default expression in contract: "${expression}". Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.`);
+}
+/**
 * Builds the column type SQL, handling autoincrement as a special case.
 * For autoincrement on int4/int8, we use SERIAL/BIGSERIAL types.
 */
@@ -1952,6 +2334,7 @@ function buildColumnTypeSql(column) {
 		if (column.nativeType === "int2" || column.nativeType === "smallint") return "SMALLSERIAL";
 	}
 	if (column.typeRef) return quoteIdentifier(column.nativeType);
+	assertSafeNativeType(column.nativeType);
 	return renderParameterizedTypeSql(column) ?? column.nativeType;
 }
 /**
@@ -1982,7 +2365,8 @@ function buildColumnDefaultSql(columnDefault, column) {
 		case "literal": return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;
 		case "function":
 			if (columnDefault.expression === "autoincrement()") return "";
-			return `DEFAULT ${columnDefault.expression}`;
+			assertSafeDefaultExpression(columnDefault.expression);
+			return `DEFAULT (${columnDefault.expression})`;
 		case "sequence": return `DEFAULT nextval(${quoteIdentifier(columnDefault.name)}::regclass)`;
 	}
 }
@@ -2001,6 +2385,14 @@ function renderDefaultLiteral(value, column) {
 	if (isJsonColumn) return `'${escapeLiteral(json)}'::${column.nativeType}`;
 	return `'${escapeLiteral(json)}'`;
 }
+function buildTargetDetails(objectType, name, schema, table) {
+	return {
+		schema,
+		objectType,
+		name,
+		...ifDefined("table", table)
+	};
+}
 function qualifyTableName(schema, table) {
 	return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
 }
@@ -2027,14 +2419,15 @@ function columnExistsCheck({ schema, table, column, exists = true }) {
     AND column_name = '${escapeLiteral(column)}'
 )`;
 }
-function columnIsNotNullCheck({ schema, table, column }) {
+function columnNullabilityCheck({ schema, table, column, nullable }) {
+	const expected = nullable ? "YES" : "NO";
 	return `SELECT EXISTS (
   SELECT 1
   FROM information_schema.columns
   WHERE table_schema = '${escapeLiteral(schema)}'
     AND table_name = '${escapeLiteral(table)}'
     AND column_name = '${escapeLiteral(column)}'
-    AND is_nullable = 'NO'
+    AND is_nullable = '${expected}'
 )`;
 }
 function tableIsEmptyCheck(qualifiedTableName) {
@@ -2065,61 +2458,29 @@ function tableHasPrimaryKeyCheck(schema, table, exists, constraintName) {
     ${constraintFilter}
 )`;
 }
-/**
-* Checks if table has a unique constraint satisfied by the given columns.
-* Uses shared semantic satisfaction predicate from verify-helpers.
-*/
-function hasUniqueConstraint(table, columns) {
-	return isUniqueConstraintSatisfied(table.uniques, table.indexes, columns);
-}
-/**
-* Checks if table has an index satisfied by the given columns.
-* Uses shared semantic satisfaction predicate from verify-helpers.
-*/
-function hasIndex(table, columns) {
-	return isIndexSatisfied(table.indexes, table.uniques, columns);
-}
-function hasForeignKey(table, fk) {
-	return table.foreignKeys.some((candidate) => arraysEqual(candidate.columns, fk.columns) && candidate.referencedTable === fk.references.table && arraysEqual(candidate.referencedColumns, fk.references.columns));
+function buildSchemaLookupMap(schema) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(schema.tables)) map.set(tableName, buildSchemaTableLookup(table));
+	return map;
 }
-function isAdditiveIssue(issue) {
-	switch (issue.kind) {
-		case "type_missing":
-		case "type_values_mismatch":
-		case "missing_table":
-		case "missing_column":
-		case "extension_missing": return true;
-		case "primary_key_mismatch": return issue.actual === void 0;
-		case "unique_constraint_mismatch":
-		case "index_mismatch":
-		case "foreign_key_mismatch": return issue.indexOrConstraint === void 0;
-		default: return false;
-	}
+function buildSchemaTableLookup(table) {
+	return {
+		uniqueKeys: new Set(table.uniques.map((u) => u.columns.join(","))),
+		indexKeys: new Set(table.indexes.map((i) => i.columns.join(","))),
+		uniqueIndexKeys: new Set(table.indexes.filter((i) => i.unique).map((i) => i.columns.join(","))),
+		fkKeys: new Set(table.foreignKeys.map((fk) => `${fk.columns.join(",")}|${fk.referencedTable}|${fk.referencedColumns.join(",")}`))
+	};
 }
-function buildConflictLocation(issue) {
-	const location = {};
-	if (issue.table) location.table = issue.table;
-	if (issue.column) location.column = issue.column;
-	if (issue.indexOrConstraint) location.constraint = issue.indexOrConstraint;
-	return Object.keys(location).length > 0 ? location : void 0;
+function hasUniqueConstraint(lookup, columns) {
+	const key = columns.join(",");
+	return lookup.uniqueKeys.has(key) || lookup.uniqueIndexKeys.has(key);
 }
-function conflictComparator(a, b) {
-	if (a.kind !== b.kind) return a.kind < b.kind ? -1 : 1;
-	const aLocation = a.location ?? {};
-	const bLocation = b.location ?? {};
-	const tableCompare = compareStrings(aLocation.table, bLocation.table);
-	if (tableCompare !== 0) return tableCompare;
-	const columnCompare = compareStrings(aLocation.column, bLocation.column);
-	if (columnCompare !== 0) return columnCompare;
-	const constraintCompare = compareStrings(aLocation.constraint, bLocation.constraint);
-	if (constraintCompare !== 0) return constraintCompare;
-	return compareStrings(a.summary, b.summary);
+function hasIndex(lookup, columns) {
+	const key = columns.join(",");
+	return lookup.indexKeys.has(key) || lookup.uniqueKeys.has(key);
 }
-function compareStrings(a, b) {
-	if (a === b) return 0;
-	if (a === void 0) return -1;
-	if (b === void 0) return 1;
-	return a < b ? -1 : 1;
+function hasForeignKey(lookup, fk) {
+	return lookup.fkKeys.has(`${fk.columns.join(",")}|${fk.references.table}|${fk.references.columns.join(",")}`);
 }
 const REFERENTIAL_ACTION_SQL = {
 	noAction: "NO ACTION",
@@ -2483,14 +2844,7 @@ var PostgresMigrationRunner = class {
 	}
 	ensureMarkerCompatibility(marker, plan) {
 		const origin = plan.origin ?? null;
-		if (!origin) {
-			if (!marker) return okVoid();
-			if (this.markerMatchesDestination(marker, plan)) return okVoid();
-			return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (no marker expected).`, { meta: {
-				markerStorageHash: marker.storageHash,
-				expectedOrigin: null
-			} });
-		}
+		if (!origin) return okVoid();
 		if (!marker) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Missing contract marker: expected origin storage hash ${origin.storageHash}.`, { meta: { expectedOriginStorageHash: origin.storageHash } });
 		if (marker.storageHash !== origin.storageHash) return runnerFailure("MARKER_ORIGIN_MISMATCH", `Existing contract marker (${marker.storageHash}) does not match plan origin (${origin.storageHash}).`, { meta: {
 			markerStorageHash: marker.storageHash,