@prisma-next/target-postgres 0.12.0-dev.62 → 0.12.0-dev.63

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,
@@ -37,22 +49,25 @@ import {
   setNotNull,
 } from './operations/columns';
 import { addForeignKey, addPrimaryKey, addUnique, dropConstraint } from './operations/constraints';
-import { createExtension, createSchema } from './operations/dependencies';
+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';
+const RELATIONAL_CORE_CONTRACT_FREE = '@prisma-next/sql-relational-core/contract-free';
 
 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 }];
@@ -67,8 +82,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 +176,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: RELATIONAL_CORE_CONTRACT_FREE, symbol: 'col' });
+      for (const sym of defaultImportSymbols(this.columns)) {
+        req.push({ moduleSpecifier: RELATIONAL_CORE_CONTRACT_FREE, symbol: sym });
+      }
+    }
+    for (const sym of constraintImportSymbols(this.constraints)) {
+      req.push({ moduleSpecifier: RELATIONAL_CORE_CONTRACT_FREE, symbol: sym });
+    }
+    return req;
   }
 }
 
@@ -776,12 +930,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 [];
   }
 }
 
@@ -867,22 +1041,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 { REFERENTIAL_ACTION_SQL } from '@prisma-next/sql-contract/referential-action-sql';
 import { 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)}

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

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

@@ -12,7 +12,7 @@ import { resolveColumnTypeMetadata } from './planner-type-resolution';
 export function buildCreateTableSql(
   qualifiedTableName: string,
   table: StorageTable,
-  codecHooks: Map<string, CodecControlHooks>,
+  codecHooks: ReadonlyMap<string, CodecControlHooks>,
   storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
 ): string {
   const columnDefinitions = Object.entries(table.columns).map(
@@ -77,7 +77,7 @@ function assertSafeDefaultExpression(expression: string): void {
  */
 export function buildColumnTypeSql(
   column: StorageColumn,
-  codecHooks: Map<string, CodecControlHooks>,
+  codecHooks: ReadonlyMap<string, CodecControlHooks>,
   storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
   allowPseudoTypes = true,
 ): string {
@@ -113,7 +113,7 @@ export function buildColumnTypeSql(
 
 function expandParameterizedTypeSql(
   column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,
-  codecHooks: Map<string, CodecControlHooks>,
+  codecHooks: ReadonlyMap<string, CodecControlHooks>,
 ): string | null {
   if (!column.typeParams) {
     return null;
@@ -197,7 +197,7 @@ export function buildAddColumnSql(
   qualifiedTableName: string,
   columnName: string,
   column: StorageColumn,
-  codecHooks: Map<string, CodecControlHooks>,
+  codecHooks: ReadonlyMap<string, CodecControlHooks>,
   temporaryDefault?: string | null,
   storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
 ): string {

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

@@ -24,6 +24,7 @@
  */
 
 import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { Lowerer } from '@prisma-next/family-sql/control-adapter';
 import type {
   MigrationPlanWithAuthoringSurface,
   OpFactoryCall,
@@ -43,16 +44,23 @@ export class TypeScriptRenderablePostgresMigration
   readonly #calls: readonly OpFactoryCall[];
   readonly #meta: MigrationMeta;
   readonly #spaceId: string;
+  readonly #lowerer: Lowerer | undefined;
 
-  constructor(calls: readonly OpFactoryCall[], meta: MigrationMeta, spaceId: string) {
+  constructor(
+    calls: readonly OpFactoryCall[],
+    meta: MigrationMeta,
+    spaceId: string,
+    lowerer?: Lowerer,
+  ) {
     super();
     this.#calls = calls;
     this.#meta = meta;
     this.#spaceId = spaceId;
+    this.#lowerer = lowerer;
   }
 
   override get operations(): readonly Op[] {
-    return renderOps(this.#calls);
+    return renderOps(this.#calls, this.#lowerer);
   }
 
   override describe(): MigrationMeta {
@@ -69,9 +77,6 @@ export class TypeScriptRenderablePostgresMigration
   }
 
   renderTypeScript(): string {
-    return renderCallsToTypeScript(this.#calls, {
-      from: this.#meta.from,
-      to: this.#meta.to,
-    });
+    return renderCallsToTypeScript(this.#calls, { from: this.#meta.from, to: this.#meta.to });
   }
 }

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

@@ -253,6 +253,7 @@ function buildColumnSpec(
     name: column,
     typeSql: buildColumnTypeSql(col, mutableHooks, mutableTypes),
     defaultSql: buildColumnDefaultSql(col.default, col),
+    columnDefault: col.default,
     nullable: overrides?.nullable ?? col.nullable,
   };
 }

package/src/core/migrations/planner.ts

@@ -12,6 +12,7 @@ import {
   planFieldEventOperations,
   plannerFailure,
 } from '@prisma-next/family-sql/control';
+import type { Lowerer } 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 {
@@ -51,8 +52,8 @@ type VerifySqlSchemaOptionsWithComponents = Parameters<typeof verifySqlSchema>[0
   readonly frameworkComponents: PlannerFrameworkComponents;
 };
 
-export function createPostgresMigrationPlanner(): PostgresMigrationPlanner {
-  return new PostgresMigrationPlanner();
+export function createPostgresMigrationPlanner(lowerer: Lowerer): PostgresMigrationPlanner {
+  return new PostgresMigrationPlanner(lowerer);
 }
 
 /**
@@ -87,6 +88,12 @@ export type PostgresPlanResult =
  * authoring surface.
  */
 export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
+  readonly #lowerer: Lowerer | undefined;
+
+  constructor(lowerer?: Lowerer) {
+    this.#lowerer = lowerer;
+  }
+
   plan(options: {
     readonly contract: unknown;
     readonly schema: unknown;
@@ -129,6 +136,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         to: context.toHash,
       },
       spaceId,
+      this.#lowerer,
     );
   }
 
@@ -225,6 +233,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
           to: options.contract.storage.storageHash,
         },
         options.spaceId,
+        this.#lowerer,
       ),
       ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),
     });

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

@@ -3,8 +3,11 @@ 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 { type DataTransformOptions, dataTransform } from './operations/data-transform';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
@@ -67,4 +70,42 @@ export abstract class PostgresMigration extends SqlMigration<
     }
     return dataTransform(contract, name, options, this.controlAdapter);
   }
+
+  /**
+   * Emit a `CREATE TABLE` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createTable(options: {
+    readonly schema?: string;
+    readonly table: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+    readonly constraints?: readonly DdlTableConstraint[];
+  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new CreateTableCall(
+      options.schema ?? UNBOUND_NAMESPACE_ID,
+      options.table,
+      options.columns,
+      options.constraints,
+    ).toOp(this.controlAdapter);
+  }
+
+  /**
+   * Emit a `CREATE SCHEMA` migration operation. Builds a typed DDL node from
+   * the supplied options and lowers it through the stored control adapter.
+   * Throws if no adapter is present (i.e. migration instantiated without a stack).
+   */
+  protected createSchema(options: {
+    readonly schema: string;
+    readonly ifNotExists?: boolean;
+  }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+    if (!this.controlAdapter) {
+      throw errorPostgresMigrationStackMissing();
+    }
+    return new CreateSchemaCall(options.schema).toOp(this.controlAdapter);
+  }
 }

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

@@ -1,5 +1,7 @@
 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 { blindCast } from '@prisma-next/utils/casts';
 import type { PostgresPlanTargetDetails } from './planner-target-details';
 
 type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
@@ -23,9 +25,12 @@ function assertPostgresOp(
   }
 }
 
-export function renderOps(calls: readonly OpFactoryCall[]): Op[] {
+export function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): Op[] {
   return calls.map((c) => {
-    const op = c.toOp();
+    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'
+    >(c).toOp(lowerer);
     assertPostgresOp(op, c.factoryName);
     return op;
   });

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

@@ -46,7 +46,7 @@ export function renderCallsToTypeScript(
   meta: RenderMigrationMeta,
 ): string {
   const imports = buildImports(calls);
-  const operationsBody = calls.map((c) => c.renderTypeScript()).join(',\n');
+  const operationsBody = calls.map((c) => renderCall(c)).join(',\n');
 
   return [
     shebangLineFor(detectScaffoldRuntime()),
@@ -66,6 +66,10 @@ export function renderCallsToTypeScript(
   ].join('\n');
 }
 
+function renderCall(call: OpFactoryCall): string {
+  return call.renderTypeScript();
+}
+
 function buildImports(calls: ReadonlyArray<OpFactoryCall>): string {
   const requirements: ImportRequirement[] = [...BASE_IMPORTS];
   for (const call of calls) {