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

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

@@ -1,21 +1,18 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type {
-  ForeignKey,
   PostgresEnumStorageEntry,
-  ReferentialAction,
   StorageColumn,
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import { escapeLiteral, quoteIdentifier } from '../sql-utils';
 import type { PostgresColumnDefault } from '../types';
-import { qualifyTableName } from './planner-sql-checks';
 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(
@@ -80,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 {
@@ -116,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;
@@ -200,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 {
@@ -216,42 +213,3 @@ export function buildAddColumnSql(
   ].filter(Boolean);
   return parts.join(' ');
 }
-
-const REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {
-  noAction: 'NO ACTION',
-  restrict: 'RESTRICT',
-  cascade: 'CASCADE',
-  setNull: 'SET NULL',
-  setDefault: 'SET DEFAULT',
-};
-
-export function buildForeignKeySql(
-  schemaName: string,
-  tableName: string,
-  fkName: string,
-  foreignKey: ForeignKey,
-): string {
-  let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
-ADD CONSTRAINT ${quoteIdentifier(fkName)}
-FOREIGN KEY (${foreignKey.source.columns.map(quoteIdentifier).join(', ')})
-REFERENCES ${qualifyTableName(schemaName, foreignKey.target.tableName)} (${foreignKey.target.columns
-    .map(quoteIdentifier)
-    .join(', ')})`;
-
-  if (foreignKey.onDelete !== undefined) {
-    const action = REFERENTIAL_ACTION_SQL[foreignKey.onDelete];
-    if (!action) {
-      throw new Error(`Unknown referential action for onDelete: ${String(foreignKey.onDelete)}`);
-    }
-    sql += `\nON DELETE ${action}`;
-  }
-  if (foreignKey.onUpdate !== undefined) {
-    const action = REFERENTIAL_ACTION_SQL[foreignKey.onUpdate];
-    if (!action) {
-      throw new Error(`Unknown referential action for onUpdate: ${String(foreignKey.onUpdate)}`);
-    }
-    sql += `\nON UPDATE ${action}`;
-  }
-
-  return sql;
-}

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-sql-checks.ts

@@ -20,11 +20,11 @@ import { resolveColumnTypeMetadata } from './planner-type-resolution';
  * site.
  */
 export function qualifyTableName(schema: string, table: string): string {
-  return postgresCreateNamespace({ id: schema }).qualifyTable(table);
+  return postgresCreateNamespace({ id: schema, entries: { table: {} } }).qualifyTable(table);
 }
 
 export function toRegclassLiteral(schema: string, name: string): string {
-  return postgresCreateNamespace({ id: schema }).regclassLiteral(name);
+  return postgresCreateNamespace({ id: schema, entries: { table: {} } }).regclassLiteral(name);
 }
 
 /**
@@ -43,7 +43,7 @@ export function constraintExistsCheck({
   table?: string;
   exists?: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const existsClause = exists ? 'EXISTS' : 'NOT EXISTS';
   const tableFilter = table
     ? `AND c.conrelid = to_regclass(${namespace.regclassLiteral(table)})`
@@ -68,7 +68,7 @@ export function columnExistsCheck({
   column: string;
   exists?: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const existsClause = exists ? '' : 'NOT ';
   return `SELECT ${existsClause}EXISTS (
   SELECT 1
@@ -90,7 +90,7 @@ export function columnNullabilityCheck({
   column: string;
   nullable: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const expected = nullable ? 'YES' : 'NO';
   return `SELECT EXISTS (
   SELECT 1
@@ -111,7 +111,7 @@ export function columnHasNoDefaultCheck(opts: {
   table: string;
   column: string;
 }): string {
-  const namespace = postgresCreateNamespace({ id: opts.schema });
+  const namespace = postgresCreateNamespace({ id: opts.schema, entries: { table: {} } });
   return `SELECT NOT EXISTS (
   SELECT 1
   FROM information_schema.columns
@@ -282,7 +282,7 @@ export function columnTypeCheck({
   column: string;
   expectedType: string;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   return `SELECT EXISTS (
   SELECT 1
   FROM pg_attribute a
@@ -307,7 +307,7 @@ export function columnDefaultExistsCheck({
   column: string;
   exists?: boolean;
 }): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const nullCheck = exists ? 'IS NOT NULL' : 'IS NULL';
   return `SELECT EXISTS (
   SELECT 1
@@ -325,7 +325,7 @@ export function tableHasPrimaryKeyCheck(
   exists: boolean,
   constraintName?: string,
 ): string {
-  const namespace = postgresCreateNamespace({ id: schema });
+  const namespace = postgresCreateNamespace({ id: schema, entries: { table: {} } });
   const comparison = exists ? '' : 'NOT ';
   const constraintFilter = constraintName
     ? `AND c2.relname = '${escapeLiteral(constraintName)}'`

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

@@ -24,6 +24,7 @@ import type {
   MigrationOperationPolicy,
   SqlMigrationPlanOperation,
 } from '@prisma-next/family-sql/control';
+import { resolveValueSetValues } from '@prisma-next/family-sql/control';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
@@ -31,10 +32,11 @@ import {
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
   type SqlStorage,
-  type StorageTable,
+  StorageTable,
   type StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
 import { PostgresEnumType } from '../postgres-enum-type';
 import { isPostgresSchema } from '../postgres-schema';
 import {
@@ -43,11 +45,13 @@ import {
   resolveDdlSchemaForNamespaceStorage,
 } from './enum-planning';
 import {
+  AddCheckConstraintCall,
   AddColumnCall,
   AddEnumValuesCall,
   AlterColumnTypeCall,
   CreateEnumTypeCall,
   DataTransformCall,
+  DropCheckConstraintCall,
   DropEnumTypeCall,
   type PostgresOpFactoryCall,
   RawSqlCall,
@@ -93,7 +97,7 @@ export function tableAt(
 ): StorageTable | undefined {
   // Namespace.tables is typed as Record<string, IRNode> at the interface level;
   // SQL family namespaces always hold StorageTable instances.
-  return storage.namespaces[namespaceId]?.tables[tableName] as StorageTable | undefined;
+  return storage.namespaces[namespaceId]?.entries.table[tableName] as StorageTable | undefined;
 }
 
 /**
@@ -134,8 +138,8 @@ const DEFAULT_ENUM_NAMESPACE_ID = 'public';
 
 function namespaceHasEnum(storage: SqlStorage, namespaceId: string, typeName: string): boolean {
   const ns = storage.namespaces[namespaceId];
-  if (!ns || !('enum' in ns) || ns.enum == null) return false;
-  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName] !== undefined;
+  if (!isPostgresSchema(ns)) return false;
+  return ns.entries.type[typeName] !== undefined;
 }
 
 /**
@@ -166,7 +170,7 @@ function resolveColumnEnumNamespace(
 
 /**
  * Finds a type entry by explicit namespace coordinate. Namespace types (e.g.
- * Postgres enums) live under `storage.namespaces[nsId].enum`. Returns the
+ * Postgres enums) live under `storage.namespaces[nsId].entries.type`. Returns the
  * entry from the named namespace only — never scans other namespaces, so two
  * namespaces that hold an enum with the same name resolve independently.
  */
@@ -176,8 +180,12 @@ function locateNamespaceType(
   typeName: string,
 ): PostgresEnumStorageEntry | undefined {
   const ns = storage.namespaces[namespaceId];
-  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
-  return (ns.enum as Record<string, PostgresEnumStorageEntry>)[typeName];
+  const raw = ns?.entries['type']?.[typeName];
+  if (raw === undefined) return undefined;
+  return blindCast<
+    PostgresEnumStorageEntry,
+    'postgres type slot carries PostgresEnumStorageEntry at the postgres target layer'
+  >(raw);
 }
 
 // ============================================================================
@@ -248,6 +256,7 @@ function buildColumnSpec(
     name: column,
     typeSql: buildColumnTypeSql(col, mutableHooks, mutableTypes),
     defaultSql: buildColumnDefaultSql(col.default, col),
+    columnDefault: col.default,
     nullable: overrides?.nullable ?? col.nullable,
   };
 }
@@ -436,7 +445,7 @@ function enumRebuildCallRecipe(
   // same-named enums in distinct namespaces keep their columns disjoint.
   const columnRefs: { namespaceId: string; table: string; column: string }[] = [];
   for (const [nsId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {
-    for (const [tableName, tableNode] of Object.entries(ns.tables)) {
+    for (const [tableName, tableNode] of Object.entries(ns.entries.table)) {
       const table = tableNode as StorageTable;
       for (const [columnName, column] of Object.entries(table.columns)) {
         if (
@@ -639,9 +648,10 @@ export const nativeEnumPlanCallStrategy: CallMigrationStrategy = (issues, ctx) =
 function collectPostgresEnumTypes(storage: SqlStorage): ReadonlyMap<string, PostgresEnumType> {
   const result = new Map<string, PostgresEnumType>();
   for (const [nsId, ns] of Object.entries(storage.namespaces)) {
-    if (!('enum' in ns) || ns.enum == null) continue;
-    const nsEnums = ns.enum as Record<string, unknown>;
-    for (const [name, instance] of Object.entries(nsEnums).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!isPostgresSchema(ns)) continue;
+    for (const [name, instance] of Object.entries(ns.entries.type).sort(([a], [b]) =>
+      a.localeCompare(b),
+    )) {
       if (instance instanceof PostgresEnumType) {
         result.set(enumCompoundKey(nsId, name), instance);
       }
@@ -650,6 +660,133 @@ function collectPostgresEnumTypes(storage: SqlStorage): ReadonlyMap<string, Post
   return result;
 }
 
+/**
+ * Collects every check constraint from a table in the contract storage.
+ * Returns an empty array when the table has no checks or the table is absent.
+ */
+function collectContractChecks(
+  storage: SqlStorage,
+  namespaceId: string,
+  tableName: string,
+): ReadonlyArray<{ name: string; column: string; permittedValues: readonly string[] }> {
+  const ns = storage.namespaces[namespaceId];
+  const tableRaw = ns?.entries.table[tableName];
+  if (!(tableRaw instanceof StorageTable)) return [];
+  const checks = tableRaw.checks;
+  if (!checks || checks.length === 0) return [];
+  return checks.map((c) => ({
+    name: c.name,
+    column: c.column,
+    permittedValues: resolveValueSetValues(
+      c.valueSet,
+      storage,
+      `check "${c.name}" on "${tableName}"`,
+    ),
+  }));
+}
+
+/**
+ * Compares two value arrays as unordered sets.
+ */
+function checkValueSetsEqual(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false;
+  const bSet = new Set(b);
+  return a.every((v) => bSet.has(v));
+}
+
+/**
+ * Plans check-constraint migrations for `enumType`-authored columns.
+ *
+ * Walks every namespace's tables in the target contract. For each table that
+ * carries `checks`, diffs the contract-expected checks against the live
+ * schema's checks:
+ *
+ * - Check in contract, absent from live DB → `AddCheckConstraintCall`.
+ * - Check in live DB, absent from contract → `DropCheckConstraintCall`.
+ * - Check on both sides but value sets differ → `DropCheckConstraintCall`
+ *   then `AddCheckConstraintCall` (drop + recreate; a check predicate cannot
+ *   be altered in place).
+ *
+ * Consumes `check_missing`, `check_removed`, and `check_mismatch` issues.
+ * Does not touch the native enum path (`nativeEnumPlanCallStrategy` is
+ * unchanged).
+ */
+export const checkConstraintPlanCallStrategy: CallMigrationStrategy = (issues, ctx) => {
+  const calls: PostgresOpFactoryCall[] = [];
+  const handledIssueKeys = new Set<string>();
+
+  for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) {
+    for (const tableName of Object.keys(ns.entries.table)) {
+      const contractChecks = collectContractChecks(ctx.toContract.storage, namespaceId, tableName);
+      if (contractChecks.length === 0) continue;
+
+      const schemaTable = ctx.schema.tables[tableName];
+      const liveChecks = schemaTable?.checks ?? [];
+      const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
+
+      for (const contractCheck of contractChecks) {
+        const liveCheck = liveChecks.find((c) => c.name === contractCheck.name);
+        const issueKey = `${tableName}${contractCheck.name}`;
+        if (!liveCheck) {
+          calls.push(
+            new AddCheckConstraintCall(
+              ddlSchema,
+              tableName,
+              contractCheck.name,
+              contractCheck.column,
+              contractCheck.permittedValues,
+            ),
+          );
+          handledIssueKeys.add(issueKey);
+        } else if (!checkValueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) {
+          calls.push(
+            new DropCheckConstraintCall(ddlSchema, tableName, contractCheck.name),
+            new AddCheckConstraintCall(
+              ddlSchema,
+              tableName,
+              contractCheck.name,
+              contractCheck.column,
+              contractCheck.permittedValues,
+            ),
+          );
+          handledIssueKeys.add(issueKey);
+        }
+        // else: values match — no op needed, still consume the issue
+        else {
+          handledIssueKeys.add(issueKey);
+        }
+      }
+
+      // Emit drops for checks that are live but not in the contract.
+      for (const liveCheck of liveChecks) {
+        const inContract = contractChecks.some((c) => c.name === liveCheck.name);
+        if (!inContract) {
+          const issueKey = `${tableName}${liveCheck.name}`;
+          calls.push(new DropCheckConstraintCall(ddlSchema, tableName, liveCheck.name));
+          handledIssueKeys.add(issueKey);
+        }
+      }
+    }
+  }
+
+  if (calls.length === 0 && handledIssueKeys.size === 0) return { kind: 'no_match' };
+
+  const remaining = issues.filter((issue) => {
+    if (
+      issue.kind !== 'check_missing' &&
+      issue.kind !== 'check_removed' &&
+      issue.kind !== 'check_mismatch'
+    ) {
+      return true;
+    }
+    if (!issue.table || !issue.indexOrConstraint) return true;
+    const key = `${issue.table}${issue.indexOrConstraint}`;
+    return !handledIssueKeys.has(key);
+  });
+
+  return { kind: 'match', issues: remaining, calls };
+};
+
 /**
  * Dispatches non-enum codec-typed storage types through their codec's
  * `planTypeOperations` hook (the authoritative source for codec-driven DDL
@@ -922,6 +1059,7 @@ export const postgresPlannerStrategies: readonly CallMigrationStrategy[] = [
   typeChangeCallStrategy,
   nullableTighteningCallStrategy,
   nativeEnumPlanCallStrategy,
+  checkConstraintPlanCallStrategy,
   storageTypePlanCallStrategy,
   notNullAddColumnCallStrategy,
 ];

package/src/core/migrations/planner-target-details.ts

@@ -8,7 +8,8 @@ export type OperationClass =
   | 'primaryKey'
   | 'unique'
   | 'index'
-  | 'foreignKey';
+  | 'foreignKey'
+  | 'checkConstraint';
 
 export interface PostgresPlanTargetDetails {
   readonly schema: string;

package/src/core/migrations/planner.ts

@@ -2,13 +2,17 @@ import type { Contract } from '@prisma-next/contract/types';
 import type {
   MigrationOperationPolicy,
   SqlMigrationPlannerPlanOptions,
+  SqlPlannerConflict,
   SqlPlannerFailureResult,
 } from '@prisma-next/family-sql/control';
 import {
   extractCodecControlHooks,
+  partitionCallsByControlPolicy,
+  partitionIssuesByControlPolicy,
   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 {
@@ -18,10 +22,18 @@ import type {
   SchemaIssue,
 } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import { blindCast } from '@prisma-next/utils/casts';
 import { parsePostgresDefault } from '../default-normalizer';
 import { normalizeSchemaNativeType } from '../native-type-normalizer';
+import {
+  formatPostgresControlPolicySubjectLabel,
+  resolvePostgresCallControlPolicySubject,
+  resolvePostgresIssueControlPolicySubject,
+  resolvePostgresIssueCreationFactoryName,
+} from './control-policy';
 import { createResolveExistingEnumValues } from './enum-planning';
 import { planIssues } from './issue-planner';
+import type { PostgresOpFactoryCall } from './op-factory-call';
 import { TypeScriptRenderablePostgresMigration } from './planner-produced-postgres-migration';
 import { postgresPlannerStrategies } from './planner-strategies';
 import { verifyPostgresNamespacePresence } from './verify-postgres-namespaces';
@@ -40,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);
 }
 
 /**
@@ -52,7 +64,11 @@ export function createPostgresMigrationPlanner(): PostgresMigrationPlanner {
  * uniformly.
  */
 export type PostgresPlanResult =
-  | { readonly kind: 'success'; readonly plan: TypeScriptRenderablePostgresMigration }
+  | {
+      readonly kind: 'success';
+      readonly plan: TypeScriptRenderablePostgresMigration;
+      readonly warnings?: readonly SqlPlannerConflict[];
+    }
   | SqlPlannerFailureResult;
 
 /**
@@ -72,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;
@@ -114,6 +136,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         to: context.toHash,
       },
       spaceId,
+      this.#lowerer,
     );
   }
 
@@ -131,8 +154,25 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
     const codecHooks = extractCodecControlHooks(options.frameworkComponents);
     const storageTypes = options.contract.storage.types ?? {};
 
-    const result = planIssues({
+    // Input-side control-policy partition. `external` / `observed` subjects
+    // — and non-creation issues for `tolerated` subjects — are dropped from
+    // the planner's input entirely; the planner never observes them, never
+    // diffs them, never generates DDL for them. Suppression warnings are
+    // built directly from the suppressed partition (one per subject), so the
+    // user-visible message survives even when the planner would have failed
+    // to model the subject's live shape.
+    const issuePartition = partitionIssuesByControlPolicy({
       issues: schemaIssues,
+      contract: options.contract,
+      resolveControlPolicySubject: (issue) =>
+        resolvePostgresIssueControlPolicySubject(issue, options.contract),
+      resolveCreationFactoryName: resolvePostgresIssueCreationFactoryName,
+      formatSubjectLabel: (factoryName, subject) =>
+        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
+    });
+
+    const result = planIssues({
+      issues: issuePartition.plannable,
       toContract: options.contract,
       // `fromContract` is only supplied by `migration plan`. It is `null` for
       // `db update` / `db init`, which means data-safety strategies needing
@@ -163,10 +203,26 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       newContract: options.contract,
       codecHooks,
     });
-    // Codec-emitted calls already conform to `OpFactoryCall` — render +
-    // toOp + importRequirements ride directly through the same emit path
-    // as structural ops, no `RawSqlCall` wrap.
-    const calls = [...result.value.calls, ...fieldEventOps];
+    // Codec hook ops are target-agnostic `OpFactoryCall`; Postgres planning
+    // lifts them at this integration boundary (see field-event-planner JSDoc).
+    const fieldEventPostgresCalls = blindCast<
+      readonly PostgresOpFactoryCall[],
+      'Codec hook ops conform to PostgresOpFactoryCall at the app emitter boundary'
+    >(fieldEventOps);
+    const fieldEventPartition = partitionCallsByControlPolicy({
+      calls: fieldEventPostgresCalls,
+      contract: options.contract,
+      resolveControlPolicySubject: (call) =>
+        resolvePostgresCallControlPolicySubject(call, options.contract),
+      resolveFactoryName: (call) => call.factoryName,
+      formatSubjectLabel: (factoryName, subject) =>
+        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
+    });
+    const calls = [...result.value.calls, ...fieldEventPartition.kept];
+    const warnings: SqlPlannerConflict[] = [
+      ...issuePartition.warnings,
+      ...fieldEventPartition.warnings,
+    ];
 
     return Object.freeze({
       kind: 'success' as const,
@@ -177,7 +233,9 @@ 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);
+  }
 }