@prisma-next/target-postgres 0.13.0-dev.3 → 0.13.0-dev.30

package/src/core/migrations/issue-planner.ts

@@ -8,7 +8,7 @@
  * through `mapIssueToCall` for the default case.
  */
 
-import type { Contract } from '@prisma-next/contract/types';
+import type { Contract, JsonValue } from '@prisma-next/contract/types';
 import type {
   CodecControlHooks,
   MigrationOperationPolicy,
@@ -19,26 +19,24 @@ import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import type {
-  PostgresEnumStorageEntry,
   SqlStorage,
   StorageColumn,
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
-import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
+import type { CodecRef, DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import * as contractFree from '@prisma-next/sql-relational-core/contract-free';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+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 } from '@prisma-next/utils/result';
-import { PostgresEnumType } from '../postgres-enum-type';
-import { isPostgresSchema } from '../postgres-schema';
 import {
   AddColumnCall,
   AddForeignKeyCall,
   AddPrimaryKeyCall,
   AddUniqueCall,
   AlterColumnTypeCall,
-  CreateEnumTypeCall,
   CreateIndexCall,
   CreateSchemaCall,
   CreateTableCall,
@@ -54,7 +52,7 @@ import {
   SetDefaultCall,
   SetNotNullCall,
 } from './op-factory-call';
-import type { ColumnSpec, ForeignKeySpec } from './operations/shared';
+import type { ForeignKeySpec } from './operations/shared';
 import { buildColumnDefaultSql, buildColumnTypeSql } from './planner-ddl-builders';
 import { buildExpectedFormatType } from './planner-sql-checks';
 import {
@@ -65,22 +63,10 @@ import {
   type StrategyContext,
   tableAt,
 } from './planner-strategies';
+import { resolveColumnTypeMetadata } from './planner-type-resolution';
 
 export type { CallMigrationStrategy, StrategyContext };
 
-/**
- * Finds a type entry by explicit namespace coordinate. Reads the named
- * namespace's `enum` slot directly — never scans other namespaces.
- */
-function locateNamespaceTypeInStorage(
-  storage: SqlStorage,
-  namespaceId: string,
-  typeName: string,
-): unknown {
-  const ns = storage.namespaces[namespaceId];
-  return isPostgresSchema(ns) ? ns.entries.type[typeName] : undefined;
-}
-
 // ============================================================================
 // Issue kind ordering (dependency order)
 // ============================================================================
@@ -165,7 +151,7 @@ export interface IssuePlannerOptions {
   readonly fromContract: Contract<SqlStorage> | null;
   readonly schemaName: string;
   readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
-  readonly storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   /**
    * Current database schema IR. Strategies read this to detect whether a
    * structure already exists (e.g. `buildSchemaLookupMap` for shared-temp-
@@ -192,31 +178,35 @@ export interface IssuePlannerValue {
   readonly calls: readonly PostgresOpFactoryCall[];
 }
 
-function toColumnSpec(
-  name: string,
-  column: StorageColumn,
-  codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
-): ColumnSpec {
-  return {
-    name,
-    typeSql: buildColumnTypeSql(column, codecHooks, storageTypes),
-    defaultSql: buildColumnDefaultSql(column.default, column),
-    nullable: column.nullable,
-  };
-}
-
 function toDdlColumn(
   name: string,
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>,
 ): DdlColumn {
   const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
   const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);
+  const resolved = resolveColumnTypeMetadata(
+    column,
+    storageTypes as Record<string, StorageTypeInstance>,
+  );
+  const codecRef: CodecRef | undefined = resolved.codecId
+    ? {
+        codecId: resolved.codecId,
+        ...(resolved.typeParams !== undefined
+          ? {
+              typeParams: blindCast<
+                JsonValue,
+                'resolved.typeParams is JsonValue-shaped storage metadata; the narrowed (non-undefined) value lands in CodecRef.typeParams which is JsonValue'
+              >(resolved.typeParams),
+            }
+          : {}),
+      }
+    : undefined;
   return contractFree.col(name, typeSql, {
     ...(!column.nullable ? { notNull: true } : {}),
-    ...(ddlDefault ? { default: ddlDefault } : {}),
+    ...ifDefined('default', ddlDefault),
+    ...ifDefined('codecRef', codecRef),
   });
 }
 
@@ -342,7 +332,7 @@ function mapIssueToCall(
           new AddColumnCall(
             tableSchema(issue),
             issue.table,
-            toColumnSpec(issue.column, column, codecHooks, storageTypes),
+            toDdlColumn(issue.column, column, codecHooks, storageTypes),
           ),
         ]);
       }
@@ -475,10 +465,7 @@ function mapIssueToCall(
             ),
           );
         const hooksMap = codecHooks as Map<string, CodecControlHooks>;
-        const typesMap = storageTypes as Record<
-          string,
-          StorageTypeInstance | PostgresEnumStorageEntry
-        >;
+        const typesMap = storageTypes as Record<string, StorageTypeInstance>;
         const qualifiedTargetType = buildColumnTypeSql(column, hooksMap, typesMap, false);
         const formatTypeExpected = buildExpectedFormatType(column, hooksMap, typesMap);
         return ok([
@@ -666,14 +653,7 @@ function mapIssueToCall(
     case 'type_missing': {
       if (!issue.typeName)
         return notOk(issueConflict('unsupportedOperation', 'Type missing issue has no typeName'));
-      // Codec aliases live in storage.types; enum types live in namespace.entries.type.
-      // Check types first; fall back to the namespace-keyed enum slot using the
-      // issue's namespace coordinate (populated by the verifier for enum-related
-      // issues per the BaseSchemaIssue.namespaceId contract).
-      const namespaceId = resolveNamespaceIdForIssue(issue);
-      const typeInstance: unknown =
-        ctx.toContract.storage.types?.[issue.typeName] ??
-        locateNamespaceTypeInStorage(ctx.toContract.storage, namespaceId, issue.typeName);
+      const typeInstance = ctx.toContract.storage.types?.[issue.typeName];
       if (!typeInstance) {
         return notOk(
           issueConflict(
@@ -682,22 +662,10 @@ function mapIssueToCall(
           ),
         );
       }
-      if (typeInstance instanceof PostgresEnumType) {
-        const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
-        return ok([
-          new CreateEnumTypeCall(
-            ddlSchema,
-            issue.typeName,
-            typeInstance.values,
-            typeInstance.nativeType,
-          ),
-        ]);
-      }
-      const codecInstance = typeInstance as StorageTypeInstance;
       return notOk(
         issueConflict(
           'unsupportedOperation',
-          `Type "${issue.typeName}" uses codec "${codecInstance.codecId}" — only enum types are supported`,
+          `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only value-set types are supported`,
         ),
       );
     }
@@ -744,10 +712,6 @@ function classifyCall(call: PostgresOpFactoryCall): CallCategory {
   switch (call.factoryName) {
     case 'createExtension':
     case 'createSchema':
-    case 'createEnumType':
-    case 'addEnumValues':
-    case 'dropEnumType':
-    case 'renameType':
       return 'dep';
     case 'dropTable':
     case 'dropColumn':
@@ -971,10 +935,10 @@ export function planIssues(
     return notOk(conflicts);
   }
 
-  // Recipe strategies (`nativeEnumPlanCallStrategy`,
-  // `notNullBackfillCallStrategy`, etc.) emit a cohesive sequence that must
+  // Recipe strategies (`notNullBackfillCallStrategy`,
+  // `nullableTighteningCallStrategy`, etc.) emit a cohesive sequence that must
   // stay contiguous. They are inserted at a single pattern slot. Non-recipe
-  // pattern strategies (`dependencyInstallCallStrategy`,
+  // pattern strategies (`checkConstraintPlanCallStrategy`,
   // `storageTypePlanCallStrategy`, `notNullAddColumnCallStrategy`) produce
   // individually classifiable calls that slot into DDL buckets alongside
   // default-mapped calls.

package/src/core/migrations/op-factory-call.ts

@@ -22,7 +22,7 @@
 
 import { errorUnfilledPlaceholder } from '@prisma-next/errors/migration';
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
+import type { ExecuteRequestLowerer, Lowerer } from '@prisma-next/family-sql/control-adapter';
 import type {
   OpFactoryCall as FrameworkOpFactoryCall,
   MigrationOperationClass,
@@ -36,11 +36,11 @@ import type {
 import { FunctionColumnDefault, LiteralColumnDefault } from '@prisma-next/sql-relational-core/ast';
 import { type ImportRequirement, jsonToTsSource, TsExpression } from '@prisma-next/ts-render';
 import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
 import * as contractFreeDdl from '../../contract-free/ddl';
 import { escapeLiteral, quoteIdentifier } from '../sql-utils';
 import type { PostgresColumnDefault } from '../types';
 import {
-  addColumn,
   alterColumnType,
   dropColumn,
   dropDefault,
@@ -57,12 +57,11 @@ import {
   dropConstraint,
 } from './operations/constraints';
 import { createExtension } from './operations/dependencies';
-import { addEnumValues, createEnumType, dropEnumType, renameType } from './operations/enums';
 import { createIndex, dropIndex } from './operations/indexes';
-import type { ColumnSpec, ForeignKeySpec } from './operations/shared';
+import type { ForeignKeySpec } from './operations/shared';
 import { step, targetDetails } from './operations/shared';
 import { dropTable } from './operations/tables';
-import { toRegclassLiteral } from './planner-sql-checks';
+import { columnExistsCheck, toRegclassLiteral } from './planner-sql-checks';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
@@ -81,11 +80,15 @@ type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 // transitive package on disk.
 const POSTGRES_MIGRATION_FACADE = '@prisma-next/postgres/migration';
 
+function boundSchema(schemaName: string): string | undefined {
+  return schemaName === UNBOUND_NAMESPACE_ID ? undefined : schemaName;
+}
+
 abstract class PostgresOpFactoryCallNode extends TsExpression implements FrameworkOpFactoryCall {
   abstract readonly factoryName: string;
   abstract readonly operationClass: MigrationOperationClass;
   abstract readonly label: string;
-  abstract toOp(lowerer?: Lowerer): Op;
+  abstract toOp(lowerer?: Lowerer): Op | Promise<Op>;
 
   importRequirements(): readonly ImportRequirement[] {
     return [{ moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: this.factoryName }];
@@ -213,19 +216,19 @@ export class CreateTableCall extends PostgresOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(lowerer?: Lowerer): Op {
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
       throw new Error(
         `CreateTableCall.toOp: a DDL lowerer is required on the Postgres planner path (table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
       );
     }
     const ddlNode = contractFreeDdl.createTable({
-      ...(this.schemaName !== UNBOUND_NAMESPACE_ID ? { schema: this.schemaName } : {}),
+      ...ifDefined('schema', boundSchema(this.schemaName)),
       table: this.tableName,
       columns: this.columns,
-      ...(this.constraints ? { constraints: this.constraints } : {}),
+      ...ifDefined('constraints', this.constraints),
     });
-    const { sql } = lowerer.lower(ddlNode, { contract: {} });
+    const statement = await lowerer.lowerToExecuteRequest(ddlNode);
     const schemaName = this.schemaName;
     const tableName = this.tableName;
     return {
@@ -240,7 +243,13 @@ export class CreateTableCall extends PostgresOpFactoryCallNode {
           `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`,
         ),
       ],
-      execute: [step(`create table "${tableName}"`, sql)],
+      execute: [
+        {
+          description: `create table "${tableName}"`,
+          sql: statement.sql,
+          params: statement.params ?? [],
+        },
+      ],
       postcheck: [
         step(
           `verify table "${tableName}" exists`,
@@ -315,10 +324,10 @@ export class AddColumnCall extends PostgresOpFactoryCallNode {
   readonly operationClass = 'additive' as const;
   readonly schemaName: string;
   readonly tableName: string;
-  readonly column: ColumnSpec;
+  readonly column: DdlColumn;
   readonly label: string;
 
-  constructor(schemaName: string, tableName: string, column: ColumnSpec) {
+  constructor(schemaName: string, tableName: string, column: DdlColumn) {
     super();
     this.schemaName = schemaName;
     this.tableName = tableName;
@@ -327,12 +336,65 @@ export class AddColumnCall extends PostgresOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return addColumn(this.schemaName, this.tableName, this.column);
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `AddColumnCall.toOp: a DDL lowerer is required on the Postgres planner path (column "${this.column.name}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    const ddlNode = contractFreeDdl.alterTable({
+      ...ifDefined('schema', boundSchema(this.schemaName)),
+      table: this.tableName,
+      actions: [contractFreeDdl.addColumnAction(this.column)],
+    });
+    const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+    const schemaName = this.schemaName;
+    const tableName = this.tableName;
+    const columnName = this.column.name;
+    return {
+      id: `column.${tableName}.${columnName}`,
+      label: `Add column "${columnName}" to "${tableName}"`,
+      operationClass: 'additive',
+      target: targetDetails('column', columnName, schemaName, tableName),
+      precheck: [
+        step(
+          `ensure column "${columnName}" is missing`,
+          columnExistsCheck({
+            schema: schemaName,
+            table: tableName,
+            column: columnName,
+            exists: false,
+          }),
+        ),
+      ],
+      execute: [step(`add column "${columnName}"`, statement.sql)],
+      postcheck: [
+        step(
+          `verify column "${columnName}" exists`,
+          columnExistsCheck({ schema: schemaName, table: tableName, column: columnName }),
+        ),
+      ],
+    };
   }
 
   renderTypeScript(): string {
-    return `addColumn(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.column)})`;
+    const opts: string[] = [];
+    if (this.schemaName !== UNBOUND_NAMESPACE_ID) {
+      opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+    }
+    opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+    opts.push(`column: ${renderDdlColumnAsTsCall(this.column)}`);
+    return `this.addColumn({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    const req: ImportRequirement[] = [
+      { moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: 'col' },
+    ];
+    for (const sym of defaultImportSymbols([this.column])) {
+      req.push({ moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: sym });
+    }
+    return req;
   }
 }
 
@@ -746,8 +808,8 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
   readonly tableName: string;
   readonly indexName: string;
   readonly columns: readonly string[];
-  // Named indexType (not typeName) to avoid collision with CreateEnumTypeCall.typeName,
-  // which identifies a CREATE TYPE target and is read by `locationForCall` in issue-planner.ts.
+  // Named indexType (not typeName): `locationForCall` in issue-planner.ts reads
+  // a call's `typeName` as a CREATE TYPE target location, which an index is not.
   readonly indexType: string | undefined;
   readonly options: Record<string, unknown> | undefined;
   readonly label: string;
@@ -820,123 +882,6 @@ export class DropIndexCall extends PostgresOpFactoryCallNode {
   }
 }
 
-// ============================================================================
-// Enum types
-// ============================================================================
-
-export class CreateEnumTypeCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'createEnumType' as const;
-  readonly operationClass = 'additive' as const;
-  readonly schemaName: string;
-  readonly typeName: string;
-  readonly nativeType: string;
-  readonly values: readonly string[];
-  readonly label: string;
-
-  constructor(
-    schemaName: string,
-    typeName: string,
-    values: readonly string[],
-    nativeType: string = typeName,
-  ) {
-    super();
-    this.schemaName = schemaName;
-    this.typeName = typeName;
-    this.nativeType = nativeType;
-    this.values = values;
-    this.label = `Create enum type "${typeName}"`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return createEnumType(this.schemaName, this.typeName, this.values, this.nativeType);
-  }
-
-  renderTypeScript(): string {
-    const nativeArg =
-      this.nativeType === this.typeName ? '' : `, ${jsonToTsSource(this.nativeType)}`;
-    return `createEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.values)}${nativeArg})`;
-  }
-}
-
-export class AddEnumValuesCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'addEnumValues' as const;
-  readonly operationClass = 'additive' as const;
-  readonly schemaName: string;
-  readonly typeName: string;
-  readonly nativeType: string;
-  readonly values: readonly string[];
-  readonly label: string;
-
-  constructor(schemaName: string, typeName: string, nativeType: string, values: readonly string[]) {
-    super();
-    this.schemaName = schemaName;
-    this.typeName = typeName;
-    this.nativeType = nativeType;
-    this.values = values;
-    this.label = `Add values to enum type "${typeName}": ${values.join(', ')}`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return addEnumValues(this.schemaName, this.typeName, this.nativeType, this.values);
-  }
-
-  renderTypeScript(): string {
-    return `addEnumValues(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.nativeType)}, ${jsonToTsSource(this.values)})`;
-  }
-}
-
-export class DropEnumTypeCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'dropEnumType' as const;
-  readonly operationClass = 'destructive' as const;
-  readonly schemaName: string;
-  readonly typeName: string;
-  readonly label: string;
-
-  constructor(schemaName: string, typeName: string) {
-    super();
-    this.schemaName = schemaName;
-    this.typeName = typeName;
-    this.label = `Drop enum type "${typeName}"`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return dropEnumType(this.schemaName, this.typeName);
-  }
-
-  renderTypeScript(): string {
-    return `dropEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)})`;
-  }
-}
-
-export class RenameTypeCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'renameType' as const;
-  readonly operationClass = 'destructive' as const;
-  readonly schemaName: string;
-  readonly fromName: string;
-  readonly toName: string;
-  readonly label: string;
-
-  constructor(schemaName: string, fromName: string, toName: string) {
-    super();
-    this.schemaName = schemaName;
-    this.fromName = fromName;
-    this.toName = toName;
-    this.label = `Rename type "${fromName}" to "${toName}"`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return renameType(this.schemaName, this.fromName, this.toName);
-  }
-
-  renderTypeScript(): string {
-    return `renameType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.fromName)}, ${jsonToTsSource(this.toName)})`;
-  }
-}
-
 // ============================================================================
 // Raw SQL
 // ============================================================================
@@ -1016,14 +961,14 @@ export class CreateSchemaCall extends PostgresOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(lowerer?: Lowerer): Op {
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
     if (lowerer === undefined) {
       throw new Error(
         `CreateSchemaCall.toOp: a DDL lowerer is required on the Postgres planner path (schema "${this.schemaName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
       );
     }
     const ddlNode = contractFreeDdl.createSchema({ schema: this.schemaName, ifNotExists: true });
-    const { sql } = lowerer.lower(ddlNode, { contract: {} });
+    const statement = await lowerer.lowerToExecuteRequest(ddlNode);
     const schemaName = this.schemaName;
     return {
       id: `schema.${schemaName}`,
@@ -1031,7 +976,13 @@ export class CreateSchemaCall extends PostgresOpFactoryCallNode {
       operationClass: 'additive',
       target: { id: 'postgres' },
       precheck: [],
-      execute: [step(`Create schema "${schemaName}"`, sql)],
+      execute: [
+        {
+          description: `Create schema "${schemaName}"`,
+          sql: statement.sql,
+          params: statement.params ?? [],
+        },
+      ],
       postcheck: [],
     };
   }
@@ -1121,10 +1072,6 @@ export type PostgresOpFactoryCall =
   | CreateIndexCall
   | DropIndexCall
   | DropConstraintCall
-  | CreateEnumTypeCall
-  | AddEnumValuesCall
-  | DropEnumTypeCall
-  | RenameTypeCall
   | RawSqlCall
   | CreateExtensionCall
   | CreateSchemaCall

package/src/core/migrations/operations/data-transform.ts

@@ -61,8 +61,8 @@ import type {
   SqlMigrationPlanOperationStep,
 } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
-import type { SerializedQueryPlan } from '@prisma-next/framework-components/control';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlExecuteRequest } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresPlanTargetDetails } from '../planner-target-details';
@@ -96,25 +96,29 @@ export interface DataTransformOptions {
   readonly run: DataTransformClosure | readonly DataTransformClosure[];
 }
 
-export function dataTransform<TContract extends Contract<SqlStorage>>(
+export async function dataTransform<TContract extends Contract<SqlStorage>>(
   contract: TContract,
   name: string,
   options: DataTransformOptions,
   adapter: SqlControlAdapter<'postgres'>,
-): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
   const runClosures: readonly DataTransformClosure[] = Array.isArray(options.run)
     ? options.run
     : [options.run as DataTransformClosure];
 
-  const checkPlan = options.check ? invokeAndLower(options.check, contract, adapter, name) : null;
-  const runPlans = runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name));
+  const checkPlan = options.check
+    ? await invokeAndLower(options.check, contract, adapter, name)
+    : null;
+  const runPlans = await Promise.all(
+    runClosures.map((closure) => invokeAndLower(closure, contract, adapter, name)),
+  );
 
   const precheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
     ? [
         {
           description: `Check ${name} has work to do`,
           sql: `SELECT EXISTS (${checkPlan.sql}) AS ok`,
-          params: checkPlan.params,
+          params: checkPlan.params ?? [],
         },
       ]
     : [];
@@ -122,7 +126,7 @@ export function dataTransform<TContract extends Contract<SqlStorage>>(
   const execute: readonly SqlMigrationPlanOperationStep[] = runPlans.map((plan) => ({
     description: `Run ${name}`,
     sql: plan.sql,
-    params: plan.params,
+    params: plan.params ?? [],
   }));
 
   const postcheck: readonly SqlMigrationPlanOperationStep[] = checkPlan
@@ -130,7 +134,7 @@ export function dataTransform<TContract extends Contract<SqlStorage>>(
         {
           description: `Verify ${name} resolved all violations`,
           sql: `SELECT NOT EXISTS (${checkPlan.sql}) AS ok`,
-          params: checkPlan.params,
+          params: checkPlan.params ?? [],
         },
       ]
     : [];
@@ -147,23 +151,16 @@ export function dataTransform<TContract extends Contract<SqlStorage>>(
   };
 }
 
-function invokeAndLower(
+async function invokeAndLower(
   closure: DataTransformClosure,
   contract: Contract<SqlStorage>,
   adapter: SqlControlAdapter<'postgres'>,
   name: string,
-): SerializedQueryPlan {
+): Promise<SqlExecuteRequest> {
   const result = closure();
   const plan = isBuildable(result) ? result.build() : result;
   assertContractMatches(plan, contract, name);
-  const lowered = adapter.lower(plan.ast, { contract });
-  const params = lowered.params.map((slot) => {
-    if (slot.kind === 'literal') return slot.value;
-    throw new Error(
-      `data-transform: bind-site slot '${slot.name}' is not allowed in migration plans`,
-    );
-  });
-  return { sql: lowered.sql, params };
+  return adapter.lowerToExecuteRequest(plan.ast, { contract });
 }
 
 function isBuildable(value: unknown): value is Buildable {

package/src/core/migrations/planner-ddl-builders.ts

@@ -1,6 +1,5 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type {
-  PostgresEnumStorageEntry,
   StorageColumn,
   StorageTable,
   StorageTypeInstance,
@@ -14,7 +13,7 @@ export function buildCreateTableSql(
   qualifiedTableName: string,
   table: StorageTable,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const columnDefinitions = Object.entries(table.columns).map(
     ([columnName, column]: [string, StorageColumn]) => {
@@ -79,7 +78,7 @@ function assertSafeDefaultExpression(expression: string): void {
 export function buildColumnTypeSql(
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
   allowPseudoTypes = true,
 ): string {
   const resolved = resolveColumnTypeMetadata(column, storageTypes);
@@ -200,7 +199,7 @@ export function buildAddColumnSql(
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
   temporaryDefault?: string | null,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
   const defaultSql =