@prisma-next/target-postgres 0.13.0 → 0.14.0-dev.2

package/src/core/migrations/planner-type-resolution.ts

@@ -1,9 +1,4 @@
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-  type StorageColumn,
-  type StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 
 export type ResolvedColumnTypeMetadata = Pick<
   StorageColumn,
@@ -12,7 +7,7 @@ export type ResolvedColumnTypeMetadata = Pick<
 
 export function resolveColumnTypeMetadata(
   column: StorageColumn,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>,
 ): ResolvedColumnTypeMetadata {
   if (!column.typeRef) {
     return column;
@@ -23,19 +18,6 @@ export function resolveColumnTypeMetadata(
     return column;
   }
 
-  if (isPostgresEnumStorageEntry(referencedType)) {
-    // Enum types are referenced by name (`quoteIdentifier(nativeType)`),
-    // not via parameterised codec expansion. The structural shape
-    // carries `codecId` as an enumerable property (mirroring the
-    // codec-typed view); `typeParams` is intentionally omitted here so
-    // `expandParameterizedTypeSql` does not try to look up a
-    // (deliberately absent) `expandNativeType` hook for `pg/enum@*`.
-    return {
-      codecId: referencedType.codecId,
-      nativeType: referencedType.nativeType,
-    };
-  }
-
   return {
     codecId: referencedType.codecId,
     nativeType: referencedType.nativeType,

package/src/core/migrations/planner.ts

@@ -12,7 +12,7 @@ import {
   planFieldEventOperations,
   plannerFailure,
 } from '@prisma-next/family-sql/control';
-import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { verifySqlSchema } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type {
@@ -31,7 +31,6 @@ import {
   resolvePostgresIssueControlPolicySubject,
   resolvePostgresIssueCreationFactoryName,
 } from './control-policy';
-import { createResolveExistingEnumValues } from './enum-planning';
 import { planIssues } from './issue-planner';
 import type { PostgresOpFactoryCall } from './op-factory-call';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
@@ -52,7 +51,9 @@ type VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0
   readonly frameworkComponents: PlannerFrameworkComponents;
 };
 
-export function createPostgresMigrationPlanner(lowerer: Lowerer): PostgresMigrationPlanner {
+export function createPostgresMigrationPlanner(
+  lowerer: ExecuteRequestLowerer,
+): PostgresMigrationPlanner {
   return new PostgresMigrationPlanner(lowerer);
 }
 
@@ -88,9 +89,9 @@ export type PostgresPlanResult =
  * authoring surface.
  */
 export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
-  readonly #lowerer: Lowerer | undefined;
+  readonly #lowerer: ExecuteRequestLowerer | undefined;
 
-  constructor(lowerer?: Lowerer) {
+  constructor(lowerer?: ExecuteRequestLowerer) {
     this.#lowerer = lowerer;
   }
 
@@ -266,7 +267,6 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       frameworkComponents: options.frameworkComponents,
       normalizeDefault: parsePostgresDefault,
       normalizeNativeType: normalizeSchemaNativeType,
-      resolveExistingEnumValues: createResolveExistingEnumValues(options.contract.storage),
     };
     const verifyResult = verifySqlSchema(verifyOptions);
     // Schema presence is a Postgres-specific concern (no equivalent in

package/src/core/migrations/postgres-migration.ts

@@ -3,12 +3,34 @@ import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control'
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { Migration as SqlMigration } from '@prisma-next/family-sql/migration';
 import type { ControlStack } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import { errorPostgresMigrationStackMissing } from '../errors';
-import { CreateSchemaCall, CreateTableCall } from './op-factory-call';
+import {
+  AddCheckConstraintCall,
+  AddColumnCall,
+  AddForeignKeyCall,
+  AddPrimaryKeyCall,
+  AddUniqueCall,
+  AlterColumnTypeCall,
+  type AlterColumnTypeOptions,
+  CreateIndexCall,
+  CreateSchemaCall,
+  CreateTableCall,
+  DropCheckConstraintCall,
+  DropColumnCall,
+  DropConstraintCall,
+  DropDefaultCall,
+  DropIndexCall,
+  DropNotNullCall,
+  DropTableCall,
+  SetDefaultCall,
+  SetNotNullCall,
+} from './op-factory-call';
 import { type DataTransformOptions, dataTransform } from './operations/data-transform';
+import { installExtension } from './operations/dependencies';
+import type { CreateIndexExtras } from './operations/indexes';
+import type { ForeignKeySpec } from './operations/shared';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 /**
@@ -30,6 +52,13 @@ import type { PostgresPlanTargetDetails } from './planner-target-details';
  * instance method forwards to the free `dataTransform` factory with that
  * stored adapter, so user migrations can write `this.dataTransform(...)`
  * without threading the adapter through every call.
+ *
+ * Every method requires an explicit `schema`. Postgres migrations name their
+ * schema deliberately — there is no default and no `search_path`-relative
+ * option. A migration that left the schema unspecified would resolve against
+ * whatever `search_path` the connection happened to carry, and that ambiguity
+ * is an antipattern in a migration. (The unbound/unspecified namespace concept
+ * remains for SQLite, which has no schemas, and for Mongo's connection `db`.)
  */
 export abstract class PostgresMigration extends SqlMigration<
   PostgresPlanTargetDetails,
@@ -64,7 +93,7 @@ export abstract class PostgresMigration extends SqlMigration<
     contract: TContract,
     name: string,
     options: DataTransformOptions,
-  ): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  ): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }
@@ -77,17 +106,17 @@ export abstract class PostgresMigration extends SqlMigration<
    * Throws if no adapter is present (i.e. migration instantiated without a stack).
    */
   protected createTable(options: {
-    readonly schema?: string;
+    readonly schema: string;
     readonly table: string;
     readonly ifNotExists?: boolean;
     readonly columns: readonly DdlColumn[];
     readonly constraints?: readonly DdlTableConstraint[];
-  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }
     return new CreateTableCall(
-      options.schema ?? UNBOUND_NAMESPACE_ID,
+      options.schema,
       options.table,
       options.columns,
       options.constraints,
@@ -102,10 +131,261 @@ export abstract class PostgresMigration extends SqlMigration<
   protected createSchema(options: {
     readonly schema: string;
     readonly ifNotExists?: boolean;
-  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
     if (!this.controlAdapter) {
       throw errorPostgresMigrationStackMissing();
     }
     return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);
   }
+
+  protected addColumn(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: DdlColumn;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddColumnCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected addPrimaryKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddPrimaryKeyCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.columns,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected addUnique(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly columns: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddUniqueCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.columns,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected addForeignKey(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly foreignKey: ForeignKeySpec;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected addCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly column: string;
+    readonly values: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AddCheckConstraintCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.column,
+      options.values,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropCheckConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected dropConstraint(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly constraint: string;
+    readonly kind?: 'foreignKey' | 'unique' | 'primaryKey';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropConstraintCall(
+      options.schema,
+      options.table,
+      options.constraint,
+      options.kind ?? 'unique',
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropTable(options: {
+    readonly schema: string;
+    readonly table: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropTableCall(options.schema, options.table).toOp(this.controlAdapter);
+  }
+
+  protected dropColumn(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropColumnCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected alterColumnType(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly options: AlterColumnTypeOptions;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new AlterColumnTypeCall(
+      options.schema,
+      options.table,
+      options.column,
+      options.options,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected setNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new SetNotNullCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected dropNotNull(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropNotNullCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected setDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+    readonly defaultSql: string;
+    readonly operationClass?: 'additive' | 'widening';
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new SetDefaultCall(
+      options.schema,
+      options.table,
+      options.column,
+      options.defaultSql,
+      options.operationClass,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropDefault(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly column: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropDefaultCall(options.schema, options.table, options.column).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected createIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+    readonly columns: readonly string[];
+    readonly extras?: CreateIndexExtras;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new CreateIndexCall(
+      options.schema,
+      options.table,
+      options.index,
+      options.columns,
+      options.extras,
+    ).toOp(this.controlAdapter);
+  }
+
+  protected dropIndex(options: {
+    readonly schema: string;
+    readonly table: string;
+    readonly index: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new DropIndexCall(options.schema, options.table, options.index).toOp(
+      this.controlAdapter,
+    );
+  }
+
+  protected installExtension(options: {
+    readonly extensionName: string;
+    readonly invariantId: string;
+    readonly id: string;
+    readonly label?: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return installExtension(options, this.controlAdapter);
+  }
 }

package/src/core/migrations/render-ops.ts

@@ -1,7 +1,11 @@
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
-import type { OpFactoryCall } from '@prisma-next/framework-components/control';
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import type {
+  MigrationPlanOperation,
+  OpFactoryCall,
+} from '@prisma-next/framework-components/control';
 import { blindCast } from '@prisma-next/utils/casts';
+import { isThenable } from '@prisma-next/utils/promise';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
@@ -13,11 +17,11 @@ type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
  * silently flow through to postgres-shaped renderers — exactly the
  * place to fail loudly with op metadata (`id` + `target.id`).
  */
-function assertPostgresOp(
-  op: ReturnType<OpFactoryCall['toOp']>,
-  callFactoryName: string,
-): asserts op is Op {
-  const targetId = (op as Partial<Op>).target?.id;
+function assertPostgresOp(op: MigrationPlanOperation, callFactoryName: string): asserts op is Op {
+  const targetId = blindCast<
+    { target?: { id?: string } },
+    'op.target is present on concrete SqlMigrationPlanOperation but absent on the framework MigrationPlanOperation base'
+  >(op).target?.id;
   if (targetId !== 'postgres') {
     throw new Error(
       `renderOps: expected postgres op but got target.id="${String(targetId)}" for op.id="${op.id}" (factoryName="${callFactoryName}"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,
@@ -25,13 +29,22 @@ function assertPostgresOp(
   }
 }
 
-export function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): Op[] {
+export function renderOps(
+  calls: readonly OpFactoryCall[],
+  lowerer?: ExecuteRequestLowerer,
+): (Op | Promise<Op>)[] {
   return calls.map((c) => {
-    const op = blindCast<
-      { toOp(lowerer?: Lowerer): ReturnType<OpFactoryCall['toOp']> },
-      'PG OpFactoryCall.toOp accepts an optional Lowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'
+    const opOrPromise = blindCast<
+      { toOp(lowerer?: ExecuteRequestLowerer): Op | Promise<Op> },
+      'PG OpFactoryCall.toOp accepts an optional ExecuteRequestLowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'
     >(c).toOp(lowerer);
-    assertPostgresOp(op, c.factoryName);
-    return op;
+    if (isThenable(opOrPromise)) {
+      return opOrPromise.then((op) => {
+        assertPostgresOp(op, c.factoryName);
+        return op;
+      });
+    }
+    assertPostgresOp(opOrPromise, c.factoryName);
+    return opOrPromise;
   });
 }

package/src/core/migrations/runner.ts

@@ -18,13 +18,13 @@ import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlControlDriverInstance, SqlStorage } from '@prisma-next/sql-contract/types';
 import { SqlQueryError } from '@prisma-next/sql-errors';
-import type { LoweredStatement } from '@prisma-next/sql-relational-core/ast';
+import type { SqlExecuteRequest } from '@prisma-next/sql-relational-core/ast';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok, okVoid } from '@prisma-next/utils/result';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
-import { createResolveExistingEnumValues } from './enum-planning';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 interface ApplyPlanSuccessValue {
@@ -86,6 +86,12 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     const space = options.plan.spaceId;
     const lockKey = `${LOCK_DOMAIN}:${schema}:${space}`;
 
+    // Materialize any async ops before running checks or executing.
+    const planOps = blindCast<
+      readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
+      'ops were produced by the PG planner and are SqlMigrationPlanOperation<PostgresPlanTargetDetails>; MigrationPlan.operations uses the wider framework type to accommodate Promise covariance'
+    >(await Promise.all(options.plan.operations));
+
     // Static checks (idempotent — safe to run again when the caller is
     // `execute(...)` because the cost is a single object comparison).
     const destinationCheck = this.ensurePlanMatchesDestinationContract(
@@ -94,7 +100,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     );
     if (!destinationCheck.ok) return destinationCheck;
 
-    const policyCheck = this.enforcePolicyCompatibility(options.policy, options.plan.operations);
+    const policyCheck = this.enforcePolicyCompatibility(options.policy, planOps);
     if (!policyCheck.ok) return policyCheck;
 
     await this.acquireLock(driver, lockKey);
@@ -113,7 +119,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (skipOperations) {
       applyValue = { operationsExecuted: 0, executedOperations: [] };
     } else {
-      const applyResult = await this.applyPlan(driver, options);
+      const applyResult = await this.applyPlan(driver, options, planOps);
       if (!applyResult.ok) return applyResult;
       applyValue = applyResult.value;
     }
@@ -137,9 +143,6 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
         frameworkComponents: options.frameworkComponents,
         normalizeDefault: parsePostgresDefault,
         normalizeNativeType: normalizeSchemaNativeType,
-        resolveExistingEnumValues: createResolveExistingEnumValues(
-          options.destinationContract.storage,
-        ),
       });
       if (!schemaVerifyResult.ok) {
         return runnerFailure('SCHEMA_VERIFY_FAILED', schemaVerifyResult.summary, {
@@ -158,11 +161,16 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (!isSelfEdgeNoOp) {
       const markerResult = await this.upsertMarker(driver, options, existingMarker, space);
       if (!markerResult.ok) return markerResult;
-      await this.recordLedgerEntries(driver, options, applyValue.executedOperations);
+      await this.recordLedgerEntries(
+        driver,
+        options,
+        applyValue.executedOperations,
+        planOps.length,
+      );
     }
 
     return runnerSuccess({
-      operationsPlanned: options.plan.operations.length,
+      operationsPlanned: planOps.length,
       operationsExecuted: applyValue.operationsExecuted,
     });
   }
@@ -209,6 +217,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
   private async applyPlan(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
+    ops: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
   ): Promise<Result<ApplyPlanSuccessValue, SqlMigrationRunnerFailure>> {
     const checks = options.executionChecks;
     const runPrechecks = checks?.prechecks !== false; // Default true
@@ -217,7 +226,7 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
 
     let operationsExecuted = 0;
     const executedOperations: Array<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> = [];
-    for (const operation of options.plan.operations) {
+    for (const operation of ops) {
       options.callbacks?.onOperationStart?.(operation);
       try {
         // Idempotency probe: only run if both postchecks and idempotency checks are enabled
@@ -282,13 +291,13 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     if (schemaQuery === undefined) {
       throw new Error('Postgres control-table bootstrap must include CREATE SCHEMA');
     }
-    await this.executeStatement(driver, this.family.lowerAst(schemaQuery, lowererContext));
+    await this.executeStatement(driver, await this.family.lowerAst(schemaQuery, lowererContext));
     const legacyDetection = await this.detectLegacyMarkerShape(driver);
     if (!legacyDetection.ok) {
       return legacyDetection;
     }
     for (const query of tableQueries) {
-      await this.executeStatement(driver, this.family.lowerAst(query, lowererContext));
+      await this.executeStatement(driver, await this.family.lowerAst(query, lowererContext));
     }
     return okVoid();
   }
@@ -629,14 +638,15 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
     options: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>,
     executedOperations: readonly SqlMigrationPlanOperation<PostgresPlanTargetDetails>[],
+    planOpsLength: number,
   ): Promise<void> {
     const plan = options.plan;
     const space = plan.spaceId;
     const edges = options.migrationEdges;
     const totalEdgeOps = edges.reduce((sum, edge) => sum + edge.operationCount, 0);
-    if (totalEdgeOps !== plan.operations.length) {
+    if (totalEdgeOps !== planOpsLength) {
       throw new Error(
-        `Ledger write: plan.operations length (${plan.operations.length}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
+        `Ledger write: plan.operations length (${planOpsLength}) does not match sum of migrationEdges operationCount (${totalEdgeOps})`,
       );
     }
     // The ledger records the operations as executed — idempotency-skipped ops
@@ -688,12 +698,8 @@ class PostgresMigrationRunner implements SqlMigrationRunner<PostgresPlanTargetDe
 
   private async executeStatement(
     driver: SqlMigrationRunnerExecuteOptions<PostgresPlanTargetDetails>['driver'],
-    statement: LoweredStatement,
+    statement: SqlExecuteRequest,
   ): Promise<void> {
-    if (statement.params.length > 0) {
-      await driver.query(statement.sql, statement.params);
-      return;
-    }
-    await driver.query(statement.sql);
+    await driver.query(statement.sql, statement.params);
   }
 }