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

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.13.0-dev.3",
+  "version": "0.13.0-dev.30",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "SQL-specific TypeScript contract authoring surface for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.13.0-dev.3",
-    "@prisma-next/contract": "0.13.0-dev.3",
-    "@prisma-next/contract-authoring": "0.13.0-dev.3",
-    "@prisma-next/framework-components": "0.13.0-dev.3",
-    "@prisma-next/sql-contract": "0.13.0-dev.3",
-    "@prisma-next/utils": "0.13.0-dev.3",
+    "@prisma-next/config": "0.13.0-dev.30",
+    "@prisma-next/contract": "0.13.0-dev.30",
+    "@prisma-next/contract-authoring": "0.13.0-dev.30",
+    "@prisma-next/framework-components": "0.13.0-dev.30",
+    "@prisma-next/sql-contract": "0.13.0-dev.30",
+    "@prisma-next/utils": "0.13.0-dev.30",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0-dev.3",
-    "@prisma-next/tsconfig": "0.13.0-dev.3",
+    "@prisma-next/test-utils": "0.13.0-dev.30",
+    "@prisma-next/tsconfig": "0.13.0-dev.30",
     "@types/pg": "8.20.0",
     "pg": "8.21.0",
-    "@prisma-next/tsdown": "0.13.0-dev.3",
+    "@prisma-next/tsdown": "0.13.0-dev.30",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/build-contract.ts

@@ -6,7 +6,6 @@ import {
 import {
   asNamespaceId,
   type ColumnDefault,
-  type ColumnDefaultLiteralInputValue,
   type Contract,
   type ContractEnum,
   type ContractField,
@@ -36,13 +35,10 @@ import {
   applyFkDefaults,
   buildSqlNamespace,
   type CheckConstraintInput,
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
   type SqlNamespaceTablesInput,
   SqlStorage,
   type SqlStorageInput,
   type StorageColumn,
-  StorageTable,
   type StorageTableInput,
   type StorageTypeInstance,
   type StorageValueSetInput,
@@ -63,16 +59,15 @@ type DomainFieldRef =
   | { readonly kind: 'scalar'; readonly many?: boolean }
   | { readonly kind: 'valueObject'; readonly name: string; readonly many?: boolean };
 
-function encodeDefaultLiteralValue(
-  value: ColumnDefaultLiteralInputValue,
-  codecId: string,
-  codecLookup?: CodecLookup,
-): JsonValue {
+function encodeViaCodec(value: unknown, codecId: string, codecLookup?: CodecLookup): JsonValue {
   const codec = codecLookup?.get(codecId);
   if (codec) {
     return codec.encodeJson(value);
   }
-  return value as JsonValue;
+  return blindCast<
+    JsonValue,
+    'no codec lookup at build time: literal/enum member value is already JSON-safe'
+  >(value);
 }
 
 function encodeColumnDefault(
@@ -85,7 +80,7 @@ function encodeColumnDefault(
   }
   return {
     kind: 'literal',
-    value: encodeDefaultLiteralValue(defaultInput.value, codecId, codecLookup),
+    value: encodeViaCodec(defaultInput.value, codecId, codecLookup),
   };
 }
 
@@ -322,55 +317,6 @@ function ensureUnboundNamespaceSlot(
   });
 }
 
-const POSTGRES_ENUM_NAMESPACE_ID = 'public';
-
-function partitionStorageTypesForTarget(
-  targetId: string,
-  types: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-  namespaceTypes?: Readonly<Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>>,
-): {
-  readonly documentTypes: Record<string, StorageTypeInstance>;
-  readonly namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>>;
-} {
-  const documentTypes: Record<string, StorageTypeInstance> = {};
-  const namespaceEnumTypesById: Record<string, Record<string, PostgresEnumStorageEntry>> = {};
-  for (const [name, entry] of Object.entries(types)) {
-    if (isPostgresEnumStorageEntry(entry)) {
-      if (targetId !== 'postgres') {
-        throw new Error(
-          `buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`,
-        );
-      }
-      let slot = namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID];
-      if (slot === undefined) {
-        slot = {};
-        namespaceEnumTypesById[POSTGRES_ENUM_NAMESPACE_ID] = slot;
-      }
-      slot[name] = entry;
-      continue;
-    }
-    documentTypes[name] = entry;
-  }
-  if (namespaceTypes !== undefined) {
-    for (const [nsId, enumsInNs] of Object.entries(namespaceTypes)) {
-      for (const [name, entry] of Object.entries(enumsInNs)) {
-        if (targetId !== 'postgres') {
-          throw new Error(
-            `buildSqlContractFromDefinition: postgres enum "${name}" is only valid when target is "postgres" (got "${targetId}").`,
-          );
-        }
-        let slot = namespaceEnumTypesById[nsId];
-        if (slot === undefined) {
-          slot = {};
-          namespaceEnumTypesById[nsId] = slot;
-        }
-        slot[name] = entry;
-      }
-    }
-  }
-  return { documentTypes, namespaceEnumTypesById };
-}
-
 export function buildSqlContractFromDefinition(
   definition: ContractDefinition,
   codecLookup?: CodecLookup,
@@ -391,7 +337,7 @@ export function buildSqlContractFromDefinition(
     definition.models.map((m) => [`${resolveNamespaceId(m)}:${m.modelName}`, m]),
   );
 
-  const tablesByNamespace: Record<string, Record<string, StorageTable>> = {};
+  const tablesByNamespace: Record<string, Record<string, StorageTableInput>> = {};
   const modelNameToNamespaceId = new Map<string, string>();
   const executionDefaults: ExecutionMutationDefault[] = [];
   const modelsByNamespace: Record<string, Record<string, ContractModel>> = {};
@@ -451,9 +397,9 @@ export function buildSqlContractFromDefinition(
         enumHandle !== undefined
           ? {
               plane: 'storage',
-              entityKind: 'value-set',
+              entityKind: 'valueSet',
               namespaceId: defaultNamespaceId,
-              name: enumHandle.enumName,
+              entityName: enumHandle.enumName,
             }
           : undefined;
       const domainValueSetRef: ValueSetRef | undefined =
@@ -462,7 +408,7 @@ export function buildSqlContractFromDefinition(
               plane: 'domain',
               entityKind: 'enum',
               namespaceId: defaultNamespaceId,
-              name: enumHandle.enumName,
+              entityName: enumHandle.enumName,
             }
           : undefined;
 
@@ -604,7 +550,7 @@ export function buildSqlContractFromDefinition(
           `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`,
         );
       }
-      nsTables[tableName] = new StorageTable(tableInput);
+      nsTables[tableName] = tableInput;
     }
 
     // --- Build contract model ---
@@ -725,13 +671,9 @@ export function buildSqlContractFromDefinition(
   // discriminator shape before hashing so the storageHash matches the
   // persisted JSON envelope produced from the SqlStorage class instance
   // (which always carries the discriminator).
-  const rawStorageTypes = (definition.storageTypes ?? {}) as Record<
-    string,
-    StorageTypeInstance | PostgresEnumStorageEntry
-  >;
-  const storageTypes = Object.fromEntries(
+  const rawStorageTypes = definition.storageTypes ?? {};
+  const documentTypes: Record<string, StorageTypeInstance> = Object.fromEntries(
     Object.entries(rawStorageTypes).map(([name, entry]) => {
-      if (isPostgresEnumStorageEntry(entry)) return [name, entry];
       if ((entry as { kind?: unknown }).kind === 'codec-instance') return [name, entry];
       return [
         name,
@@ -743,15 +685,7 @@ export function buildSqlContractFromDefinition(
       ];
     }),
   );
-  const { documentTypes, namespaceEnumTypesById } = partitionStorageTypesForTarget(
-    target,
-    storageTypes,
-    definition.namespaceTypes,
-  );
   const namespaceCoordinateIds = collectStorageNamespaceCoordinateIds(definition);
-  for (const id of Object.keys(namespaceEnumTypesById)) {
-    namespaceCoordinateIds.add(id);
-  }
 
   // Build per-namespace registries for `enumType()` handles.
   // All authored enums target the contract's default namespace.
@@ -771,7 +705,10 @@ export function buildSqlContractFromDefinition(
     }
     domainSlot[enumName] = {
       codecId: handle.codecId,
-      members: handle.enumMembers,
+      members: handle.enumMembers.map((m) => ({
+        name: m.name,
+        value: encodeViaCodec(m.value, handle.codecId, codecLookup),
+      })),
     };
 
     let storageSlot = storageValueSetsByNs[nsId];
@@ -780,8 +717,8 @@ export function buildSqlContractFromDefinition(
       storageValueSetsByNs[nsId] = storageSlot;
     }
     storageSlot[enumName] = {
-      kind: 'value-set',
-      values: handle.values,
+      kind: 'valueSet',
+      values: handle.values.map((v) => encodeViaCodec(v, handle.codecId, codecLookup)),
     };
   }
 
@@ -792,7 +729,6 @@ export function buildSqlContractFromDefinition(
   >(
     Object.fromEntries(
       [...namespaceCoordinateIds].sort().map((id) => {
-        const enumTypes = namespaceEnumTypesById[id];
         const valueSetEntries = storageValueSetsByNs[id];
         const nsInput: SqlNamespaceTablesInput = {
           id,
@@ -803,10 +739,7 @@ export function buildSqlContractFromDefinition(
               : {}),
           },
         };
-        return [
-          id,
-          createNamespace ? createNamespace(nsInput, enumTypes) : buildSqlNamespace(nsInput),
-        ];
+        return [id, createNamespace ? createNamespace(nsInput) : buildSqlNamespace(nsInput)];
       }),
     ),
   );

package/src/contract-builder.ts

@@ -7,11 +7,7 @@ import type {
   TargetPackRef,
 } from '@prisma-next/framework-components/components';
 import type { Namespace } from '@prisma-next/framework-components/ir';
-import type {
-  PostgresEnumStorageEntry,
-  SqlNamespaceTablesInput,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { SqlNamespaceTablesInput, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { buildSqlContractFromDefinition } from './build-contract';
@@ -55,13 +51,14 @@ type ModelLike = {
 type ContractDefinition<
   Family extends FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string>,
-  Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  Types extends Record<string, StorageTypeInstance>,
   Models extends Record<string, ModelLike>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
   Naming extends ContractInput['naming'] | undefined,
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
   Namespaces extends readonly string[] | undefined = undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -75,7 +72,7 @@ type ContractDefinition<
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractScaffold<
@@ -86,6 +83,7 @@ type ContractScaffold<
   StorageHash extends string | undefined,
   ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined,
   Namespaces extends readonly string[] | undefined = undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = {
   readonly family: Family;
   readonly target: Target;
@@ -99,18 +97,20 @@ type ContractScaffold<
   readonly types?: never;
   readonly models?: never;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractFactory<
   Family extends FamilyPackRef<string>,
   Target extends TargetPackRef<'sql', string>,
-  Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  Types extends Record<string, StorageTypeInstance>,
   Models extends Record<string, ModelLike>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined,
+  Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 > = (helpers: ComposedAuthoringHelpers<Family, Target, ExtensionPacks>) => {
   readonly types?: Types;
   readonly models?: Models;
+  readonly enums?: Enums;
 };
 
 function validateTargetPackRef(
@@ -300,10 +300,7 @@ function buildContractFromDsl<Definition extends ContractInput>(
 // Input for buildBoundContract — all fields from ContractInput except family/target
 // (those are injected by the builder, pre-bound at the call site).
 type BoundDefinitionInput<
-  Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<
-    never,
-    never
-  >,
+  Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   Models extends Record<string, ModelLike> = Record<never, never>,
   ExtensionPacks extends Record<string, ExtensionPackRef<'sql', string>> | undefined = undefined,
   Naming extends ContractInput['naming'] | undefined = undefined,
@@ -324,6 +321,20 @@ type BoundDefinitionInput<
   readonly enums?: Record<string, EnumTypeHandle>;
 };
 
+// A bare `Record<string, EnumTypeHandle>` (no literal keys) is the widened
+// default for a side that declared no enums; drop it so the merge keeps only
+// literally-authored enum handles.
+type LiteralEnums<E extends Record<string, EnumTypeHandle>> = string extends keyof E
+  ? Record<never, never>
+  : E;
+
+// Merges enum handles authored on the scaffold definition with those returned
+// from the factory callback. Either side may be the widened default (empty).
+export type MergeEnums<
+  ScaffoldEnums extends Record<string, EnumTypeHandle>,
+  FactoryEnums extends Record<string, EnumTypeHandle>,
+> = LiteralEnums<ScaffoldEnums> & LiteralEnums<FactoryEnums>;
+
 // Merges a bound input with the pre-bound family/target to produce a full ContractDefinition.
 type WithFamilyTarget<
   Input,
@@ -343,7 +354,7 @@ export function buildBoundContract<
   const F extends FamilyPackRef<string>,
   const T extends TargetPackRef<'sql', string>,
   const Definition extends BoundDefinitionInput<
-    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, StorageTypeInstance>,
     Record<string, ModelLike>,
     Record<string, ExtensionPackRef<'sql', string>> | undefined,
     ContractInput['naming'] | undefined,
@@ -364,7 +375,7 @@ export function buildBoundContract<
   const F extends FamilyPackRef<string>,
   const T extends TargetPackRef<'sql', string>,
   const Definition extends BoundDefinitionInput<
-    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, StorageTypeInstance>,
     Record<string, ModelLike>,
     Record<string, ExtensionPackRef<'sql', string>> | undefined,
     ContractInput['naming'] | undefined,
@@ -373,8 +384,9 @@ export function buildBoundContract<
     readonly string[] | undefined
   >,
   const Built extends {
-    readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+    readonly types?: Record<string, StorageTypeInstance>;
     readonly models?: Record<string, ModelLike>;
+    readonly enums?: Record<string, EnumTypeHandle>;
   },
 >(
   family: F,
@@ -397,8 +409,9 @@ export function buildBoundContract(
           Record<string, ExtensionPackRef<'sql', string>> | undefined
         >,
       ) => {
-        readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+        readonly types?: Record<string, StorageTypeInstance>;
         readonly models?: Record<string, ModelLike>;
+        readonly enums?: Record<string, EnumTypeHandle>;
       })
     | undefined,
 ) {
@@ -412,10 +425,12 @@ export function buildBoundContract(
         extensionPacks: definition.extensionPacks,
       }),
     );
+    const mergedEnums = { ...(definition.enums ?? {}), ...built.enums };
     return buildContractFromDsl({
       ...full,
       ...ifDefined('types', built.types),
       ...ifDefined('models', built.models),
+      ...ifDefined('enums', Object.keys(mergedEnums).length > 0 ? mergedEnums : undefined),
     });
   }
 
@@ -425,10 +440,7 @@ export function buildBoundContract(
 export function defineContract<
   const Family extends FamilyPackRef<string>,
   const Target extends TargetPackRef<'sql', string>,
-  const Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<
-    never,
-    never
-  >,
+  const Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   const Models extends Record<string, ModelLike> = Record<never, never>,
   const ExtensionPacks extends
     | Record<string, ExtensionPackRef<'sql', string>>
@@ -437,6 +449,7 @@ export function defineContract<
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
   const Namespaces extends readonly string[] | undefined = undefined,
+  const Enums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 >(
   definition: ContractDefinition<
     Family,
@@ -447,7 +460,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >,
 ): SqlContractResult<
   ContractDefinition<
@@ -459,16 +473,14 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >
 >;
 export function defineContract<
   const Family extends FamilyPackRef<string>,
   const Target extends TargetPackRef<'sql', string>,
-  const Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = Record<
-    never,
-    never
-  >,
+  const Types extends Record<string, StorageTypeInstance> = Record<never, never>,
   const Models extends Record<string, ModelLike> = Record<never, never>,
   const ExtensionPacks extends
     | Record<string, ExtensionPackRef<'sql', string>>
@@ -477,6 +489,8 @@ export function defineContract<
   const StorageHash extends string | undefined = undefined,
   const ForeignKeyDefaults extends ForeignKeyDefaultsState | undefined = undefined,
   const Namespaces extends readonly string[] | undefined = undefined,
+  const ScaffoldEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
+  const FactoryEnums extends Record<string, EnumTypeHandle> = Record<string, EnumTypeHandle>,
 >(
   definition: ContractScaffold<
     Family,
@@ -485,9 +499,10 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    ScaffoldEnums
   >,
-  factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks>,
+  factory: ContractFactory<Family, Target, Types, Models, ExtensionPacks, FactoryEnums>,
 ): SqlContractResult<
   ContractDefinition<
     Family,
@@ -498,7 +513,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    MergeEnums<ScaffoldEnums, FactoryEnums>
   >
 >;
 export function defineContract(
@@ -506,7 +522,7 @@ export function defineContract(
   factory?: ContractFactory<
     FamilyPackRef<string>,
     TargetPackRef<'sql', string>,
-    Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+    Record<string, StorageTypeInstance>,
     Record<string, ModelLike>,
     Record<string, ExtensionPackRef<'sql', string>> | undefined
   >,

package/src/contract-definition.ts

@@ -8,7 +8,6 @@ import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/cod
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type { Namespace } from '@prisma-next/framework-components/ir';
 import type {
-  PostgresEnumStorageEntry,
   ReferentialAction,
   SqlNamespaceTablesInput,
   StorageTypeInstance,
@@ -162,33 +161,14 @@ export interface ContractDefinition {
   readonly extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>;
   readonly storageHash?: string;
   readonly foreignKeyDefaults?: ForeignKeyDefaultsState;
-  readonly storageTypes?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
-  /**
-   * Enum types declared inside a named `namespace { enum … }` block,
-   * keyed first by namespace id then by type name. These are routed to
-   * `storage.namespaces[nsId].entries.type` rather than the implicit fallback
-   * namespace used for top-level `storageTypes` enums.
-   */
-  readonly namespaceTypes?: Readonly<
-    Record<string, Readonly<Record<string, PostgresEnumStorageEntry>>>
-  >;
+  readonly storageTypes?: Record<string, StorageTypeInstance>;
   /**
    * Declared namespace coordinates for this contract — populates
    * `SqlStorage.namespaces` together with `createNamespace`.
    */
   readonly namespaces?: readonly string[];
-  /**
-   * Target-supplied factory that materialises a `Namespace` concretion
-   * for a declared namespace coordinate. Mirrors
-   * `ContractInput.createNamespace`.
-   *
-   * The optional second argument carries target-specific enum types for the
-   * namespace (e.g. postgres enum registrations keyed by type name).
-   */
-  readonly createNamespace?: (
-    input: SqlNamespaceTablesInput,
-    enumTypes?: Readonly<Record<string, PostgresEnumStorageEntry>>,
-  ) => Namespace;
+  /** Target-supplied factory that materialises a `Namespace` concretion for a declared namespace coordinate. */
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
   readonly models: readonly ModelNode[];
   readonly valueObjects?: readonly ValueObjectNode[];
   /**

package/src/contract-dsl.ts

@@ -16,11 +16,7 @@ import type {
   TargetPackRef,
 } from '@prisma-next/framework-components/components';
 import type { Namespace } from '@prisma-next/framework-components/ir';
-import type {
-  PostgresEnumStorageEntry,
-  SqlNamespaceTablesInput,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { SqlNamespaceTablesInput, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { NamedConstraintSpec } from './authoring-type-utils';
@@ -34,7 +30,7 @@ export type NamingConfig = {
   readonly columns?: NamingStrategy;
 };
 
-type NamedStorageTypeRef = string | StorageTypeInstance | PostgresEnumStorageEntry | EnumTypeHandle;
+type NamedStorageTypeRef = string | StorageTypeInstance | EnumTypeHandle;
 
 type NamedConstraintNameSpec<Name extends string = string> = {
   readonly name: Name;
@@ -338,6 +334,36 @@ export class ScalarFieldBuilder<State extends AnyScalarFieldState = AnyScalarFie
   }
 }
 
+export class EnumScalarFieldBuilder<
+  Handle extends EnumTypeHandle,
+  State extends AnyScalarFieldState = ScalarFieldState<Handle['codecId'], Handle, false, undefined>,
+> extends ScalarFieldBuilder<State> {
+  readonly #handle: Handle;
+
+  constructor(state: State, handle: Handle) {
+    super(state);
+    this.#handle = handle;
+  }
+
+  override default(value: Handle['values'][number]): EnumScalarFieldBuilder<Handle, State> {
+    return blindCast<
+      EnumScalarFieldBuilder<Handle, State>,
+      'object spread does not narrow the generic State conditional; runtime shape is correct'
+    >(
+      new EnumScalarFieldBuilder(
+        { ...this.build(), default: { kind: 'literal', value } },
+        this.#handle,
+      ),
+    );
+  }
+
+  override defaultSql(_expression: never): never {
+    throw new Error(
+      'defaultSql is not available on an enum field; use .default(members.X) instead',
+    );
+  }
+}
+
 function columnField<Descriptor extends ColumnTypeDescriptor>(
   descriptor: Descriptor,
 ): ScalarFieldBuilder<ScalarFieldState<Descriptor['codecId'], undefined, false, undefined>> {
@@ -368,21 +394,19 @@ function namedTypeField<TypeRef extends string>(
 function namedTypeField<TypeRef extends StorageTypeInstance>(
   typeRef: TypeRef,
 ): ScalarFieldBuilder<ScalarFieldState<TypeRef['codecId'], TypeRef, false, undefined>>;
-function namedTypeField<TypeRef extends PostgresEnumStorageEntry>(
-  typeRef: TypeRef,
-): ScalarFieldBuilder<ScalarFieldState<string, TypeRef, false, undefined>>;
 function namedTypeField<Handle extends EnumTypeHandle>(
   typeRef: Handle,
-): ScalarFieldBuilder<ScalarFieldState<Handle['codecId'], Handle, false, undefined>>;
-function namedTypeField(
-  typeRef: NamedStorageTypeRef,
-): ScalarFieldBuilder<ScalarFieldState<string, NamedStorageTypeRef, false, undefined>> {
+): EnumScalarFieldBuilder<Handle>;
+function namedTypeField(typeRef: NamedStorageTypeRef): ScalarFieldBuilder {
   if (isEnumTypeHandle(typeRef)) {
-    return new ScalarFieldBuilder({
-      kind: 'scalar',
+    return new EnumScalarFieldBuilder(
+      {
+        kind: 'scalar',
+        typeRef,
+        nullable: false,
+      },
       typeRef,
-      nullable: false,
-    });
+    );
   }
   return new ScalarFieldBuilder({
     kind: 'scalar',