@prisma-next/target-postgres 0.14.0-dev.44 → 0.14.0-dev.46

package/src/core/authoring.ts

@@ -1,18 +1,44 @@
 import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';
 import type {
   AuthoringEntityContext,
+  AuthoringEntityTypeFactoryOutput,
   AuthoringEntityTypeNamespace,
   AuthoringFieldNamespace,
   AuthoringPslBlockDescriptorNamespace,
   AuthoringTypeNamespace,
   PslExtensionBlock,
 } from '@prisma-next/framework-components/authoring';
+import type { SqlValueSetDerivingEntityTypeOutput } from '@prisma-next/sql-contract/value-set-derivation-hook';
+import { PG_ENUM_CODEC_ID } from './codec-ids';
+import { PostgresNativeEnum } from './postgres-native-enum';
 import { PostgresRlsPolicy } from './postgres-rls-policy';
 import { PostgresRole, type PostgresRoleInput } from './postgres-role';
-import { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';
+import {
+  PostgresNativeEnumSchema,
+  PostgresRlsPolicySchema,
+  PostgresRoleSchema,
+} from './postgres-validators';
 import { computeContentHash, normalizePredicate } from './rls/canonicalize';
 
-export const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;
+/**
+ * `pg.enum(<ref>)` registers as an ordinary type constructor whose sole
+ * positional argument names a `native_enum` entity instead of carrying a
+ * literal value. The interpreter resolves the ref to the `native_enum`
+ * entity generically (driven by `entityRefArg`); the `pg/enum@1` codec
+ * descriptor's `columnFromEntity` hook (see `codecs.ts`) converts that
+ * entity into the column's `typeParams` and native type.
+ */
+export const postgresAuthoringTypes = {
+  pg: {
+    enum: {
+      kind: 'typeConstructor',
+      entityRefArg: { index: 0, entityKind: 'native_enum' },
+      output: {
+        codecId: PG_ENUM_CODEC_ID,
+      },
+    },
+  },
+} as const satisfies AuthoringTypeNamespace;
 
 export interface RlsPolicyExtensionBlock extends PslExtensionBlock {
   readonly namespaceId: string;
@@ -71,6 +97,127 @@ function lowerRlsPolicyFromBlock(
   });
 }
 
+/**
+ * Lowers a `native_enum { memberName = "value" … @@map("type_name") }` block
+ * into a {@link PostgresNativeEnum}. Members must be authored as explicit
+ * `key = "value"` pairs — a bare (value-less) member is a diagnostic, not
+ * accepted (authoring-design.md §2.1). The parsed `memberName` is only used
+ * to duplicate-check and report diagnostics; the lowered entity carries just
+ * the member values (a native enum is value-only — the member "name" isn't
+ * a separate authoring concept from the value). `typeName` comes from
+ * `@@map` or defaults to the block name verbatim.
+ */
+function lowerNativeEnumFromBlock(
+  block: PslExtensionBlock,
+  ctx: AuthoringEntityContext,
+): PostgresNativeEnum | undefined {
+  const sourceId = ctx.sourceId ?? 'unknown';
+  const diagnostics = ctx.diagnostics;
+
+  const mapAttr = block.blockAttributes.find((a) => a.name === 'map');
+  let typeName = block.name;
+  if (mapAttr) {
+    const rawArg = mapAttr.args[0]?.value;
+    const mapped = rawArg !== undefined ? unwrapQuotedString(rawArg) : undefined;
+    if (mapped === undefined) {
+      diagnostics?.push({
+        code: 'PSL_NATIVE_ENUM_INVALID_MAP',
+        message: `native_enum "${block.name}" @@map attribute must have a quoted type-name argument`,
+        sourceId,
+        span: mapAttr.span,
+      });
+      return undefined;
+    }
+    typeName = mapped;
+  }
+
+  let memberError = false;
+  const seenValues = new Set<string>();
+  const members: string[] = [];
+  for (const [memberName, paramValue] of Object.entries(block.parameters)) {
+    if (paramValue.kind === 'bare') {
+      diagnostics?.push({
+        code: 'PSL_NATIVE_ENUM_BARE_MEMBER',
+        message: `native_enum "${block.name}" member "${memberName}" has no value; members must be authored as "${memberName} = \\"value\\""`,
+        sourceId,
+        span: paramValue.span,
+      });
+      memberError = true;
+      continue;
+    }
+    if (paramValue.kind !== 'value') continue;
+
+    let jsonValue: unknown;
+    try {
+      jsonValue = JSON.parse(paramValue.raw);
+    } catch {
+      diagnostics?.push({
+        code: 'PSL_EXTENSION_INVALID_VALUE',
+        message: `native_enum "${block.name}" member "${memberName}" value "${paramValue.raw}" is not valid JSON`,
+        sourceId,
+        span: paramValue.span,
+      });
+      memberError = true;
+      continue;
+    }
+    if (typeof jsonValue !== 'string') {
+      diagnostics?.push({
+        code: 'PSL_EXTENSION_INVALID_VALUE',
+        message: `native_enum "${block.name}" member "${memberName}" value must be a string`,
+        sourceId,
+        span: paramValue.span,
+      });
+      memberError = true;
+      continue;
+    }
+    if (seenValues.has(jsonValue)) {
+      diagnostics?.push({
+        code: 'PSL_NATIVE_ENUM_DUPLICATE_MEMBER_VALUE',
+        message: `native_enum "${block.name}": duplicate member value "${jsonValue}"`,
+        sourceId,
+        span: paramValue.span,
+      });
+      memberError = true;
+      continue;
+    }
+    seenValues.add(jsonValue);
+    members.push(jsonValue);
+  }
+
+  if (memberError) return undefined;
+
+  if (members.length === 0) {
+    diagnostics?.push({
+      code: 'PSL_NATIVE_ENUM_MISSING_MEMBERS',
+      message: `native_enum "${block.name}" must have at least one member`,
+      sourceId,
+      span: block.span,
+    });
+    return undefined;
+  }
+
+  // `control` stays unset — the effective grade is resolved at read time via `effectiveControlPolicy`, like `StorageTable`/`StorageColumn`.
+  return new PostgresNativeEnum({ typeName, members });
+}
+
+/**
+ * `native_enum`'s entity-type factory output, checked separately from the assembled
+ * `postgresAuthoringEntityTypes` map below: `deriveValueSet` is SQL-family surface
+ * ({@link SqlValueSetDerivingEntityTypeOutput}), not part of the framework
+ * `AuthoringEntityTypeFactoryOutput` shape, so folding it directly into the map's single
+ * `satisfies AuthoringEntityTypeNamespace` check would trip an excess-property error. Checking it
+ * here against the intersection of both shapes keeps it structurally valid against each without
+ * widening the map's own check.
+ */
+const nativeEnumEntityTypeOutput = {
+  factory: lowerNativeEnumFromBlock,
+  deriveValueSet: (entity: PostgresNativeEnum) => ({
+    kind: 'valueSet' as const,
+    values: [...entity.members],
+  }),
+} satisfies AuthoringEntityTypeFactoryOutput<PslExtensionBlock, PostgresNativeEnum | undefined> &
+  SqlValueSetDerivingEntityTypeOutput;
+
 export const postgresAuthoringEntityTypes = {
   role: {
     kind: 'entity',
@@ -88,6 +235,12 @@ export const postgresAuthoringEntityTypes = {
       factory: lowerRlsPolicyFromBlock,
     },
   },
+  native_enum: {
+    kind: 'entity',
+    discriminator: 'native_enum',
+    validatorSchema: PostgresNativeEnumSchema,
+    output: nativeEnumEntityTypeOutput,
+  },
 } as const satisfies AuthoringEntityTypeNamespace;
 
 /**
@@ -134,6 +287,24 @@ export const postgresAuthoringPslBlockDescriptors = {
       using: { kind: 'value', codecId: 'pg/text@1', required: true },
     },
   },
+  /**
+   * PSL block descriptor for `native_enum`.
+   *
+   * Reuses the existing variadic-block mechanism (the same shape the SQL
+   * family's `enum` block ships): the body is an open `memberName = "value"`
+   * list. `variadicParameters: true` opens the block to arbitrary keys
+   * beyond the declared (empty) `parameters` set — the lowering factory
+   * (`lowerNativeEnumFromBlock`) turns the variadic entries into ordered
+   * members and rejects a bare (value-less) member.
+   */
+  native_enum: {
+    kind: 'pslBlock',
+    keyword: 'native_enum',
+    discriminator: 'native_enum',
+    name: { required: true },
+    parameters: {},
+    variadicParameters: true,
+  },
 } as const satisfies AuthoringPslBlockDescriptorNamespace;
 
 export const postgresAuthoringFieldPresets = {

package/src/core/codec-ids.ts

@@ -8,6 +8,7 @@ export {
 } from '@prisma-next/sql-relational-core/ast';
 export const PG_TEXT_CODEC_ID = 'pg/text@1' as const;
 export const PG_TEXT_ARRAY_CODEC_ID = 'pg/text-array@1' as const;
+export const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;
 export const PG_CHAR_CODEC_ID = 'pg/char@1' as const;
 export const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;
 export const PG_INT_CODEC_ID = 'pg/int@1' as const;

package/src/core/codec-type-map.ts

@@ -21,6 +21,7 @@ import {
   pgBoolDescriptor,
   pgByteaDescriptor,
   pgCharDescriptor,
+  pgEnumDescriptor,
   pgFloat4Descriptor,
   pgFloat8Descriptor,
   pgFloatDescriptor,
@@ -50,6 +51,7 @@ export const codecDescriptorMap = {
   'sql-text': sqlTextDescriptor,
   'sql-timestamp': sqlTimestampDescriptor,
   text: pgTextDescriptor,
+  enum: pgEnumDescriptor,
   character: pgCharDescriptor,
   'character varying': pgVarcharDescriptor,
   integer: pgIntDescriptor,

package/src/core/codecs.ts

@@ -19,12 +19,14 @@ import {
   CodecDescriptorImpl,
   CodecImpl,
   type CodecInstanceContext,
+  type CodecMeta,
   type ColumnHelperFor,
   type ColumnHelperForStrict,
   column,
   renderTsLiteral,
   voidParamsSchema,
 } from '@prisma-next/framework-components/codec';
+import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   SqlCharCodec,
   SqlFloatCodec,
@@ -60,6 +62,7 @@ import {
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
+  PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
@@ -81,6 +84,8 @@ import {
   PG_VARBIT_CODEC_ID,
   PG_VARCHAR_CODEC_ID,
 } from './codec-ids';
+import { DEFAULT_NAMESPACE_ID } from './namespace-ids';
+import { PostgresNativeEnum } from './postgres-native-enum';
 
 type LengthParams = { readonly length?: number };
 type PrecisionParams = { readonly precision?: number };
@@ -165,6 +170,106 @@ export const pgTextColumn = () =>
 pgTextColumn satisfies ColumnHelperFor<PgTextDescriptor>;
 pgTextColumn satisfies ColumnHelperForStrict<PgTextDescriptor>;
 
+/**
+ * Codec for a `pg.enum(Ref)` column bound to a native Postgres enum type.
+ * Text passthrough, identical to `pg/text@1` — encode/decode do not carry the
+ * enum's member values; membership is enforced by the native type itself, not
+ * by this codec. `renderValueLiteral` renders a member value as its TS
+ * literal, which is what drives the column's typed value-union (via
+ * `renderValueSetType` reading the column's `valueSet` ref) — the codec
+ * itself carries no params of its own; typing comes entirely from the
+ * column's value-set, not from `pg/enum@1`.
+ *
+ * A distinct codec id (rather than reusing `pg/text@1` on a plain text
+ * column) keeps native-enum columns independently identifiable — from a
+ * column's `codecId` alone, without also inspecting `nativeType` — which
+ * the managed (DDL) phase needs to target `CREATE TYPE`/`ALTER TYPE`
+ * operations at exactly the columns that use one.
+ */
+export class PgEnumCodec extends CodecImpl<
+  typeof PG_ENUM_CODEC_ID,
+  readonly ['equality', 'order', 'textual'],
+  string,
+  string
+> {
+  async encode(value: string, _ctx: CodecCallContext): Promise<string> {
+    return value;
+  }
+  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
+    return wire;
+  }
+  encodeJson(value: string): JsonValue {
+    return value;
+  }
+  decodeJson(json: JsonValue): string {
+    return blindCast<
+      string,
+      'text codec: a native-enum member value is stored as its wire string form'
+    >(json);
+  }
+}
+
+type PgEnumParams = { readonly typeName: string };
+
+const pgEnumParamsSchema = arktype({
+  typeName: 'string',
+}) satisfies StandardSchemaV1<PgEnumParams>;
+
+function isJsonObject(
+  value: JsonValue | undefined,
+): value is { readonly [key: string]: JsonValue } {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export class PgEnumDescriptor extends CodecDescriptorImpl<PgEnumParams> {
+  override readonly codecId = PG_ENUM_CODEC_ID;
+  override readonly traits = ['equality', 'order', 'textual'] as const;
+  override readonly targetTypes = ['text'] as const;
+  override readonly meta = PG_TEXT_META;
+  override readonly paramsSchema = pgEnumParamsSchema satisfies StandardSchemaV1<PgEnumParams>;
+  override renderValueLiteral(value: JsonValue): string | undefined {
+    return renderTsLiteral(value);
+  }
+  override metaFor(typeParams: JsonValue | undefined): CodecMeta | undefined {
+    if (!isJsonObject(typeParams)) return this.meta;
+    const typeName = typeParams['typeName'];
+    return typeof typeName === 'string'
+      ? { db: { sql: { postgres: { nativeType: typeName } } } }
+      : this.meta;
+  }
+  override factory(_params: PgEnumParams): (ctx: CodecInstanceContext) => PgEnumCodec {
+    return () => new PgEnumCodec(this);
+  }
+
+  /**
+   * Authoring-time hook a `pg.enum(<ref>)` type constructor calls once it has
+   * resolved its ref argument to the referenced `native_enum` entity: given
+   * that entity and the field's namespace id, produces this codec's
+   * per-column `typeParams` and native type. The type name is schema-qualified
+   * for a named non-default schema (matching `format_type()`); `public` and
+   * the unbound namespace stay bare (`search_path`). `nativeType` mirrors
+   * `typeParams.typeName` — the same value {@link metaFor} derives at
+   * render time — so the column's declared native type and the render-time
+   * cast agree. Returns `undefined` if `entity` is not a `PostgresNativeEnum`
+   * (a contributor bug, not a user-schema error — the caller decides how to
+   * report it).
+   */
+  columnFromEntity(
+    entity: object,
+    namespaceId?: string,
+  ): { readonly typeParams: PgEnumParams; readonly nativeType: string } | undefined {
+    if (!PostgresNativeEnum.is(entity)) return undefined;
+    const qualifyNativeType =
+      namespaceId !== undefined &&
+      namespaceId !== DEFAULT_NAMESPACE_ID &&
+      namespaceId !== UNBOUND_NAMESPACE_ID;
+    const typeName = qualifyNativeType ? `${namespaceId}.${entity.typeName}` : entity.typeName;
+    return { typeParams: { typeName }, nativeType: typeName };
+  }
+}
+
+export const pgEnumDescriptor = new PgEnumDescriptor();
+
 /**
  * Postgres `text[]` codec. Encode is an identity pass-through: the pg wire
  * driver serialises a JS `string[]` to a Postgres array literal under the
@@ -1086,6 +1191,7 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   sqlTextDescriptor,
   sqlTimestampDescriptor,
   pgTextDescriptor,
+  pgEnumDescriptor,
   pgCharDescriptor,
   pgVarcharDescriptor,
   pgIntDescriptor,

package/src/core/descriptor-meta.ts

@@ -6,11 +6,12 @@ import {
   postgresAuthoringTypes,
 } from './authoring';
 import { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';
+import { DEFAULT_NAMESPACE_ID } from './namespace-ids';
 import { postgresCreateNamespace } from './postgres-schema';
 
 const postgresTargetDescriptorMetaBase = {
   ...postgresTargetDescriptorMetaRuntime,
-  defaultNamespaceId: 'public',
+  defaultNamespaceId: DEFAULT_NAMESPACE_ID,
   authoring: {
     type: postgresAuthoringTypes,
     field: postgresAuthoringFieldPresets,

package/src/core/entity-kinds.ts

@@ -1,7 +1,12 @@
 import type { EntityKindDescriptor } from '@prisma-next/framework-components/ir';
+import { PostgresNativeEnum, type PostgresNativeEnumInput } from './postgres-native-enum';
 import { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './postgres-rls-policy';
 import { PostgresRole, type PostgresRoleInput } from './postgres-role';
-import { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';
+import {
+  PostgresNativeEnumSchema,
+  PostgresRlsPolicySchema,
+  PostgresRoleSchema,
+} from './postgres-validators';
 
 export const policyEntityKind: EntityKindDescriptor<PostgresRlsPolicyInput, PostgresRlsPolicy> = {
   kind: 'policy',
@@ -14,3 +19,12 @@ export const roleEntityKind: EntityKindDescriptor<PostgresRoleInput, PostgresRol
   schema: PostgresRoleSchema,
   construct: (input) => new PostgresRole(input),
 };
+
+export const nativeEnumEntityKind: EntityKindDescriptor<
+  PostgresNativeEnumInput,
+  PostgresNativeEnum
+> = {
+  kind: 'native_enum',
+  schema: PostgresNativeEnumSchema,
+  construct: (input) => new PostgresNativeEnum(input),
+};

package/src/core/migrations/operations/dependencies.ts

@@ -1,5 +1,6 @@
 import type { ExecuteRequestLowerer } from '@prisma-next/family-sql/control-adapter';
 import { extensionExistsAst } from '../../../contract-free/checks';
+import { DEFAULT_NAMESPACE_ID } from '../../namespace-ids';
 import { quoteIdentifier } from '../../sql-utils';
 import { type Op, step } from './shared';
 
@@ -55,7 +56,7 @@ export async function installExtension(
     invariantId,
     target: {
       id: 'postgres',
-      details: { schema: 'public', objectType: 'dependency', name: extensionName },
+      details: { schema: DEFAULT_NAMESPACE_ID, objectType: 'dependency', name: extensionName },
     },
     precheck: [
       step(`verify extension "${extensionName}" is not already enabled`, absent.sql, absent.params),

package/src/core/migrations/resolve-ddl-schema.ts

@@ -1,20 +1,22 @@
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { DEFAULT_NAMESPACE_ID } from '../namespace-ids';
 import { isPostgresSchema } from '../postgres-schema';
 
 /**
  * Given the contract's storage and a namespace id, returns the live Postgres
  * DDL schema name that namespace maps to. A named Postgres namespace dispatches
- * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to `public`
- * (the search-path default for offline planning); a bare object payload (used
- * by some tests) falls back to the namespace id itself.
+ * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to
+ * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a
+ * bare object payload (used by some tests) falls back to the namespace id
+ * itself.
  */
 export function resolveDdlSchemaForNamespaceStorage(
   storage: SqlStorage,
   namespaceId: string,
 ): string {
   if (namespaceId === UNBOUND_NAMESPACE_ID) {
-    return 'public';
+    return DEFAULT_NAMESPACE_ID;
   }
   const namespace = storage.namespaces[namespaceId];
   if (namespace && isPostgresSchema(namespace)) {

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

@@ -3,6 +3,7 @@ import type { SchemaIssue } 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 { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
+import { DEFAULT_NAMESPACE_ID } from '../namespace-ids';
 import { isPostgresSchema } from '../postgres-schema';
 import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
 
@@ -43,7 +44,7 @@ function existingSchemasFromSchema(schema: SqlSchemaIRNode): readonly string[] {
   if (PostgresDatabaseSchemaNode.is(schema)) {
     return schema.existingSchemas;
   }
-  return ['public'];
+  return [DEFAULT_NAMESPACE_ID];
 }
 
 /**

package/src/core/namespace-ids.ts

@@ -0,0 +1,3 @@
+// Leaf module: authoring.ts and descriptor-meta.ts both need this and import each other.
+/** Postgres's default schema; `postgresTargetDescriptorMeta.defaultNamespaceId` is this value. */
+export const DEFAULT_NAMESPACE_ID = 'public' as const;

package/src/core/postgres-contract-serializer.ts

@@ -19,7 +19,7 @@ import { blindCast } from '@prisma-next/utils/casts';
 import type { JsonObject, JsonValue } from '@prisma-next/utils/json';
 import { postgresAuthoringEntityTypes } from './authoring';
 import { PG_INT_CODEC_ID, PG_TEXT_CODEC_ID } from './codec-ids';
-import { policyEntityKind, roleEntityKind } from './entity-kinds';
+import { nativeEnumEntityKind, policyEntityKind, roleEntityKind } from './entity-kinds';
 import { isPostgresSchema, PostgresSchema } from './postgres-schema';
 
 const POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {
@@ -70,7 +70,12 @@ function collectStorageTypesHydrators(
 export class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor(extraPackEntityKinds: readonly AnyEntityKindDescriptor[] = []) {
     const storageTypesHydrators = collectStorageTypesHydrators(postgresAuthoringEntityTypes);
-    super(storageTypesHydrators, [policyEntityKind, roleEntityKind, ...extraPackEntityKinds]);
+    super(storageTypesHydrators, [
+      policyEntityKind,
+      roleEntityKind,
+      nativeEnumEntityKind,
+      ...extraPackEntityKinds,
+    ]);
   }
 
   protected override hydrateSqlNamespaceEntry(
@@ -143,26 +148,19 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     });
   }
 
+  /**
+   * Native enums are deliberately not serialized here — `native_enum` is
+   * authoring-time-only. Once lowered, its member values live on in the
+   * `valueSet` slot it derives (via the SQL family's generic
+   * `deriveValueSet` mechanism); nothing downstream reads the
+   * `PostgresNativeEnum` entity itself, so re-emitting it into
+   * `contract.json` would be dead weight.
+   */
   private serializePostgresNamespace(ns: PostgresSchema, isUnboundSlot: boolean): JsonObject {
-    const tablesOut: Record<string, JsonObject> = {};
-    for (const [tableName, table] of Object.entries(ns.table)) {
-      tablesOut[tableName] = this.serializeJsonObject(table);
-    }
-    const valueSetEntries = ns.valueSet;
-    const valueSetOut: Record<string, JsonObject> = {};
-    if (valueSetEntries !== undefined) {
-      for (const [valueSetName, valueSet] of Object.entries(valueSetEntries)) {
-        valueSetOut[valueSetName] = this.serializeJsonObject(valueSet);
-      }
-    }
-    const roleOut: Record<string, JsonObject> = {};
-    for (const [roleName, role] of Object.entries(ns.role)) {
-      roleOut[roleName] = this.serializeJsonObject(role);
-    }
-    const policyOut: Record<string, JsonObject> = {};
-    for (const [policyName, policy] of Object.entries(ns.policy)) {
-      policyOut[policyName] = this.serializeJsonObject(policy);
-    }
+    const tablesOut = this.serializeEntries(ns.table);
+    const valueSetOut = this.serializeEntries(ns.valueSet ?? {});
+    const roleOut = this.serializeEntries(ns.role);
+    const policyOut = this.serializeEntries(ns.policy);
     return {
       id: ns.id,
       kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',
@@ -175,6 +173,14 @@ export class PostgresContractSerializer extends SqlContractSerializerBase<Contra
     };
   }
 
+  private serializeEntries(entries: Readonly<Record<string, unknown>>): Record<string, JsonObject> {
+    const out: Record<string, JsonObject> = {};
+    for (const [name, entry] of Object.entries(entries)) {
+      out[name] = this.serializeJsonObject(entry);
+    }
+    return out;
+  }
+
   private serializeJsonObject(value: unknown): JsonObject {
     return blindCast<
       JsonObject,

package/src/core/postgres-native-enum.ts

@@ -0,0 +1,51 @@
+import type { ControlPolicy } from '@prisma-next/contract/types';
+import { freezeNode } from '@prisma-next/framework-components/ir';
+import { SqlNode } from '@prisma-next/sql-contract/types';
+
+export interface PostgresNativeEnumInput {
+  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */
+  readonly typeName: string;
+  /** Member values in declaration order — this is the Postgres enum sort order. */
+  readonly members: readonly string[];
+  readonly control?: ControlPolicy;
+}
+
+/**
+ * Postgres contract-IR class for a native enum type (`CREATE TYPE … AS ENUM (…)`).
+ *
+ * This is an authored, serialized Contract-IR entity — it is registered as an entity
+ * kind, extends `SqlNode`, and is stored in `contract.json`. It is NOT a DiffableNode;
+ * the schema-diff tree will use `PostgresNativeEnumSchemaNode` when the managed phase
+ * builds it.
+ *
+ * A member is a value, not a name→value pair — matching `CREATE TYPE … AS ENUM
+ * ('a', 'b')`, which has no separate member name.
+ *
+ * Target-only concept — no SQL-family abstract. Extends `SqlNode` directly,
+ * frozen at construction via `freezeNode(this)`. The `kind: 'postgres-enum'`
+ * discriminant is enumerable so it survives JSON. Lives at
+ * `storage.namespaces[ns].entries.native_enum[HandleName]`; the entries key
+ * (`native_enum`) is the entity-kind descriptor's `kind`, decoupled from this
+ * node's own `kind` literal — the same shape as `table`/`StorageTable` and
+ * `valueSet`/`StorageValueSet`.
+ */
+export class PostgresNativeEnum extends SqlNode {
+  static is(node: unknown): node is PostgresNativeEnum {
+    return (
+      typeof node === 'object' && node !== null && 'kind' in node && node.kind === 'postgres-enum'
+    );
+  }
+
+  override readonly kind = 'postgres-enum' as const;
+  readonly typeName: string;
+  readonly members: readonly string[];
+  declare readonly control?: ControlPolicy;
+
+  constructor(input: PostgresNativeEnumInput) {
+    super();
+    this.typeName = input.typeName;
+    this.members = Object.freeze([...input.members]);
+    if (input.control !== undefined) this.control = input.control;
+    freezeNode(this);
+  }
+}