@prisma-next/target-postgres 0.13.0 → 0.14.0-dev.2

package/dist/postgres-schema-BuxCxbvB.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-schema-BuxCxbvB.mjs","names":[],"sources":["../src/core/postgres-schema.ts"],"sourcesContent":["import {\n  freezeNode,\n  NamespaceBase,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport {\n  type PostgresEnumStorageEntry,\n  type SqlNamespaceTablesInput,\n  type SqlStorage,\n  StorageTable,\n  type StorageTableInput,\n} from '@prisma-next/sql-contract/types';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\nimport { escapeLiteral } from './sql-utils';\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly entries: {\n    readonly table: Record<string, StorageTable | StorageTableInput>;\n    readonly type: Record<string, PostgresEnumType | PostgresEnumTypeInput>;\n  };\n}\n\n/**\n * Postgres target `Namespace` concretion — a Postgres schema (`CREATE\n * SCHEMA …`). Each Postgres `SqlStorage` carries a\n * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by\n * the Postgres PSL interpreter from `namespace { … }` AST buckets.\n *\n * `entries` holds entity-kind slot maps (`table`, `type`). Qualifier\n * emission is the rendering seam: DDL / SQL emission asks the namespace\n * for its qualifier (`\"<schema>\"`) or for a qualified table name\n * (`\"<schema>\".\"<table>\"`) and consumes the result polymorphically.\n * The unbound singleton below overrides these methods to elide the\n * prefix entirely — call sites stay polymorphic and never branch on\n * `id === UNBOUND_NAMESPACE_ID`.\n */\nexport class PostgresSchema extends NamespaceBase {\n  /**\n   * Stable singleton reference for the late-bound slot. Materialised\n   * lazily below the singleton subclass declaration so the static\n   * initialiser sees the subclass before assigning. Consumers always\n   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`\n   * — same identity).\n   */\n  static unbound: PostgresUnboundSchema;\n\n  declare readonly kind: 'schema';\n  readonly id: string;\n  readonly entries: Readonly<{\n    readonly table: Readonly<Record<string, StorageTable>>;\n    readonly type: Readonly<Record<string, PostgresEnumType>>;\n  }>;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n    this.entries = Object.freeze({\n      table: Object.freeze(\n        Object.fromEntries(\n          Object.entries(input.entries.table).map(([k, v]) => [\n            k,\n            v instanceof StorageTable ? v : new StorageTable(v as StorageTableInput),\n          ]),\n        ),\n      ),\n      type: Object.freeze(\n        Object.fromEntries(\n          Object.entries(input.entries.type).map(([k, v]) => [\n            k,\n            v instanceof PostgresEnumType ? v : new PostgresEnumType(v as PostgresEnumTypeInput),\n          ]),\n        ),\n      ),\n    });\n    Object.defineProperty(this, 'kind', {\n      value: 'schema',\n      writable: false,\n      enumerable: false,\n      configurable: true,\n    });\n    freezeNode(this);\n  }\n\n  /**\n   * The bare schema qualifier as it would appear in a rendered SQL\n   * fragment (already quoted). The unbound-schema singleton overrides\n   * this to return `''`.\n   */\n  qualifier(): string {\n    return `\"${this.id}\"`;\n  }\n\n  /**\n   * Qualify a table name with the schema prefix\n   * (`\"<schema>\".\"<table>\"`). The unbound-schema singleton overrides\n   * this to emit just `\"<table>\"` so the resolved DDL is unqualified\n   * and `search_path` decides where the object lands at runtime.\n   */\n  qualifyTable(tableName: string): string {\n    return `\"${this.id}\".\"${tableName}\"`;\n  }\n\n  /**\n   * Render a SQL string-literal containing the qualified-name form\n   * suitable for `to_regclass(...)` arguments (e.g. `'\"public\".\"user\"'`).\n   * The unbound singleton overrides this to elide the schema prefix\n   * (`'\"user\"'`) so `search_path` resolves the object at runtime.\n   */\n  regclassLiteral(name: string): string {\n    return `'${escapeLiteral(this.qualifyTable(name))}'`;\n  }\n\n  /**\n   * Render a SQL expression that evaluates to this namespace's schema\n   * name at runtime, ready to drop into a `WHERE table_schema = …` /\n   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL\n   * literal (`'public'`); the unbound singleton overrides this to emit\n   * `current_schema()` so catalog queries match whichever schema the\n   * connection's `search_path` resolved at runtime.\n   */\n  schemaSqlExpression(): string {\n    return `'${escapeLiteral(this.id)}'`;\n  }\n\n  /**\n   * The bare schema name a DDL planner should target when emitting\n   * statements that need to identify this namespace in the live\n   * database (e.g. `CREATE TABLE \"<ddlSchemaName>\".\"<table>\" …`,\n   * catalog filters, planner conflict lookups). Named schemas resolve\n   * to their own id. The `PostgresUnboundSchema` singleton inherits\n   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch\n   * through `qualifyTableName` / `toRegclassLiteral` route through the\n   * polymorphic `PostgresUnboundSchema` overrides and produce\n   * unqualified (search-path-resolved) output automatically.\n   */\n  ddlSchemaName(_storage: SqlStorage): string {\n    return this.id;\n  }\n}\n\n/**\n * Singleton subclass for the reserved sentinel namespace id\n * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding\n * the connection's `search_path` resolves at runtime. Overrides\n * qualifier emission to elide the schema prefix; call sites that consume\n * `qualifier()` / `qualifyTable()` get unqualified output without\n * branching on the namespace id.\n *\n * This is the target-side materialization of \"the framework provides\n * affordances; targets implement specifics\": the framework names the\n * sentinel; Postgres decides what late-bound means here (the table\n * name, naked — the schema is supplied by the live connection's\n * `search_path`).\n *\n * `ddlSchemaName` is inherited from `PostgresSchema` and returns\n * `UNBOUND_NAMESPACE_ID`. Downstream helpers (`qualifyTableName`,\n * `toRegclassLiteral`) route through the polymorphic factory and\n * produce unqualified output automatically.\n */\nexport class PostgresUnboundSchema extends PostgresSchema {\n  static readonly instance: PostgresUnboundSchema = new PostgresUnboundSchema();\n\n  constructor(input?: PostgresSchemaInput) {\n    super(input ?? { id: UNBOUND_NAMESPACE_ID, entries: { table: {}, type: {} } });\n  }\n\n  override qualifier(): string {\n    return '';\n  }\n\n  override qualifyTable(tableName: string): string {\n    return `\"${tableName}\"`;\n  }\n\n  override schemaSqlExpression(): string {\n    return 'current_schema()';\n  }\n}\n\nPostgresSchema.unbound = PostgresUnboundSchema.instance;\n\n/**\n * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`\n * so callers can dispatch to the polymorphic emission methods without\n * branching at the call site. Uses the structural `kind` discriminator\n * (`'schema'`) rather than `instanceof` so the check survives realm /\n * bundle / hot-reload boundaries — matching the rest of the IR's\n * narrowing convention. `PostgresUnboundSchema` passes through because\n * it inherits the same `kind: 'schema'` from `PostgresSchema`.\n */\nexport function isPostgresSchema(ns: unknown): ns is PostgresSchema {\n  return (ns as { kind?: unknown } | null | undefined)?.kind === 'schema';\n}\n\n/**\n * Target-supplied `Namespace` factory the Postgres target plumbs\n * through `defineContract({ createNamespace })` and the SQL PSL\n * interpreter. Returns the unbound singleton for the framework\n * sentinel and a fresh `PostgresSchema` for any other coordinate.\n *\n * The factory has no per-call state — every named id deterministically\n * maps to a distinct schema instance — so callers can pass it through\n * by reference and trust the resulting `SqlStorage.namespaces` map to\n * be value-stable for a given input set.\n */\nexport function postgresCreateNamespace(\n  input: SqlNamespaceTablesInput,\n  enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>,\n): PostgresSchema {\n  const schemaInput: PostgresSchemaInput = {\n    id: input.id,\n    entries: {\n      table: input.entries.table,\n      type: (enumTypes ?? {}) as Record<string, PostgresEnumTypeInput>,\n    },\n  };\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(schemaInput);\n  }\n  return new PostgresSchema(schemaInput);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,cAAoC,cAAc;;;;;;;;CAQhD,OAAO;CAGP;CACA;CAKA,YAAY,OAA4B;EACtC,MAAM;EACN,KAAK,KAAK,MAAM;EAChB,KAAK,UAAU,OAAO,OAAO;GAC3B,OAAO,OAAO,OACZ,OAAO,YACL,OAAO,QAAQ,MAAM,QAAQ,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,OAAO,CAClD,GACA,aAAa,eAAe,IAAI,IAAI,aAAa,CAAsB,CACzE,CAAC,CACH,CACF;GACA,MAAM,OAAO,OACX,OAAO,YACL,OAAO,QAAQ,MAAM,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,OAAO,CACjD,GACA,aAAa,mBAAmB,IAAI,IAAI,iBAAiB,CAA0B,CACrF,CAAC,CACH,CACF;EACF,CAAC;EACD,OAAO,eAAe,MAAM,QAAQ;GAClC,OAAO;GACP,UAAU;GACV,YAAY;GACZ,cAAc;EAChB,CAAC;EACD,WAAW,IAAI;CACjB;;;;;;CAOA,YAAoB;EAClB,OAAO,IAAI,KAAK,GAAG;CACrB;;;;;;;CAQA,aAAa,WAA2B;EACtC,OAAO,IAAI,KAAK,GAAG,KAAK,UAAU;CACpC;;;;;;;CAQA,gBAAgB,MAAsB;EACpC,OAAO,IAAI,cAAc,KAAK,aAAa,IAAI,CAAC,EAAE;CACpD;;;;;;;;;CAUA,sBAA8B;EAC5B,OAAO,IAAI,cAAc,KAAK,EAAE,EAAE;CACpC;;;;;;;;;;;;CAaA,cAAc,UAA8B;EAC1C,OAAO,KAAK;CACd;AACF;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,wBAAb,MAAa,8BAA8B,eAAe;CACxD,OAAgB,WAAkC,IAAI,sBAAsB;CAE5E,YAAY,OAA6B;EACvC,MAAM,SAAS;GAAE,IAAI;GAAsB,SAAS;IAAE,OAAO,CAAC;IAAG,MAAM,CAAC;GAAE;EAAE,CAAC;CAC/E;CAEA,YAA6B;EAC3B,OAAO;CACT;CAEA,aAAsB,WAA2B;EAC/C,OAAO,IAAI,UAAU;CACvB;CAEA,sBAAuC;EACrC,OAAO;CACT;AACF;AAEA,eAAe,UAAU,sBAAsB;;;;;;;;;;AAW/C,SAAgB,iBAAiB,IAAmC;CAClE,OAAQ,IAA8C,SAAS;AACjE;;;;;;;;;;;;AAaA,SAAgB,wBACd,OACA,WACgB;CAChB,MAAM,cAAmC;EACvC,IAAI,MAAM;EACV,SAAS;GACP,OAAO,MAAM,QAAQ;GACrB,MAAO,aAAa,CAAC;EACvB;CACF;CACA,IAAI,MAAM,OAAO,sBACf,OAAO,IAAI,sBAAsB,WAAW;CAE9C,OAAO,IAAI,eAAe,WAAW;AACvC"}

package/dist/render-ops-BpjstrKQ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"render-ops-BpjstrKQ.mjs","names":[],"sources":["../src/core/migrations/render-ops.ts"],"sourcesContent":["import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type { Lowerer } from '@prisma-next/family-sql/control-adapter';\nimport type { OpFactoryCall } from '@prisma-next/framework-components/control';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { PostgresPlanTargetDetails } from './planner-target-details';\n\ntype Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;\n\n/**\n * Asserts an op materialised by an `OpFactoryCall` targets postgres. The\n * extension surface lets any contributor emit calls, so this is the\n * integration boundary where a stray non-postgres op would otherwise\n * silently flow through to postgres-shaped renderers — exactly the\n * place to fail loudly with op metadata (`id` + `target.id`).\n */\nfunction assertPostgresOp(\n  op: ReturnType<OpFactoryCall['toOp']>,\n  callFactoryName: string,\n): asserts op is Op {\n  const targetId = (op as Partial<Op>).target?.id;\n  if (targetId !== 'postgres') {\n    throw new Error(\n      `renderOps: expected postgres op but got target.id=\"${String(targetId)}\" for op.id=\"${op.id}\" (factoryName=\"${callFactoryName}\"). An OpFactoryCall produced an op for a different target on the postgres planner path; check the call's target binding.`,\n    );\n  }\n}\n\nexport function renderOps(calls: readonly OpFactoryCall[], lowerer?: Lowerer): Op[] {\n  return calls.map((c) => {\n    const op = blindCast<\n      { toOp(lowerer?: Lowerer): ReturnType<OpFactoryCall['toOp']> },\n      'PG OpFactoryCall.toOp accepts an optional Lowerer; the framework interface omits it because not all targets need a lowerer — the PG target overrides with this extended signature'\n    >(c).toOp(lowerer);\n    assertPostgresOp(op, c.factoryName);\n    return op;\n  });\n}\n"],"mappings":";;;;;;;;;AAeA,SAAS,iBACP,IACA,iBACkB;CAClB,MAAM,WAAY,GAAmB,QAAQ;CAC7C,IAAI,aAAa,YACf,MAAM,IAAI,MACR,sDAAsD,OAAO,QAAQ,EAAE,eAAe,GAAG,GAAG,kBAAkB,gBAAgB,0HAChI;AAEJ;AAEA,SAAgB,UAAU,OAAiC,SAAyB;CAClF,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,KAAK,UAGT,CAAC,CAAC,CAAC,KAAK,OAAO;EACjB,iBAAiB,IAAI,EAAE,WAAW;EAClC,OAAO;CACT,CAAC;AACH"}

package/dist/shared-DarONYBZ.d.mts

@@ -1,43 +0,0 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIY6tLeo.mjs";
-import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
-import { ReferentialAction } from "@prisma-next/sql-contract/types";
-
-//#region src/core/migrations/operations/shared.d.ts
-type Op = SqlMigrationPlanOperation<PostgresPlanTargetDetails>;
-/**
- * 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
- *   call-factory wrapper.
- * - `defaultSql` is the full `DEFAULT …` clause (e.g. `"DEFAULT 42"`) or an
- *   empty string when the column has no default, matching
- *   `buildColumnDefaultSql`'s output.
- */
-interface ColumnSpec {
-  readonly name: string;
-  readonly typeSql: string;
-  readonly defaultSql: string;
-  readonly nullable: boolean;
-}
-/**
- * Literal-args shape for a foreign key definition. `references.schema`
- * carries the target table's namespace (schema) coordinate so the rendered
- * DDL qualifies the REFERENCES clause correctly for cross-schema FKs.
- */
-interface ForeignKeySpec {
-  readonly name: string;
-  readonly columns: readonly string[];
-  readonly references: {
-    readonly schema: string;
-    readonly table: string;
-    readonly columns: readonly string[];
-  };
-  readonly onDelete?: ReferentialAction;
-  readonly onUpdate?: ReferentialAction;
-}
-//#endregion
-export { ForeignKeySpec as n, Op as r, ColumnSpec as t };
-//# sourceMappingURL=shared-DarONYBZ.d.mts.map

package/dist/shared-DarONYBZ.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared-DarONYBZ.d.mts","names":[],"sources":["../src/core/migrations/operations/shared.ts"],"mappings":";;;;;KAMY,EAAA,GAAK,yBAAyB,CAAC,yBAAA;;AAA3C;;;;AAAoE;AAcpE;;;;;;UAAiB,UAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;AAAA;;;;;;UAQM,cAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;IAAA,SACE,MAAA;IAAA,SACA,KAAA;IAAA,SACA,OAAA;EAAA;EAAA,SAEF,QAAA,GAAW,iBAAA;EAAA,SACX,QAAA,GAAW,iBAAiB;AAAA"}

package/src/core/migrations/enum-planning.ts

@@ -1,213 +0,0 @@
-/**
- * Pure planning helpers for Postgres enum types: the diff/rebuild logic
- * that the verifier and planner use to walk `PostgresEnumType` instances
- * natively. Op builders live in `./operations/enums.ts`.
- */
-
-import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';
-import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
-import { PG_ENUM_CODEC_ID } from '../codec-ids';
-import type { PostgresEnumType } from '../postgres-enum-type';
-import { isPostgresSchema } from '../postgres-schema';
-
-/**
- * Codec-typed enum entry shape stored under
- * `schema.annotations.pg.storageTypes[(schemaName, nativeType)]`.
- */
-interface PgStorageTypeEntry {
-  readonly codecId?: string;
-  readonly typeParams?: { readonly values?: unknown };
-}
-
-/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */
-export interface PostgresSchemaIrAnnotations {
-  readonly schema?: string;
-  readonly storageTypes?: Readonly<Record<string, PgStorageTypeEntry>>;
-}
-
-function readOptionalString(value: unknown): string | undefined {
-  return typeof value === 'string' ? value : undefined;
-}
-
-function readPgStorageTypeEntry(value: unknown): PgStorageTypeEntry | undefined {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    return undefined;
-  }
-  const codecId = Reflect.get(value, 'codecId');
-  const typeParamsRaw = Reflect.get(value, 'typeParams');
-  const typeParams =
-    typeParamsRaw !== undefined &&
-    typeParamsRaw !== null &&
-    typeof typeParamsRaw === 'object' &&
-    !Array.isArray(typeParamsRaw)
-      ? { values: Reflect.get(typeParamsRaw, 'values') }
-      : undefined;
-  return {
-    ...(typeof codecId === 'string' ? { codecId } : {}),
-    ...(typeParams !== undefined ? { typeParams } : {}),
-  };
-}
-
-function readPgStorageTypesMap(
-  value: unknown,
-): Readonly<Record<string, PgStorageTypeEntry>> | undefined {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    return undefined;
-  }
-  const entries: Record<string, PgStorageTypeEntry> = {};
-  for (const [key, entryValue] of Object.entries(value)) {
-    const entry = readPgStorageTypeEntry(entryValue);
-    if (entry !== undefined) {
-      entries[key] = entry;
-    }
-  }
-  return Object.keys(entries).length > 0 ? entries : undefined;
-}
-
-/**
- * Reads the Postgres annotation envelope (`schema.annotations.pg`) from
- * family Schema IR. `SqlAnnotations` is an open target-pack extensibility
- * map (`Record<string, unknown>`); this accessor narrows the `pg` slot at
- * runtime so Postgres code can read introspection fields without casts.
- */
-export function readPostgresSchemaIrAnnotations(schema: SqlSchemaIR): PostgresSchemaIrAnnotations {
-  const raw = schema.annotations?.['pg'];
-  if (raw === undefined || raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-    return {};
-  }
-  const schemaField = readOptionalString(Reflect.get(raw, 'schema'));
-  const storageTypes = readPgStorageTypesMap(Reflect.get(raw, 'storageTypes'));
-  return {
-    ...(schemaField !== undefined ? { schema: schemaField } : {}),
-    ...(storageTypes !== undefined ? { storageTypes } : {}),
-  };
-}
-
-/**
- * Separator for `(schemaName, nativeType)` keys in introspected
- * `schema.annotations.pg.storageTypes`. NUL cannot appear in Postgres
- * identifiers, so the pair is unambiguous.
- */
-export const ENUM_STORAGE_KEY_SEP = '\u0000';
-
-/** Builds the schema-qualified storageTypes map key for a live Postgres enum. */
-export function enumStorageCompoundKey(schemaName: string, nativeType: string): string {
-  return `${schemaName}${ENUM_STORAGE_KEY_SEP}${nativeType}`;
-}
-
-/**
- * Resolves the live-schema name a namespace's enums are introspected under,
- * for keying `readExistingEnumValues` lookups. The unbound namespace's
- * `ddlSchemaName` is a planner-emit sentinel (`__unbound__`) that never names a
- * real schema, so for the unbound coordinate we read the *introspected* schema
- * recorded on `annotations.pg.schema` (the live `current_schema()` the adapter
- * walked) — that is the schema the enum's `storageTypes` entry is keyed under.
- * Named namespaces resolve to their own DDL schema, which matches the
- * per-schema introspection key directly.
- */
-export function resolveDdlSchemaForNamespaceStorage(
-  storage: SqlStorage,
-  namespaceId: string,
-  schemaIr?: SqlSchemaIR,
-): string {
-  if (namespaceId === UNBOUND_NAMESPACE_ID) {
-    return (schemaIr ? readPostgresSchemaIrAnnotations(schemaIr).schema : undefined) ?? 'public';
-  }
-  const namespace = storage.namespaces[namespaceId];
-  if (namespace && isPostgresSchema(namespace)) {
-    return namespace.ddlSchemaName(storage);
-  }
-  return namespaceId;
-}
-
-/** Contract-scoped bridge for the family verifier's enum value resolver. */
-export function createResolveExistingEnumValues(
-  storage: SqlStorage,
-): (
-  schema: SqlSchemaIR,
-  enumType: PostgresEnumStorageEntry,
-  namespaceId: string,
-) => readonly string[] | null {
-  return (schema, enumType, namespaceId) =>
-    readExistingEnumValues(
-      schema,
-      resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schema),
-      enumType.nativeType,
-    );
-}
-
-/**
- * Categorisation of how an existing enum type's values relate to the
- * desired set in the contract.
- */
-export type EnumDiff =
-  | { readonly kind: 'unchanged' }
-  | { readonly kind: 'add_values'; readonly values: readonly string[] }
-  | { readonly kind: 'rebuild'; readonly removedValues: readonly string[] };
-
-/**
- * Reads existing enum values for `(schemaName, nativeType)` from the
- * Postgres-introspected `schema.annotations.pg.storageTypes` map.
- *
- * Schema IR's `storageTypes` slots are always codec-typed
- * (`{codecId: PG_ENUM_CODEC_ID, typeParams.values}`): the introspector
- * writes that shape, and the Contract→Schema IR projector resolves
- * `PostgresEnumType` instances down to the same codec-typed triple before
- * they ever land in Schema IR. There is no second on-disk shape to
- * accept here.
- *
- * Returns `null` when no enum entry exists for the given native type.
- */
-export function readExistingEnumValues(
-  schema: SqlSchemaIR,
-  schemaName: string,
-  nativeType: string,
-): readonly string[] | null {
-  const storageTypes = readPostgresSchemaIrAnnotations(schema).storageTypes;
-  const existing = storageTypes?.[enumStorageCompoundKey(schemaName, nativeType)];
-  if (!existing || existing.codecId !== PG_ENUM_CODEC_ID) {
-    return null;
-  }
-  const enumValues = existing.typeParams?.values;
-  if (!Array.isArray(enumValues) || !enumValues.every((v) => typeof v === 'string')) {
-    return null;
-  }
-  return enumValues;
-}
-
-/**
- * Determines what changes are needed to transform existing enum values to
- * desired values.
- *
- * Postgres enums can only have values added (not removed or reordered)
- * without a full type rebuild involving temp type creation and column
- * migration; `'rebuild'` covers the value-removal and reorder cases.
- */
-export function determineEnumDiff(
-  existing: readonly string[],
-  desired: readonly string[],
-): EnumDiff {
-  if (arraysEqual(existing, desired)) {
-    return { kind: 'unchanged' };
-  }
-  const existingSet = new Set(existing);
-  const desiredSet = new Set(desired);
-  const missingValues = desired.filter((value) => !existingSet.has(value));
-  const removedValues = existing.filter((value) => !desiredSet.has(value));
-  const orderMismatch =
-    missingValues.length === 0 && removedValues.length === 0 && !arraysEqual(existing, desired);
-  if (removedValues.length > 0 || orderMismatch) {
-    return { kind: 'rebuild', removedValues };
-  }
-  return { kind: 'add_values', values: missingValues };
-}
-
-/**
- * Convenience accessor — returns the enum's desired values from a
- * `PostgresEnumType` IR instance.
- */
-export function getDesiredEnumValues(typeInstance: PostgresEnumType): readonly string[] {
-  return typeInstance.values;
-}

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

@@ -1,114 +0,0 @@
-import { escapeLiteral, qualifyName, quoteIdentifier } from '../../sql-utils';
-import { type Op, step, targetDetails } from './shared';
-
-function enumTypeExistsCheck(schemaName: string, nativeType: string, exists = true): string {
-  const clause = exists ? 'EXISTS' : 'NOT EXISTS';
-  return `SELECT ${clause} (
-  SELECT 1
-  FROM pg_type t
-  JOIN pg_namespace n ON t.typnamespace = n.oid
-  WHERE n.nspname = '${escapeLiteral(schemaName)}'
-    AND t.typname = '${escapeLiteral(nativeType)}'
-)`;
-}
-
-export function createEnumType(
-  schemaName: string,
-  typeName: string,
-  values: readonly string[],
-  nativeType: string = typeName,
-): Op {
-  const qualifiedType = qualifyName(schemaName, nativeType);
-  const literalValues = values.map((v) => `'${escapeLiteral(v)}'`).join(', ');
-  return {
-    id: `type.${typeName}`,
-    label: `Create enum type "${typeName}"`,
-    operationClass: 'additive',
-    target: targetDetails('type', typeName, schemaName),
-    precheck: [
-      step(
-        `ensure type "${nativeType}" does not exist`,
-        enumTypeExistsCheck(schemaName, nativeType, false),
-      ),
-    ],
-    execute: [
-      step(
-        `create enum type "${typeName}"`,
-        `CREATE TYPE ${qualifiedType} AS ENUM (${literalValues})`,
-      ),
-    ],
-    postcheck: [
-      step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType)),
-    ],
-  };
-}
-
-/**
- * `typeName` is the contract-facing type name (used for id/label).
- * `nativeType` is the Postgres type name to mutate (may differ for external types).
- */
-export function addEnumValues(
-  schemaName: string,
-  typeName: string,
-  nativeType: string,
-  values: readonly string[],
-): Op {
-  const qualifiedType = qualifyName(schemaName, nativeType);
-  return {
-    id: `type.${typeName}.addValues`,
-    label: `Add values to enum type "${typeName}": ${values.join(', ')}`,
-    operationClass: 'additive',
-    target: targetDetails('type', typeName, schemaName),
-    precheck: [
-      step(`ensure type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType)),
-    ],
-    execute: values.map((value) =>
-      step(
-        `add value '${value}' to enum "${nativeType}"`,
-        `ALTER TYPE ${qualifiedType} ADD VALUE '${escapeLiteral(value)}'`,
-      ),
-    ),
-    postcheck: [
-      step(`verify type "${nativeType}" exists`, enumTypeExistsCheck(schemaName, nativeType)),
-    ],
-  };
-}
-
-export function dropEnumType(schemaName: string, typeName: string): Op {
-  const qualified = qualifyName(schemaName, typeName);
-  return {
-    id: `type.${typeName}.drop`,
-    label: `Drop enum type "${typeName}"`,
-    operationClass: 'destructive',
-    target: targetDetails('type', typeName, schemaName),
-    precheck: [step(`ensure type "${typeName}" exists`, enumTypeExistsCheck(schemaName, typeName))],
-    execute: [step(`drop enum type "${typeName}"`, `DROP TYPE ${qualified}`)],
-    postcheck: [
-      step(`verify type "${typeName}" removed`, enumTypeExistsCheck(schemaName, typeName, false)),
-    ],
-  };
-}
-
-export function renameType(schemaName: string, fromName: string, toName: string): Op {
-  const qualifiedFrom = qualifyName(schemaName, fromName);
-  return {
-    id: `type.${fromName}.rename`,
-    label: `Rename type "${fromName}" to "${toName}"`,
-    operationClass: 'destructive',
-    target: targetDetails('type', fromName, schemaName),
-    precheck: [
-      step(`ensure type "${fromName}" exists`, enumTypeExistsCheck(schemaName, fromName)),
-      step(
-        `ensure type "${toName}" does not already exist`,
-        enumTypeExistsCheck(schemaName, toName, false),
-      ),
-    ],
-    execute: [
-      step(
-        `rename type "${fromName}" to "${toName}"`,
-        `ALTER TYPE ${qualifiedFrom} RENAME TO ${quoteIdentifier(toName)}`,
-      ),
-    ],
-    postcheck: [step(`verify type "${toName}" exists`, enumTypeExistsCheck(schemaName, toName))],
-  };
-}

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

@@ -1,89 +0,0 @@
-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 PostgresEnumTypeInput<
-  TName extends string = string,
-  TValues extends readonly string[] = readonly string[],
-> {
-  /**
-   * Contract-level enum name (e.g. `'Role'`). Used as the key in
-   * `SqlStorage.types` and as the contract-facing identifier in
-   * planner / verifier diagnostics.
-   */
-  readonly name: TName;
-  /**
-   * Postgres-side native type name created by `CREATE TYPE … AS ENUM`.
-   * Defaults to `name` when not overridden via PSL `@map(...)` or the
-   * TS authoring surface.
-   */
-  readonly nativeType?: string;
-  readonly values: TValues;
-  readonly control?: ControlPolicy;
-}
-
-/** Codec id used by Postgres enum-typed columns (text wire format). */
-const PG_ENUM_CODEC_ID = 'pg/enum@1';
-
-/**
- * Postgres IR class for the `CREATE TYPE … AS ENUM` concept.
- *
- * Per Decision 18, enum is a target-only concept (Postgres alone today;
- * SQLite emulates via CHECK constraints). There is no family-layer
- * enum abstract — the abstract-earns-existence rule keeps the IR class
- * hierarchy minimal: this class extends `SqlNode` directly and is the
- * single concrete representation of the polymorphic `'postgres-enum'`
- * slot variant.
- *
- * Carries Postgres-specific resolution (`nativeType` defaults to
- * `name`; `values` is frozen at construction time). Constructor calls
- * `freezeNode(this)` per Decision 8 — the instance is fully immutable,
- * JSON-clean, and dispatchable on its enumerable `kind: 'postgres-enum'`
- * literal.
- *
- * The family-layer slot dispatch (verifier, planner, lowering, etc.)
- * narrows polymorphic `StorageType` entries via the `kind` literal
- * (e.g. `isPostgresEnumStorageEntry`) — SQL-domain code must not import
- * `target-postgres` directly (cross-domain layering rule). The
- * structural interface lives at the family layer for that purpose;
- * this class is the runtime concrete that satisfies it.
- */
-export class PostgresEnumType<
-  TName extends string = string,
-  TValues extends readonly string[] = readonly string[],
-> extends SqlNode {
-  override readonly kind = 'postgres-enum' as const;
-  readonly name: TName;
-  readonly nativeType: string;
-  readonly values: TValues;
-  /**
-   * Enumerable own property so the persisted JSON envelope carries
-   * `codecId: 'pg/enum@1'` alongside `kind: 'postgres-enum'`. The
-   * runtime path (`codecRefForStorageColumn`, `assertColumnCodecIntegrity`)
-   * receives JSON-shaped contracts (e.g. inside a user-written
-   * `migration.ts` that loads `endContract` from `end-contract.json`)
-   * and reads `codecId` directly from the envelope rather than
-   * dispatching through the prototype-only `codecBinding` accessor.
-   */
-  readonly codecId: typeof PG_ENUM_CODEC_ID = PG_ENUM_CODEC_ID;
-  declare readonly control?: ControlPolicy;
-
-  constructor(input: PostgresEnumTypeInput<TName, TValues>) {
-    super();
-    this.name = input.name;
-    this.nativeType = input.nativeType ?? input.name;
-    // `Object.freeze` returns `Readonly<string[]>`, widening past the
-    // `TValues` literal tuple. Cast preserves the caller-supplied
-    // tuple shape so inferred contract types retain literal narrowing.
-    this.values = Object.freeze([...input.values] as unknown as TValues);
-    if (input.control !== undefined) this.control = input.control;
-    freezeNode(this);
-  }
-
-  get codecBinding(): {
-    readonly codecId: typeof PG_ENUM_CODEC_ID;
-    readonly typeParams: { readonly values: TValues };
-  } {
-    return { codecId: PG_ENUM_CODEC_ID, typeParams: { values: this.values } };
-  }
-}

package/src/exports/enum-planning.ts

@@ -1,11 +0,0 @@
-export {
-  createResolveExistingEnumValues,
-  determineEnumDiff,
-  type EnumDiff,
-  enumStorageCompoundKey,
-  getDesiredEnumValues,
-  type PostgresSchemaIrAnnotations,
-  readExistingEnumValues,
-  readPostgresSchemaIrAnnotations,
-  resolveDdlSchemaForNamespaceStorage,
-} from '../core/migrations/enum-planning';