@prisma-next/target-postgres 0.12.0 → 0.13.0-dev.1

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

@@ -25,10 +25,13 @@ import type {
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import type { 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 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,
@@ -39,6 +42,7 @@ import {
   CreateIndexCall,
   CreateSchemaCall,
   CreateTableCall,
+  DropCheckConstraintCall,
   DropColumnCall,
   DropConstraintCall,
   DropDefaultCall,
@@ -46,6 +50,7 @@ import {
   DropNotNullCall,
   DropTableCall,
   type PostgresOpFactoryCall,
+  postgresDefaultToDdlColumnDefault,
   SetDefaultCall,
   SetNotNullCall,
 } from './op-factory-call';
@@ -73,8 +78,7 @@ function locateNamespaceTypeInStorage(
   typeName: string,
 ): unknown {
   const ns = storage.namespaces[namespaceId];
-  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
-  return (ns.enum as Record<string, unknown>)[typeName];
+  return isPostgresSchema(ns) ? ns.entries.type[typeName] : undefined;
 }
 
 // ============================================================================
@@ -118,6 +122,11 @@ const ISSUE_KIND_ORDER: Record<string, number> = {
   unique_constraint_mismatch: 51,
   index_mismatch: 52,
   foreign_key_mismatch: 60,
+
+  // Check constraints
+  check_missing: 53,
+  check_mismatch: 54,
+  check_removed: 55,
 };
 
 function issueOrder(issue: SchemaIssue): number {
@@ -191,16 +200,26 @@ function toColumnSpec(
 ): ColumnSpec {
   return {
     name,
-    typeSql: buildColumnTypeSql(
-      column,
-      codecHooks as Map<string, CodecControlHooks>,
-      storageTypes as Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-    ),
+    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>>,
+): DdlColumn {
+  const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
+  const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);
+  return contractFree.col(name, typeSql, {
+    ...(!column.nullable ? { notNull: true } : {}),
+    ...(ddlDefault ? { default: ddlDefault } : {}),
+  });
+}
+
 function mapIssueToCall(
   issue: SchemaIssue,
   ctx: StrategyContext,
@@ -245,14 +264,18 @@ function mapIssueToCall(
         );
       }
       const schemaForTable = tableSchema(issue);
-      const columns: ColumnSpec[] = Object.entries(contractTable.columns).map(([name, column]) =>
-        toColumnSpec(name, column, codecHooks, storageTypes),
+      const ddlColumns: DdlColumn[] = Object.entries(contractTable.columns).map(([name, column]) =>
+        toDdlColumn(name, column, codecHooks, storageTypes),
       );
-      const primaryKey = contractTable.primaryKey
-        ? { columns: contractTable.primaryKey.columns }
+      const ddlConstraints: DdlTableConstraint[] | undefined = contractTable.primaryKey
+        ? [
+            contractFree.primaryKey(contractTable.primaryKey.columns, {
+              ...(contractTable.primaryKey.name ? { name: contractTable.primaryKey.name } : {}),
+            }),
+          ]
         : undefined;
       const calls: PostgresOpFactoryCall[] = [
-        new CreateTableCall(schemaForTable, issue.table, columns, primaryKey),
+        new CreateTableCall(schemaForTable, issue.table, ddlColumns, ddlConstraints),
       ];
       for (const index of contractTable.indexes) {
         const indexName = index.name ?? `${issue.table}_${index.columns.join('_')}_idx`;
@@ -555,6 +578,48 @@ function mapIssueToCall(
         ),
       );
 
+    case 'check_missing': {
+      if (!issue.table || !issue.indexOrConstraint)
+        return notOk(
+          issueConflict('unsupportedOperation', 'Check missing issue has no table/constraint name'),
+        );
+      // check_missing is normally consumed by checkConstraintPlanCallStrategy.
+      // This case handles any that arrive here (e.g. in tests that invoke
+      // mapIssueToCall directly or skip the strategy).
+      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'));
@@ -601,7 +666,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.enum.
+      // 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).
@@ -687,9 +752,12 @@ function classifyCall(call: PostgresOpFactoryCall): CallCategory {
     case 'dropTable':
     case 'dropColumn':
     case 'dropConstraint':
+    case 'dropCheckConstraint':
     case 'dropIndex':
     case 'dropDefault':
       return 'drop';
+    case 'addCheckConstraint':
+      return 'unique'; // after uniques, before indexes
     case 'createTable':
       return 'table';
     case 'addColumn':

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

@@ -22,11 +22,23 @@
 
 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 {
   OpFactoryCall as FrameworkOpFactoryCall,
   MigrationOperationClass,
 } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type {
+  AnyDdlColumnDefault,
+  DdlColumn,
+  DdlTableConstraint,
+} from '@prisma-next/sql-relational-core/ast';
+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 * as contractFreeDdl from '../../contract-free/ddl';
+import { escapeLiteral, quoteIdentifier } from '../sql-utils';
+import type { PostgresColumnDefault } from '../types';
 import {
   addColumn,
   alterColumnType,
@@ -36,26 +48,47 @@ import {
   setDefault,
   setNotNull,
 } from './operations/columns';
-import { addForeignKey, addPrimaryKey, addUnique, dropConstraint } from './operations/constraints';
-import { createExtension, createSchema } from './operations/dependencies';
+import {
+  addCheckConstraint,
+  addForeignKey,
+  addPrimaryKey,
+  addUnique,
+  dropCheckConstraint,
+  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 { createTable, dropTable } from './operations/tables';
+import { step, targetDetails } from './operations/shared';
+import { dropTable } from './operations/tables';
+import { toRegclassLiteral } from './planner-sql-checks';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 
-const TARGET_MIGRATION_MODULE = '@prisma-next/postgres/migration';
+// Single module specifier emitted in user-edited `migration.ts` imports. The
+// Postgres migration facade re-exports both the `*Call` factory names
+// (createTable / addColumn / …) and the contract-free DDL builders
+// (col / lit / fn / primaryKey / foreignKey / unique) from
+// sql-relational-core/contract-free. We emit imports against the facade,
+// not against the underlying sql-relational-core subpath, because user
+// projects depend on `@prisma-next/postgres` (a runtime dep of every
+// init-scaffolded project) — they do not depend on the internal
+// `@prisma-next/sql-relational-core` package, so an emitted
+// `import … from '@prisma-next/sql-relational-core/contract-free'` fails
+// ESM resolution at runtime in user migrations even though pnpm has the
+// transitive package on disk.
+const POSTGRES_MIGRATION_FACADE = '@prisma-next/postgres/migration';
 
 abstract class PostgresOpFactoryCallNode extends TsExpression implements FrameworkOpFactoryCall {
   abstract readonly factoryName: string;
   abstract readonly operationClass: MigrationOperationClass;
   abstract readonly label: string;
-  abstract toOp(): Op;
+  abstract toOp(lowerer?: Lowerer): Op;
 
   importRequirements(): readonly ImportRequirement[] {
-    return [{ moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: this.factoryName }];
+    return [{ moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: this.factoryName }];
   }
 
   protected freeze(): void {
@@ -67,8 +100,93 @@ abstract class PostgresOpFactoryCallNode extends TsExpression implements Framewo
 // Table
 // ============================================================================
 
-export interface CreateTablePrimaryKey {
-  readonly columns: readonly string[];
+export function postgresDefaultToDdlColumnDefault(
+  columnDefault: PostgresColumnDefault | undefined,
+): DdlColumn['default'] {
+  if (!columnDefault) return undefined;
+  switch (columnDefault.kind) {
+    case 'literal':
+      return new LiteralColumnDefault(columnDefault.value);
+    case 'function':
+      if (columnDefault.expression === 'autoincrement()') return undefined;
+      return new FunctionColumnDefault(columnDefault.expression);
+    case 'sequence':
+      return new FunctionColumnDefault(
+        `nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`,
+      );
+    default: {
+      const exhaustive: never = columnDefault;
+      throw new Error(
+        `postgresDefaultToDdlColumnDefault: unhandled kind "${blindCast<{ kind: string }, 'exhaustiveness: surface the unhandled default kind'>(exhaustive).kind}"`,
+      );
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// TypeScript rendering helpers for DdlColumn / DdlTableConstraint
+// ---------------------------------------------------------------------------
+
+function renderDdlColumnDefault(def: AnyDdlColumnDefault | undefined): string {
+  if (!def) return '';
+  if (def.kind === 'literal') {
+    return `lit(${jsonToTsSource(def.value)})`;
+  }
+  return `fn(${jsonToTsSource(def.expression)})`;
+}
+
+function renderDdlColumnAsTsCall(col: DdlColumn): string {
+  const opts: string[] = [];
+  if (col.notNull) opts.push('notNull: true');
+  if (col.primaryKey) opts.push('primaryKey: true');
+  if (col.default) opts.push(`default: ${renderDdlColumnDefault(col.default)}`);
+  const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+  return `col(${jsonToTsSource(col.name)}, ${jsonToTsSource(col.type)}${optsStr})`;
+}
+
+function renderDdlConstraintAsTsCall(constraint: DdlTableConstraint): string {
+  switch (constraint.kind) {
+    case 'primary-key': {
+      const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
+      return `primaryKey(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+    }
+    case 'foreign-key': {
+      const opts: string[] = [];
+      if (constraint.name) opts.push(`name: ${jsonToTsSource(constraint.name)}`);
+      if (constraint.onDelete) opts.push(`onDelete: ${jsonToTsSource(constraint.onDelete)}`);
+      if (constraint.onUpdate) opts.push(`onUpdate: ${jsonToTsSource(constraint.onUpdate)}`);
+      const optsStr = opts.length > 0 ? `, { ${opts.join(', ')} }` : '';
+      return `foreignKey(${jsonToTsSource(constraint.columns)}, ${jsonToTsSource(constraint.refTable)}, ${jsonToTsSource(constraint.refColumns)}${optsStr})`;
+    }
+    case 'unique': {
+      const nameOpt = constraint.name ? `, { name: ${jsonToTsSource(constraint.name)} }` : '';
+      return `unique(${jsonToTsSource(constraint.columns)}${nameOpt})`;
+    }
+  }
+}
+
+function needsColOrConstraintImport(columns: readonly DdlColumn[]): boolean {
+  return columns.length > 0;
+}
+
+function constraintImportSymbols(constraints: readonly DdlTableConstraint[] | undefined): string[] {
+  if (!constraints || constraints.length === 0) return [];
+  const symbols = new Set<string>();
+  for (const c of constraints) {
+    if (c.kind === 'primary-key') symbols.add('primaryKey');
+    else if (c.kind === 'foreign-key') symbols.add('foreignKey');
+    else if (c.kind === 'unique') symbols.add('unique');
+  }
+  return [...symbols];
+}
+
+function defaultImportSymbols(columns: readonly DdlColumn[]): string[] {
+  const symbols = new Set<string>();
+  for (const col of columns) {
+    if (col.default?.kind === 'literal') symbols.add('lit');
+    else if (col.default?.kind === 'function') symbols.add('fn');
+  }
+  return [...symbols];
 }
 
 export class CreateTableCall extends PostgresOpFactoryCallNode {
@@ -76,37 +194,91 @@ export class CreateTableCall extends PostgresOpFactoryCallNode {
   readonly operationClass = 'additive' as const;
   readonly schemaName: string;
   readonly tableName: string;
-  readonly columns: readonly ColumnSpec[];
-  readonly primaryKey: CreateTablePrimaryKey | undefined;
+  readonly columns: readonly DdlColumn[];
+  readonly constraints: readonly DdlTableConstraint[] | undefined;
   readonly label: string;
 
   constructor(
     schemaName: string,
     tableName: string,
-    columns: readonly ColumnSpec[],
-    primaryKey?: CreateTablePrimaryKey,
+    columns: readonly DdlColumn[],
+    constraints?: readonly DdlTableConstraint[],
   ) {
     super();
     this.schemaName = schemaName;
     this.tableName = tableName;
-    this.columns = columns;
-    this.primaryKey = primaryKey;
+    this.columns = Object.freeze([...columns]);
+    this.constraints = constraints ? Object.freeze([...constraints]) : undefined;
     this.label = `Create table "${tableName}"`;
     this.freeze();
   }
 
-  toOp(): Op {
-    return createTable(this.schemaName, this.tableName, this.columns, this.primaryKey);
+  toOp(lowerer?: Lowerer): 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 } : {}),
+      table: this.tableName,
+      columns: this.columns,
+      ...(this.constraints ? { constraints: this.constraints } : {}),
+    });
+    const { sql } = lowerer.lower(ddlNode, { contract: {} });
+    const schemaName = this.schemaName;
+    const tableName = this.tableName;
+    return {
+      id: `table.${tableName}`,
+      label: `Create table "${tableName}"`,
+      summary: `Creates table "${tableName}"`,
+      operationClass: 'additive',
+      target: targetDetails('table', tableName, schemaName),
+      precheck: [
+        step(
+          `ensure table "${tableName}" does not exist`,
+          `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NULL`,
+        ),
+      ],
+      execute: [step(`create table "${tableName}"`, sql)],
+      postcheck: [
+        step(
+          `verify table "${tableName}" exists`,
+          `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`,
+        ),
+      ],
+    };
   }
 
   renderTypeScript(): string {
-    const args = [
-      jsonToTsSource(this.schemaName),
-      jsonToTsSource(this.tableName),
-      jsonToTsSource(this.columns),
-    ];
-    if (this.primaryKey) args.push(jsonToTsSource(this.primaryKey));
-    return `createTable(${args.join(', ')})`;
+    const columnsList = this.columns.map(renderDdlColumnAsTsCall).join(', ');
+    const constraintsList = this.constraints
+      ? this.constraints.map(renderDdlConstraintAsTsCall).join(', ')
+      : undefined;
+
+    const opts: string[] = [];
+    if (this.schemaName !== UNBOUND_NAMESPACE_ID) {
+      opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+    }
+    opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+    opts.push(`columns: [${columnsList}]`);
+    if (constraintsList) opts.push(`constraints: [${constraintsList}]`);
+
+    return `this.createTable({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    const req: ImportRequirement[] = [];
+    if (needsColOrConstraintImport(this.columns)) {
+      req.push({ moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: 'col' });
+      for (const sym of defaultImportSymbols(this.columns)) {
+        req.push({ moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: sym });
+      }
+    }
+    for (const sym of constraintImportSymbols(this.constraints)) {
+      req.push({ moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: sym });
+    }
+    return req;
   }
 }
 
@@ -495,6 +667,74 @@ export class DropConstraintCall extends PostgresOpFactoryCallNode {
   }
 }
 
+export class AddCheckConstraintCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'addCheckConstraint' as const;
+  readonly operationClass = 'additive' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly column: string;
+  readonly values: readonly string[];
+  readonly label: string;
+
+  constructor(
+    schemaName: string,
+    tableName: string,
+    constraintName: string,
+    column: string,
+    values: readonly string[],
+  ) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.constraintName = constraintName;
+    this.column = column;
+    this.values = values;
+    this.label = `Add check constraint "${constraintName}" on "${tableName}"."${column}"`;
+    this.freeze();
+  }
+
+  toOp(): Op {
+    return addCheckConstraint(
+      this.schemaName,
+      this.tableName,
+      this.constraintName,
+      this.column,
+      this.values,
+    );
+  }
+
+  renderTypeScript(): string {
+    return `addCheckConstraint(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)}, ${jsonToTsSource(this.column)}, ${jsonToTsSource(this.values)})`;
+  }
+}
+
+export class DropCheckConstraintCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'dropCheckConstraint' as const;
+  readonly operationClass = 'destructive' as const;
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly constraintName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, tableName: string, constraintName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.tableName = tableName;
+    this.constraintName = constraintName;
+    this.label = `Drop check constraint "${constraintName}" on "${tableName}"`;
+    this.freeze();
+  }
+
+  toOp(): Op {
+    return dropCheckConstraint(this.schemaName, this.tableName, this.constraintName);
+  }
+
+  renderTypeScript(): string {
+    return `dropCheckConstraint(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.tableName)}, ${jsonToTsSource(this.constraintName)})`;
+  }
+}
+
 // ============================================================================
 // Indexes
 // ============================================================================
@@ -776,12 +1016,32 @@ export class CreateSchemaCall extends PostgresOpFactoryCallNode {
     this.freeze();
   }
 
-  toOp(): Op {
-    return createSchema(this.schemaName);
+  toOp(lowerer?: Lowerer): 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 schemaName = this.schemaName;
+    return {
+      id: `schema.${schemaName}`,
+      label: `Create schema "${schemaName}"`,
+      operationClass: 'additive',
+      target: { id: 'postgres' },
+      precheck: [],
+      execute: [step(`Create schema "${schemaName}"`, sql)],
+      postcheck: [],
+    };
   }
 
   renderTypeScript(): string {
-    return `createSchema(${jsonToTsSource(this.schemaName)})`;
+    return `this.createSchema({ schema: ${jsonToTsSource(this.schemaName)} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
   }
 }
 
@@ -832,7 +1092,7 @@ export class DataTransformCall extends PostgresOpFactoryCallNode {
 
   override importRequirements(): readonly ImportRequirement[] {
     return [
-      { moduleSpecifier: TARGET_MIGRATION_MODULE, symbol: 'placeholder' },
+      { moduleSpecifier: POSTGRES_MIGRATION_FACADE, symbol: 'placeholder' },
       {
         moduleSpecifier: './end-contract.json',
         symbol: 'endContract',
@@ -856,6 +1116,8 @@ export type PostgresOpFactoryCall =
   | AddPrimaryKeyCall
   | AddForeignKeyCall
   | AddUniqueCall
+  | AddCheckConstraintCall
+  | DropCheckConstraintCall
   | CreateIndexCall
   | DropIndexCall
   | DropConstraintCall
@@ -867,22 +1129,3 @@ export type PostgresOpFactoryCall =
   | CreateExtensionCall
   | CreateSchemaCall
   | DataTransformCall;
-
-/**
- * Stable identity key for reconciliation-level dedup.
- *
- * Two calls whose runtime ops would share the same `id` return the same
- * key, so a `Set<string>` can collapse them before they're emitted. The
- * current implementation delegates to `toOp().id`, which is the
- * authoritative identity; isolating dedup behind this helper lets a future
- * pass replace it with an allocation-free computation directly from the
- * call's fields without touching call sites.
- *
- * `DataTransformCall` intentionally has no sensible identity today — it
- * throws `PN-MIG-2001` on `toOp()`. Reconciliation never produces one; the
- * helper is unspecified for that variant and only meant for
- * reconciliation-emitted calls.
- */
-export function identityKeyFor(call: PostgresOpFactoryCall): string {
-  return call.toOp().id;
-}