@prisma-next/target-postgres 0.14.0-dev.60 → 0.14.0-dev.62

package/src/core/migrations/op-factory-call.ts

@@ -63,6 +63,7 @@ import {
 } from './operations/constraints';
 import { createExtension } from './operations/dependencies';
 import { createIndex, dropIndex } from './operations/indexes';
+import { createNativeEnumType, dropNativeEnumType } from './operations/native-enum-types';
 import {
   createRlsPolicy,
   disableRowLevelSecurity,
@@ -1318,6 +1319,87 @@ export class CreateSchemaCall extends PostgresOpFactoryCallNode {
   }
 }
 
+// ============================================================================
+// Native enum types
+// ============================================================================
+
+export class CreateNativeEnumTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'createNativeEnumType' as const;
+  readonly operationClass = 'additive' as const;
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly members: readonly string[];
+  readonly label: string;
+
+  constructor(schemaName: string, typeName: string, members: readonly string[]) {
+    super();
+    this.schemaName = schemaName;
+    this.typeName = typeName;
+    this.members = Object.freeze([...members]);
+    this.label = `Create enum type "${typeName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `CreateNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return createNativeEnumType(this.schemaName, this.typeName, this.members, lowerer);
+  }
+
+  renderTypeScript(): string {
+    const opts = [
+      `schema: ${jsonToTsSource(this.schemaName)}`,
+      `typeName: ${jsonToTsSource(this.typeName)}`,
+      `members: ${jsonToTsSource(this.members)}`,
+    ];
+    return `this.createNativeEnumType({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
+  }
+}
+
+export class DropNativeEnumTypeCall extends PostgresOpFactoryCallNode {
+  readonly factoryName = 'dropNativeEnumType' as const;
+  readonly operationClass = 'destructive' as const;
+  readonly schemaName: string;
+  readonly typeName: string;
+  readonly label: string;
+
+  constructor(schemaName: string, typeName: string) {
+    super();
+    this.schemaName = schemaName;
+    this.typeName = typeName;
+    this.label = `Drop enum type "${typeName}"`;
+    this.freeze();
+  }
+
+  async toOp(lowerer?: ExecuteRequestLowerer): Promise<Op> {
+    if (lowerer === undefined) {
+      throw new Error(
+        `DropNativeEnumTypeCall.toOp: a DDL lowerer is required on the Postgres planner path (type "${this.typeName}"). Pass the control adapter to createPostgresMigrationPlanner.`,
+      );
+    }
+    return dropNativeEnumType(this.schemaName, this.typeName, lowerer);
+  }
+
+  renderTypeScript(): string {
+    const opts = [
+      `schema: ${jsonToTsSource(this.schemaName)}`,
+      `typeName: ${jsonToTsSource(this.typeName)}`,
+    ];
+    return `this.dropNativeEnumType({ ${opts.join(', ')} })`;
+  }
+
+  override importRequirements(): readonly ImportRequirement[] {
+    return [];
+  }
+}
+
 // ============================================================================
 // Data transform
 // ============================================================================
@@ -1562,6 +1644,8 @@ export type PostgresOpFactoryCall =
   | RawSqlCall
   | CreateExtensionCall
   | CreateSchemaCall
+  | CreateNativeEnumTypeCall
+  | DropNativeEnumTypeCall
   | CreatePostgresRlsPolicyCall
   | DropPostgresRlsPolicyCall
   | EnableRowLevelSecurityCall

package/src/core/migrations/operations/native-enum-types.ts

@@ -0,0 +1,62 @@
+import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { createType, dropType } from '../../../contract-free/ddl';
+import { validateEnumValueLength } from '../../sql-utils';
+import { boundSchema } from '../bound-schema';
+import { type Op, step, targetDetails } from './shared';
+
+/**
+ * `CREATE TYPE <qualified> AS ENUM (…)` for a managed native enum, built as a
+ * typed DDL node and lowered by the control adapter (the type name is quoted,
+ * member values render as escaped string literals in declaration order —
+ * Postgres enum sort order is semantic). `boundSchema` maps the unbound sentinel
+ * to an absent schema so the type name renders unqualified and the connection's
+ * `search_path` resolves the schema at runtime.
+ */
+export async function createNativeEnumType(
+  schemaName: string,
+  typeName: string,
+  members: readonly string[],
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  for (const member of members) {
+    validateEnumValueLength(member, typeName);
+  }
+  const ddlNode = createType({
+    ...ifDefined('schema', boundSchema(schemaName)),
+    name: typeName,
+    values: members,
+  });
+  const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+  return {
+    id: `createNativeEnumType.${typeName}`,
+    label: `Create enum type "${typeName}"`,
+    operationClass: 'additive',
+    target: targetDetails('type', typeName, schemaName),
+    precheck: [],
+    execute: [step(`create enum type "${typeName}"`, statement.sql, statement.params)],
+    postcheck: [],
+  };
+}
+
+/** `DROP TYPE <qualified>` for an unclaimed managed native enum, via typed DDL. */
+export async function dropNativeEnumType(
+  schemaName: string,
+  typeName: string,
+  lowerer: ExecuteRequestLowerer,
+): Promise<Op> {
+  const ddlNode = dropType({
+    ...ifDefined('schema', boundSchema(schemaName)),
+    name: typeName,
+  });
+  const statement = await lowerer.lowerToExecuteRequest(ddlNode);
+  return {
+    id: `dropNativeEnumType.${typeName}`,
+    label: `Drop enum type "${typeName}"`,
+    operationClass: 'destructive',
+    target: targetDetails('type', typeName, schemaName),
+    precheck: [],
+    execute: [step(`drop enum type "${typeName}"`, statement.sql, statement.params)],
+    postcheck: [],
+  };
+}

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

@@ -1,7 +1,7 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { escapeLiteral, quoteIdentifier } from '../sql-utils';
+import { escapeLiteral, quoteIdentifier, quoteQualifiedName } from '../sql-utils';
 import type { PostgresColumnDefault } from '../types';
 import { resolveColumnTypeMetadata } from './planner-type-resolution';
 
@@ -65,13 +65,23 @@ export function buildColumnTypeSql(
     }
   }
 
+  // A column whose codec supplied a `typeParams.typeName` references a named
+  // database type (e.g. a native enum), not a parameterized builtin: render it
+  // as its quoted, schema-qualified type-name identifier. DDL-render only — the
+  // verify comparison value (`resolvedNativeType`) stays the bare name the
+  // family expander produces, matching introspection.
+  if (typeof resolved.typeParams?.['typeName'] === 'string') {
+    const quoted = quoteQualifiedName(resolved.nativeType);
+    return column.many ? `${quoted}[]` : quoted;
+  }
+
   const expanded = expandParameterizedTypeSql(resolved, codecHooks);
   if (expanded !== null) {
     return column.many ? `${expanded}[]` : expanded;
   }
 
   if (column.typeRef) {
-    const base = quoteIdentifier(resolved.nativeType);
+    const base = quoteQualifiedName(resolved.nativeType);
     return column.many ? `${base}[]` : base;
   }
 

package/src/core/migrations/planner.ts

@@ -28,24 +28,19 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresRlsPolicy } from '../postgres-rls-policy';
 import { parseRlsPolicyWireName } from '../rls/wire-name';
+import { postgresNodeStorageCoordinate } from '../schema-ir/node-storage-coordinate';
 import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 import { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';
-import { PostgresSchemaNodeKind, type SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';
+import type { SqlSchemaDiffNode } from '../schema-ir/schema-node-kinds';
 import {
-  formatPostgresControlPolicySubjectLabel,
+  renderPostgresSuppression,
   resolveNamespaceIdForDdlSchema,
   resolvePostgresCallControlPolicySubject,
   resolvePostgresNodeIssueControlPolicySubject,
   resolvePostgresNodeIssueCreationFactoryName,
 } from './control-policy';
 import { buildPostgresPlanDiff } from './diff-database-schema';
-import {
-  coalesceSubtreeIssues,
-  issueNode,
-  issueSchemaName,
-  issueTableName,
-  planIssues,
-} from './issue-planner';
+import { coalesceSubtreeIssues, issueNode, issueSchemaName, planIssues } from './issue-planner';
 import type { PostgresOpFactoryCall } from './op-factory-call';
 import {
   CreatePostgresRlsPolicyCall,
@@ -186,6 +181,11 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       frameworkComponents: options.frameworkComponents,
     });
     const policyDiffIssues = rawIssues.filter((issue) => isPolicyDiffIssue(issue));
+    // Role diff issues resolve to the `external` control policy (see
+    // `resolvePostgresNodeIssueControlPolicySubject`'s role branch), so the
+    // control-policy partition below suppresses them to zero ops on its own,
+    // before `mapNodeIssueToCall` ever sees them — no separate exclusion
+    // needed here.
     const relationalDiffIssues = rawIssues.filter((issue) => !isPolicyDiffIssue(issue));
 
     // The generic differ is total and un-gated: strict-mode extras filtering
@@ -250,8 +250,6 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       resolveControlPolicySubject: (issue) =>
         resolvePostgresNodeIssueControlPolicySubject(issue, options.contract),
       resolveCreationFactoryName: resolvePostgresNodeIssueCreationFactoryName,
-      formatSubjectLabel: (factoryName, subject) =>
-        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
     });
 
     const result = planIssues({
@@ -283,8 +281,6 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       resolveControlPolicySubject: (call) =>
         resolvePostgresCallControlPolicySubject(call, options.contract),
       resolveFactoryName: (call) => call.factoryName,
-      formatSubjectLabel: (factoryName, subject) =>
-        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
     });
 
     // Inline `onFieldEvent`-emitted ops after structural DDL. The fixed
@@ -309,15 +305,13 @@ export class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgr
       resolveControlPolicySubject: (call) =>
         resolvePostgresCallControlPolicySubject(call, options.contract),
       resolveFactoryName: (call) => call.factoryName,
-      formatSubjectLabel: (factoryName, subject) =>
-        formatPostgresControlPolicySubjectLabel(factoryName, subject, options.contract),
     });
     const calls = [...result.value.calls, ...schemaDiffPartition.kept, ...fieldEventPartition.kept];
     const warnings: SqlPlannerConflict[] = [
-      ...issuePartition.warnings,
-      ...schemaDiffPartition.warnings,
-      ...fieldEventPartition.warnings,
-    ];
+      ...issuePartition.suppressions,
+      ...schemaDiffPartition.suppressions,
+      ...fieldEventPartition.suppressions,
+    ].map((record) => renderPostgresSuppression(record, options.contract));
 
     return Object.freeze({
       kind: 'success' as const,
@@ -495,41 +489,14 @@ function isPolicyDiffIssue(issue: SchemaDiffIssue<SqlSchemaDiffNode>): boolean {
 }
 
 /**
- * Drops a `not-expected` issue when it is a whole extra TABLE that some
- * contract space owns, asking the ownership oracle per node.
- *
- * The consultation applies ONLY to table-level extras — a live table this
- * space's contract lacks — identified by asking the issue's own node
- * (`nodeKind === table`), never by counting path segments. `declaresEntity`
- * answers over the whole composition (self included), keyed on the schema-IR
- * entity coordinate so a genuine orphan in one namespace is never conflated
- * with a same-named table a sibling space declares in another, or with a
- * same-named non-table entity (an enum, an RLS policy) a sibling declares in
- * the SAME namespace: a positive answer means another space owns THIS table
- * in THIS namespace (a table this space owned would be in its expected tree,
- * never an extra) — leave it. A negative answer means no space owns it — a
- * genuine orphan to drop. `entityKind` is the literal `'table'` here: this
- * function only ever asks about a node already confirmed to be
- * `PostgresSchemaNodeKind.table` (checked just above), and the diff tree's
- * `nodeKind` vocabulary (`'postgres-table'`) is distinct from the storage
- * `entries` vocabulary `elementCoordinates` walks (`'table'`) — the literal
- * is that storage-entries spelling, not the node kind.
- *
- * The issue path carries the *resolved DDL schema* (e.g. `public`), but a
- * contract space's own declared namespace id can be the unbound sentinel
- * (`__unbound__`) that resolves to that schema — the two spellings would
- * never string-match. `resolveNamespaceIdForDdlSchema` recovers the raw
- * namespace id THIS space's own contract would use for that DDL schema, so
- * a table this space's own unbound namespace declares (and any sibling
- * whose own unbound namespace resolves the same way) is compared on the
- * same coordinate the aggregate's `elementCoordinates` walk yields.
- *
- * A DEEPER extra (an extra column/constraint on a table this space DOES own —
- * only the child drifted, so the table is in the expected tree) is this
- * space's own drift and is always kept for dropping; asking the oracle there
- * would wrongly suppress it, because the owned table answers `true`. Shallower
- * issues (namespace/root) are never ownership-scoped here. No oracle ⇒ every
- * extra is kept (single-space plan).
+ * Drops a `not-expected` issue when it is a whole extra storage entity (a table
+ * or a native enum) that some space in the composition owns. Each such node
+ * yields its own storage coordinate (see {@link postgresNodeStorageCoordinate}),
+ * so `declaresEntity` answers over the whole composition on one uniform
+ * coordinate: a positive answer means a sibling owns this entity here — leave
+ * it; a negative answer means a genuine orphan — drop it. A node with no storage
+ * coordinate (a namespace, or a deeper column/constraint drift on an owned
+ * table) is this space's own and is always kept. No oracle ⇒ keep everything.
  */
 function retainUnownedExtras(
   issues: readonly SchemaDiffIssue<SqlSchemaDiffNode>[],
@@ -540,12 +507,13 @@ function retainUnownedExtras(
   return issues.filter((issue) => {
     if (issue.reason !== 'not-expected') return true;
     const node = issueNode(issue);
-    if (node === undefined || node.nodeKind !== PostgresSchemaNodeKind.table) return true;
+    if (node === undefined) return true;
+    const coordinate = postgresNodeStorageCoordinate(node);
+    if (coordinate === undefined) return true;
     const ddlSchemaName = issueSchemaName(issue);
-    const tableName = issueTableName(issue);
-    if (ddlSchemaName === undefined || tableName === undefined) return true;
+    if (ddlSchemaName === undefined) return true;
     const namespaceId = resolveNamespaceIdForDdlSchema(contract, ddlSchemaName);
-    return !ownership.declaresEntity({ namespaceId, entityKind: 'table', entityName: tableName });
+    return !ownership.declaresEntity({ namespaceId, ...coordinate });
   });
 }
 
@@ -562,9 +530,9 @@ function retainUnownedExtras(
  * Returns the real `PostgresNamespaceSchemaNode` reference rather than a
  * projection: `storageTypePlanCallStrategy` hands this same value to codec
  * `planTypeOperations` hooks as `schema`, and hooks read the Postgres-specific
- * `nativeEnumTypeNames` field off it (via `PostgresNamespaceSchemaNode.is`) to
- * decide whether a native enum type already exists — a projection that only
- * copies `tables` would silently drop that signal. `StrategyContext.schema`'s
+ * `nativeEnums` field off it (via `PostgresNamespaceSchemaNode.is`) to decide
+ * whether a native enum type already exists — a projection that only copies
+ * `tables` would silently drop that signal. `StrategyContext.schema`'s
  * declared type (`SqlSchemaIR`, shared with SQLite's flat shape) doesn't
  * capture this, so the return is `blindCast` the same way `namespaceSchemaNodes`
  * in the family's relational walk already treats a namespace node as a
@@ -580,7 +548,7 @@ function relationalNamespaceNode(
   if (namespaceNode === undefined) return undefined;
   return blindCast<
     SqlSchemaIR,
-    'PostgresNamespaceSchemaNode carries tables (+ nativeEnumTypeNames, read by codec hooks via PostgresNamespaceSchemaNode.is) structurally compatible with the SqlSchemaIR shape the strategy layer declares'
+    'PostgresNamespaceSchemaNode carries tables (+ nativeEnums, read by codec hooks via PostgresNamespaceSchemaNode.is) structurally compatible with the SqlSchemaIR shape the strategy layer declares'
   >(namespaceNode);
 }
 

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

@@ -17,6 +17,7 @@ import {
   AlterColumnTypeCall,
   type AlterColumnTypeOptions,
   CreateIndexCall,
+  CreateNativeEnumTypeCall,
   CreateSchemaCall,
   CreateTableCall,
   DropCheckConstraintCall,
@@ -24,6 +25,7 @@ import {
   DropConstraintCall,
   DropDefaultCall,
   DropIndexCall,
+  DropNativeEnumTypeCall,
   DropNotNullCall,
   DropTableCall,
   SetDefaultCall,
@@ -171,6 +173,35 @@ export abstract class PostgresMigration<
     return new CreateSchemaCall(options.schema).toOp(this.controlAdapterFor('createSchema'));
   }
 
+  /**
+   * Emit a `CREATE TYPE ... AS ENUM (...)` migration operation for a managed
+   * native enum. Builds a typed DDL node and lowers it through the stored
+   * control adapter (members render in declaration order). Throws if no adapter
+   * is present.
+   */
+  protected createNativeEnumType(options: {
+    readonly schema: string;
+    readonly typeName: string;
+    readonly members: readonly string[];
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    return new CreateNativeEnumTypeCall(options.schema, options.typeName, options.members).toOp(
+      this.controlAdapterFor('createNativeEnumType'),
+    );
+  }
+
+  /**
+   * Emit a `DROP TYPE` migration operation for a managed native enum, lowered
+   * through the stored control adapter. Throws if no adapter is present.
+   */
+  protected dropNativeEnumType(options: {
+    readonly schema: string;
+    readonly typeName: string;
+  }): Promise<SqlMigrationPlanOperation<PostgresPlanTargetDetails>> {
+    return new DropNativeEnumTypeCall(options.schema, options.typeName).toOp(
+      this.controlAdapterFor('dropNativeEnumType'),
+    );
+  }
+
   protected addColumn(options: {
     readonly schema: string;
     readonly table: string;

package/src/core/migrations/verify-postgres-namespaces.ts

@@ -91,7 +91,6 @@ export function verifyPostgresNamespacePresence(input: {
     const namespace = new PostgresNamespaceSchemaNode({
       schemaName: ddlName,
       tables: {},
-      nativeEnumTypeNames: [],
     });
     issues.push({
       path: ['database', ddlName],

package/src/core/postgres-role.ts

@@ -1,6 +1,15 @@
 import { freezeNode } from '@prisma-next/framework-components/ir';
 import { SqlNode } from '@prisma-next/sql-contract/types';
 
+/**
+ * Roles are referenced by the contract but never owned — the framework
+ * issues no `CREATE`/`DROP ROLE`, so a role's effective governance is always
+ * `external`: a missing declared role fails verify, an extra live role is
+ * tolerated, and the planner emits zero role DDL. `external` is the only
+ * value a role's control can ever carry.
+ */
+export const ROLE_DEFAULT_CONTROL_POLICY = 'external';
+
 export interface PostgresRoleInput {
   readonly name: string;
   /**
@@ -8,6 +17,11 @@ export interface PostgresRoleInput {
    * from `@prisma-next/framework-components/ir`.
    */
   readonly namespaceId: string;
+  /**
+   * Defaults to {@link ROLE_DEFAULT_CONTROL_POLICY} when omitted. Roles are
+   * referenced but never owned, so `'external'` is the only allowed value.
+   */
+  readonly control?: 'external';
 }
 
 /**
@@ -22,16 +36,24 @@ export interface PostgresRoleInput {
  * Extends `SqlNode` directly, frozen at construction via `freezeNode(this)`.
  * The `kind: 'role'` discriminant is enumerable so it survives JSON.
  * Matches the entries key (one-string rule).
+ *
+ * `control` always carries a value (never omitted): it defaults to
+ * {@link ROLE_DEFAULT_CONTROL_POLICY} in the constructor, so both a
+ * freshly-authored role and one hydrated from an older `contract.json`
+ * lacking the field resolve the same way — the control-policy resolver
+ * reads it directly off the entity instead of special-casing role issues.
  */
 export class PostgresRole extends SqlNode {
   override readonly kind = 'role' as const;
   readonly name: string;
   readonly namespaceId: string;
+  readonly control: 'external';
 
   constructor(input: PostgresRoleInput) {
     super();
     this.name = input.name;
     this.namespaceId = input.namespaceId;
+    this.control = input.control ?? ROLE_DEFAULT_CONTROL_POLICY;
     freezeNode(this);
   }
 }

package/src/core/postgres-schema.ts

@@ -15,6 +15,7 @@ import {
 } from '@prisma-next/sql-contract/types';
 
 import { type CfExpr, cfExpr } from '@prisma-next/sql-relational-core/contract-free';
+import { invariant } from '@prisma-next/utils/assertions';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresTableSource } from './ast/table-source';
@@ -25,7 +26,7 @@ import {
   rlsEnablementEntityKind,
   roleEntityKind,
 } from './entity-kinds';
-import type { PostgresNativeEnum } from './postgres-native-enum';
+import { PostgresNativeEnum } from './postgres-native-enum';
 import type { PostgresRlsEnablement } from './postgres-rls-enablement';
 import type { PostgresRlsPolicy } from './postgres-rls-policy';
 import type { PostgresRole } from './postgres-role';
@@ -88,6 +89,26 @@ export class PostgresSchema extends SqlNamespaceBase {
       'carry',
     );
 
+    // A native enum keys under its PHYSICAL type name in storage `entries`
+    // (ADR 221 coordinate `entityName`). The family/authoring layer keys every
+    // block by its author handle, so re-key the `native_enum` slot by each
+    // entity's `typeName` here — target-local Postgres code that already knows
+    // this entity kind. This runs at both authoring and hydration; a serialized
+    // contract's key already equals the `typeName`, so the re-key is idempotent.
+    const nativeEnumSlot = dispatched['native_enum'];
+    if (nativeEnumSlot !== undefined) {
+      const rekeyed: Record<string, unknown> = {};
+      for (const [handle, entity] of Object.entries(nativeEnumSlot)) {
+        const physicalName = PostgresNativeEnum.is(entity) ? entity.typeName : handle;
+        invariant(
+          !Object.hasOwn(rekeyed, physicalName),
+          `PostgresSchema "${input.id}": two native_enum entities resolve to the same physical type name "${physicalName}". Give them distinct @@map type names.`,
+        );
+        rekeyed[physicalName] = entity;
+      }
+      dispatched['native_enum'] = Object.freeze(rekeyed);
+    }
+
     // Drop an empty valueSet so presence signals non-emptiness.
     const valueSetRaw = dispatched['valueSet'];
     const withPresence =

package/src/core/postgres-validators.ts

@@ -4,6 +4,7 @@ export const PostgresRoleSchema = type({
   kind: "'role'",
   name: 'string',
   namespaceId: 'string',
+  'control?': "'external'",
 });
 
 export const PostgresRlsPolicySchema = type({

package/src/core/psl-infer/infer-psl-contract.ts

@@ -300,10 +300,10 @@ export function inferPostgresPslContract(
   const owners = describedContractOwners(describedContracts ?? []);
   const enumOwners = describedNativeEnumOwnersByTypeName(describedContracts ?? []);
 
-  // Native enum adoption: each namespace's introspected `{ typeName, values }`
-  // entries become `native_enum` blocks + `pg.enum(<Name>)` columns, minus the
-  // types a described pack contract already declares (matched by TYPE NAME —
-  // see describedNativeEnumOwnersByTypeName). Transitional grade gap: an
+  // Native enum adoption: each namespace's introspected `enums` nodes become
+  // `native_enum` blocks + `pg.enum(<Name>)` columns, minus the types a
+  // described pack contract already declares (matched by TYPE NAME — see
+  // describedNativeEnumOwnersByTypeName). Transitional grade gap: an
   // inferred block carries no explicit `control` and inherits the contract's
   // `defaultControl`; under `defaultControl: 'managed'` the planner does not
   // yet enforce the native enum lifecycle (CREATE TYPE / DROP TYPE / ADD
@@ -313,17 +313,7 @@ export function inferPostgresPslContract(
   const packOwnedEnumTypesByNamespace = new Map<string, Map<string, string>>();
   const enumNamespaceNames = new Set<string>();
   for (const namespace of namespaces) {
-    const definitionsForNamespace = new Set(namespace.nativeEnums.map((e) => e.typeName));
-    for (const typeName of namespace.nativeEnumTypeNames) {
-      if (!definitionsForNamespace.has(typeName)) {
-        throw new Error(
-          `contract infer: introspection reported native enum type "${typeName}" in schema ` +
-            `"${namespace.schemaName}" without member values — the introspected tree's ` +
-            '`nativeEnumTypeNames` and `nativeEnums` are out of sync (internal invariant).',
-        );
-      }
-    }
-    for (const { typeName, values } of namespace.nativeEnums) {
+    for (const { typeName, members } of namespace.nativeEnums) {
       const owner = enumOwners.get(
         coordinateKey({
           namespaceId: namespace.schemaName,
@@ -341,7 +331,7 @@ export function inferPostgresPslContract(
         packOwnedEnumTypesByNamespace.set(namespace.schemaName, owned);
         continue;
       }
-      enumDefinitions.set(typeName, values);
+      enumDefinitions.set(typeName, members);
       enumNamespaceNames.add(namespace.schemaName);
     }
   }
@@ -663,6 +653,7 @@ function buildNativeEnumBlock(
 
   return {
     kind: 'native_enum',
+    keyword: 'native_enum',
     name,
     parameters,
     blockAttributes:

package/src/core/schema-ir/node-storage-coordinate.ts

@@ -0,0 +1,26 @@
+import type { EntityCoordinate } from '@prisma-next/framework-components/ir';
+import type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { PostgresNativeEnumSchemaNode } from './postgres-native-enum-schema-node';
+import { PostgresTableSchemaNode } from './postgres-table-schema-node';
+import { postgresNodeEntityKind } from './schema-node-kinds';
+
+/**
+ * The storage-`entries` coordinate `(entityKind, entityName)` a Postgres diff
+ * node addresses — a table by its name, a native enum by its physical type
+ * name. `undefined` for a node that is not a whole storage entity (a namespace,
+ * a column, a policy). Lets ownership/subject resolution treat every entity kind
+ * uniformly, the node self-describing its storage identity.
+ */
+export function postgresNodeStorageCoordinate(
+  node: SqlSchemaIRNode,
+): Pick<EntityCoordinate, 'entityKind' | 'entityName'> | undefined {
+  if (PostgresTableSchemaNode.is(node)) {
+    const entityKind = postgresNodeEntityKind(node.nodeKind);
+    return entityKind === undefined ? undefined : { entityKind, entityName: node.name };
+  }
+  if (PostgresNativeEnumSchemaNode.is(node)) {
+    const entityKind = postgresNodeEntityKind(node.nodeKind);
+    return entityKind === undefined ? undefined : { entityKind, entityName: node.typeName };
+  }
+  return undefined;
+}

package/src/core/schema-ir/postgres-database-schema-node.ts

@@ -17,9 +17,10 @@ export interface PostgresDatabaseSchemaNodeInput {
  *
  * `id` is the fixed sentinel `'database'` — the root has no siblings and
  * the value is never emitted into migration paths. `isEqualTo` is identity
- * (roots always share the `'database'` id). `children()` returns namespace
- * nodes only; roles are held on the root but not yielded (role diffing is a
- * later slice).
+ * (roots always share the `'database'` id). `children()` yields the namespace
+ * nodes followed by the role nodes — both are root-level diff subjects. The
+ * differ pairs siblings by `(nodeKind, id)`, so a role and a namespace may
+ * share a name without colliding.
  */
 export class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {
   override readonly nodeKind = PostgresSchemaNodeKind.database;
@@ -47,7 +48,7 @@ export class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements Diffa
   }
 
   children(): readonly DiffableNode[] {
-    return Object.values(this.namespaces);
+    return [...Object.values(this.namespaces), ...this.roles];
   }
 
   static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode {