@prisma-next/target-postgres 0.13.0-dev.3 → 0.13.0-dev.31

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';