@prisma-next/family-sql 0.13.0-dev.3 → 0.13.0-dev.30

package/src/core/migrations/contract-to-schema-ir.ts

@@ -1,18 +1,14 @@
-import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
+import type { ColumnDefault, Contract, JsonValue } from '@prisma-next/contract/types';
 import type { MigrationPlannerConflict } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import {
   type CheckConstraint,
   type ForeignKey,
   type Index,
-  isPostgresEnumStorageEntry,
   isStorageTypeInstance,
-  type PostgresEnumStorageEntry,
   type SqlStorage,
   type StorageColumn,
   StorageTable,
   type StorageTypeInstance,
-  toStorageTypeInstance,
   type UniqueConstraint,
 } from '@prisma-next/sql-contract/types';
 import { defaultIndexName } from '@prisma-next/sql-schema-ir/naming';
@@ -26,7 +22,6 @@ import type {
   SqlTableIR,
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
-import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 
 /**
@@ -57,24 +52,19 @@ export type NativeTypeExpander = (input: {
 export type DefaultRenderer = (def: ColumnDefault, column: StorageColumn) => string;
 
 /**
- * Target-supplied callback that computes the schema-qualified annotation-map
- * key for a namespace-scoped enum storage type.
+ * Target-supplied callback that resolves a contract namespace to the live
+ * database schema its enums are stored under.
  *
- * Enum lookups (`readExistingEnumValues`) are namespace/schema-qualified so two
- * namespaces holding an enum with the same TypeScript name (and even the same
- * native type) resolve to distinct live-database types. The *format* of that
- * key — and the namespace → DDL-schema resolution it depends on — is a
- * target-specific concern (Postgres schemas; SQLite/MySQL differ), so the
- * target injects it here as data rather than the family layer importing a
- * concrete `ddlSchemaName`/key implementation. This keeps the family layer
- * target-agnostic (no `@prisma-next/target-*` dependency) while the projection
- * still emits keys that match the target's read side exactly.
+ * The projected enum annotations are nested by schema
+ * (`storageTypes[schema][nativeType]`) so two namespaces holding an enum with
+ * the same native type resolve to distinct live-database types. Mapping a
+ * namespace to its DDL schema is target-specific (Postgres schemas;
+ * SQLite/MySQL differ), so the target injects it here rather than the family
+ * importing a concrete `ddlSchemaName`. This keeps the family layer
+ * target-agnostic while the projection nests under the same schema the
+ * target's read side (`readExistingEnumValues`) looks up.
  */
-export type EnumStorageKeyResolver = (
-  storage: SqlStorage,
-  namespaceId: string,
-  nativeType: string,
-) => string;
+export type EnumNamespaceSchemaResolver = (storage: SqlStorage, namespaceId: string) => string;
 
 function convertColumn(
   name: string,
@@ -110,17 +100,7 @@ function convertColumn(
   };
 }
 
-/**
- * `storageTypes` is polymorphic per Decision 18 (Option B) — codec-typed
- * entries match `StorageTypeInstance`; enum entries match the structural
- * `PostgresEnumStorageEntry` shape (Postgres-only; cross-domain layering
- * keeps target IR classes out of the family layer). Both shapes resolve
- * into the same `(codecId, nativeType, typeParams)` triplet at the
- * column-resolution boundary so downstream walks stay uniform.
- */
-type ResolvedStorageTypes = Readonly<
-  Record<string, StorageTypeInstance | PostgresEnumStorageEntry>
->;
+type ResolvedStorageTypes = Readonly<Record<string, StorageTypeInstance>>;
 
 function resolveColumnTypeMetadata(
   column: StorageColumn,
@@ -135,13 +115,6 @@ function resolveColumnTypeMetadata(
       `Column references storage type "${column.typeRef}" but it is not defined in storage.types.`,
     );
   }
-  if (isPostgresEnumStorageEntry(referenced)) {
-    return {
-      codecId: referenced.codecId,
-      nativeType: referenced.nativeType,
-      typeParams: { values: referenced.values } as Record<string, unknown>,
-    };
-  }
   if (isStorageTypeInstance(referenced)) {
     return {
       codecId: referenced.codecId,
@@ -150,7 +123,7 @@ function resolveColumnTypeMetadata(
     };
   }
   throw new Error(
-    `Storage type "${column.typeRef}" has an unknown polymorphic kind; expected codec-instance or postgres-enum.`,
+    `Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`,
   );
 }
 
@@ -164,8 +137,12 @@ function resolveColumnTypeMetadata(
  * `checkConstraintPlanCallStrategy` (migration planning) so all three agree on
  * the resolved values and the error behavior on a missing reference.
  */
+function allStrings(values: readonly JsonValue[]): values is readonly string[] {
+  return values.every((value) => typeof value === 'string');
+}
+
 export function resolveValueSetValues(
-  ref: { readonly namespaceId: string; readonly name: string },
+  ref: { readonly namespaceId: string; readonly entityName: string },
   storage: SqlStorage,
   contextLabel: string,
 ): readonly string[] {
@@ -175,13 +152,22 @@ export function resolveValueSetValues(
       `resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`,
     );
   }
-  const valueSet = ns.entries.valueSet?.[ref.name];
+  const valueSet = ns.entries.valueSet?.[ref.entityName];
   if (!valueSet) {
     throw new Error(
-      `resolveValueSetValues: value-set "${ref.name}" not found in namespace "${ref.namespaceId}" (${contextLabel})`,
+      `resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`,
+    );
+  }
+  // Only TEXT enums ship a CHECK-constraint round-trip in this slice. A
+  // non-string value-set is a numeric enum, whose CHECK rendering/verification
+  // is future work; fail loudly rather than emit a wrong numeric-as-text check.
+  const values = valueSet.values;
+  if (!allStrings(values)) {
+    throw new Error(
+      `resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`,
     );
   }
-  return valueSet.values;
+  return values;
 }
 
 /**
@@ -316,7 +302,7 @@ export function detectDestructiveChanges(
     if (!fromTables) continue;
 
     for (const tableName of Object.keys(fromTables)) {
-      const toTableRaw = toNs?.entries.table[tableName];
+      const toTableRaw = toNs?.entries.table?.[tableName];
       if (!(toTableRaw instanceof StorageTable)) {
         conflicts.push({
           kind: 'tableRemoved',
@@ -349,13 +335,13 @@ export interface ContractToSchemaIROptions {
   readonly expandNativeType?: NativeTypeExpander;
   readonly renderDefault?: DefaultRenderer;
   /**
-   * Target-supplied resolver for namespace/schema-qualified enum annotation
-   * keys. When provided (Postgres), every namespace-scoped enum is keyed by the
-   * resolver's output so the projected `storageTypes` map matches the target's
-   * `readExistingEnumValues` lookup. Targets without namespace-qualified enum
-   * storage (SQLite) omit it; enums are absent there.
+   * Target-supplied resolver mapping a namespace to the live database schema
+   * its enums are stored under. When provided (Postgres), namespace-scoped
+   * enums are nested by that schema in `enumTypes` so the projection matches
+   * the target's `readExistingEnumValues` lookup. Targets without
+   * schema-scoped enum storage (SQLite) omit it; enums are absent there.
    */
-  readonly resolveEnumStorageKey?: EnumStorageKeyResolver;
+  readonly resolveEnumNamespaceSchema?: EnumNamespaceSchemaResolver;
 }
 
 /**
@@ -385,24 +371,12 @@ export function contractToSchemaIR(
   }
 
   const storage = contract.storage;
-  const allTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {
+  const storageTypes: ResolvedStorageTypes = {
     ...((storage.types ?? {}) as ResolvedStorageTypes),
   };
-  for (const ns of Object.values(storage.namespaces)) {
-    const nsEnums = ns.entries['type'];
-    if (nsEnums) {
-      for (const [k, v] of Object.entries(nsEnums)) {
-        allTypes[k] = blindCast<
-          PostgresEnumStorageEntry | StorageTypeInstance,
-          'entries.type holds postgres-specific enum entries at runtime'
-        >(v);
-      }
-    }
-  }
-  const storageTypes = allTypes as ResolvedStorageTypes;
   const tables: Record<string, SqlTableIR> = {};
   for (const ns of Object.values(storage.namespaces)) {
-    for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table)) {
+    for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
       if (!(tableDefRaw instanceof StorageTable)) {
         throw new Error(
           `contractToSchemaIR: expected StorageTable at namespaces.${ns.id}.entries.table.${tableName}`,
@@ -428,7 +402,7 @@ export function contractToSchemaIR(
   const annotations = deriveAnnotations(
     storage,
     options.annotationNamespace,
-    options.resolveEnumStorageKey,
+    options.resolveEnumNamespaceSchema,
   );
 
   return {
@@ -437,61 +411,22 @@ export function contractToSchemaIR(
   };
 }
 
-/**
- * Normalises a native enum storage entry to the codec-typed annotation shape
- * `{codecId, nativeType, typeParams}` the introspector writes and
- * `readExistingEnumValues` reads (`existing.codecId` + `existing.typeParams.values`).
- * Without this the projector would emit the raw `PostgresEnumStorageEntry`
- * shape (top-level `values`, no `typeParams`) and the enum would read as new.
- */
-function normalizeEnumAnnotation(entry: PostgresEnumStorageEntry): StorageTypeInstance {
-  return toStorageTypeInstance({
-    codecId: entry.codecId,
-    nativeType: entry.nativeType,
-    typeParams: { values: entry.values },
-  });
-}
-
 function deriveAnnotations(
   storage: SqlStorage,
   annotationNamespace: string,
-  resolveEnumStorageKey: EnumStorageKeyResolver | undefined,
+  _resolveEnumNamespaceSchema: EnumNamespaceSchemaResolver | undefined,
 ): SqlAnnotations | undefined {
   const storageTypes: Record<string, StorageTypeInstance> = {};
 
-  // Top-level `storage.types`: codec-typed entries (vector, decimal, …) keyed
-  // by bare `nativeType` (unchanged). Post-S1.B enums live in
-  // `namespaces[*].entries.type`, not here; a defensive top-level enum is still
-  // namespace/schema-qualified via the resolver under the unbound coordinate
-  // so it never collides on a bare name.
   for (const typeInstance of Object.values((storage.types ?? {}) as ResolvedStorageTypes)) {
-    if (isPostgresEnumStorageEntry(typeInstance)) {
-      const key = resolveEnumStorageKey
-        ? resolveEnumStorageKey(storage, UNBOUND_NAMESPACE_ID, typeInstance.nativeType)
-        : typeInstance.nativeType;
-      storageTypes[key] = normalizeEnumAnnotation(typeInstance);
-      continue;
-    }
     if (isStorageTypeInstance(typeInstance)) {
       storageTypes[typeInstance.nativeType] = typeInstance;
     }
   }
 
-  // Namespace-scoped enums: schema-qualified compound key matching the target's
-  // `readExistingEnumValues` read side, so two namespaces sharing an enum name
-  // (or native type) resolve to distinct live-database types.
-  for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
-    const nsEnums = ns.entries['type'];
-    if (!nsEnums) continue;
-    for (const entry of Object.values(nsEnums)) {
-      if (!isPostgresEnumStorageEntry(entry)) continue;
-      const key = resolveEnumStorageKey
-        ? resolveEnumStorageKey(storage, namespaceId, entry.nativeType)
-        : entry.nativeType;
-      storageTypes[key] = normalizeEnumAnnotation(entry);
-    }
-  }
-
-  if (Object.keys(storageTypes).length === 0) return undefined;
-  return { [annotationNamespace]: { storageTypes } };
+  const envelope = {
+    ...(Object.keys(storageTypes).length > 0 ? { storageTypes } : {}),
+  };
+  if (Object.keys(envelope).length === 0) return undefined;
+  return { [annotationNamespace]: envelope };
 }

package/src/core/migrations/types.ts

@@ -251,7 +251,10 @@ export interface SqlMigrationPlan<TTargetDetails> extends MigrationPlan {
    * Destination contract identity that the plan intends to reach.
    */
   readonly destination: SqlMigrationPlanContractInfo;
-  readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+  readonly operations: readonly (
+    | SqlMigrationPlanOperation<TTargetDetails>
+    | Promise<SqlMigrationPlanOperation<TTargetDetails>>
+  )[];
   /**
    * Sorted, deduplicated invariant ids declared by this plan's data-transform
    * ops. Required at the SQL-family layer (the SQL runners consume this as

package/src/core/psl-contract-infer/postgres-type-map.ts

@@ -63,8 +63,6 @@ const PARAMETERIZED_NATIVE_TYPES: Record<
 
 const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
 
-const ENUM_CODEC_ID = 'pg/enum@1';
-
 function getOwnMappingValue(map: Record<string, string>, key: string): string | undefined {
   return Object.hasOwn(map, key) ? map[key] : undefined;
 }
@@ -132,21 +130,15 @@ export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslT
 
 export function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo {
   const pgAnnotations = annotations?.['pg'] as Record<string, unknown> | undefined;
-  const storageTypes = pgAnnotations?.['storageTypes'] as
-    | Record<string, { codecId: string; nativeType: string; typeParams?: Record<string, unknown> }>
-    | undefined;
+  const nativeEnumTypeNames = pgAnnotations?.['nativeEnumTypeNames'];
 
   const typeNames = new Set<string>();
   const definitions = new Map<string, readonly string[]>();
 
-  if (storageTypes) {
-    for (const [key, typeInstance] of Object.entries(storageTypes)) {
-      if (typeInstance.codecId === ENUM_CODEC_ID) {
-        typeNames.add(key);
-        const values = typeInstance.typeParams?.['values'];
-        if (Array.isArray(values)) {
-          definitions.set(key, values as string[]);
-        }
+  if (Array.isArray(nativeEnumTypeNames)) {
+    for (const name of nativeEnumTypeNames) {
+      if (typeof name === 'string') {
+        typeNames.add(name);
       }
     }
   }

package/src/core/psl-contract-infer/sql-schema-ir-to-psl-ast.ts

@@ -3,7 +3,6 @@ import type {
   PslAttribute,
   PslAttributeArgument,
   PslDocumentAst,
-  PslEnum,
   PslField,
   PslFieldAttribute,
   PslModel,
@@ -20,11 +19,10 @@ import {
 import type { SqlColumnIR, SqlSchemaIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
 import type { DefaultMappingOptions } from './default-mapping';
 import { mapDefault } from './default-mapping';
-import { toEnumName, toFieldName, toModelName, toNamedTypeName } from './name-transforms';
+import { toFieldName, toModelName, toNamedTypeName } from './name-transforms';
 import { createPostgresDefaultMapping } from './postgres-default-mapping';
 import { createPostgresTypeMap, extractEnumInfo } from './postgres-type-map';
 import type {
-  EnumInfo,
   PslNativeTypeAttribute,
   PslPrinterOptions,
   PslTypeMap,
@@ -82,10 +80,19 @@ type TopLevelNameResult = {
  */
 export function sqlSchemaIrToPslAst(schemaIR: SqlSchemaIR): PslDocumentAst {
   const enumInfo = extractEnumInfo(schemaIR.annotations);
+  if (enumInfo.typeNames.size > 0) {
+    const names = [...enumInfo.typeNames].join(', ');
+    throw new Error(
+      `contract infer: the database contains native Postgres enum type(s): ${names}. ` +
+        'Native Postgres enums (CREATE TYPE … AS ENUM) are not adoptable by contract infer. ' +
+        'Drop the native type and replace each column with a text column carrying a CHECK constraint, ' +
+        `then re-run contract infer. The domain enum (enum Name { @@type("pg/text@1") … }) authoring ` +
+        'surface generates the required check automatically.',
+    );
+  }
   const options: PslPrinterOptions = {
-    typeMap: createPostgresTypeMap(enumInfo.typeNames),
+    typeMap: createPostgresTypeMap(new Set()),
     defaultMapping: createPostgresDefaultMapping(),
-    enumInfo,
     parseRawDefault,
   };
 
@@ -93,12 +100,7 @@ export function sqlSchemaIrToPslAst(schemaIR: SqlSchemaIR): PslDocumentAst {
 }
 
 function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions): PslDocumentAst {
-  const { typeMap, defaultMapping, enumInfo, parseRawDefault: rawDefaultParser } = options;
-  const emptyEnumInfo: EnumInfo = {
-    typeNames: new Set<string>(),
-    definitions: new Map<string, readonly string[]>(),
-  };
-  const { typeNames: enumTypeNames, definitions: enumDefinitions } = enumInfo ?? emptyEnumInfo;
+  const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
 
   const modelNames = buildTopLevelNameMap(
     Object.keys(schemaIR.tables),
@@ -106,20 +108,15 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
     'model',
     'table',
   );
-  const enumNames = buildTopLevelNameMap(enumTypeNames, toEnumName, 'enum', 'enum type');
-  assertNoCrossKindNameCollisions(modelNames, enumNames);
 
   const modelNameMap = new Map(
     [...modelNames].map(([tableName, result]) => [tableName, result.name]),
   );
-  const enumNameMap = new Map(
-    [...enumNames].map(([pgTypeName, result]) => [pgTypeName, result.name]),
-  );
-  const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames, enumNames);
+  const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
 
   const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
   const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-  const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNamedTypeNames);
+  const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, new Map(), reservedNamedTypeNames);
 
   const models: PslModel[] = [];
   for (const table of Object.values(schemaIR.tables)) {
@@ -127,7 +124,7 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
       buildModel(
         table,
         typeMap,
-        enumNameMap,
+        new Map(),
         fieldNamesByTable,
         namedTypes,
         defaultMapping,
@@ -139,13 +136,6 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
 
   const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
 
-  const enums: PslEnum[] = [];
-  for (const [pgTypeName, values] of enumDefinitions) {
-    const enumName = enumNames.get(pgTypeName) as TopLevelNameResult;
-    enums.push(buildEnum(enumName, values));
-  }
-  enums.sort((a, b) => a.name.localeCompare(b.name));
-
   const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) =>
     a.name.localeCompare(b.name),
   );
@@ -171,7 +161,7 @@ function buildPslDocumentAst(schemaIR: SqlSchemaIR, options: PslPrinterOptions):
       makePslNamespace({
         kind: 'namespace',
         name: UNSPECIFIED_PSL_NAMESPACE_ID,
-        entries: makePslNamespaceEntries(sortedModels, enums, [], []),
+        entries: makePslNamespaceEntries(sortedModels, [], []),
         span: SYNTHETIC_SPAN,
       }),
     ],
@@ -485,24 +475,6 @@ function namedArg(name: string, value: string): PslAttributeArgument {
   return { kind: 'named', name, value, span: SYNTHETIC_SPAN };
 }
 
-function buildEnum(name: TopLevelNameResult, values: readonly string[]): PslEnum {
-  const attrs: PslAttribute[] = [];
-  if (name.map) {
-    attrs.push(buildMapAttribute('enum', name.map));
-  }
-  return {
-    kind: 'enum',
-    name: name.name,
-    values: values.map((value) => ({
-      kind: 'enumValue',
-      name: value,
-      span: SYNTHETIC_SPAN,
-    })),
-    attributes: attrs,
-    span: SYNTHETIC_SPAN,
-  };
-}
-
 function buildNamedTypeDeclaration(entry: NamedTypeRegistryEntry): PslNamedTypeDeclaration {
   const attribute = buildAttribute(
     'namedType',
@@ -647,29 +619,8 @@ function buildTopLevelNameMap(
   return results;
 }
 
-function assertNoCrossKindNameCollisions(
-  modelNames: ReadonlyMap<string, TopLevelNameResult>,
-  enumNames: ReadonlyMap<string, TopLevelNameResult>,
-): void {
-  const enumSourceByName = new Map([...enumNames].map(([source, result]) => [result.name, source]));
-
-  const collisions = [...modelNames.entries()]
-    .map(([tableName, result]) => {
-      const enumSource = enumSourceByName.get(result.name);
-      return enumSource
-        ? `- identifier "${result.name}" from table "${tableName}" collides with enum type "${enumSource}"`
-        : undefined;
-    })
-    .filter((detail): detail is string => detail !== undefined);
-
-  if (collisions.length > 0) {
-    throw new Error(`PSL top-level name collisions detected:\n${collisions.join('\n')}`);
-  }
-}
-
 function createReservedNamedTypeNames(
   modelNames: ReadonlyMap<string, TopLevelNameResult>,
-  enumNames: ReadonlyMap<string, TopLevelNameResult>,
 ): Set<string> {
   const reservedNames = new Set<string>(PSL_SCALAR_TYPE_NAMES);
 
@@ -677,10 +628,6 @@ function createReservedNamedTypeNames(
     reservedNames.add(result.name);
   }
 
-  for (const result of enumNames.values()) {
-    reservedNames.add(result.name);
-  }
-
   return reservedNames;
 }