@prisma-next/target-postgres 0.13.0-dev.28 → 0.13.0-dev.29

package/dist/postgres-enum-type-schema-DZBTtvBF.mjs

@@ -1,20 +0,0 @@
-import { type } from "arktype";
-//#region src/core/postgres-enum-type-schema.ts
-const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
-/**
-* Arktype validator for a `postgres-enum` entry under
-* `storage.namespaces[id].entries.type[name]`. Registered by the Postgres
-* target pack against the `'type'` entries key so the family-layer namespace
-* validator accepts (and rejects) entries of this kind.
-*/
-const PostgresEnumTypeSchema = type({
-	kind: "'postgres-enum'",
-	"name?": "string",
-	"nativeType?": "string",
-	values: type.string.array().readonly(),
-	"control?": ControlPolicySchema
-});
-//#endregion
-export { PostgresEnumTypeSchema as t };
-
-//# sourceMappingURL=postgres-enum-type-schema-DZBTtvBF.mjs.map

package/dist/postgres-enum-type-schema-DZBTtvBF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-enum-type-schema-DZBTtvBF.mjs","names":[],"sources":["../src/core/postgres-enum-type-schema.ts"],"sourcesContent":["import { type } from 'arktype';\n\nconst ControlPolicySchema = type(\"'managed' | 'tolerated' | 'external' | 'observed'\");\n\n/**\n * Arktype validator for a `postgres-enum` entry under\n * `storage.namespaces[id].entries.type[name]`. Registered by the Postgres\n * target pack against the `'type'` entries key so the family-layer namespace\n * validator accepts (and rejects) entries of this kind.\n */\nexport const PostgresEnumTypeSchema = type({\n  kind: \"'postgres-enum'\",\n  'name?': 'string',\n  'nativeType?': 'string',\n  values: type.string.array().readonly(),\n  'control?': ControlPolicySchema,\n});\n"],"mappings":";;AAEA,MAAM,sBAAsB,KAAK,mDAAmD;;;;;;;AAQpF,MAAa,yBAAyB,KAAK;CACzC,MAAM;CACN,SAAS;CACT,eAAe;CACf,QAAQ,KAAK,OAAO,MAAM,CAAC,CAAC,SAAS;CACrC,YAAY;AACd,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-schema-C7c9rhGk.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 SqlNamespaceEntries,\n  type SqlNamespaceTablesInput,\n  type SqlStorage,\n  StorageTable,\n  type StorageTableInput,\n  StorageValueSet,\n  type StorageValueSetInput,\n} from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { PostgresEnumType, type PostgresEnumTypeInput } from './postgres-enum-type';\nimport { escapeLiteral } from './sql-utils';\n\nexport type PostgresNamespaceEntries = SqlNamespaceEntries & {\n  readonly type?: Readonly<Record<string, PostgresEnumType>>;\n};\n\nexport interface PostgresSchemaInput {\n  readonly id: string;\n  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;\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 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: PostgresNamespaceEntries;\n\n  constructor(input: PostgresSchemaInput) {\n    super();\n    this.id = input.id;\n\n    const carried: Record<string, Readonly<Record<string, unknown>>> = {};\n    let table: Readonly<Record<string, StorageTable>> = Object.freeze({});\n    let type: Readonly<Record<string, PostgresEnumType>> = Object.freeze({});\n    let valueSet: Readonly<Record<string, StorageValueSet>> | undefined;\n    for (const [kind, rawMap] of Object.entries(input.entries)) {\n      if (kind === 'table') {\n        const tableMap: Record<string, StorageTable> = {};\n        for (const [name, v] of Object.entries(\n          blindCast<\n            Record<string, StorageTableInput>,\n            'entries[table] holds StorageTableInput by construction'\n          >(rawMap),\n        )) {\n          tableMap[name] = new StorageTable(v);\n        }\n        table = Object.freeze(tableMap);\n      } else if (kind === 'type') {\n        const typeMap: Record<string, PostgresEnumType> = {};\n        for (const [name, v] of Object.entries(\n          blindCast<\n            Record<string, PostgresEnumTypeInput>,\n            'entries[type] holds PostgresEnumTypeInput by construction'\n          >(rawMap),\n        )) {\n          typeMap[name] = new PostgresEnumType(v);\n        }\n        type = Object.freeze(typeMap);\n      } else if (kind === 'valueSet') {\n        const vsMap: Record<string, StorageValueSet> = {};\n        for (const [name, v] of Object.entries(\n          blindCast<\n            Record<string, StorageValueSetInput>,\n            'entries[valueSet] holds StorageValueSetInput by construction'\n          >(rawMap),\n        )) {\n          vsMap[name] = new StorageValueSet(v);\n        }\n        if (Object.keys(vsMap).length > 0) {\n          valueSet = Object.freeze(vsMap);\n        }\n      } else {\n        carried[kind] = Object.freeze(rawMap);\n      }\n    }\n\n    this.entries = Object.freeze({\n      ...carried,\n      table,\n      type,\n      ...ifDefined('valueSet', valueSet),\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  get table(): Readonly<Record<string, StorageTable>> {\n    return this.entries.table ?? Object.freeze({});\n  }\n\n  get type(): Readonly<Record<string, PostgresEnumType>> {\n    return this.entries.type ?? Object.freeze({});\n  }\n\n  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined {\n    return this.entries.valueSet;\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      ...input.entries,\n      table: input.entries['table'] ?? {},\n      type: blindCast<\n        Record<string, PostgresEnumTypeInput>,\n        'enumTypes values are PostgresEnumTypeInput by construction'\n      >(enumTypes ?? {}),\n    },\n  };\n  if (input.id === UNBOUND_NAMESPACE_ID) {\n    return new PostgresUnboundSchema(schemaInput);\n  }\n  return new PostgresSchema(schemaInput);\n}\n"],"mappings":"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"}

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

@@ -1,217 +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.enumTypes[schemaName][nativeType]`.
- */
-interface PgStorageTypeEntry {
-  readonly codecId?: string;
-  readonly typeParams?: { readonly values?: unknown };
-}
-
-/**
- * Live enum types keyed by `(schemaName, nativeType)` as a nested map, so two
- * schemas sharing a native enum name stay distinct without packing the pair
- * into a string. This is the same `(namespace, entityName)` coordinate the
- * contract side addresses entities by.
- */
-type PgEnumTypesMap = Readonly<Record<string, Readonly<Record<string, PgStorageTypeEntry>>>>;
-
-/** Postgres-specific subtree on family `SqlSchemaIR.annotations`. */
-export interface PostgresSchemaIrAnnotations {
-  readonly schema?: string;
-  readonly enumTypes?: PgEnumTypesMap;
-}
-
-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 readPgEnumTypesMap(value: unknown): PgEnumTypesMap | undefined {
-  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-    return undefined;
-  }
-  const bySchema: Record<string, Record<string, PgStorageTypeEntry>> = {};
-  for (const [schemaName, byTypeRaw] of Object.entries(value)) {
-    if (byTypeRaw === null || typeof byTypeRaw !== 'object' || Array.isArray(byTypeRaw)) {
-      continue;
-    }
-    const byType: Record<string, PgStorageTypeEntry> = {};
-    for (const [nativeType, entryValue] of Object.entries(byTypeRaw)) {
-      const entry = readPgStorageTypeEntry(entryValue);
-      if (entry !== undefined) {
-        byType[nativeType] = entry;
-      }
-    }
-    if (Object.keys(byType).length > 0) {
-      bySchema[schemaName] = byType;
-    }
-  }
-  return Object.keys(bySchema).length > 0 ? bySchema : 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 enumTypes = readPgEnumTypesMap(Reflect.get(raw, 'enumTypes'));
-  return {
-    ...(schemaField !== undefined ? { schema: schemaField } : {}),
-    ...(enumTypes !== undefined ? { enumTypes } : {}),
-  };
-}
-
-/**
- * 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.enumTypes` map, addressed by
- * the `(schema, nativeType)` coordinate.
- *
- * Schema IR's enum entries 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 enumTypes = readPostgresSchemaIrAnnotations(schema).enumTypes;
-  const existing = enumTypes?.[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,10 +0,0 @@
-export {
-  createResolveExistingEnumValues,
-  determineEnumDiff,
-  type EnumDiff,
-  getDesiredEnumValues,
-  type PostgresSchemaIrAnnotations,
-  readExistingEnumValues,
-  readPostgresSchemaIrAnnotations,
-  resolveDdlSchemaForNamespaceStorage,
-} from '../core/migrations/enum-planning';