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

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

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

@@ -1,21 +1,19 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type {
-  ForeignKey,
   PostgresEnumStorageEntry,
-  ReferentialAction,
   StorageColumn,
   StorageTable,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
 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 +78,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,9 +114,9 @@ export function buildColumnTypeSql(
 
 function expandParameterizedTypeSql(
   column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,
-  codecHooks: Map<string, CodecControlHooks>,
+  codecHooks: ReadonlyMap<string, CodecControlHooks>,
 ): string | null {
-  if (!column.typeParams) {
+  if (!column.typeParams || Object.keys(column.typeParams).length === 0) {
     return null;
   }
 
@@ -144,7 +142,7 @@ function expandParameterizedTypeSql(
   const expanded = hooks.expandNativeType({
     nativeType: column.nativeType,
     codecId: column.codecId,
-    typeParams: column.typeParams,
+    ...ifDefined('typeParams', column.typeParams),
   });
 
   return expanded !== column.nativeType ? expanded : null;
@@ -200,7 +198,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 +214,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;