@prisma-next/target-postgres 0.14.0-dev.49 → 0.14.0-dev.50

package/dist/issue-planner-Cbh-xTEr.mjs

@@ -1,849 +0,0 @@
-import { r as isPostgresSchema } from "./postgres-schema-CajYAwny.mjs";
-import { i as quoteIdentifier } from "./sql-utils-DcfMz4MQ.mjs";
-import { D as postgresDefaultToDdlColumnDefault, E as SetNotNullCall, O as buildTargetDetails, S as DropTableCall, T as SetDefaultCall, _ as DropConstraintCall, a as AddNotNullColumnWithTempDefaultCall, b as DropNotNullCall, c as AlterColumnTypeCall, f as CreateSchemaCall, g as DropColumnCall, h as DropCheckConstraintCall, i as AddNotNullColumnDirectCall, m as DataTransformCall, n as AddColumnCall, o as AddPrimaryKeyCall, p as CreateTableCall, r as AddForeignKeyCall, s as AddUniqueCall, t as AddCheckConstraintCall, u as CreateIndexCall, v as DropDefaultCall, w as RawSqlCall, y as DropIndexCall } from "./op-factory-call-BuoGT5UI.mjs";
-import { t as resolveColumnTypeMetadata } from "./planner-type-resolution-Bt2f_q-F.mjs";
-import { t as buildExpectedFormatType } from "./planner-sql-checks-Cze3vMfe.mjs";
-import { n as buildColumnTypeSql, t as buildColumnDefaultSql } from "./planner-ddl-builders-B8Nn6nHN.mjs";
-import { n as resolveIdentityValue } from "./planner-identity-values-CJPha2Sz.mjs";
-import { i as hasUniqueConstraint, n as hasForeignKey, t as buildSchemaLookupMap } from "./planner-schema-lookup-CiVaAQP-.mjs";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { blindCast } from "@prisma-next/utils/casts";
-import { StorageTable } from "@prisma-next/sql-contract/types";
-import { resolveValueSetValues } from "@prisma-next/family-sql/control";
-import { ifDefined } from "@prisma-next/utils/defined";
-import * as contractFree from "@prisma-next/sql-relational-core/contract-free";
-import { col } from "@prisma-next/sql-relational-core/contract-free";
-import { arraysEqual } from "@prisma-next/family-sql/diff";
-import { notOk, ok } from "@prisma-next/utils/result";
-//#region src/core/migrations/planner-strategies.ts
-/**
-* Look up a storage table by its explicit namespace coordinate. Returns
-* `undefined` when the namespace has no table by that name (or no such
-* namespace exists). Callers that get `undefined` MUST treat it as an
-* explicit conflict — never silently fall back to a global default
-* schema or a name-only walk, because that footgun would resolve a
-* stale or duplicate table name to whichever namespace the iteration
-* order surfaced first (a real data-loss hazard in multi-namespace
-* contracts where two namespaces can carry the same table name).
-*/
-function tableAt(storage, namespaceId, tableName) {
-	const ns = storage.namespaces[namespaceId];
-	if (ns === void 0) return void 0;
-	return ns.entries.table?.[tableName];
-}
-/**
-* Default namespace coordinate for an issue that does not carry one
-* explicitly. Hand-crafted unit-test issues and `extra_table` issues
-* fall back to `__unbound__`, the only namespace any single-namespace
-* contract carries — verifier-emitted issues for legacy
-* single-namespace contracts already stamp this id explicitly. Typed
-* structurally so issue variants without a `namespaceId` slot
-* (e.g. `EnumValuesChangedIssue`) flow through to the same fallback.
-*/
-function resolveNamespaceIdForIssue(issue) {
-	return issue.namespaceId ?? UNBOUND_NAMESPACE_ID;
-}
-/**
-* Resolve the DDL schema name for a namespace coordinate. Postgres-aware
-* namespaces dispatch to their polymorphic `ddlSchemaName` override —
-* named schemas return their own id; the unbound singleton returns
-* `UNBOUND_NAMESPACE_ID`. Legacy single-namespace contracts whose
-* `__unbound__` slot is the framework-default `SqlUnboundNamespace`
-* (rather than the Postgres-aware `PostgresUnboundSchema`) flow the
-* coordinate through unchanged so downstream `qualifyTableName`
-* resolves polymorphically.
-*/
-function resolveDdlSchemaForNamespace(ctx, namespaceId) {
-	const namespace = ctx.toContract.storage.namespaces[namespaceId];
-	if (isPostgresSchema(namespace)) return namespace.ddlSchemaName(ctx.toContract.storage);
-	return namespaceId;
-}
-function buildColumnSpec(namespaceId, table, column, ctx, overrides) {
-	const storageCol = tableAt(ctx.toContract.storage, namespaceId, table)?.columns[column];
-	if (!storageCol) throw new Error(`Column "${table}"."${column}" not found in destination contract`);
-	const mutableHooks = ctx.codecHooks;
-	const mutableTypes = ctx.storageTypes;
-	const typeSql = buildColumnTypeSql(storageCol, mutableHooks, mutableTypes);
-	const ddlDefault = postgresDefaultToDdlColumnDefault(storageCol.default);
-	const resolved = resolveColumnTypeMetadata(storageCol, mutableTypes);
-	const typeParams = resolved.typeParams === void 0 ? void 0 : blindCast(resolved.typeParams);
-	const codecRef = resolved.codecId ? {
-		codecId: resolved.codecId,
-		...ifDefined("typeParams", typeParams)
-	} : void 0;
-	return col(column, typeSql, {
-		...!(overrides?.nullable ?? storageCol.nullable) ? { notNull: true } : {},
-		...ifDefined("default", ddlDefault),
-		...ifDefined("codecRef", codecRef)
-	});
-}
-function buildAlterTypeOptions(namespaceId, table, column, ctx, using) {
-	const col = tableAt(ctx.toContract.storage, namespaceId, 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 namespaceId = resolveNamespaceIdForIssue(issue);
-		const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
-		if (!column) continue;
-		if (column.nullable === true || column.default !== void 0) continue;
-		matched.push(issue);
-		const spec = buildColumnSpec(namespaceId, issue.table, issue.column, ctx, { nullable: true });
-		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
-		calls.push(new AddColumnCall(schemaForTable, issue.table, spec), new DataTransformCall(`backfill-${issue.table}-${issue.column}`, `backfill-${issue.table}-${issue.column}:check`, `backfill-${issue.table}-${issue.column}:run`), new SetNotNullCall(schemaForTable, 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 namespaceId = resolveNamespaceIdForIssue(issue);
-		const fromColumn = ctx.fromContract ? tableAt(ctx.fromContract.storage, namespaceId, issue.table)?.columns[issue.column] : void 0;
-		const toColumn = tableAt(ctx.toContract.storage, namespaceId, 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(namespaceId, issue.table, issue.column, ctx);
-		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
-		if (isSafeWidening) calls.push(new AlterColumnTypeCall(schemaForTable, 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(schemaForTable, 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 namespaceId = resolveNamespaceIdForIssue(issue);
-		const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
-		if (!column) continue;
-		if (column.nullable === true) continue;
-		matched.push(issue);
-		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
-		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(schemaForTable, 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
-	};
-};
-/**
-* Collects every check constraint from a table in the contract storage.
-* Returns an empty array when the table has no checks or the table is absent.
-*/
-function collectContractChecks(storage, namespaceId, tableName) {
-	const ns = storage.namespaces[namespaceId];
-	const tableRaw = ns !== void 0 ? ns.entries.table?.[tableName] : void 0;
-	if (!(tableRaw instanceof StorageTable)) return [];
-	const checks = tableRaw.checks;
-	if (!checks || checks.length === 0) return [];
-	return checks.map((c) => ({
-		name: c.name,
-		column: c.column,
-		permittedValues: resolveValueSetValues(c.valueSet, storage, `check "${c.name}" on "${tableName}"`)
-	}));
-}
-/**
-* Compares two value arrays as unordered sets.
-*/
-function checkValueSetsEqual(a, b) {
-	if (a.length !== b.length) return false;
-	const bSet = new Set(b);
-	return a.every((v) => bSet.has(v));
-}
-/**
-* Plans check-constraint migrations for `enumType`-authored columns.
-*
-* Walks every namespace's tables in the target contract. For each table that
-* carries `checks`, diffs the contract-expected checks against the live
-* schema's checks:
-*
-* - Check in contract, absent from live DB → `AddCheckConstraintCall`.
-* - Check in live DB, absent from contract → `DropCheckConstraintCall`.
-* - Check on both sides but value sets differ → `DropCheckConstraintCall`
-*   then `AddCheckConstraintCall` (drop + recreate; a check predicate cannot
-*   be altered in place).
-*
-* Consumes `check_missing`, `check_removed`, and `check_mismatch` issues.
-*/
-const checkConstraintPlanCallStrategy = (issues, ctx) => {
-	const calls = [];
-	const handledIssueKeys = /* @__PURE__ */ new Set();
-	for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const tableName of Object.keys(ns.entries.table ?? {})) {
-		const contractChecks = collectContractChecks(ctx.toContract.storage, namespaceId, tableName);
-		if (contractChecks.length === 0) continue;
-		const liveChecks = ctx.schema.tables[tableName]?.checks ?? [];
-		const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
-		for (const contractCheck of contractChecks) {
-			const liveCheck = liveChecks.find((c) => c.name === contractCheck.name);
-			const issueKey = `${tableName}${contractCheck.name}`;
-			if (!liveCheck) {
-				calls.push(new AddCheckConstraintCall(ddlSchema, tableName, contractCheck.name, contractCheck.column, contractCheck.permittedValues));
-				handledIssueKeys.add(issueKey);
-			} else if (!checkValueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) {
-				calls.push(new DropCheckConstraintCall(ddlSchema, tableName, contractCheck.name), new AddCheckConstraintCall(ddlSchema, tableName, contractCheck.name, contractCheck.column, contractCheck.permittedValues));
-				handledIssueKeys.add(issueKey);
-			} else handledIssueKeys.add(issueKey);
-		}
-		for (const liveCheck of liveChecks) if (!contractChecks.some((c) => c.name === liveCheck.name)) {
-			const issueKey = `${tableName}${liveCheck.name}`;
-			calls.push(new DropCheckConstraintCall(ddlSchema, tableName, liveCheck.name));
-			handledIssueKeys.add(issueKey);
-		}
-	}
-	if (calls.length === 0 && handledIssueKeys.size === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: issues.filter((issue) => {
-			if (issue.kind !== "check_missing" && issue.kind !== "check_removed" && issue.kind !== "check_mismatch") return true;
-			if (!issue.table || !issue.indexOrConstraint) return true;
-			const key = `${issue.table}${issue.indexOrConstraint}`;
-			return !handledIssueKeys.has(key);
-		}),
-		calls
-	};
-};
-/**
-* Dispatches codec-typed storage types through their codec's
-* `planTypeOperations` hook (the authoritative source for codec-driven DDL
-* such as custom type creation).
-*/
-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 codecInstance = typeInstance;
-		const hook = ctx.codecHooks.get(codecInstance.codecId);
-		if (!hook?.planTypeOperations) continue;
-		const planResult = hook.planTypeOperations({
-			typeName,
-			typeInstance: codecInstance,
-			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
-	};
-};
-/**
-* 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 namespaceId = resolveNamespaceIdForIssue(issue);
-		const contractTable = tableAt(ctx.toContract.storage, namespaceId, 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);
-		const schemaForTable = resolveDdlSchemaForNamespace(ctx, namespaceId);
-		if (canUseSharedTempDefault && temporaryDefault !== null) {
-			calls.push(new AddNotNullColumnWithTempDefaultCall({
-				schemaName: schemaForTable,
-				tableName: issue.table,
-				columnName: issue.column,
-				column,
-				codecHooks: mutableCodecHooks,
-				storageTypes: mutableStorageTypes,
-				temporaryDefault
-			}));
-			continue;
-		}
-		calls.push(new AddNotNullColumnDirectCall(schemaForTable, issue.table, issue.column, buildColumnSpec(namespaceId, issue.table, issue.column, ctx)));
-	}
-	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.source.columns.includes(columnName)) continue;
-		if (!schemaLookup || !hasForeignKey(schemaLookup, foreignKey)) return false;
-	}
-	return true;
-}
-/**
-* 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
-*   (`notNullBackfillCallStrategy`, `typeChangeCallStrategy`,
-*   `nullableTighteningCallStrategy`) consume their matching issues and emit
-*   `DataTransformCall` placeholders or recipe ops.
-*
-* - When `'data'` is not allowed (`db update` / `db init`), the
-*   placeholder-emitting strategies short-circuit to `no_match`, leaving
-*   the issue for the downstream walk-schema strategies
-*   (`storageTypePlanCallStrategy`, `notNullAddColumnCallStrategy`) or the
-*   `mapIssueToCall` default to handle with direct DDL.
-*
-* Codec-typed storage type entries are dispatched through
-* `storageTypePlanCallStrategy`.
-*/
-const postgresPlannerStrategies = [
-	notNullBackfillCallStrategy,
-	typeChangeCallStrategy,
-	nullableTighteningCallStrategy,
-	checkConstraintPlanCallStrategy,
-	storageTypePlanCallStrategy,
-	notNullAddColumnCallStrategy
-];
-//#endregion
-//#region src/core/migrations/issue-planner.ts
-/**
-* Deterministic name for the element-non-null CHECK constraint on a scalar-array
-* column. Distinct `_elem_not_null` suffix avoids collision with the enum
-* value-set `_check` constraints. Re-emitting the same schema produces the same
-* name, so `pg_get_constraintdef`-based verify sees no drift.
-*/
-function elementNonNullCheckName(tableName, columnName) {
-	return `${tableName}_${columnName}_elem_not_null`;
-}
-/**
-* Predicate enforcing that a scalar-array column carries no NULL element. The
-* array column itself may be NULL (container nullability is the column's NOT NULL
-* clause); `array_position` over a NULL array yields NULL, which a CHECK treats
-* as satisfied, so a nullable array column is unaffected.
-*/
-function elementNonNullCheckExpression(columnName) {
-	return `array_position(${quoteIdentifier(columnName)}, NULL) IS NULL`;
-}
-const ISSUE_KIND_ORDER = {
-	missing_schema: 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,
-	check_missing: 53,
-	check_mismatch: 54,
-	check_removed: 55
-};
-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 toDdlColumn(name, column, codecHooks, storageTypes) {
-	const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
-	const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);
-	const resolved = resolveColumnTypeMetadata(column, storageTypes);
-	const codecRef = resolved.codecId ? {
-		codecId: resolved.codecId,
-		...resolved.typeParams !== void 0 ? { typeParams: blindCast(resolved.typeParams) } : {}
-	} : void 0;
-	return contractFree.col(name, typeSql, {
-		...!column.nullable ? { notNull: true } : {},
-		...ifDefined("default", ddlDefault),
-		...ifDefined("codecRef", codecRef)
-	});
-}
-function mapIssueToCall(issue, ctx) {
-	const { schemaName, codecHooks, storageTypes } = ctx;
-	const tableSchema = (issue) => {
-		if (issue.kind === "extra_table") return schemaName;
-		if (!("table" in issue) || !issue.table) return schemaName;
-		return resolveDdlSchemaForNamespace(ctx, resolveNamespaceIdForIssue(issue));
-	};
-	switch (issue.kind) {
-		case "missing_schema": {
-			const namespaceId = issue.namespaceId;
-			if (!namespaceId) return notOk(issueConflict("unsupportedOperation", "Missing schema issue has no namespaceId"));
-			return ok([new CreateSchemaCall(resolveDdlSchemaForNamespace(ctx, namespaceId))]);
-		}
-		case "missing_table": {
-			if (!issue.table) return notOk(issueConflict("unsupportedOperation", "Missing table issue has no table name"));
-			const namespaceId = resolveNamespaceIdForIssue(issue);
-			const contractTable = tableAt(ctx.toContract.storage, namespaceId, issue.table);
-			if (!contractTable) return notOk(issueConflict("unsupportedOperation", `Table "${issue.table}" in namespace "${namespaceId}" reported missing but not found in destination contract`));
-			const schemaForTable = tableSchema(issue);
-			const missingTableName = issue.table;
-			const ddlColumns = Object.entries(contractTable.columns).map(([name, column]) => toDdlColumn(name, column, codecHooks, storageTypes));
-			const primaryKeyConstraints = contractTable.primaryKey ? [contractFree.primaryKey(contractTable.primaryKey.columns, { ...contractTable.primaryKey.name ? { name: contractTable.primaryKey.name } : {} })] : [];
-			const elementNonNullChecks = Object.entries(contractTable.columns).filter(([, column]) => column.many === true).map(([columnName]) => contractFree.checkExpression(elementNonNullCheckName(missingTableName, columnName), elementNonNullCheckExpression(columnName)));
-			const allTableConstraints = [...primaryKeyConstraints, ...elementNonNullChecks];
-			const ddlConstraints = allTableConstraints.length > 0 ? allTableConstraints : void 0;
-			const calls = [new CreateTableCall(schemaForTable, issue.table, ddlColumns, ddlConstraints)];
-			for (const index of contractTable.indexes) {
-				const indexName = index.name ?? `${issue.table}_${index.columns.join("_")}_idx`;
-				const extras = {};
-				if (index.type !== void 0) extras.type = index.type;
-				if (index.options !== void 0) extras.options = index.options;
-				calls.push(new CreateIndexCall(schemaForTable, issue.table, indexName, [...index.columns], extras));
-			}
-			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.source.columns.join("_")}_fkey`,
-						columns: fk.source.columns,
-						references: {
-							schema: fk.target.namespaceId,
-							table: fk.target.tableName,
-							columns: fk.target.columns
-						},
-						...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
-						...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
-					};
-					calls.push(new AddForeignKeyCall(schemaForTable, issue.table, fkSpec));
-				}
-				if (fk.index && !explicitIndexColumnSets.has(fk.source.columns.join(","))) {
-					const indexName = `${issue.table}_${fk.source.columns.join("_")}_idx`;
-					calls.push(new CreateIndexCall(schemaForTable, issue.table, indexName, [...fk.source.columns]));
-				}
-			}
-			for (const unique of contractTable.uniques) {
-				const constraintName = unique.name ?? `${issue.table}_${unique.columns.join("_")}_key`;
-				calls.push(new AddUniqueCall(schemaForTable, 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 namespaceId = resolveNamespaceIdForIssue(issue);
-				const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
-				if (!column) return notOk(issueConflict("unsupportedOperation", `Column "${issue.table}"."${issue.column}" not in destination contract`));
-				return ok([new AddColumnCall(tableSchema(issue), issue.table, toDdlColumn(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 namespaceId = resolveNamespaceIdForIssue(issue);
-				const column = tableAt(ctx.toContract.storage, namespaceId, 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(tableSchema(issue), 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(tableSchema(issue), 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(tableSchema(issue), 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(tableSchema(issue), 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(tableSchema(issue), 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(tableSchema(issue), issue.table, issue.column)]);
-		case "nullability_mismatch": {
-			if (!issue.table || !issue.column) return notOk(issueConflict("nullabilityConflict", "Nullability mismatch has no table/column name"));
-			const namespaceId = resolveNamespaceIdForIssue(issue);
-			const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
-			if (!column) return notOk(issueConflict("nullabilityConflict", `Column "${issue.table}"."${issue.column}" not found in destination contract`));
-			const schemaForTable = tableSchema(issue);
-			return ok(column.nullable ? [new DropNotNullCall(schemaForTable, issue.table, issue.column)] : [new SetNotNullCall(schemaForTable, issue.table, issue.column)]);
-		}
-		case "type_mismatch":
-			if (!issue.table || !issue.column) return notOk(issueConflict("typeMismatch", "Type mismatch has no table/column name"));
-			{
-				const namespaceId = resolveNamespaceIdForIssue(issue);
-				const column = tableAt(ctx.toContract.storage, namespaceId, 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(tableSchema(issue), 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 namespaceId = resolveNamespaceIdForIssue(issue);
-				const column = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.columns[issue.column];
-				if (!column?.default) return ok([]);
-				const defaultSql = buildColumnDefaultSql(column.default, column);
-				if (!defaultSql) return ok([]);
-				return ok([new SetDefaultCall(tableSchema(issue), 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 namespaceId = resolveNamespaceIdForIssue(issue);
-				const pk = tableAt(ctx.toContract.storage, namespaceId, 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(tableSchema(issue), 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(tableSchema(issue), 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 namespaceId = resolveNamespaceIdForIssue(issue);
-				const columns = issue.expected.split(", ");
-				const contractIndex = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.indexes.find((idx) => arraysEqual(idx.columns, columns));
-				const indexName = contractIndex?.name ?? `${issue.table}_${columns.join("_")}_idx`;
-				const extras = {};
-				if (contractIndex?.type !== void 0) extras.type = contractIndex.type;
-				if (contractIndex?.options !== void 0) extras.options = contractIndex.options;
-				return ok([new CreateIndexCall(tableSchema(issue), issue.table, indexName, columns, extras)]);
-			}
-			return notOk(issueConflict("indexIncompatible", `Index on "${issue.table}" differs (expected: ${issue.expected}, actual: ${issue.actual})`, { table: issue.table }));
-		case "check_missing":
-			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Check missing issue has no table/constraint name"));
-			return notOk(issueConflict("unsupportedOperation", `Check constraint "${issue.indexOrConstraint}" missing on "${issue.table}" — handled by checkConstraintPlanCallStrategy`));
-		case "check_mismatch":
-			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Check mismatch issue has no table/constraint name"));
-			return notOk(issueConflict("unsupportedOperation", `Check constraint "${issue.indexOrConstraint}" values mismatch on "${issue.table}" — handled by checkConstraintPlanCallStrategy`));
-		case "check_removed":
-			if (!issue.table || !issue.indexOrConstraint) return notOk(issueConflict("unsupportedOperation", "Check removed issue has no table/constraint name"));
-			return ok([new DropCheckConstraintCall(tableSchema(issue), issue.table, issue.indexOrConstraint)]);
-		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 namespaceId = resolveNamespaceIdForIssue(issue);
-					const columns = issue.expected.slice(0, arrowIdx).split(", ");
-					const fkName = `${issue.table}_${columns.join("_")}_fkey`;
-					const fk = tableAt(ctx.toContract.storage, namespaceId, issue.table)?.foreignKeys.find((k) => k.source.columns.join(", ") === columns.join(", "));
-					if (fk) {
-						const fkSpec = {
-							name: fkName,
-							columns: fk.source.columns,
-							references: {
-								schema: fk.target.namespaceId,
-								table: fk.target.tableName,
-								columns: fk.target.columns
-							},
-							...fk.onDelete !== void 0 && { onDelete: fk.onDelete },
-							...fk.onUpdate !== void 0 && { onUpdate: fk.onUpdate }
-						};
-						return ok([new AddForeignKeyCall(tableSchema(issue), 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`));
-			return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only value-set types are supported`));
-		}
-		case "type_values_mismatch": return notOk(issueConflict("unsupportedOperation", `Type "${issue.typeName ?? "unknown"}" values differ — type alteration not yet supported`));
-		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": return "dep";
-		case "dropTable":
-		case "dropColumn":
-		case "dropConstraint":
-		case "dropCheckConstraint":
-		case "dropIndex":
-		case "dropDefault": return "drop";
-		case "addCheckConstraint": return "unique";
-		case "createTable": return "table";
-		case "enableRowLevelSecurity": return "rlsEnable";
-		case "createRlsPolicy": return "rlsPolicy";
-		case "dropRlsPolicy": return "drop";
-		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":
-			if (call.op?.target?.details?.objectType === "type") 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: {} };
-}
-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-Cbh-xTEr.mjs.map