@prisma-next/target-postgres 0.4.0-dev.9 → 0.4.2

package/src/core/migrations/planner.ts

@@ -1,24 +1,9 @@
-import {
-  normalizeSchemaNativeType,
-  parsePostgresDefault,
-  quoteIdentifier,
-} from '@prisma-next/adapter-postgres/control';
-import { errorPlanDoesNotSupportAuthoringSurface } from '@prisma-next/errors/migration';
 import type {
-  CodecControlHooks,
-  ComponentDatabaseDependency,
   MigrationOperationPolicy,
   SqlMigrationPlannerPlanOptions,
-  SqlMigrationPlanOperation,
-  SqlPlannerConflict,
   SqlPlannerFailureResult,
 } from '@prisma-next/family-sql/control';
-import {
-  collectInitDependencies,
-  createMigrationPlan,
-  extractCodecControlHooks,
-  plannerFailure,
-} from '@prisma-next/family-sql/control';
+import { extractCodecControlHooks, plannerFailure } from '@prisma-next/family-sql/control';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
@@ -27,44 +12,11 @@ import type {
   MigrationScaffoldContext,
   SchemaIssue,
 } from '@prisma-next/framework-components/control';
-import type {
-  StorageColumn,
-  StorageTable,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
-import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
-import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
-import { ifDefined } from '@prisma-next/utils/defined';
-import { buildAddColumnSql, buildCreateTableSql, buildForeignKeySql } from './planner-ddl-builders';
-import { resolveIdentityValue } from './planner-identity-values';
-import {
-  buildAddColumnOperationIdentity,
-  buildAddNotNullColumnWithTemporaryDefaultOperation,
-} from './planner-recipes';
-import { buildReconciliationPlan } from './planner-reconciliation';
-import {
-  buildSchemaLookupMap,
-  hasForeignKey,
-  hasIndex,
-  hasUniqueConstraint,
-  type SchemaTableLookup,
-} from './planner-schema-lookup';
-import {
-  columnExistsCheck,
-  columnNullabilityCheck,
-  constraintExistsCheck,
-  qualifyTableName,
-  tableHasPrimaryKeyCheck,
-  tableIsEmptyCheck,
-  toRegclassLiteral,
-} from './planner-sql-checks';
-import {
-  buildTargetDetails,
-  type OperationClass,
-  type PlanningMode,
-  type PostgresPlanTargetDetails,
-} from './planner-target-details';
-import { renderDescriptorTypeScript } from './scaffolding';
+import { parsePostgresDefault } from '../default-normalizer';
+import { normalizeSchemaNativeType } from '../native-type-normalizer';
+import { planIssues } from './issue-planner';
+import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
+import { postgresPlannerStrategies } from './planner-strategies';
 
 type PlannerFrameworkComponents = SqlMigrationPlannerPlanOptions extends {
   readonly frameworkComponents: infer T;
@@ -80,12 +32,6 @@ type VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0
   readonly frameworkComponents: PlannerFrameworkComponents;
 };
 
-type PlannerDatabaseDependency = {
-  readonly id: string;
-  readonly label: string;
-  readonly install: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[];
-};
-
 interface PlannerConfig {
   readonly defaultSchema: string;
 }
@@ -104,44 +50,31 @@ export function createPostgresMigrationPlanner(
 }
 
 /**
- * Postgres planner success plan: the SQL-typed plan (so target-detail
- * typing is preserved for direct SQL callers, including this package's unit
- * tests) plus the framework-required `renderTypeScript()` stub.
- */
-export type PostgresPlanWithRender = ReturnType<
-  typeof createMigrationPlan<PostgresPlanTargetDetails>
-> & {
-  renderTypeScript(): string;
-};
-
-/**
- * Result of `PostgresMigrationPlanner.plan()`. A discriminated union that
- * satisfies both the framework's `MigrationPlannerResult` (success plan
- * carries `renderTypeScript()`) and the SQL family's typed result shape
- * (success plan is a `SqlMigrationPlan<PostgresPlanTargetDetails>`).
+ * Result of `PostgresMigrationPlanner.plan()`. A discriminated union whose
+ * success variant carries a `TypeScriptRenderablePostgresMigration` — a
+ * migration object that both the CLI (via `renderTypeScript()`) and the
+ * SQL-typed callers (via `operations`, `describe()`, etc.) consume
+ * uniformly.
  */
 export type PostgresPlanResult =
-  | { readonly kind: 'success'; readonly plan: PostgresPlanWithRender }
+  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }
   | SqlPlannerFailureResult;
 
 /**
- * Postgres migration planner.
- *
- * Implements the framework's `MigrationPlanner<'sql', 'postgres'>` directly
- * — meaning it owns `emptyMigration()` and attaches the `renderTypeScript()`
- * stub to success plans (Postgres uses descriptor-flow authoring, so
- * `renderTypeScript()` throws on planner-produced plans). No external wrapper
- * is required at the descriptor level.
- *
- * `plan()` accepts the framework's option shape (with `contract`/`schema`
- * typed as `unknown`); SQL-typed callers may pass the more specific
- * `SqlMigrationPlannerPlanOptions`, since those structurally satisfy the
- * looser framework contract. Internally we treat options as the SQL-typed
- * superset so the existing planner logic stays identical.
+ * Postgres migration planner — a thin wrapper over `planIssues`.
  *
- * `fromHash` is accepted but ignored: Postgres is descriptor-flow and never
- * needs it (only class-flow planners like Mongo populate `describe()` from
- * `fromHash`).
+ * `plan()` verifies the live schema against the target contract (producing
+ * `SchemaIssue[]`) and delegates to `planIssues` with the unified
+ * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,
+ * type-change, nullable-tightening, codec-hook storage types,
+ * component-declared dependency installs, and shared-temp-default /
+ * empty-table-guarded NOT-NULL add-column. The same strategy list runs for
+ * `migration plan`, `db update`, and `db init`; behavior diverges purely on
+ * `policy.allowedOperationClasses` (the data-safe strategies short-circuit
+ * when `'data'` is excluded). The issue planner applies operation-class
+ * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both
+ * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`
+ * authoring surface.
  */
 export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
   constructor(private readonly config: PlannerConfig) {}
@@ -151,107 +84,66 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     readonly schema: unknown;
     readonly policy: MigrationOperationPolicy;
     readonly fromHash?: string;
+    /**
+     * The "from" contract (state the planner assumes the database starts
+     * at). Only `migration plan` supplies this; `db update` / `db init`
+     * reconcile against the live schema with no old contract. When present
+     * alongside the `'data'` operation class, strategies that need from/to
+     * column shape comparisons (unsafe type change, nullability tightening)
+     * activate.
+     */
+    readonly fromContract?: unknown;
     readonly schemaName?: string;
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
   }): PostgresPlanResult {
-    return this.planSql(options as SqlMigrationPlannerPlanOptions);
+    return this.planSql(options as SqlMigrationPlannerPlanOptions, options.fromHash ?? '');
   }
 
   emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface {
-    return {
-      targetId: 'postgres',
-      destination: { storageHash: context.toHash },
-      operations: [],
-      renderTypeScript(): string {
-        return renderDescriptorTypeScript([], context);
-      },
-    };
+    return new TypeScriptRenderablePostgresMigration([], {
+      from: context.fromHash,
+      to: context.toHash,
+    });
   }
 
-  private planSql(options: SqlMigrationPlannerPlanOptions): PostgresPlanResult {
+  private planSql(options: SqlMigrationPlannerPlanOptions, fromHash: string): PostgresPlanResult {
     const schemaName = options.schemaName ?? this.config.defaultSchema;
     const policyResult = this.ensureAdditivePolicy(options.policy);
     if (policyResult) {
       return policyResult;
     }
 
-    const planningMode = this.resolvePlanningMode(options.policy);
-    const schemaIssues = this.collectSchemaIssues(options, planningMode.includeExtraObjects);
-
-    // Extract codec control hooks once at entry point for reuse across all operations.
-    // This avoids repeated iteration over frameworkComponents for each method that needs hooks.
+    const schemaIssues = this.collectSchemaIssues(options);
     const codecHooks = extractCodecControlHooks(options.frameworkComponents);
-
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
     const storageTypes = options.contract.storage.types ?? {};
 
-    const reconciliationPlan = buildReconciliationPlan({
-      contract: options.contract,
+    const result = planIssues({
       issues: schemaIssues,
+      toContract: options.contract,
+      // `fromContract` is only supplied by `migration plan`. It is `null` for
+      // `db update` / `db init`, which means data-safety strategies needing
+      // from/to comparisons (unsafe type change, nullable tightening) are
+      // inapplicable there — reconciliation falls through to
+      // `mapIssueToCall`'s direct destructive handlers.
+      fromContract: options.fromContract ?? null,
       schemaName,
-      mode: planningMode,
-      policy: options.policy,
       codecHooks,
+      storageTypes,
+      schema: options.schema,
+      policy: options.policy,
+      frameworkComponents: options.frameworkComponents,
+      strategies: postgresPlannerStrategies,
     });
-    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);
+    if (!result.ok) {
+      return plannerFailure(result.failure);
     }
 
-    // Sort table entries once for reuse across all additive operation builders.
-    const sortedTables = sortedEntries(options.contract.storage.tables);
-
-    // Pre-compute constraint lookups once per schema table for O(1) checks across all builders.
-    const schemaLookups = buildSchemaLookupMap(options.schema);
-
-    // Build extension operations from component-owned database dependencies
-    operations.push(
-      ...this.buildDatabaseDependencyOperations(options),
-      ...storageTypePlan.operations,
-      ...reconciliationPlan.operations,
-      ...this.buildTableOperations(
-        sortedTables,
-        options.schema,
-        schemaName,
-        codecHooks,
-        storageTypes,
-      ),
-      ...this.buildColumnOperations(
-        sortedTables,
-        options.schema,
-        schemaLookups,
-        schemaName,
-        codecHooks,
-        storageTypes,
-      ),
-      ...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),
-    );
-
-    const plan = createMigrationPlan<PostgresPlanTargetDetails>({
-      targetId: 'postgres',
-      origin: null,
-      destination: {
-        storageHash: options.contract.storage.storageHash,
-        ...ifDefined('profileHash', options.contract.profileHash),
-      },
-      operations,
-    });
-
     return Object.freeze({
       kind: 'success' as const,
-      plan: Object.freeze({
-        ...plan,
-        renderTypeScript(): string {
-          throw errorPlanDoesNotSupportAuthoringSurface({ targetId: 'postgres' });
-        },
+      plan: new TypeScriptRenderablePostgresMigration(result.value.calls, {
+        from: fromHash,
+        to: options.contract.storage.storageHash,
       }),
     });
   }
@@ -269,573 +161,12 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     return null;
   }
 
-  /**
-   * Builds migration operations from component-owned database dependencies.
-   * These operations install database-side persistence structures declared by components.
-   */
-  private buildDatabaseDependencyOperations(
-    options: PlannerOptionsWithComponents,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const dependencies = this.collectDependencies(options);
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    const seenDependencyIds = new Set<string>();
-    const seenOperationIds = new Set<string>();
-
-    const installedIds = new Set(options.schema.dependencies.map((d) => d.id));
-
-    for (const dependency of dependencies) {
-      if (seenDependencyIds.has(dependency.id)) {
-        continue;
-      }
-      seenDependencyIds.add(dependency.id);
-
-      if (installedIds.has(dependency.id)) {
-        continue;
-      }
-
-      for (const installOp of dependency.install) {
-        if (seenOperationIds.has(installOp.id)) {
-          continue;
-        }
-        seenOperationIds.add(installOp.id);
-        operations.push(installOp as SqlMigrationPlanOperation<PostgresPlanTargetDetails>);
-      }
-    }
-
-    return operations;
-  }
-
-  private buildStorageTypeOperations(
-    options: PlannerOptionsWithComponents,
-    schemaName: string,
-    codecHooks: Map<string, CodecControlHooks>,
-  ): {
-    readonly operations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[];
-    readonly conflicts: readonly SqlPlannerConflict[];
-  } {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    const conflicts: SqlPlannerConflict[] = [];
-    const storageTypes = options.contract.storage.types ?? {};
-
-    for (const [typeName, typeInstance] of sortedEntries(storageTypes)) {
-      const hook = codecHooks.get(typeInstance.codecId);
-      const planResult = hook?.planTypeOperations?.({
-        typeName,
-        typeInstance,
-        contract: options.contract,
-        schema: options.schema,
-        schemaName,
-        policy: options.policy,
-      });
-      if (!planResult) {
-        continue;
-      }
-      for (const operation of planResult.operations) {
-        if (!options.policy.allowedOperationClasses.includes(operation.operationClass)) {
-          conflicts.push({
-            kind: 'missingButNonAdditive',
-            summary: `Storage type "${typeName}" requires "${operation.operationClass}" operation "${operation.id}"`,
-            location: {
-              type: typeName,
-            },
-          });
-          continue;
-        }
-        operations.push({
-          ...operation,
-          target: {
-            id: operation.target.id,
-            details: this.buildTargetDetails('type', typeName, schemaName),
-          },
-        });
-      }
-    }
-
-    return { operations, conflicts };
-  }
-  private collectDependencies(
-    options: PlannerOptionsWithComponents,
-  ): ReadonlyArray<PlannerDatabaseDependency> {
-    const dependencies = collectInitDependencies(options.frameworkComponents);
-    return sortDependencies(dependencies.filter(isPostgresPlannerDependency));
-  }
-
-  private buildTableOperations(
-    tables: ReadonlyArray<[string, StorageTable]>,
-    schema: SqlSchemaIR,
-    schemaName: string,
-    codecHooks: Map<string, CodecControlHooks>,
-    storageTypes: Record<string, StorageTypeInstance>,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    for (const [tableName, table] of tables) {
-      if (schema.tables[tableName]) {
-        continue;
-      }
-      const qualified = qualifyTableName(schemaName, tableName);
-      operations.push({
-        id: `table.${tableName}`,
-        label: `Create table ${tableName}`,
-        summary: `Creates table ${tableName} with required columns`,
-        operationClass: 'additive',
-        target: {
-          id: 'postgres',
-          details: this.buildTargetDetails('table', tableName, schemaName),
-        },
-        precheck: [
-          {
-            description: `ensure table "${tableName}" does not exist`,
-            sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`,
-          },
-        ],
-        execute: [
-          {
-            description: `create table "${tableName}"`,
-            sql: buildCreateTableSql(qualified, table, codecHooks, storageTypes),
-          },
-        ],
-        postcheck: [
-          {
-            description: `verify table "${tableName}" exists`,
-            sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`,
-          },
-        ],
-      });
-    }
-    return operations;
-  }
-
-  private buildColumnOperations(
-    tables: ReadonlyArray<[string, StorageTable]>,
-    schema: SqlSchemaIR,
-    schemaLookups: ReadonlyMap<string, SchemaTableLookup>,
-    schemaName: string,
-    codecHooks: Map<string, CodecControlHooks>,
-    storageTypes: Record<string, StorageTypeInstance>,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    for (const [tableName, table] of tables) {
-      const schemaTable = schema.tables[tableName];
-      if (!schemaTable) {
-        continue;
-      }
-      const schemaLookup = schemaLookups.get(tableName);
-      for (const [columnName, column] of sortedEntries(table.columns)) {
-        if (schemaTable.columns[columnName]) {
-          continue;
-        }
-        operations.push(
-          this.buildAddColumnOperation({
-            schema: schemaName,
-            tableName,
-            table,
-            schemaTable,
-            schemaLookup,
-            columnName,
-            column,
-            codecHooks,
-            storageTypes,
-          }),
-        );
-      }
-    }
-    return operations;
-  }
-
-  private buildAddColumnOperation(options: {
-    readonly schema: string;
-    readonly tableName: string;
-    readonly table: StorageTable;
-    readonly schemaTable: SqlSchemaIR['tables'][string];
-    readonly schemaLookup: SchemaTableLookup | undefined;
-    readonly columnName: string;
-    readonly column: StorageColumn;
-    readonly codecHooks: Map<string, CodecControlHooks>;
-    readonly storageTypes: Record<string, StorageTypeInstance>;
-  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
-    const {
-      schema,
-      tableName,
-      table,
-      schemaTable,
-      schemaLookup,
-      columnName,
-      column,
-      codecHooks,
-      storageTypes,
-    } = options;
-    const notNull = !column.nullable;
-    const hasDefault = column.default !== undefined;
-    // Planner logic decides whether this column needs the coordinated multi-step
-    // strategy. The strategy recipe itself is built by a dedicated helper.
-    const needsTemporaryDefault = notNull && !hasDefault;
-    const temporaryDefault = needsTemporaryDefault
-      ? resolveIdentityValue(column, codecHooks, storageTypes)
-      : null;
-    const canUseSharedTemporaryDefault =
-      needsTemporaryDefault &&
-      temporaryDefault !== null &&
-      canUseSharedTemporaryDefaultStrategy({
-        table,
-        schemaTable,
-        schemaLookup,
-        columnName,
-      });
-
-    if (canUseSharedTemporaryDefault) {
-      return buildAddNotNullColumnWithTemporaryDefaultOperation({
-        schema,
-        tableName,
-        columnName,
-        column,
-        codecHooks,
-        storageTypes,
-        temporaryDefault,
-      });
-    }
-
-    const qualified = qualifyTableName(schema, tableName);
-    const requiresEmptyTableCheck = needsTemporaryDefault && !canUseSharedTemporaryDefault;
-    return {
-      ...buildAddColumnOperationIdentity(schema, tableName, columnName),
-      operationClass: 'additive',
-      precheck: [
-        {
-          description: `ensure column "${columnName}" is missing`,
-          sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false }),
-        },
-        ...(requiresEmptyTableCheck
-          ? [
-              {
-                description: `ensure table "${tableName}" is empty before adding NOT NULL column without default`,
-                sql: tableIsEmptyCheck(qualified),
-              },
-            ]
-          : []),
-      ],
-      execute: [
-        {
-          description: `add column "${columnName}"`,
-          sql: buildAddColumnSql(
-            qualified,
-            columnName,
-            column,
-            codecHooks,
-            undefined,
-            storageTypes,
-          ),
-        },
-      ],
-      postcheck: [
-        {
-          description: `verify column "${columnName}" exists`,
-          sql: columnExistsCheck({ schema, table: tableName, column: columnName }),
-        },
-        ...(notNull
-          ? [
-              {
-                description: `verify column "${columnName}" is NOT NULL`,
-                sql: columnNullabilityCheck({
-                  schema,
-                  table: tableName,
-                  column: columnName,
-                  nullable: false,
-                }),
-              },
-            ]
-          : []),
-      ],
-    };
-  }
-
-  private buildPrimaryKeyOperations(
-    tables: ReadonlyArray<[string, StorageTable]>,
-    schema: SqlSchemaIR,
-    schemaName: string,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    for (const [tableName, table] of tables) {
-      if (!table.primaryKey) {
-        continue;
-      }
-      const schemaTable = schema.tables[tableName];
-      if (!schemaTable || schemaTable.primaryKey) {
-        continue;
-      }
-      const constraintName = table.primaryKey.name ?? `${tableName}_pkey`;
-      operations.push({
-        id: `primaryKey.${tableName}.${constraintName}`,
-        label: `Add primary key ${constraintName} on ${tableName}`,
-        summary: `Adds primary key ${constraintName} on ${tableName}`,
-        operationClass: 'additive',
-        target: {
-          id: 'postgres',
-          details: this.buildTargetDetails('table', tableName, schemaName),
-        },
-        precheck: [
-          {
-            description: `ensure primary key does not exist on "${tableName}"`,
-            sql: tableHasPrimaryKeyCheck(schemaName, tableName, false),
-          },
-        ],
-        execute: [
-          {
-            description: `add primary key "${constraintName}"`,
-            sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(constraintName)}
-PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(', ')})`,
-          },
-        ],
-        postcheck: [
-          {
-            description: `verify primary key "${constraintName}" exists`,
-            sql: tableHasPrimaryKeyCheck(schemaName, tableName, true, constraintName),
-          },
-        ],
-      });
-    }
-    return operations;
-  }
-
-  private buildUniqueOperations(
-    tables: ReadonlyArray<[string, StorageTable]>,
-    schemaLookups: ReadonlyMap<string, SchemaTableLookup>,
-    schemaName: string,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    for (const [tableName, table] of tables) {
-      const lookup = schemaLookups.get(tableName);
-      for (const unique of table.uniques) {
-        if (lookup && hasUniqueConstraint(lookup, unique.columns)) {
-          continue;
-        }
-        const constraintName = unique.name ?? `${tableName}_${unique.columns.join('_')}_key`;
-        operations.push({
-          id: `unique.${tableName}.${constraintName}`,
-          label: `Add unique constraint ${constraintName} on ${tableName}`,
-          summary: `Adds unique constraint ${constraintName} on ${tableName}`,
-          operationClass: 'additive',
-          target: {
-            id: 'postgres',
-            details: this.buildTargetDetails('unique', constraintName, schemaName, tableName),
-          },
-          precheck: [
-            {
-              description: `ensure unique constraint "${constraintName}" is missing`,
-              sql: constraintExistsCheck({
-                constraintName,
-                schema: schemaName,
-                table: tableName,
-                exists: false,
-              }),
-            },
-          ],
-          execute: [
-            {
-              description: `add unique constraint "${constraintName}"`,
-              sql: `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(constraintName)}
-UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
-            },
-          ],
-          postcheck: [
-            {
-              description: `verify unique constraint "${constraintName}" exists`,
-              sql: constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
-            },
-          ],
-        });
-      }
-    }
-    return operations;
-  }
-
-  private buildIndexOperations(
-    tables: ReadonlyArray<[string, StorageTable]>,
-    schemaLookups: ReadonlyMap<string, SchemaTableLookup>,
-    schemaName: string,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    for (const [tableName, table] of tables) {
-      const lookup = schemaLookups.get(tableName);
-      for (const index of table.indexes) {
-        if (lookup && hasIndex(lookup, index.columns)) {
-          continue;
-        }
-        const indexName = index.name ?? defaultIndexName(tableName, index.columns);
-        operations.push({
-          id: `index.${tableName}.${indexName}`,
-          label: `Create index ${indexName} on ${tableName}`,
-          summary: `Creates index ${indexName} on ${tableName}`,
-          operationClass: 'additive',
-          target: {
-            id: 'postgres',
-            details: this.buildTargetDetails('index', indexName, schemaName, tableName),
-          },
-          precheck: [
-            {
-              description: `ensure index "${indexName}" is missing`,
-              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`,
-            },
-          ],
-          execute: [
-            {
-              description: `create index "${indexName}"`,
-              sql: `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualifyTableName(
-                schemaName,
-                tableName,
-              )} (${index.columns.map(quoteIdentifier).join(', ')})`,
-            },
-          ],
-          postcheck: [
-            {
-              description: `verify index "${indexName}" exists`,
-              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
-            },
-          ],
-        });
-      }
-    }
-    return operations;
-  }
-
-  /**
-   * Generates FK-backing index operations for FKs with `index: true`,
-   * but only when no matching user-declared index exists in `contractTable.indexes`.
-   */
-  private buildFkBackingIndexOperations(
-    tables: ReadonlyArray<[string, StorageTable]>,
-    schemaLookups: ReadonlyMap<string, SchemaTableLookup>,
-    schemaName: string,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    for (const [tableName, table] of tables) {
-      const lookup = schemaLookups.get(tableName);
-      // Collect column sets of user-declared indexes to avoid duplicates
-      const declaredIndexColumns = new Set(table.indexes.map((idx) => idx.columns.join(',')));
-
-      for (const fk of table.foreignKeys) {
-        if (fk.index === false) continue;
-        // Skip if user already declared an index with these columns
-        if (declaredIndexColumns.has(fk.columns.join(','))) continue;
-        // Skip if the index already exists in the database
-        if (lookup && hasIndex(lookup, fk.columns)) continue;
-
-        const indexName = defaultIndexName(tableName, fk.columns);
-        operations.push({
-          id: `index.${tableName}.${indexName}`,
-          label: `Create FK-backing index ${indexName} on ${tableName}`,
-          summary: `Creates FK-backing index ${indexName} on ${tableName}`,
-          operationClass: 'additive',
-          target: {
-            id: 'postgres',
-            details: this.buildTargetDetails('index', indexName, schemaName, tableName),
-          },
-          precheck: [
-            {
-              description: `ensure index "${indexName}" is missing`,
-              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NULL`,
-            },
-          ],
-          execute: [
-            {
-              description: `create FK-backing index "${indexName}"`,
-              sql: `CREATE INDEX ${quoteIdentifier(indexName)} ON ${qualifyTableName(
-                schemaName,
-                tableName,
-              )} (${fk.columns.map(quoteIdentifier).join(', ')})`,
-            },
-          ],
-          postcheck: [
-            {
-              description: `verify index "${indexName}" exists`,
-              sql: `SELECT to_regclass(${toRegclassLiteral(schemaName, indexName)}) IS NOT NULL`,
-            },
-          ],
-        });
-      }
-    }
-    return operations;
-  }
-
-  private buildForeignKeyOperations(
-    tables: ReadonlyArray<[string, StorageTable]>,
-    schemaLookups: ReadonlyMap<string, SchemaTableLookup>,
-    schemaName: string,
-  ): readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] {
-    const operations: SqlMigrationPlanOperation<PostgresPlanTargetDetails>[] = [];
-    for (const [tableName, table] of tables) {
-      const lookup = schemaLookups.get(tableName);
-      for (const foreignKey of table.foreignKeys) {
-        if (foreignKey.constraint === false) continue;
-        if (lookup && hasForeignKey(lookup, foreignKey)) {
-          continue;
-        }
-        const fkName = foreignKey.name ?? `${tableName}_${foreignKey.columns.join('_')}_fkey`;
-        operations.push({
-          id: `foreignKey.${tableName}.${fkName}`,
-          label: `Add foreign key ${fkName} on ${tableName}`,
-          summary: `Adds foreign key ${fkName} referencing ${foreignKey.references.table}`,
-          operationClass: 'additive',
-          target: {
-            id: 'postgres',
-            details: this.buildTargetDetails('foreignKey', fkName, schemaName, tableName),
-          },
-          precheck: [
-            {
-              description: `ensure foreign key "${fkName}" is missing`,
-              sql: constraintExistsCheck({
-                constraintName: fkName,
-                schema: schemaName,
-                table: tableName,
-                exists: false,
-              }),
-            },
-          ],
-          execute: [
-            {
-              description: `add foreign key "${fkName}"`,
-              sql: buildForeignKeySql(schemaName, tableName, fkName, foreignKey),
-            },
-          ],
-          postcheck: [
-            {
-              description: `verify foreign key "${fkName}" exists`,
-              sql: constraintExistsCheck({
-                constraintName: fkName,
-                schema: schemaName,
-                table: tableName,
-              }),
-            },
-          ],
-        });
-      }
-    }
-    return operations;
-  }
-
-  private buildTargetDetails(
-    objectType: OperationClass,
-    name: string,
-    schema: string,
-    table?: string,
-  ): PostgresPlanTargetDetails {
-    return buildTargetDetails(objectType, name, schema, table);
-  }
-
-  private resolvePlanningMode(policy: MigrationOperationPolicy): PlanningMode {
-    const allowWidening = policy.allowedOperationClasses.includes('widening');
-    const allowDestructive = policy.allowedOperationClasses.includes('destructive');
-    // `db init` uses additive-only policy and intentionally ignores extras.
-    // Any reconciliation-capable policy should inspect extras to reconcile strict equality.
-    const includeExtraObjects = allowWidening || allowDestructive;
-    return { includeExtraObjects, allowWidening, allowDestructive };
-  }
-
-  private collectSchemaIssues(
-    options: PlannerOptionsWithComponents,
-    strict: boolean,
-  ): readonly SchemaIssue[] {
+  private collectSchemaIssues(options: PlannerOptionsWithComponents): readonly SchemaIssue[] {
+    // `db init` uses additive-only policy and intentionally ignores extra
+    // schema objects. Any reconciliation-capable policy (widening or
+    // destructive) must inspect extras to reconcile strict equality.
+    const allowed = options.policy.allowedOperationClasses;
+    const strict = allowed.includes('widening') || allowed.includes('destructive');
     const verifyOptions: VerifySqlSchemaOptionsWithComponents = {
       contract: options.contract,
       schema: options.schema,
@@ -849,54 +180,3 @@ UNIQUE (${unique.columns.map(quoteIdentifier).join(', ')})`,
     return verifyResult.schema.issues;
   }
 }
-
-function canUseSharedTemporaryDefaultStrategy(options: {
-  readonly table: StorageTable;
-  readonly schemaTable: SqlSchemaIR['tables'][string];
-  readonly schemaLookup: SchemaTableLookup | undefined;
-  readonly columnName: string;
-}): boolean {
-  const { table, schemaTable, schemaLookup, columnName } = options;
-
-  // Shared placeholders are only safe when later plan steps do not require
-  // row-specific values for this newly added column.
-  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 sortDependencies(
-  dependencies: ReadonlyArray<PlannerDatabaseDependency>,
-): ReadonlyArray<PlannerDatabaseDependency> {
-  return [...dependencies].sort((a, b) => a.id.localeCompare(b.id));
-}
-
-function isPostgresPlannerDependency(
-  dependency: ComponentDatabaseDependency<unknown>,
-): dependency is PlannerDatabaseDependency {
-  return dependency.install.every((operation) => operation.target.id === 'postgres');
-}
-
-function sortedEntries<V>(record: Readonly<Record<string, V>>): Array<[string, V]> {
-  return Object.entries(record).sort(([a], [b]) => a.localeCompare(b)) as Array<[string, V]>;
-}