@prisma-next/target-postgres 0.4.1 → 0.4.2

package/dist/issue-planner-CFjB0_oO.mjs

@@ -0,0 +1,879 @@
+import { i as quoteIdentifier } from "./sql-utils-r-Lw535w.mjs";
+import { a as columnNullabilityCheck, c as qualifyTableName, i as columnHasNoDefaultCheck, r as columnExistsCheck, t as buildExpectedFormatType, u as tableIsEmptyCheck } from "./planner-sql-checks-7jkgm9TX.mjs";
+import { C as SetNotNullCall, S as SetDefaultCall, _ as DropIndexCall, a as AddUniqueCall, b as RawSqlCall, c as CreateExtensionCall, d as CreateTableCall, f as DataTransformCall, g as DropEnumTypeCall, h as DropDefaultCall, i as AddPrimaryKeyCall, l as CreateIndexCall, m as DropConstraintCall, n as AddEnumValuesCall, o as AlterColumnTypeCall, p as DropColumnCall, r as AddForeignKeyCall, s as CreateEnumTypeCall, t as AddColumnCall, u as CreateSchemaCall, v as DropNotNullCall, x as RenameTypeCall, y as DropTableCall } from "./op-factory-call-BKlruaiC.mjs";
+import { n as buildColumnDefaultSql, r as buildColumnTypeSql, t as buildAddColumnSql } from "./planner-ddl-builders-Dxvw1LHw.mjs";
+import { n as resolveIdentityValue } from "./planner-identity-values-Dju-o5GF.mjs";
+import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-B7lkypwn.mjs";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { collectInitDependencies } from "@prisma-next/family-sql/control";
+import { notOk, ok } from "@prisma-next/utils/result";
+
+//#region src/core/migrations/planner-target-details.ts
+function buildTargetDetails(objectType, name, schema, table) {
+	return {
+		schema,
+		objectType,
+		name,
+		...ifDefined("table", table)
+	};
+}
+
+//#endregion
+//#region src/core/migrations/planner-recipes.ts
+function buildAddColumnOperationIdentity(schema, tableName, columnName) {
+	return {
+		id: `column.${tableName}.${columnName}`,
+		label: `Add column ${columnName} to ${tableName}`,
+		summary: `Adds column ${columnName} to table ${tableName}`,
+		target: {
+			id: "postgres",
+			details: buildTargetDetails("table", tableName, schema)
+		}
+	};
+}
+function buildAddNotNullColumnWithTemporaryDefaultOperation(options) {
+	const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } = options;
+	const qualified = qualifyTableName(schema, tableName);
+	return {
+		...buildAddColumnOperationIdentity(schema, tableName, columnName),
+		operationClass: "additive",
+		precheck: [{
+			description: `ensure column "${columnName}" is missing`,
+			sql: columnExistsCheck({
+				schema,
+				table: tableName,
+				column: columnName,
+				exists: false
+			})
+		}],
+		execute: [{
+			description: `add column "${columnName}"`,
+			sql: buildAddColumnSql(qualified, columnName, column, codecHooks, temporaryDefault, storageTypes)
+		}, {
+			description: `drop temporary default from column "${columnName}"`,
+			sql: `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`
+		}],
+		postcheck: [
+			{
+				description: `verify column "${columnName}" exists`,
+				sql: columnExistsCheck({
+					schema,
+					table: tableName,
+					column: columnName
+				})
+			},
+			{
+				description: `verify column "${columnName}" is NOT NULL`,
+				sql: columnNullabilityCheck({
+					schema,
+					table: tableName,
+					column: columnName,
+					nullable: false
+				})
+			},
+			{
+				description: `verify column "${columnName}" has no default after temporary default removal`,
+				sql: columnHasNoDefaultCheck({
+					schema,
+					table: tableName,
+					column: columnName
+				})
+			}
+		]
+	};
+}
+
+//#endregion
+//#region src/core/migrations/planner-strategies.ts
+const REBUILD_SUFFIX = "__prisma_next_new";
+function buildColumnSpec(table, column, ctx, overrides) {
+	const col = ctx.toContract.storage.tables[table]?.columns[column];
+	if (!col) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
+	const mutableHooks = ctx.codecHooks;
+	const mutableTypes = ctx.storageTypes;
+	return {
+		name: column,
+		typeSql: buildColumnTypeSql(col, mutableHooks, mutableTypes),
+		defaultSql: buildColumnDefaultSql(col.default, col),
+		nullable: overrides?.nullable ?? col.nullable
+	};
+}
+function buildAlterTypeOptions(table, column, ctx, using) {
+	const col = ctx.toContract.storage.tables[table]?.columns[column];
+	if (!col) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
+	const mutableHooks = ctx.codecHooks;
+	const mutableTypes = ctx.storageTypes;
+	const qualifiedTargetType = buildColumnTypeSql(col, mutableHooks, mutableTypes, false);
+	return {
+		qualifiedTargetType,
+		formatTypeExpected: buildExpectedFormatType(col, mutableHooks, mutableTypes),
+		rawTargetTypeForLabel: qualifiedTargetType,
+		...using !== void 0 ? { using } : {}
+	};
+}
+const notNullBackfillCallStrategy = (issues, ctx) => {
+	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
+	const matched = [];
+	const calls = [];
+	for (const issue of issues) {
+		if (issue.kind !== "missing_column" || !issue.table || !issue.column) continue;
+		const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+		if (!column) continue;
+		if (column.nullable === true || column.default !== void 0) continue;
+		matched.push(issue);
+		const spec = buildColumnSpec(issue.table, issue.column, ctx, { nullable: true });
+		calls.push(new AddColumnCall(ctx.schemaName, issue.table, spec), new DataTransformCall(`backfill-${issue.table}-${issue.column}`, `backfill-${issue.table}-${issue.column}:check`, `backfill-${issue.table}-${issue.column}:run`), new SetNotNullCall(ctx.schemaName, issue.table, issue.column));
+	}
+	if (matched.length === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: issues.filter((i) => !matched.includes(i)),
+		calls,
+		recipe: true
+	};
+};
+const SAFE_WIDENINGS = new Set([
+	"int2→int4",
+	"int2→int8",
+	"int4→int8",
+	"float4→float8"
+]);
+const typeChangeCallStrategy = (issues, ctx) => {
+	const dataAllowed = ctx.policy.allowedOperationClasses.includes("data");
+	const matched = [];
+	const calls = [];
+	for (const issue of issues) {
+		if (issue.kind !== "type_mismatch") continue;
+		if (!issue.table || !issue.column) continue;
+		const fromColumn = ctx.fromContract?.storage.tables[issue.table]?.columns[issue.column];
+		const toColumn = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+		if (!fromColumn || !toColumn) continue;
+		const fromType = fromColumn.nativeType;
+		const toType = toColumn.nativeType;
+		if (fromType === toType) continue;
+		const isSafeWidening = SAFE_WIDENINGS.has(`${fromType}→${toType}`);
+		if (!isSafeWidening && !dataAllowed) continue;
+		matched.push(issue);
+		const alterOpts = buildAlterTypeOptions(issue.table, issue.column, ctx);
+		if (isSafeWidening) calls.push(new AlterColumnTypeCall(ctx.schemaName, issue.table, issue.column, alterOpts));
+		else calls.push(new DataTransformCall(`typechange-${issue.table}-${issue.column}`, `typechange-${issue.table}-${issue.column}:check`, `typechange-${issue.table}-${issue.column}:run`), new AlterColumnTypeCall(ctx.schemaName, issue.table, issue.column, alterOpts));
+	}
+	if (matched.length === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: issues.filter((i) => !matched.includes(i)),
+		calls,
+		recipe: true
+	};
+};
+const nullableTighteningCallStrategy = (issues, ctx) => {
+	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
+	const matched = [];
+	const calls = [];
+	for (const issue of issues) {
+		if (issue.kind !== "nullability_mismatch" || !issue.table || !issue.column) continue;
+		const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+		if (!column) continue;
+		if (column.nullable === true) continue;
+		matched.push(issue);
+		calls.push(new DataTransformCall(`handle-nulls-${issue.table}-${issue.column}`, `handle-nulls-${issue.table}-${issue.column}:check`, `handle-nulls-${issue.table}-${issue.column}:run`), new SetNotNullCall(ctx.schemaName, issue.table, issue.column));
+	}
+	if (matched.length === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: issues.filter((i) => !matched.includes(i)),
+		calls,
+		recipe: true
+	};
+};
+function enumRebuildCallRecipe(typeName, ctx) {
+	const toType = ctx.toContract.storage.types?.[typeName];
+	if (!toType) return [];
+	const nativeType = toType.nativeType;
+	const desiredValues = toType.typeParams["values"] ?? [];
+	const tempName = `${nativeType}${REBUILD_SUFFIX}`;
+	const columnRefs = [];
+	for (const [tableName, table] of Object.entries(ctx.toContract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeRef === typeName) columnRefs.push({
+		table: tableName,
+		column: columnName
+	});
+	return [
+		new CreateEnumTypeCall(ctx.schemaName, tempName, desiredValues),
+		...columnRefs.map((ref) => {
+			const using = `${ref.column}::text::${tempName}`;
+			return new AlterColumnTypeCall(ctx.schemaName, ref.table, ref.column, {
+				qualifiedTargetType: tempName,
+				formatTypeExpected: tempName,
+				rawTargetTypeForLabel: tempName,
+				using
+			});
+		}),
+		new DropEnumTypeCall(ctx.schemaName, nativeType),
+		new RenameTypeCall(ctx.schemaName, tempName, nativeType)
+	];
+}
+const enumChangeCallStrategy = (issues, ctx) => {
+	if (!ctx.policy.allowedOperationClasses.includes("data")) return { kind: "no_match" };
+	const matched = [];
+	const calls = [];
+	for (const issue of issues) {
+		if (issue.kind !== "enum_values_changed") continue;
+		matched.push(issue);
+		if (issue.removedValues.length > 0) calls.push(new DataTransformCall(`migrate-${issue.typeName}-values`, `migrate-${issue.typeName}-values:check`, `migrate-${issue.typeName}-values:run`), ...enumRebuildCallRecipe(issue.typeName, ctx));
+		else if (issue.addedValues.length === 0) calls.push(...enumRebuildCallRecipe(issue.typeName, ctx));
+		else {
+			const toType = ctx.toContract.storage.types?.[issue.typeName];
+			if (toType) calls.push(new AddEnumValuesCall(ctx.schemaName, issue.typeName, toType.nativeType, issue.addedValues));
+		}
+	}
+	if (matched.length === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: issues.filter((i) => !matched.includes(i)),
+		calls,
+		recipe: true
+	};
+};
+/**
+* Dispatches storage types through their codec's `planTypeOperations` hook.
+* Replaces the walk-schema `buildStorageTypeOperations` path: the hook is
+* the authoritative source for codec-driven DDL (enum create/rebuild/add-
+* value, custom type creation, etc.).
+*
+* Runs after `enumChangeCallStrategy` so the structured enum path (value
+* add, rebuild recipe) gets first pick at `enum_values_changed` issues;
+* this strategy then handles remaining `type_missing` / `enum_values_changed`
+* issues for types whose hook produced at least one op.
+*/
+const storageTypePlanCallStrategy = (issues, ctx) => {
+	const storageTypes = ctx.toContract.storage.types ?? {};
+	if (Object.keys(storageTypes).length === 0) return { kind: "no_match" };
+	const calls = [];
+	const handledTypeNames = /* @__PURE__ */ new Set();
+	for (const [typeName, typeInstance] of Object.entries(storageTypes).sort(([a], [b]) => a.localeCompare(b))) {
+		const hook = ctx.codecHooks.get(typeInstance.codecId);
+		if (!hook?.planTypeOperations) continue;
+		const planResult = hook.planTypeOperations({
+			typeName,
+			typeInstance,
+			contract: ctx.toContract,
+			schema: ctx.schema,
+			schemaName: ctx.schemaName,
+			policy: ctx.policy
+		});
+		if (!planResult) continue;
+		if (planResult.operations.length === 0) {
+			handledTypeNames.add(typeName);
+			continue;
+		}
+		handledTypeNames.add(typeName);
+		for (const op of planResult.operations) calls.push(new RawSqlCall({
+			...op,
+			target: {
+				id: op.target.id,
+				details: buildTargetDetails("type", typeName, ctx.schemaName)
+			}
+		}));
+	}
+	const remaining = issues.filter((issue) => !((issue.kind === "type_missing" || issue.kind === "enum_values_changed") && issue.typeName && handledTypeNames.has(issue.typeName)));
+	if (calls.length === 0 && remaining.length === issues.length) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: remaining,
+		calls
+	};
+};
+/**
+* Dispatches component-declared database dependencies. Replaces the
+* walk-schema `buildDatabaseDependencyOperations` path. Rather than consuming
+* `dependency_missing` issues (which only carry the id), this strategy
+* re-invokes `collectInitDependencies(frameworkComponents)` at plan time so
+* the handler has access to the structured `install` ops each component
+* declared — including arbitrary SQL launders — and dedupes by dependency id
+* plus per-op id.
+*/
+const dependencyInstallCallStrategy = (issues, ctx) => {
+	const installedIds = new Set(ctx.schema.dependencies.map((d) => d.id));
+	const dependencies = sortDependencies(collectInitDependencies(ctx.frameworkComponents).filter(isPostgresPlannerDependency));
+	const calls = [];
+	const handledDependencyIds = /* @__PURE__ */ new Set();
+	const seenOperationIds = /* @__PURE__ */ new Set();
+	for (const dep of dependencies) {
+		handledDependencyIds.add(dep.id);
+		if (installedIds.has(dep.id)) continue;
+		for (const installOp of dep.install) {
+			if (seenOperationIds.has(installOp.id)) continue;
+			seenOperationIds.add(installOp.id);
+			calls.push(liftInstallOpToCall(installOp));
+		}
+	}
+	const remaining = issues.filter((issue) => issue.kind !== "dependency_missing");
+	if (calls.length === 0 && remaining.length === issues.length) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: remaining,
+		calls
+	};
+};
+/**
+* Handles `missing_column` issues for NOT NULL columns without a contract
+* default. Replaces the walk-schema `buildAddColumnItem` non-default branches.
+*
+* Two shapes:
+*  - Shared-temp-default safe: emit a single atomic composite op (add
+*    nullable → backfill identity value → `SET NOT NULL` → `DROP DEFAULT`).
+*  - Empty-table guarded: emit a hand-built op with a `tableIsEmptyCheck`
+*    precheck so the failure message is "table is not empty" rather than the
+*    raw PG NOT NULL violation.
+*
+* "Normal" missing_column cases (nullable or has a contract default) are left
+* for `mapIssueToCall`'s default `AddColumnCall` emission.
+*/
+const notNullAddColumnCallStrategy = (issues, ctx) => {
+	const matched = [];
+	const calls = [];
+	const schemaLookups = buildSchemaLookupMap(ctx.schema);
+	const mutableCodecHooks = ctx.codecHooks;
+	const mutableStorageTypes = ctx.storageTypes;
+	for (const issue of issues) {
+		if (issue.kind !== "missing_column" || !issue.table || !issue.column) continue;
+		const contractTable = ctx.toContract.storage.tables[issue.table];
+		const column = contractTable?.columns[issue.column];
+		if (!column) continue;
+		const notNull = column.nullable !== true;
+		const hasDefault = column.default !== void 0;
+		if (!notNull || hasDefault) continue;
+		const schemaTable = ctx.schema.tables[issue.table];
+		if (!schemaTable) continue;
+		const temporaryDefault = resolveIdentityValue(column, mutableCodecHooks, mutableStorageTypes);
+		const schemaLookup = schemaLookups.get(issue.table);
+		const canUseSharedTempDefault = temporaryDefault !== null && canUseSharedTemporaryDefaultStrategy({
+			table: contractTable,
+			schemaTable,
+			schemaLookup,
+			columnName: issue.column
+		});
+		matched.push(issue);
+		if (canUseSharedTempDefault && temporaryDefault !== null) {
+			calls.push(new RawSqlCall(buildAddNotNullColumnWithTemporaryDefaultOperation({
+				schema: ctx.schemaName,
+				tableName: issue.table,
+				columnName: issue.column,
+				column,
+				codecHooks: mutableCodecHooks,
+				storageTypes: mutableStorageTypes,
+				temporaryDefault
+			})));
+			continue;
+		}
+		const qualified = qualifyTableName(ctx.schemaName, issue.table);
+		calls.push(new RawSqlCall({
+			...buildAddColumnOperationIdentity(ctx.schemaName, issue.table, issue.column),
+			operationClass: "additive",
+			precheck: [{
+				description: `ensure column "${issue.column}" is missing`,
+				sql: columnExistsCheck({
+					schema: ctx.schemaName,
+					table: issue.table,
+					column: issue.column,
+					exists: false
+				})
+			}, {
+				description: `ensure table "${issue.table}" is empty before adding NOT NULL column without default`,
+				sql: tableIsEmptyCheck(qualified)
+			}],
+			execute: [{
+				description: `add column "${issue.column}"`,
+				sql: buildAddColumnSql(qualified, issue.column, column, mutableCodecHooks, void 0, mutableStorageTypes)
+			}],
+			postcheck: [{
+				description: `verify column "${issue.column}" exists`,
+				sql: columnExistsCheck({
+					schema: ctx.schemaName,
+					table: issue.table,
+					column: issue.column
+				})
+			}, {
+				description: `verify column "${issue.column}" is NOT NULL`,
+				sql: columnNullabilityCheck({
+					schema: ctx.schemaName,
+					table: issue.table,
+					column: issue.column,
+					nullable: false
+				})
+			}]
+		}));
+	}
+	if (matched.length === 0) return { kind: "no_match" };
+	return {
+		kind: "match",
+		issues: issues.filter((i) => !matched.includes(i)),
+		calls
+	};
+};
+function canUseSharedTemporaryDefaultStrategy(options) {
+	const { table, schemaTable, schemaLookup, columnName } = options;
+	if (table.primaryKey?.columns.includes(columnName) && !schemaTable.primaryKey) return false;
+	for (const unique of table.uniques) {
+		if (!unique.columns.includes(columnName)) continue;
+		if (!schemaLookup || !hasUniqueConstraint(schemaLookup, unique.columns)) return false;
+	}
+	for (const foreignKey of table.foreignKeys) {
+		if (foreignKey.constraint === false || !foreignKey.columns.includes(columnName)) continue;
+		if (!schemaLookup || !hasForeignKey(schemaLookup, foreignKey)) return false;
+	}
+	return true;
+}
+function isPostgresPlannerDependency(dependency) {
+	return dependency.install.every((operation) => operation.target.id === "postgres");
+}
+function sortDependencies(dependencies) {
+	return [...dependencies].sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+* Lift a component install op into migration IR. Structured shapes — extension
+* and schema installs with predictable SQL — collapse to typed `*Call`
+* subclasses so the scaffolded migration authoring surface stays readable.
+* Everything else (arbitrary SQL) falls through to `RawSqlCall` as an escape
+* hatch.
+*/
+/**
+* Component-declared install ops are wrapped as `RawSqlCall` so the
+* component's original `label`, `precheck`, `execute`, `postcheck`, and op
+* id are preserved verbatim. Structured conversion (to e.g.
+* `CreateExtensionCall`) would drop the precheck/postcheck pair and
+* change the DDL label, breaking walk-schema output parity. Classification
+* as `'dep'` happens in `classifyCall` via the underlying op's id prefix.
+*/
+function liftInstallOpToCall(op) {
+	return new RawSqlCall(op);
+}
+/**
+* Ordered list of Postgres planner strategies, shared by `migration plan`
+* and `db update` / `db init`. The issue planner runs each strategy in
+* order, letting it consume any issues it handles, and routes whatever's
+* left through `mapIssueToCall`. Behavior diverges purely on
+* `policy.allowedOperationClasses`:
+*
+* - When `'data'` is allowed (`migration plan`), the data-safe strategies
+*   (`enumChangeCallStrategy`, `notNullBackfillCallStrategy`,
+*   `typeChangeCallStrategy`, `nullableTighteningCallStrategy`) consume their
+*   matching issues and emit `DataTransformCall` placeholders or recipe ops.
+*
+* - When `'data'` is not allowed (`db update` / `db init`), each data-safe
+*   strategy short-circuits to `no_match`, leaving the issue for the
+*   downstream walk-schema strategies (`storageTypePlanCallStrategy`,
+*   `dependencyInstallCallStrategy`, `notNullAddColumnCallStrategy`) or the
+*   `mapIssueToCall` default to handle with direct DDL.
+*
+* Order matters: data-safe strategies must run before the walk-schema
+* strategies on overlapping issue kinds (e.g. `enum_values_changed`,
+* `missing_column` for NOT NULL) so they take priority when active.
+*/
+const postgresPlannerStrategies = [
+	enumChangeCallStrategy,
+	notNullBackfillCallStrategy,
+	typeChangeCallStrategy,
+	nullableTighteningCallStrategy,
+	storageTypePlanCallStrategy,
+	dependencyInstallCallStrategy,
+	notNullAddColumnCallStrategy
+];
+
+//#endregion
+//#region src/core/migrations/issue-planner.ts
+const ISSUE_KIND_ORDER = {
+	dependency_missing: 1,
+	type_missing: 2,
+	type_values_mismatch: 3,
+	enum_values_changed: 3,
+	extra_foreign_key: 10,
+	extra_unique_constraint: 11,
+	extra_primary_key: 12,
+	extra_index: 13,
+	extra_default: 14,
+	extra_column: 15,
+	extra_table: 16,
+	missing_table: 20,
+	missing_column: 30,
+	type_mismatch: 40,
+	nullability_mismatch: 41,
+	default_missing: 42,
+	default_mismatch: 43,
+	primary_key_mismatch: 50,
+	unique_constraint_mismatch: 51,
+	index_mismatch: 52,
+	foreign_key_mismatch: 60
+};
+function issueOrder(issue) {
+	return ISSUE_KIND_ORDER[issue.kind] ?? 99;
+}
+function issueConflict(kind, summary, location) {
+	return {
+		kind,
+		summary,
+		why: "Use `migration new` to author a custom migration for this change.",
+		...location ? { location } : {}
+	};
+}
+function isMissing(issue) {
+	if (issue.kind === "enum_values_changed") return false;
+	return issue.actual === void 0;
+}
+function toColumnSpec(name, column, codecHooks, storageTypes) {
+	return {
+		name,
+		typeSql: buildColumnTypeSql(column, codecHooks, storageTypes),
+		defaultSql: buildColumnDefaultSql(column.default, column),
+		nullable: column.nullable
+	};
+}
+function mapIssueToCall(issue, ctx) {
+	const { schemaName, codecHooks, storageTypes } = ctx;
+	switch (issue.kind) {
+		case "missing_table": {
+			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Missing table issue has no table name"));
+			const contractTable = ctx.toContract.storage.tables[issue.table];
+			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" reported missing but not found in destination contract`));
+			const columns = Object.entries(contractTable.columns).map(([name, column]) => toColumnSpec(name, column, codecHooks, storageTypes));
+			const primaryKey = contractTable.primaryKey ? { columns: contractTable.primaryKey.columns } : void 0;
+			const calls = [new CreateTableCall(schemaName, issue.table, columns, primaryKey)];
+			for (const index of contractTable.indexes) {
+				const indexName = index.name ?? `${issue.table}_${index.columns.join("_")}_idx`;
+				calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...index.columns]));
+			}
+			const explicitIndexColumnSets = new Set(contractTable.indexes.map((idx) => idx.columns.join(",")));
+			for (const fk of contractTable.foreignKeys) {
+				if (fk.constraint) {
+					const fkSpec = {
+						name: fk.name ?? `${issue.table}_${fk.columns.join("_")}_fkey`,
+						columns: fk.columns,
+						references: {
+							table: fk.references.table,
+							columns: fk.references.columns
+						},
+						...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
+						...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
+					};
+					calls.push(new AddForeignKeyCall(schemaName, issue.table, fkSpec));
+				}
+				if (fk.index && !explicitIndexColumnSets.has(fk.columns.join(","))) {
+					const indexName = `${issue.table}_${fk.columns.join("_")}_idx`;
+					calls.push(new CreateIndexCall(schemaName, issue.table, indexName, [...fk.columns]));
+				}
+			}
+			for (const unique of contractTable.uniques) {
+				const constraintName = unique.name ?? `${issue.table}_${unique.columns.join("_")}_key`;
+				calls.push(new AddUniqueCall(schemaName, issue.table, constraintName, [...unique.columns]));
+			}
+			return ok(calls);
+		}
+		case "missing_column":
+			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Missing column issue has no table/column name"));
+			{
+				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				if (!column) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" not in destination contract`));
+				return ok([new AddColumnCall(schemaName, issue.table, toColumnSpec(issue.column, column, codecHooks, storageTypes))]);
+			}
+		case "default_missing":
+			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Default missing issue has no table/column name"));
+			{
+				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				if (!column?.default) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" has no default in contract`));
+				const defaultSql = buildColumnDefaultSql(column.default, column);
+				if (!defaultSql) return ok([]);
+				return ok([new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql)]);
+			}
+		case "extra_table":
+			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra table issue has no table name"));
+			return ok([new DropTableCall(schemaName, issue.table)]);
+		case "extra_column":
+			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra column issue has no table/column name"));
+			return ok([new DropColumnCall(schemaName, issue.table, issue.column)]);
+		case "extra_index":
+			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Extra index issue has no table/index name"));
+			return ok([new DropIndexCall(schemaName, issue.table, issue.indexOrConstraint)]);
+		case "extra_unique_constraint":
+		case "extra_foreign_key":
+		case "extra_primary_key": {
+			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Extra constraint issue has no table/constraint name"));
+			const constraintName = issue.indexOrConstraint ?? (issue.kind === "extra_primary_key" ? `${issue.table}_pkey` : void 0);
+			if (!constraintName) return notOk(issueConflict("unsupportedOperation", "Extra constraint issue has no table/constraint name"));
+			return ok([new DropConstraintCall(schemaName, issue.table, constraintName, {
+				extra_unique_constraint: "unique",
+				extra_foreign_key: "foreignKey",
+				extra_primary_key: "primaryKey"
+			}[issue.kind])]);
+		}
+		case "extra_default":
+			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Extra default issue has no table/column name"));
+			return ok([new DropDefaultCall(schemaName, issue.table, issue.column)]);
+		case "nullability_mismatch": {
+			if (!issue.table || !issue.column) return notOk(issueConflict("nullabilityConflict", "Nullability mismatch has no table/column name"));
+			const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+			if (!column) return notOk(issueConflict("nullabilityConflict", `Column "${issue.table}"."${issue.column}" not found in destination contract`));
+			return ok(column.nullable ? [new DropNotNullCall(schemaName, issue.table, issue.column)] : [new SetNotNullCall(schemaName, issue.table, issue.column)]);
+		}
+		case "type_mismatch":
+			if (!issue.table || !issue.column) return notOk(issueConflict("typeMismatch", "Type mismatch has no table/column name"));
+			{
+				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				if (!column) return notOk(issueConflict("typeMismatch", `Column "${issue.table}"."${issue.column}" not in destination contract`));
+				const hooksMap = codecHooks;
+				const typesMap = storageTypes;
+				const qualifiedTargetType = buildColumnTypeSql(column, hooksMap, typesMap, false);
+				const formatTypeExpected = buildExpectedFormatType(column, hooksMap, typesMap);
+				return ok([new AlterColumnTypeCall(schemaName, issue.table, issue.column, {
+					qualifiedTargetType,
+					formatTypeExpected,
+					rawTargetTypeForLabel: qualifiedTargetType
+				})]);
+			}
+		case "default_mismatch":
+			if (!issue.table || !issue.column) return notOk(issueConflict("unsupportedOperation", "Default mismatch has no table/column name"));
+			{
+				const column = ctx.toContract.storage.tables[issue.table]?.columns[issue.column];
+				if (!column?.default) return ok([]);
+				const defaultSql = buildColumnDefaultSql(column.default, column);
+				if (!defaultSql) return ok([]);
+				return ok([new SetDefaultCall(schemaName, issue.table, issue.column, defaultSql, "widening")]);
+			}
+		case "primary_key_mismatch":
+			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Primary key issue has no table name"));
+			if (isMissing(issue)) {
+				const pk = ctx.toContract.storage.tables[issue.table]?.primaryKey;
+				if (!pk) return notOk(issueConflict("indexIncompatible", `No primary key in contract for "${issue.table}"`));
+				const constraintName = pk.name ?? `${issue.table}_pkey`;
+				return ok([new AddPrimaryKeyCall(schemaName, issue.table, constraintName, pk.columns)]);
+			}
+			return notOk(issueConflict("indexIncompatible", `Primary key on "${issue.table}" has different columns (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
+		case "unique_constraint_mismatch":
+			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Unique constraint issue has no table name"));
+			if (isMissing(issue) && issue.expected) {
+				const columns = issue.expected.split(", ");
+				const constraintName = `${issue.table}_${columns.join("_")}_key`;
+				return ok([new AddUniqueCall(schemaName, issue.table, constraintName, columns)]);
+			}
+			return notOk(issueConflict("indexIncompatible", `Unique constraint on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
+		case "index_mismatch":
+			if (!issue.table) return notOk(issueConflict("indexIncompatible", "Index issue has no table name"));
+			if (isMissing(issue) && issue.expected) {
+				const columns = issue.expected.split(", ");
+				const indexName = `${issue.table}_${columns.join("_")}_idx`;
+				return ok([new CreateIndexCall(schemaName, issue.table, indexName, columns)]);
+			}
+			return notOk(issueConflict("indexIncompatible", `Index on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
+		case "foreign_key_mismatch":
+			if (!issue.table) return notOk(issueConflict("foreignKeyConflict", "Foreign key issue has no table name"));
+			if (isMissing(issue) && issue.expected) {
+				const arrowIdx = issue.expected.indexOf(" -> ");
+				if (arrowIdx >= 0) {
+					const columns = issue.expected.slice(0, arrowIdx).split(", ");
+					const fkName = `${issue.table}_${columns.join("_")}_fkey`;
+					const fk = ctx.toContract.storage.tables[issue.table]?.foreignKeys.find((k) => k.columns.join(", ") === columns.join(", "));
+					if (fk) {
+						const fkSpec = {
+							name: fkName,
+							columns: fk.columns,
+							references: {
+								table: fk.references.table,
+								columns: fk.references.columns
+							},
+							...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
+							...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
+						};
+						return ok([new AddForeignKeyCall(schemaName, issue.table, fkSpec)]);
+					}
+					return notOk(issueConflict("foreignKeyConflict", `Foreign key on "${issue.table}" (${columns.join(", ")}) not found in destination contract`, { table: issue.table }));
+				}
+			}
+			return notOk(issueConflict("foreignKeyConflict", `Foreign key on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
+		case "type_missing": {
+			if (!issue.typeName) return notOk(issueConflict("unsupportedOperation", "Type missing issue has no typeName"));
+			const typeInstance = ctx.toContract.storage.types?.[issue.typeName];
+			if (!typeInstance) return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" reported missing but not found in destination contract`));
+			if (typeInstance.codecId.startsWith("pg/enum")) {
+				const values = typeInstance.typeParams["values"] ?? [];
+				return ok([new CreateEnumTypeCall(schemaName, typeInstance.nativeType, values)]);
+			}
+			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only enum types are supported`));
+		}
+		case "type_values_mismatch": return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName ?? "unknown"}" values differ — type alteration not yet supported`));
+		case "dependency_missing":
+			if (!issue.dependencyId) return notOk(issueConflict("unsupportedOperation", "Dependency missing issue has no dependencyId"));
+			if (issue.dependencyId.startsWith("ext:")) return ok([new CreateExtensionCall(issue.dependencyId.slice(4))]);
+			if (issue.dependencyId.startsWith("schema:")) return ok([new CreateSchemaCall(issue.dependencyId.slice(7))]);
+			return notOk(issueConflict("unsupportedOperation", `Unknown dependency type: ${issue.dependencyId}`));
+		default: return notOk(issueConflict("unsupportedOperation", `Unhandled issue kind: ${issue.kind}`));
+	}
+}
+/**
+* Classifies calls into DDL sequencing buckets. The order matches the
+* legacy walk-schema planner's emission order so `db init` and `db update`
+* produce byte-identical plans for the shared shape (deps → drops → tables
+* → columns → alters → PKs → uniques → indexes → FKs).
+*/
+function classifyCall(call) {
+	switch (call.factoryName) {
+		case "createExtension":
+		case "createSchema":
+		case "createEnumType":
+		case "addEnumValues":
+		case "dropEnumType":
+		case "renameType": return "dep";
+		case "dropTable":
+		case "dropColumn":
+		case "dropConstraint":
+		case "dropIndex":
+		case "dropDefault": return "drop";
+		case "createTable": return "table";
+		case "addColumn": return "column";
+		case "alterColumnType":
+		case "setNotNull":
+		case "dropNotNull":
+		case "setDefault": return "alter";
+		case "addPrimaryKey": return "primaryKey";
+		case "addUnique": return "unique";
+		case "createIndex": return "index";
+		case "addForeignKey": return "foreignKey";
+		case "rawSql": {
+			const op = call.op;
+			if (op?.target?.details?.objectType === "type") return "dep";
+			const id = typeof op?.id === "string" ? op.id : "";
+			if (id.startsWith("extension.") || id.startsWith("schema.")) return "dep";
+			return "alter";
+		}
+		default: return "alter";
+	}
+}
+/** Stable lexical key used to order issues within the same kind bucket. */
+function issueKey(issue) {
+	return `${"table" in issue && typeof issue.table === "string" ? issue.table : ""}\u0000${"column" in issue && typeof issue.column === "string" ? issue.column : ""}\u0000${"indexOrConstraint" in issue && typeof issue.indexOrConstraint === "string" ? issue.indexOrConstraint : ""}`;
+}
+const DEFAULT_POLICY = { allowedOperationClasses: [
+	"additive",
+	"widening",
+	"destructive",
+	"data"
+] };
+function emptySchemaIR() {
+	return {
+		tables: {},
+		dependencies: []
+	};
+}
+function conflictKindForCall(call) {
+	switch (call.factoryName) {
+		case "alterColumnType": return "typeMismatch";
+		case "setNotNull":
+		case "dropNotNull": return "nullabilityConflict";
+		case "addForeignKey":
+		case "dropConstraint": return "foreignKeyConflict";
+		case "createIndex":
+		case "dropIndex": return "indexIncompatible";
+		default: return "missingButNonAdditive";
+	}
+}
+function locationForCall(call) {
+	const anyCall = call;
+	const location = {};
+	if (anyCall.tableName) location.table = anyCall.tableName;
+	if (anyCall.columnName) location.column = anyCall.columnName;
+	if (anyCall.indexName) location.index = anyCall.indexName;
+	if (anyCall.constraintName) location.constraint = anyCall.constraintName;
+	if (anyCall.typeName) location.type = anyCall.typeName;
+	return Object.keys(location).length > 0 ? location : void 0;
+}
+function conflictForDisallowedCall(call, allowed) {
+	const summary = `Operation "${call.label}" requires class "${call.operationClass}", but policy allows only: ${allowed.join(", ")}`;
+	const location = locationForCall(call);
+	return {
+		kind: conflictKindForCall(call),
+		summary,
+		why: "Use `migration new` to author a custom migration for this change.",
+		...location ? { location } : {}
+	};
+}
+function planIssues(options) {
+	const policyProvided = options.policy !== void 0;
+	const policy = options.policy ?? DEFAULT_POLICY;
+	const schema = options.schema ?? emptySchemaIR();
+	const frameworkComponents = options.frameworkComponents ?? [];
+	const context = {
+		toContract: options.toContract,
+		fromContract: options.fromContract,
+		schemaName: options.schemaName,
+		codecHooks: options.codecHooks,
+		storageTypes: options.storageTypes,
+		schema,
+		policy,
+		frameworkComponents
+	};
+	const strategies = options.strategies ?? postgresPlannerStrategies;
+	let remaining = options.issues;
+	const recipeCalls = [];
+	const bucketablePatternCalls = [];
+	for (const strategy of strategies) {
+		const result = strategy(remaining, context);
+		if (result.kind === "match") {
+			remaining = result.issues;
+			if (result.recipe) recipeCalls.push(...result.calls);
+			else bucketablePatternCalls.push(...result.calls);
+		}
+	}
+	const sorted = [...remaining].sort((a, b) => {
+		const kindDelta = issueOrder(a) - issueOrder(b);
+		if (kindDelta !== 0) return kindDelta;
+		const keyA = issueKey(a);
+		const keyB = issueKey(b);
+		return keyA < keyB ? -1 : keyA > keyB ? 1 : 0;
+	});
+	const defaultCalls = [];
+	const conflicts = [];
+	for (const issue of sorted) {
+		const result = mapIssueToCall(issue, context);
+		if (result.ok) defaultCalls.push(...result.value);
+		else conflicts.push(result.failure);
+	}
+	const allowed = policy.allowedOperationClasses;
+	let gatedDefault = defaultCalls;
+	let gatedRecipe = recipeCalls;
+	let gatedBucketable = bucketablePatternCalls;
+	if (policyProvided) {
+		const keepIfAllowed = (bucket) => (call) => {
+			if (allowed.includes(call.operationClass)) {
+				bucket.push(call);
+				return;
+			}
+			conflicts.push(conflictForDisallowedCall(call, allowed));
+		};
+		const gatedDefaultBucket = [];
+		const gatedRecipeBucket = [];
+		const gatedBucketableBucket = [];
+		defaultCalls.forEach(keepIfAllowed(gatedDefaultBucket));
+		recipeCalls.forEach(keepIfAllowed(gatedRecipeBucket));
+		bucketablePatternCalls.forEach(keepIfAllowed(gatedBucketableBucket));
+		gatedDefault = gatedDefaultBucket;
+		gatedRecipe = gatedRecipeBucket;
+		gatedBucketable = gatedBucketableBucket;
+	}
+	if (conflicts.length > 0) return notOk(conflicts);
+	const combinedBucketable = [...gatedDefault, ...gatedBucketable];
+	const byCategory = (cat) => combinedBucketable.filter((c) => classifyCall(c) === cat);
+	return ok({ calls: [
+		...byCategory("dep"),
+		...byCategory("drop"),
+		...byCategory("table"),
+		...byCategory("column"),
+		...gatedRecipe,
+		...byCategory("alter"),
+		...byCategory("primaryKey"),
+		...byCategory("unique"),
+		...byCategory("index"),
+		...byCategory("foreignKey")
+	] });
+}
+
+//#endregion
+export { postgresPlannerStrategies as n, planIssues as t };
+//# sourceMappingURL=issue-planner-CFjB0_oO.mjs.map