@prisma-next/target-postgres 0.13.0 → 0.14.0

package/src/core/codecs.ts

@@ -36,10 +36,10 @@ import {
   sqlTimestampDescriptor,
   sqlVarcharDescriptor,
 } from '@prisma-next/sql-relational-core/ast';
+import { blindCast } from '@prisma-next/utils/casts';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { type as arktype } from 'arktype';
 import {
-  pgEnumRenderOutputType,
   pgIntervalDecode,
   pgJsonbDecode,
   pgJsonbEncode,
@@ -59,7 +59,6 @@ import {
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
-  PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
@@ -77,6 +76,7 @@ import {
   PG_TIMESTAMP_CODEC_ID,
   PG_TIMESTAMPTZ_CODEC_ID,
   PG_TIMETZ_CODEC_ID,
+  PG_UUID_CODEC_ID,
   PG_VARBIT_CODEC_ID,
   PG_VARCHAR_CODEC_ID,
 } from './codec-ids';
@@ -84,7 +84,6 @@ import {
 type LengthParams = { readonly length?: number };
 type PrecisionParams = { readonly precision?: number };
 type NumericParams = { readonly precision: number; readonly scale?: number };
-type EnumParams = { readonly values?: readonly string[] };
 
 const lengthParamsSchema = arktype({
   'length?': 'number.integer > 0',
@@ -789,64 +788,58 @@ export const pgByteaColumn = () =>
 pgByteaColumn satisfies ColumnHelperFor<PgByteaDescriptor>;
 pgByteaColumn satisfies ColumnHelperForStrict<PgByteaDescriptor>;
 
-export class PgIntervalCodec extends CodecImpl<
-  typeof PG_INTERVAL_CODEC_ID,
+const PG_UUID_META = { db: { sql: { postgres: { nativeType: 'uuid' } } } } as const;
+
+export class PgUuidCodec extends CodecImpl<
+  typeof PG_UUID_CODEC_ID,
   readonly ['equality', 'order'],
-  string | Record<string, unknown>,
+  string,
   string
 > {
   async encode(value: string, _ctx: CodecCallContext): Promise<string> {
     return value;
   }
-  async decode(wire: string | Record<string, unknown>, _ctx: CodecCallContext): Promise<string> {
-    return pgIntervalDecode(wire);
+  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
+    return wire;
   }
   encodeJson(value: string): JsonValue {
     return value;
   }
   decodeJson(json: JsonValue): string {
-    return json as string;
+    return blindCast<string, 'uuid columns serialize to JSON as their wire string form'>(json);
   }
 }
 
-export class PgIntervalDescriptor extends CodecDescriptorImpl<PrecisionParams> {
-  override readonly codecId = PG_INTERVAL_CODEC_ID;
+export class PgUuidDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = PG_UUID_CODEC_ID;
   override readonly traits = ['equality', 'order'] as const;
-  override readonly targetTypes = ['interval'] as const;
-  override readonly meta = PG_INTERVAL_META;
-  override readonly paramsSchema =
-    precisionParamsSchema satisfies StandardSchemaV1<PrecisionParams>;
-  override renderOutputType(params: PrecisionParams): string | undefined {
-    return renderPrecision('Interval', params as Record<string, unknown>);
-  }
-  override factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgIntervalCodec {
-    return () => new PgIntervalCodec(this);
+  override readonly targetTypes = ['uuid'] as const;
+  override readonly meta = PG_UUID_META;
+  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => PgUuidCodec {
+    return () => new PgUuidCodec(this);
   }
 }
 
-export const pgIntervalDescriptor = new PgIntervalDescriptor();
+export const pgUuidDescriptor = new PgUuidDescriptor();
 
-export const pgIntervalColumn = (params: PrecisionParams = {}) =>
-  column(pgIntervalDescriptor.factory(params), pgIntervalDescriptor.codecId, params, 'interval');
+export const pgUuidColumn = () =>
+  column(pgUuidDescriptor.factory(), pgUuidDescriptor.codecId, undefined, 'uuid');
 
-pgIntervalColumn satisfies ColumnHelperFor<PgIntervalDescriptor>;
-pgIntervalColumn satisfies ColumnHelperForStrict<PgIntervalDescriptor>;
-
-const enumParamsSchema = arktype({
-  'values?': 'string[]',
-});
+pgUuidColumn satisfies ColumnHelperFor<PgUuidDescriptor>;
+pgUuidColumn satisfies ColumnHelperForStrict<PgUuidDescriptor>;
 
-export class PgEnumCodec extends CodecImpl<
-  typeof PG_ENUM_CODEC_ID,
+export class PgIntervalCodec extends CodecImpl<
+  typeof PG_INTERVAL_CODEC_ID,
   readonly ['equality', 'order'],
-  string,
+  string | Record<string, unknown>,
   string
 > {
   async encode(value: string, _ctx: CodecCallContext): Promise<string> {
     return value;
   }
-  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
-    return wire;
+  async decode(wire: string | Record<string, unknown>, _ctx: CodecCallContext): Promise<string> {
+    return pgIntervalDecode(wire);
   }
   encodeJson(value: string): JsonValue {
     return value;
@@ -856,26 +849,28 @@ export class PgEnumCodec extends CodecImpl<
   }
 }
 
-export class PgEnumDescriptor extends CodecDescriptorImpl<EnumParams> {
-  override readonly codecId = PG_ENUM_CODEC_ID;
+export class PgIntervalDescriptor extends CodecDescriptorImpl<PrecisionParams> {
+  override readonly codecId = PG_INTERVAL_CODEC_ID;
   override readonly traits = ['equality', 'order'] as const;
-  override readonly targetTypes = ['enum'] as const;
-  override readonly paramsSchema = enumParamsSchema satisfies StandardSchemaV1<EnumParams>;
-  override renderOutputType(params: EnumParams): string | undefined {
-    return pgEnumRenderOutputType(params);
+  override readonly targetTypes = ['interval'] as const;
+  override readonly meta = PG_INTERVAL_META;
+  override readonly paramsSchema =
+    precisionParamsSchema satisfies StandardSchemaV1<PrecisionParams>;
+  override renderOutputType(params: PrecisionParams): string | undefined {
+    return renderPrecision('Interval', params as Record<string, unknown>);
   }
-  override factory(_params: EnumParams): (ctx: CodecInstanceContext) => PgEnumCodec {
-    return () => new PgEnumCodec(this);
+  override factory(_params: PrecisionParams): (ctx: CodecInstanceContext) => PgIntervalCodec {
+    return () => new PgIntervalCodec(this);
   }
 }
 
-export const pgEnumDescriptor = new PgEnumDescriptor();
+export const pgIntervalDescriptor = new PgIntervalDescriptor();
 
-export const pgEnumColumn = (params: EnumParams = {}) =>
-  column(pgEnumDescriptor.factory(params), pgEnumDescriptor.codecId, params, 'enum');
+export const pgIntervalColumn = (params: PrecisionParams = {}) =>
+  column(pgIntervalDescriptor.factory(params), pgIntervalDescriptor.codecId, params, 'interval');
 
-pgEnumColumn satisfies ColumnHelperFor<PgEnumDescriptor>;
-pgEnumColumn satisfies ColumnHelperForStrict<PgEnumDescriptor>;
+pgIntervalColumn satisfies ColumnHelperFor<PgIntervalDescriptor>;
+pgIntervalColumn satisfies ColumnHelperForStrict<PgIntervalDescriptor>;
 
 export class PgJsonCodec extends CodecImpl<
   typeof PG_JSON_CODEC_ID,
@@ -1075,8 +1070,8 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   pgBitDescriptor,
   pgVarbitDescriptor,
   pgByteaDescriptor,
+  pgUuidDescriptor,
   pgIntervalDescriptor,
-  pgEnumDescriptor,
   pgJsonDescriptor,
   pgJsonbDescriptor,
   pgTextArrayDescriptor,

package/src/core/ddl/nodes.ts

@@ -4,9 +4,44 @@ import {
   type DdlTableConstraint,
 } from '@prisma-next/sql-relational-core/ast';
 
+// ---------------------------------------------------------------------------
+// AlterTableAction — nested polymorphic hierarchy
+// ---------------------------------------------------------------------------
+
+export interface AlterTableActionVisitor<R> {
+  addColumn(action: AddColumnAction): R;
+}
+
+export abstract class AlterTableAction {
+  abstract readonly kind: string;
+  abstract accept<R>(visitor: AlterTableActionVisitor<R>): R;
+}
+
+export class AddColumnAction extends AlterTableAction {
+  readonly kind = 'add-column' as const;
+  readonly column: DdlColumn;
+
+  constructor(column: DdlColumn) {
+    super();
+    this.column = column;
+    Object.freeze(this);
+  }
+
+  override accept<R>(visitor: AlterTableActionVisitor<R>): R {
+    return visitor.addColumn(this);
+  }
+}
+
+export type AnyAlterTableAction = AddColumnAction;
+
+// ---------------------------------------------------------------------------
+// Top-level DDL visitor
+// ---------------------------------------------------------------------------
+
 export interface PostgresDdlVisitor<R> {
   createTable(node: PostgresCreateTable): R;
   createSchema(node: PostgresCreateSchema): R;
+  alterTable(node: PostgresAlterTable): R;
 }
 
 export abstract class PostgresDdlNode extends DdlNode {
@@ -69,4 +104,27 @@ export class PostgresCreateSchema extends PostgresDdlNode {
   }
 }
 
-export type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema;
+export class PostgresAlterTable extends PostgresDdlNode {
+  readonly kind = 'alter-table' as const;
+  readonly table: string;
+  readonly schema: string | undefined;
+  readonly actions: ReadonlyArray<AnyAlterTableAction>;
+
+  constructor(options: {
+    readonly table: string;
+    readonly schema?: string;
+    readonly actions: readonly AnyAlterTableAction[];
+  }) {
+    super();
+    this.table = options.table;
+    this.schema = options.schema;
+    this.actions = Object.freeze([...options.actions]);
+    this.freeze();
+  }
+
+  override accept<R>(visitor: PostgresDdlVisitor<R>): R {
+    return visitor.alterTable(this);
+  }
+}
+
+export type AnyPostgresDdlNode = PostgresCreateTable | PostgresCreateSchema | PostgresAlterTable;

package/src/core/migrations/control-policy.ts

@@ -1,12 +1,8 @@
 import type { Contract } from '@prisma-next/contract/types';
 import type { ControlPolicySubject } from '@prisma-next/family-sql/control';
 import type { SchemaIssue } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import {
-  isPostgresEnumStorageEntry,
-  type SqlStorage,
-  storageTableAt,
-} from '@prisma-next/sql-contract/types';
+import { entityAt, UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import type { SqlStorage, StorageTable } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { isPostgresSchema } from '../postgres-schema';
 import type { PostgresOpFactoryCall } from './op-factory-call';
@@ -24,7 +20,6 @@ import type { PostgresOpFactoryCall } from './op-factory-call';
  */
 const OBJECT_CREATION_FACTORIES: ReadonlySet<string> = new Set<string>([
   'createTable',
-  'createEnumType',
   'createSchema',
 ]);
 
@@ -43,7 +38,11 @@ function resolveNamespaceIdForTable(
   ddlSchemaName: string | undefined,
 ): string {
   for (const namespaceId of Object.keys(contract.storage.namespaces)) {
-    const table = storageTableAt(contract.storage, namespaceId, tableName);
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
     if (!table) continue;
     if (
       ddlSchemaName === undefined ||
@@ -75,7 +74,6 @@ interface PostgresCallFields {
   readonly schemaName?: string;
   readonly tableName?: string;
   readonly columnName?: string;
-  readonly typeName?: string;
 }
 
 function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
@@ -83,7 +81,6 @@ function postgresCallFields(call: PostgresOpFactoryCall): PostgresCallFields {
     ...ifDefined('schemaName', 'schemaName' in call ? call.schemaName : undefined),
     ...ifDefined('tableName', 'tableName' in call ? call.tableName : undefined),
     ...ifDefined('columnName', 'columnName' in call ? call.columnName : undefined),
-    ...ifDefined('typeName', 'typeName' in call ? call.typeName : undefined),
   };
 }
 
@@ -96,10 +93,6 @@ export function formatPostgresControlPolicySubjectLabel(
     const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
     return `${factoryName}(${ddlSchema}.${subject.table})`;
   }
-  if (subject?.typeName) {
-    const ddlSchema = ddlSchemaNameForNamespace(contract, subject.namespaceId);
-    return `${factoryName}(${ddlSchema}.${subject.typeName})`;
-  }
   return factoryName;
 }
 
@@ -117,29 +110,17 @@ export function resolvePostgresCallControlPolicySubject(
     };
   }
 
-  if (callFields.typeName && call.factoryName !== 'addColumn') {
-    const namespaceId = callFields.schemaName
-      ? resolveNamespaceIdForDdlSchema(contract, callFields.schemaName)
-      : UNBOUND_NAMESPACE_ID;
-    const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[callFields.typeName] : undefined;
-    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
-    return {
-      namespaceId,
-      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
-      typeName: callFields.typeName,
-      createsNewObject,
-    };
-  }
-
   if (callFields.tableName) {
     const namespaceId = resolveNamespaceIdForTable(
       contract,
       callFields.tableName,
       callFields.schemaName,
     );
-    const table = storageTableAt(contract.storage, namespaceId, callFields.tableName);
-    const tableControlPolicy = table?.control;
+    const tableControlPolicy = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: callFields.tableName,
+    })?.control;
     return {
       namespaceId,
       ...ifDefined('explicitNodeControlPolicy', tableControlPolicy),
@@ -170,7 +151,6 @@ export function resolvePostgresCallControlPolicySubject(
 const POSTGRES_ISSUE_CREATION_FACTORY: Readonly<Record<string, string>> = Object.freeze({
   missing_schema: 'createSchema',
   missing_table: 'createTable',
-  type_missing: 'createEnumType',
 });
 
 export function resolvePostgresIssueCreationFactoryName(issue: SchemaIssue): string | undefined {
@@ -201,26 +181,16 @@ export function resolvePostgresIssueControlPolicySubject(
     return { namespaceId: issue.namespaceId, createsNewObject };
   }
 
-  if ('typeName' in issue && issue.typeName) {
-    const namespaceId =
-      'namespaceId' in issue && issue.namespaceId ? issue.namespaceId : UNBOUND_NAMESPACE_ID;
-    const ns = contract.storage.namespaces[namespaceId];
-    const rawEnum = isPostgresSchema(ns) ? ns.entries.type[issue.typeName] : undefined;
-    const controlPolicy = isPostgresEnumStorageEntry(rawEnum) ? rawEnum.control : undefined;
-    return {
-      namespaceId,
-      ...ifDefined('explicitNodeControlPolicy', controlPolicy),
-      typeName: issue.typeName,
-      createsNewObject,
-    };
-  }
-
   if ('table' in issue && issue.table) {
     const namespaceId =
       'namespaceId' in issue && issue.namespaceId
         ? issue.namespaceId
         : resolveNamespaceIdForTable(contract, issue.table, undefined);
-    const table = storageTableAt(contract.storage, namespaceId, issue.table);
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: issue.table,
+    });
     return {
       namespaceId,
       ...ifDefined('explicitNodeControlPolicy', table?.control),

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

@@ -8,7 +8,7 @@
  * through `mapIssueToCall` for the default case.
  */
 
-import type { Contract } from '@prisma-next/contract/types';
+import type { Contract, JsonValue } from '@prisma-next/contract/types';
 import type {
   CodecControlHooks,
   MigrationOperationPolicy,
@@ -19,26 +19,24 @@ 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,
   StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
-import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
+import type { CodecRef, DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';
 import * as contractFree from '@prisma-next/sql-relational-core/contract-free';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+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,
@@ -54,7 +52,7 @@ import {
   SetDefaultCall,
   SetNotNullCall,
 } from './op-factory-call';
-import type { ColumnSpec, ForeignKeySpec } from './operations/shared';
+import type { ForeignKeySpec } from './operations/shared';
 import { buildColumnDefaultSql, buildColumnTypeSql } from './planner-ddl-builders';
 import { buildExpectedFormatType } from './planner-sql-checks';
 import {
@@ -65,22 +63,10 @@ import {
   type StrategyContext,
   tableAt,
 } from './planner-strategies';
+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.entries.type[typeName] : undefined;
-}
-
 // ============================================================================
 // Issue kind ordering (dependency order)
 // ============================================================================
@@ -165,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-
@@ -192,31 +178,35 @@ export interface IssuePlannerValue {
   readonly calls: readonly PostgresOpFactoryCall[];
 }
 
-function toColumnSpec(
-  name: string,
-  column: StorageColumn,
-  codecHooks: ReadonlyMap<string, CodecControlHooks>,
-  storageTypes: Readonly<Record<string, StorageTypeInstance | PostgresEnumStorageEntry>>,
-): ColumnSpec {
-  return {
-    name,
-    typeSql: buildColumnTypeSql(column, codecHooks, storageTypes),
-    defaultSql: buildColumnDefaultSql(column.default, column),
-    nullable: column.nullable,
-  };
-}
-
 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>,
+  );
+  const codecRef: CodecRef | undefined = resolved.codecId
+    ? {
+        codecId: resolved.codecId,
+        ...(resolved.typeParams !== undefined
+          ? {
+              typeParams: blindCast<
+                JsonValue,
+                'resolved.typeParams is JsonValue-shaped storage metadata; the narrowed (non-undefined) value lands in CodecRef.typeParams which is JsonValue'
+              >(resolved.typeParams),
+            }
+          : {}),
+      }
+    : undefined;
   return contractFree.col(name, typeSql, {
     ...(!column.nullable ? { notNull: true } : {}),
-    ...(ddlDefault ? { default: ddlDefault } : {}),
+    ...ifDefined('default', ddlDefault),
+    ...ifDefined('codecRef', codecRef),
   });
 }
 
@@ -342,7 +332,7 @@ function mapIssueToCall(
           new AddColumnCall(
             tableSchema(issue),
             issue.table,
-            toColumnSpec(issue.column, column, codecHooks, storageTypes),
+            toDdlColumn(issue.column, column, codecHooks, storageTypes),
           ),
         ]);
       }
@@ -475,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([
@@ -666,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(
@@ -682,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`,
         ),
       );
     }
@@ -744,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':
@@ -971,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.