@prisma-next/target-postgres 0.12.0-dev.5 → 0.12.0-dev.51

package/src/core/codecs.ts

@@ -71,6 +71,7 @@ import {
   PG_JSON_CODEC_ID,
   PG_JSONB_CODEC_ID,
   PG_NUMERIC_CODEC_ID,
+  PG_TEXT_ARRAY_CODEC_ID,
   PG_TEXT_CODEC_ID,
   PG_TIME_CODEC_ID,
   PG_TIMESTAMP_CODEC_ID,
@@ -99,6 +100,7 @@ const precisionParamsSchema = arktype({
 }) satisfies StandardSchemaV1<PrecisionParams>;
 
 const PG_TEXT_META = { db: { sql: { postgres: { nativeType: 'text' } } } } as const;
+const PG_TEXT_ARRAY_META = { db: { sql: { postgres: { nativeType: 'text[]' } } } } as const;
 const PG_INT4_META = { db: { sql: { postgres: { nativeType: 'integer' } } } } as const;
 const PG_INT2_META = { db: { sql: { postgres: { nativeType: 'smallint' } } } } as const;
 const PG_INT8_META = { db: { sql: { postgres: { nativeType: 'bigint' } } } } as const;
@@ -160,6 +162,47 @@ export const pgTextColumn = () =>
 pgTextColumn satisfies ColumnHelperFor<PgTextDescriptor>;
 pgTextColumn satisfies ColumnHelperForStrict<PgTextDescriptor>;
 
+/**
+ * Postgres `text[]` codec. Encode is an identity pass-through: the pg wire
+ * driver serialises a JS `string[]` to a Postgres array literal under the
+ * `$N::text[]` cast the renderer emits from this codec's `text[]` native type,
+ * and decode reads it back as a JS array. Used by the control plane to write
+ * the marker's `invariants` column. Not a user-facing scalar — it is not part
+ * of the authorable `CodecTypes` surface, only the runtime codec registry.
+ */
+export class PgTextArrayCodec extends CodecImpl<
+  typeof PG_TEXT_ARRAY_CODEC_ID,
+  readonly ['equality'],
+  readonly string[],
+  readonly string[]
+> {
+  async encode(value: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]> {
+    return value;
+  }
+  async decode(wire: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]> {
+    return wire;
+  }
+  encodeJson(value: readonly string[]): JsonValue {
+    return [...value];
+  }
+  decodeJson(json: JsonValue): readonly string[] {
+    return Array.isArray(json) ? json.map((entry) => String(entry)) : [];
+  }
+}
+
+export class PgTextArrayDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = PG_TEXT_ARRAY_CODEC_ID;
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['text[]'] as const;
+  override readonly meta = PG_TEXT_ARRAY_META;
+  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => PgTextArrayCodec {
+    return () => new PgTextArrayCodec(this);
+  }
+}
+
+export const pgTextArrayDescriptor = new PgTextArrayDescriptor();
+
 export class PgInt4Codec extends CodecImpl<
   typeof PG_INT4_CODEC_ID,
   readonly ['equality', 'order', 'numeric'],
@@ -1036,4 +1079,5 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   pgEnumDescriptor,
   pgJsonDescriptor,
   pgJsonbDescriptor,
+  pgTextArrayDescriptor,
 ];

package/src/core/ddl/nodes.ts

@@ -0,0 +1,59 @@
+import { type DdlColumn, DdlNode } from '@prisma-next/sql-relational-core/ast';
+
+export interface PostgresDdlVisitor<R> {
+  createTable(node: PostgresCreateTable): R;
+  createSchema(node: PostgresCreateSchema): R;
+}
+
+export abstract class PostgresDdlNode extends DdlNode {
+  abstract accept<R>(visitor: PostgresDdlVisitor<R>): R;
+}
+
+function freezeDdlColumns(columns: readonly DdlColumn[]): ReadonlyArray<DdlColumn> {
+  return Object.freeze([...columns]);
+}
+
+export class PostgresCreateTable extends PostgresDdlNode {
+  readonly kind = 'create-table' as const;
+  readonly table: string;
+  readonly schema: string | undefined;
+  readonly ifNotExists: boolean | undefined;
+  readonly columns: ReadonlyArray<DdlColumn>;
+
+  constructor(options: {
+    readonly table: string;
+    readonly schema?: string;
+    readonly ifNotExists?: boolean;
+    readonly columns: readonly DdlColumn[];
+  }) {
+    super();
+    this.table = options.table;
+    this.schema = options.schema;
+    this.ifNotExists = options.ifNotExists;
+    this.columns = freezeDdlColumns(options.columns);
+    this.freeze();
+  }
+
+  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
+    return visitor.createTable(this);
+  }
+}
+
+export class PostgresCreateSchema extends PostgresDdlNode {
+  readonly kind = 'create-schema' as const;
+  readonly schema: string;
+  readonly ifNotExists: boolean | undefined;
+
+  constructor(options: { readonly schema: string; readonly ifNotExists?: boolean }) {
+    super();
+    this.schema = options.schema;
+    this.ifNotExists = options.ifNotExists;
+    this.freeze();
+  }
+
+  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
+    return visitor.createSchema(this);
+  }
+}
+
+export type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema;

package/src/core/descriptor-meta.ts

@@ -8,6 +8,7 @@ import { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';
 
 const postgresTargetDescriptorMetaBase = {
   ...postgresTargetDescriptorMetaRuntime,
+  defaultNamespaceId: 'public',
   authoring: {
     type: postgresAuthoringTypes,
     field: postgresAuthoringFieldPresets,

package/src/core/migrations/control-policy.ts

@@ -0,0 +1,234 @@
+import type { Contract } from '@prisma-next/contract/types';
+import type { ControlPolicySubject } from '@prisma-next/family-sql/control';
+import type { SchemaIssue } from '@prisma-next/framework-components/control';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import {
+  isPostgresEnumStorageEntry,
+  type SqlStorage,
+  storageTableAt,
+} from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { isPostgresSchema } from '../postgres-schema';
+import type { PostgresOpFactoryCall } from './op-factory-call';
+
+/**
+ * Factory calls that create a whole, previously-absent top-level storage
+ * object. Used to decide whether `tolerated` permits a call (it only allows
+ * creating absent objects, never modifying existing ones).
+ *
+ * Deliberately an explicit, closed set rather than a `factoryName`
+ * create/alter/drop classification: it answers exactly one yes/no question
+ * and is fail-closed. Any call not listed here — including future or
+ * extension-contributed factories — is treated as NOT object-creation, so it
+ * is suppressed under `tolerated` rather than permissively emitted.
+ */
+const OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([
+  'createTable',
+  'createEnumType',
+  'createSchema',
+]);
+
+function createsNewTopLevelObject(call: PostgresOpFactoryCall): boolean {
+  return OBJECT_CREATION_FACTORIES.has(call.factoryName);
+}
+
+function ddlSchemaNameForNamespace(contract: Contract<SqlStorage>, namespaceId: string): string {
+  const namespace = contract.storage.namespaces[namespaceId];
+  return isPostgresSchema(namespace) ? namespace.ddlSchemaName(contract.storage) : namespaceId;
+}
+
+function resolveNamespaceIdForTable(
+  contract: Contract<SqlStorage>,
+  tableName: string,
+  ddlSchemaName: string | undefined,
+): string {
+  for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+    const table = storageTableAt(contract.storage, namespaceId, tableName);
+    if (!table) continue;
+    if (
+      ddlSchemaName === undefined ||
+      ddlSchemaNameForNamespace(contract, namespaceId) === ddlSchemaName
+    ) {
+      return namespaceId;
+    }
+  }
+  return UNBOUND_NAMESPACE_ID;
+}
+
+function resolveNamespaceIdForDdlSchema(
+  contract: Contract<SqlStorage>,
+  ddlSchemaName: string,
+): string {
+  for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+    const ns = contract.storage.namespaces[namespaceId];
+    if (isPostgresSchema(ns) && ns.ddlSchemaName(contract.storage) === ddlSchemaName) {
+      return namespaceId;
+    }
+    if (namespaceId === ddlSchemaName) {
+      return namespaceId;
+    }
+  }
+  return UNBOUND_NAMESPACE_ID;
+}
+
+interface PostgresCallFields {
+  readonly schemaName?: string;
+  readonly tableName?: string;
+  readonly columnName?: string;
+  readonly typeName?: string;
+}
+
+function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
+  return {
+    ...ifDefined('schemaName', 'schemaName' in call ? call.schemaName : undefined),
+    ...ifDefined('tableName', 'tableName' in call ? call.tableName : undefined),
+    ...ifDefined('columnName', 'columnName' in call ? call.columnName : undefined),
+    ...ifDefined('typeName', 'typeName' in call ? call.typeName : undefined),
+  };
+}
+
+export function formatPostgresControlPolicySubjectLabel(
+  factoryName: string,
+  subject: ControlPolicySubject | undefined,
+  contract: Contract<SqlStorage>,
+): string {
+  if (subject?.table) {
+    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
+    return `${factoryName}(${ddlSchema}.${subject.table})`;
+  }
+  if (subject?.typeName) {
+    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
+    return `${factoryName}(${ddlSchema}.${subject.typeName})`;
+  }
+  return factoryName;
+}
+
+export function resolvePostgresCallControlPolicySubject(
+  call: PostgresOpFactoryCall,
+  contract: Contract<SqlStorage>,
+): ControlPolicySubject | undefined {
+  const callFields = postgresCallFields(call);
+  const createsNewObject = createsNewTopLevelObject(call);
+
+  if (call.factoryName === 'createSchema' && callFields.schemaName) {
+    return {
+      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),
+      createsNewObject,
+    };
+  }
+
+  if (callFields.typeName && call.factoryName !== 'addColumn') {
+    const namespaceId = callFields.schemaName
+      ? resolveNamespaceIdForDdlSchema(contract, callFields.schemaName)
+      : UNBOUND_NAMESPACE_ID;
+    const ns = contract.storage.namespaces[namespaceId];
+    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[callFields.typeName] : undefined;
+    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
+      typeName: callFields.typeName,
+      createsNewObject,
+    };
+  }
+
+  if (callFields.tableName) {
+    const namespaceId = resolveNamespaceIdForTable(
+      contract,
+      callFields.tableName,
+      callFields.schemaName,
+    );
+    const table = storageTableAt(contract.storage, namespaceId, callFields.tableName);
+    const tableControlPolicy = table?.control;
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', tableControlPolicy),
+      table: callFields.tableName,
+      ...ifDefined('column', callFields.columnName),
+      createsNewObject,
+    };
+  }
+
+  if (callFields.schemaName) {
+    return {
+      namespaceId: resolveNamespaceIdForDdlSchema(contract, callFields.schemaName),
+      createsNewObject,
+    };
+  }
+
+  return undefined;
+}
+
+/**
+ * Issue kinds that describe the absence of a whole, top-level Postgres
+ * object — the same kinds `createsNewTopLevelObject` recognises for calls.
+ * Used by {@link resolvePostgresIssueCreationFactoryName} to decide whether
+ * a `tolerated` subject permits the issue to flow into the planner
+ * (create-if-absent) and to seed the suppressed-subject warning's
+ * `factoryName` when the planner is skipped.
+ */
+const POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({
+  missing_schema: 'createSchema',
+  missing_table: 'createTable',
+  type_missing: 'createEnumType',
+});
+
+export function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {
+  return POSTGRES_ISSUE_CREATION_FACTORY[issue.kind];
+}
+
+/**
+ * Resolve the control-policy subject coordinate for a single
+ * {@link SchemaIssue}. Mirrors the resolution `resolvePostgresCallControlPolicySubject`
+ * performs for a generated DDL call, but works *off the issue* — so the
+ * planner can partition issues by effective policy before the diff engine
+ * runs. `createsNewObject` is derived from the issue's kind: schema/table/
+ * type-missing issues describe a brand-new top-level object; everything else
+ * touches an existing object.
+ *
+ * An `extra_table` issue carries no contract namespace coordinate (the table
+ * isn't in any contract namespace), so the subject's `namespaceId` falls
+ * back to {@link UNBOUND_NAMESPACE_ID}; the call-side resolver does the same
+ * for the `DropTableCall` it produces.
+ */
+export function resolvePostgresIssueControlPolicySubject(
+  issue: SchemaIssue,
+  contract: Contract<SqlStorage>,
+): ControlPolicySubject | undefined {
+  const createsNewObject = POSTGRES_ISSUE_CREATION_FACTORY[issue.kind] !== undefined;
+
+  if (issue.kind === 'missing_schema' && issue.namespaceId) {
+    return { namespaceId: issue.namespaceId, createsNewObject };
+  }
+
+  if ('typeName' in issue && issue.typeName) {
+    const namespaceId =
+      'namespaceId' in issue && issue.namespaceId ? issue.namespaceId : UNBOUND_NAMESPACE_ID;
+    const ns = contract.storage.namespaces[namespaceId];
+    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[issue.typeName] : undefined;
+    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
+      typeName: issue.typeName,
+      createsNewObject,
+    };
+  }
+
+  if ('table' in issue && issue.table) {
+    const namespaceId =
+      'namespaceId' in issue && issue.namespaceId
+        ? issue.namespaceId
+        : resolveNamespaceIdForTable(contract, issue.table, undefined);
+    const table = storageTableAt(contract.storage, namespaceId, issue.table);
+    return {
+      namespaceId,
+      ...ifDefined('explicitNodeControlPolicy', table?.control),
+      table: issue.table,
+      ...ifDefined('column', 'column' in issue ? issue.column : undefined),
+      createsNewObject,
+    };
+  }
+
+  return undefined;
+}

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

@@ -29,6 +29,7 @@ import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { PostgresEnumType } from '../postgres-enum-type';
+import { isPostgresSchema } from '../postgres-schema';
 import {
   AddColumnCall,
   AddForeignKeyCall,
@@ -73,8 +74,7 @@ function locateNamespaceTypeInStorage(
   typeName: string,
 ): unknown {
   const ns = storage.namespaces[namespaceId];
-  if (!ns || !('enum' in ns) || ns.enum == null) return undefined;
-  return (ns.enum as Record<string, unknown>)[typeName];
+  return isPostgresSchema(ns) ? ns.entries.type[typeName] : undefined;
 }
 
 // ============================================================================
@@ -601,7 +601,7 @@ function mapIssueToCall(
     case 'type_missing': {
       if (!issue.typeName)
         return notOk(issueConflict('unsupportedOperation', 'Type missing issue has no typeName'));
-      // Codec aliases live in storage.types; enum types live in namespace.enum.
+      // Codec aliases live in storage.types; enum types live in namespace.entries.type.
       // Check types first; fall back to the namespace-keyed enum slot using the
       // issue's namespace coordinate (populated by the verifier for enum-related
       // issues per the BaseSchemaIssue.namespaceId contract).

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

@@ -35,6 +35,7 @@ import {
   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 {
@@ -93,7 +94,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 +135,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 +167,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 +177,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);
 }
 
 // ============================================================================
@@ -436,7 +441,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 +644,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);
       }

package/src/core/migrations/planner.ts

@@ -2,10 +2,13 @@ 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';
@@ -18,10 +21,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';
@@ -52,7 +63,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;
 
 /**
@@ -131,8 +146,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 +195,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,
@@ -178,6 +226,7 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
         },
         options.spaceId,
       ),
+      ...(warnings.length > 0 ? { warnings: Object.freeze(warnings) } : {}),
     });
   }