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

package/src/core/migrations/issue-planner.ts

@@ -19,7 +19,6 @@ import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
 import type {
-  PostgresEnumStorageEntry,
   SqlStorage,
   StorageColumn,
   StorageTable,
@@ -32,15 +31,12 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok } from '@prisma-next/utils/result';
-import { PostgresEnumType } from '../postgres-enum-type';
-import { isPostgresSchema } from '../postgres-schema';
 import {
   AddColumnCall,
   AddForeignKeyCall,
   AddPrimaryKeyCall,
   AddUniqueCall,
   AlterColumnTypeCall,
-  CreateEnumTypeCall,
   CreateIndexCall,
   CreateSchemaCall,
   CreateTableCall,
@@ -71,19 +67,6 @@ import { resolveColumnTypeMetadata } from './planner-type-resolution';
 
 export type { CallMigrationStrategy, StrategyContext };
 
-/**
- * Finds a type entry by explicit namespace coordinate. Reads the named
- * namespace's `enum` slot directly — never scans other namespaces.
- */
-function locateNamespaceTypeInStorage(
-  storage: SqlStorage,
-  namespaceId: string,
-  typeName: string,
-): unknown {
-  const ns = storage.namespaces[namespaceId];
-  return isPostgresSchema(ns) ? ns.type[typeName] : undefined;
-}
-
 // ============================================================================
 // Issue kind ordering (dependency order)
 // ============================================================================
@@ -168,7 +151,7 @@ export interface IssuePlannerOptions {
   readonly fromContract: Contract<SqlStorage> | null;
   readonly schemaName: string;
   readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
-  readonly storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>;
+  readonly storageTypes: Readonly<Record<string, StorageTypeInstance>>;
   /**
    * Current database schema IR. Strategies read this to detect whether a
    * structure already exists (e.g. `buildSchemaLookupMap` for shared-temp-
@@ -199,13 +182,13 @@ function toDdlColumn(
   name: string,
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
+  storageTypes: Readonly<Record<string, StorageTypeInstance>>,
 ): DdlColumn {
   const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
   const ddlDefault = postgresDefaultToDdlColumnDefault(column.default);
   const resolved = resolveColumnTypeMetadata(
     column,
-    storageTypes as Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    storageTypes as Record<string, StorageTypeInstance>,
   );
   const codecRef: CodecRef | undefined = resolved.codecId
     ? {
@@ -482,10 +465,7 @@ function mapIssueToCall(
             ),
           );
         const hooksMap = codecHooks as Map<string, CodecControlHooks>;
-        const typesMap = storageTypes as Record<
-          string,
-          StorageTypeInstance | PostgresEnumStorageEntry
-        >;
+        const typesMap = storageTypes as Record<string, StorageTypeInstance>;
         const qualifiedTargetType = buildColumnTypeSql(column, hooksMap, typesMap, false);
         const formatTypeExpected = buildExpectedFormatType(column, hooksMap, typesMap);
         return ok([
@@ -673,14 +653,7 @@ function mapIssueToCall(
     case 'type_missing': {
       if (!issue.typeName)
         return notOk(issueConflict('unsupportedOperation', 'Type missing issue has no typeName'));
-      // Codec aliases live in storage.types; enum types live in namespace.entries.type.
-      // Check types first; fall back to the namespace-keyed enum slot using the
-      // issue's namespace coordinate (populated by the verifier for enum-related
-      // issues per the BaseSchemaIssue.namespaceId contract).
-      const namespaceId = resolveNamespaceIdForIssue(issue);
-      const typeInstance: unknown =
-        ctx.toContract.storage.types?.[issue.typeName] ??
-        locateNamespaceTypeInStorage(ctx.toContract.storage, namespaceId, issue.typeName);
+      const typeInstance = ctx.toContract.storage.types?.[issue.typeName];
       if (!typeInstance) {
         return notOk(
           issueConflict(
@@ -689,22 +662,10 @@ function mapIssueToCall(
           ),
         );
       }
-      if (typeInstance instanceof PostgresEnumType) {
-        const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
-        return ok([
-          new CreateEnumTypeCall(
-            ddlSchema,
-            issue.typeName,
-            typeInstance.values,
-            typeInstance.nativeType,
-          ),
-        ]);
-      }
-      const codecInstance = typeInstance as StorageTypeInstance;
       return notOk(
         issueConflict(
           'unsupportedOperation',
-          `Type "${issue.typeName}" uses codec "${codecInstance.codecId}" — only enum types are supported`,
+          `Type "${issue.typeName}" uses codec "${typeInstance.codecId}" — only value-set types are supported`,
         ),
       );
     }
@@ -751,10 +712,6 @@ function classifyCall(call: PostgresOpFactoryCall): CallCategory {
   switch (call.factoryName) {
     case 'createExtension':
     case 'createSchema':
-    case 'createEnumType':
-    case 'addEnumValues':
-    case 'dropEnumType':
-    case 'renameType':
       return 'dep';
     case 'dropTable':
     case 'dropColumn':
@@ -978,10 +935,10 @@ export function planIssues(
     return notOk(conflicts);
   }
 
-  // Recipe strategies (`nativeEnumPlanCallStrategy`,
-  // `notNullBackfillCallStrategy`, etc.) emit a cohesive sequence that must
+  // Recipe strategies (`notNullBackfillCallStrategy`,
+  // `nullableTighteningCallStrategy`, etc.) emit a cohesive sequence that must
   // stay contiguous. They are inserted at a single pattern slot. Non-recipe
-  // pattern strategies (`dependencyInstallCallStrategy`,
+  // pattern strategies (`checkConstraintPlanCallStrategy`,
   // `storageTypePlanCallStrategy`, `notNullAddColumnCallStrategy`) produce
   // individually classifiable calls that slot into DDL buckets alongside
   // default-mapped calls.

package/src/core/migrations/op-factory-call.ts

@@ -57,7 +57,6 @@ import {
   dropConstraint,
 } from './operations/constraints';
 import { createExtension } from './operations/dependencies';
-import { addEnumValues, createEnumType, dropEnumType, renameType } from './operations/enums';
 import { createIndex, dropIndex } from './operations/indexes';
 import type { ForeignKeySpec } from './operations/shared';
 import { step, targetDetails } from './operations/shared';
@@ -809,8 +808,8 @@ export class CreateIndexCall extends PostgresOpFactoryCallNode {
   readonly tableName: string;
   readonly indexName: string;
   readonly columns: readonly string[];
-  // Named indexType (not typeName) to avoid collision with CreateEnumTypeCall.typeName,
-  // which identifies a CREATE TYPE target and is read by `locationForCall` in issue-planner.ts.
+  // Named indexType (not typeName): `locationForCall` in issue-planner.ts reads
+  // a call's `typeName` as a CREATE TYPE target location, which an index is not.
   readonly indexType: string | undefined;
   readonly options: Record<string, unknown> | undefined;
   readonly label: string;
@@ -883,123 +882,6 @@ export class DropIndexCall extends PostgresOpFactoryCallNode {
   }
 }
 
-// ============================================================================
-// Enum types
-// ============================================================================
-
-export class CreateEnumTypeCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'createEnumType' as const;
-  readonly operationClass = 'additive' as const;
-  readonly schemaName: string;
-  readonly typeName: string;
-  readonly nativeType: string;
-  readonly values: readonly string[];
-  readonly label: string;
-
-  constructor(
-    schemaName: string,
-    typeName: string,
-    values: readonly string[],
-    nativeType: string = typeName,
-  ) {
-    super();
-    this.schemaName = schemaName;
-    this.typeName = typeName;
-    this.nativeType = nativeType;
-    this.values = values;
-    this.label = `Create enum type "${typeName}"`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return createEnumType(this.schemaName, this.typeName, this.values, this.nativeType);
-  }
-
-  renderTypeScript(): string {
-    const nativeArg =
-      this.nativeType === this.typeName ? '' : `, ${jsonToTsSource(this.nativeType)}`;
-    return `createEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.values)}${nativeArg})`;
-  }
-}
-
-export class AddEnumValuesCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'addEnumValues' as const;
-  readonly operationClass = 'additive' as const;
-  readonly schemaName: string;
-  readonly typeName: string;
-  readonly nativeType: string;
-  readonly values: readonly string[];
-  readonly label: string;
-
-  constructor(schemaName: string, typeName: string, nativeType: string, values: readonly string[]) {
-    super();
-    this.schemaName = schemaName;
-    this.typeName = typeName;
-    this.nativeType = nativeType;
-    this.values = values;
-    this.label = `Add values to enum type "${typeName}": ${values.join(', ')}`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return addEnumValues(this.schemaName, this.typeName, this.nativeType, this.values);
-  }
-
-  renderTypeScript(): string {
-    return `addEnumValues(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)}, ${jsonToTsSource(this.nativeType)}, ${jsonToTsSource(this.values)})`;
-  }
-}
-
-export class DropEnumTypeCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'dropEnumType' as const;
-  readonly operationClass = 'destructive' as const;
-  readonly schemaName: string;
-  readonly typeName: string;
-  readonly label: string;
-
-  constructor(schemaName: string, typeName: string) {
-    super();
-    this.schemaName = schemaName;
-    this.typeName = typeName;
-    this.label = `Drop enum type "${typeName}"`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return dropEnumType(this.schemaName, this.typeName);
-  }
-
-  renderTypeScript(): string {
-    return `dropEnumType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.typeName)})`;
-  }
-}
-
-export class RenameTypeCall extends PostgresOpFactoryCallNode {
-  readonly factoryName = 'renameType' as const;
-  readonly operationClass = 'destructive' as const;
-  readonly schemaName: string;
-  readonly fromName: string;
-  readonly toName: string;
-  readonly label: string;
-
-  constructor(schemaName: string, fromName: string, toName: string) {
-    super();
-    this.schemaName = schemaName;
-    this.fromName = fromName;
-    this.toName = toName;
-    this.label = `Rename type "${fromName}" to "${toName}"`;
-    this.freeze();
-  }
-
-  toOp(): Op {
-    return renameType(this.schemaName, this.fromName, this.toName);
-  }
-
-  renderTypeScript(): string {
-    return `renameType(${jsonToTsSource(this.schemaName)}, ${jsonToTsSource(this.fromName)}, ${jsonToTsSource(this.toName)})`;
-  }
-}
-
 // ============================================================================
 // Raw SQL
 // ============================================================================
@@ -1190,10 +1072,6 @@ export type PostgresOpFactoryCall =
   | CreateIndexCall
   | DropIndexCall
   | DropConstraintCall
-  | CreateEnumTypeCall
-  | AddEnumValuesCall
-  | DropEnumTypeCall
-  | RenameTypeCall
   | RawSqlCall
   | CreateExtensionCall
   | CreateSchemaCall

package/src/core/migrations/planner-ddl-builders.ts

@@ -1,6 +1,5 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
 import type {
-  PostgresEnumStorageEntry,
   StorageColumn,
   StorageTable,
   StorageTypeInstance,
@@ -14,7 +13,7 @@ export function buildCreateTableSql(
   qualifiedTableName: string,
   table: StorageTable,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const columnDefinitions = Object.entries(table.columns).map(
     ([columnName, column]: [string, StorageColumn]) => {
@@ -79,7 +78,7 @@ function assertSafeDefaultExpression(expression: string): void {
 export function buildColumnTypeSql(
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
   allowPseudoTypes = true,
 ): string {
   const resolved = resolveColumnTypeMetadata(column, storageTypes);
@@ -200,7 +199,7 @@ export function buildAddColumnSql(
   column: StorageColumn,
   codecHooks: ReadonlyMap<string, CodecControlHooks>,
   temporaryDefault?: string | null,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
   const defaultSql =

package/src/core/migrations/planner-identity-values.ts

@@ -1,12 +1,6 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-  type StorageColumn,
-  type StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
-import type { PostgresEnumType } from '../postgres-enum-type';
 
 /**
  * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.
@@ -16,30 +10,12 @@ import type { PostgresEnumType } from '../postgres-enum-type';
 export function resolveIdentityValue(
   column: StorageColumn,
   codecHooks: Map<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string | null {
   const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;
-  const referencedIsEnum =
-    referencedType !== undefined && isPostgresEnumStorageEntry(referencedType);
-  const referencedBinding = referencedIsEnum
-    ? ((referencedType as PostgresEnumType).codecBinding ?? {
-        codecId: (referencedType as PostgresEnumStorageEntry).codecId,
-        typeParams: { values: (referencedType as PostgresEnumStorageEntry).values },
-      })
-    : undefined;
-  const codecId =
-    referencedBinding?.codecId ??
-    (referencedType && !referencedIsEnum
-      ? (referencedType as StorageTypeInstance).codecId
-      : undefined) ??
-    column.codecId;
+  const codecId = referencedType?.codecId ?? column.codecId;
   const nativeType = referencedType?.nativeType ?? column.nativeType;
-  const typeParams =
-    (referencedBinding?.typeParams as Record<string, unknown> | undefined) ??
-    (referencedType && !referencedIsEnum
-      ? (referencedType as StorageTypeInstance).typeParams
-      : undefined) ??
-    column.typeParams;
+  const typeParams = referencedType?.typeParams ?? column.typeParams;
 
   if (codecId) {
     const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({

package/src/core/migrations/planner-recipes.ts

@@ -1,9 +1,5 @@
 import type { CodecControlHooks, SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type {
-  PostgresEnumStorageEntry,
-  StorageColumn,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { quoteIdentifier } from '../sql-utils';
 import { buildAddColumnSql } from './planner-ddl-builders';
 import {
@@ -39,7 +35,7 @@ export function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
   readonly columnName: string;
   readonly column: StorageColumn;
   readonly codecHooks: Map<string, CodecControlHooks>;
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly temporaryDefault: string;
 }): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
   const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } =

package/src/core/migrations/planner-sql-checks.ts

@@ -1,9 +1,5 @@
 import type { CodecControlHooks } from '@prisma-next/family-sql/control';
-import type {
-  PostgresEnumStorageEntry,
-  StorageColumn,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { postgresCreateNamespace } from '../postgres-schema';
 import { escapeLiteral, quoteIdentifier } from '../sql-utils';
 import { resolveColumnTypeMetadata } from './planner-type-resolution';
@@ -249,7 +245,7 @@ function formatUserDefinedTypeName(identifier: string): string {
 export function buildExpectedFormatType(
   column: StorageColumn,
   codecHooks: Map<string, CodecControlHooks>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {},
+  storageTypes: Record<string, StorageTypeInstance> = {},
 ): string {
   const resolved = resolveColumnTypeMetadata(column, storageTypes);