@prisma-next/target-postgres 0.12.0-dev.7 → 0.12.0-dev.71

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;
-}

package/src/core/migrations/operations/constraints.ts

@@ -1,16 +1,8 @@
-import type { ReferentialAction } from '@prisma-next/sql-contract/types';
-import { quoteIdentifier } from '../../sql-utils';
+import { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
+import { escapeLiteral, quoteIdentifier } from '../../sql-utils';
 import { constraintExistsCheck, qualifyTableName } from '../planner-sql-checks';
 import { type ForeignKeySpec, type Op, step, targetDetails } from './shared';
 
-const REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {
-  noAction: 'NO ACTION',
-  restrict: 'RESTRICT',
-  cascade: 'CASCADE',
-  setNull: 'SET NULL',
-  setDefault: 'SET DEFAULT',
-};
-
 function renderForeignKeySql(schemaName: string, tableName: string, fk: ForeignKeySpec): string {
   let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
 ADD CONSTRAINT ${quoteIdentifier(fk.name)}
@@ -145,6 +137,83 @@ export function addForeignKey(schemaName: string, tableName: string, fk: Foreign
   };
 }
 
+export function addCheckConstraint(
+  schemaName: string,
+  tableName: string,
+  constraintName: string,
+  column: string,
+  values: readonly string[],
+): Op {
+  const qualified = qualifyTableName(schemaName, tableName);
+  const valueList = values.map((v) => `'${escapeLiteral(v)}'`).join(', ');
+  return {
+    id: `checkConstraint.${tableName}.${constraintName}`,
+    label: `Add check constraint "${constraintName}" on "${tableName}"."${column}"`,
+    operationClass: 'additive',
+    target: targetDetails('checkConstraint', constraintName, schemaName, tableName),
+    precheck: [
+      step(
+        `ensure constraint "${constraintName}" does not exist`,
+        constraintExistsCheck({
+          constraintName,
+          schema: schemaName,
+          table: tableName,
+          exists: false,
+        }),
+      ),
+    ],
+    execute: [
+      step(
+        `add check constraint "${constraintName}"`,
+        `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} CHECK (${quoteIdentifier(column)} IN (${valueList}))`,
+      ),
+    ],
+    postcheck: [
+      step(
+        `verify constraint "${constraintName}" exists`,
+        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
+      ),
+    ],
+  };
+}
+
+export function dropCheckConstraint(
+  schemaName: string,
+  tableName: string,
+  constraintName: string,
+): Op {
+  const qualified = qualifyTableName(schemaName, tableName);
+  return {
+    id: `dropCheckConstraint.${tableName}.${constraintName}`,
+    label: `Drop check constraint "${constraintName}" on "${tableName}"`,
+    operationClass: 'destructive',
+    target: targetDetails('checkConstraint', constraintName, schemaName, tableName),
+    precheck: [
+      step(
+        `ensure constraint "${constraintName}" exists`,
+        constraintExistsCheck({ constraintName, schema: schemaName, table: tableName }),
+      ),
+    ],
+    execute: [
+      step(
+        `drop check constraint "${constraintName}"`,
+        `ALTER TABLE ${qualified} DROP CONSTRAINT ${quoteIdentifier(constraintName)}`,
+      ),
+    ],
+    postcheck: [
+      step(
+        `verify constraint "${constraintName}" does not exist`,
+        constraintExistsCheck({
+          constraintName,
+          schema: schemaName,
+          table: tableName,
+          exists: false,
+        }),
+      ),
+    ],
+  };
+}
+
 /**
  * `kind` feeds the operation's `target.details.objectType`. Descriptor-flow
  * does not carry kind information in its drop-constraint descriptor, so the

package/src/core/migrations/operations/dependencies.ts

@@ -69,20 +69,3 @@ export function installExtension(options: {
     ],
   };
 }
-
-export function createSchema(schemaName: string): Op {
-  return {
-    id: `schema.${schemaName}`,
-    label: `Create schema "${schemaName}"`,
-    operationClass: 'additive',
-    target: { id: 'postgres' },
-    precheck: [],
-    execute: [
-      step(
-        `Create schema "${schemaName}"`,
-        `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schemaName)}`,
-      ),
-    ],
-    postcheck: [],
-  };
-}

package/src/core/migrations/operations/shared.ts

@@ -7,9 +7,9 @@ import type { OperationClass, PostgresPlanTargetDetails } from '../planner-targe
 export type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
 
 /**
- * Literal-args shape for a column definition consumed by `createTable` and
- * `addColumn`. Fully materialized: codec expansion and default rendering have
- * already happened in the wrapper.
+ * Literal-args shape for a column definition consumed by `addColumn` and
+ * similar operations. Fully materialized: codec expansion and default
+ * rendering have already happened in the wrapper.
  *
  * - `typeSql` is the column's DDL type string (e.g. `"integer"`, `"SERIAL"`,
  *   `"varchar(100)"`), already produced by `buildColumnTypeSql` in the

package/src/core/migrations/operations/tables.ts

@@ -1,43 +1,5 @@
-import { quoteIdentifier } from '../../sql-utils';
 import { qualifyTableName, toRegclassLiteral } from '../planner-sql-checks';
-import { type ColumnSpec, type Op, renderColumnDefinition, step, targetDetails } from './shared';
-
-export function createTable(
-  schemaName: string,
-  tableName: string,
-  columns: ReadonlyArray<ColumnSpec>,
-  primaryKey?: { readonly columns: readonly string[] },
-): Op {
-  const qualified = qualifyTableName(schemaName, tableName);
-  const columnDefs = columns.map(renderColumnDefinition);
-  const constraintDefs: string[] = [];
-  if (primaryKey) {
-    constraintDefs.push(`PRIMARY KEY (${primaryKey.columns.map(quoteIdentifier).join(', ')})`);
-  }
-  const allDefs = [...columnDefs, ...constraintDefs];
-  const createSql = `CREATE TABLE ${qualified} (\n  ${allDefs.join(',\n  ')}\n)`;
-
-  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}"`, createSql)],
-    postcheck: [
-      step(
-        `verify table "${tableName}" exists`,
-        `SELECT to_regclass(${toRegclassLiteral(schemaName, tableName)}) IS NOT NULL`,
-      ),
-    ],
-  };
-}
+import { type Op, step, targetDetails } from './shared';
 
 export function dropTable(schemaName: string, tableName: string): Op {
   const qualified = qualifyTableName(schemaName, tableName);