@prisma-next/sql-contract-ts 0.12.0 → 0.13.0-dev.10

package/src/contract-lowering.ts

@@ -1,4 +1,5 @@
 import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
+import type { ExtensionPackRef } from '@prisma-next/framework-components/components';
 import {
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
@@ -35,6 +36,7 @@ import {
   emitTypedCrossModelFallbackWarnings,
   emitTypedNamedTypeFallbackWarnings,
 } from './contract-warnings';
+import { isEnumTypeHandle } from './enum-type';
 
 type RuntimeModel = ContractModelBuilder<
   string | undefined,
@@ -84,6 +86,13 @@ function resolveFieldDescriptor(
   }
 
   if ('typeRef' in fieldState && fieldState.typeRef) {
+    if (isEnumTypeHandle(fieldState.typeRef)) {
+      return {
+        codecId: fieldState.typeRef.codecId,
+        nativeType: fieldState.typeRef.nativeType,
+      };
+    }
+
     const typeRef =
       typeof fieldState.typeRef === 'string'
         ? fieldState.typeRef
@@ -253,6 +262,41 @@ function resolveRelationForeignKeys(
     }
 
     const targetModelName = resolveRelationModelName(relation.toModel);
+
+    // F-relfk: cross-space relations carry a spaceId; skip the local spec lookup
+    // and include cross-space coordinates so resolveForeignKeyNodes routes the FK
+    // through the cross-space path.
+    if (relation.spaceId !== undefined) {
+      const fields = normalizeRelationFieldNames(relation.from);
+      const targetFields = normalizeRelationFieldNames(relation.to);
+      assertRelationFieldArity({
+        modelName: spec.modelName,
+        relationName,
+        leftLabel: 'source',
+        leftFields: fields,
+        rightLabel: 'target',
+        rightFields: targetFields,
+      });
+
+      foreignKeys.push({
+        kind: 'fk',
+        fields,
+        targetModel: targetModelName,
+        targetFields,
+        targetSpaceId: relation.spaceId,
+        ...(relation.namespaceId !== undefined ? { targetNamespaceId: relation.namespaceId } : {}),
+        ...(relation.tableName !== undefined ? { targetTableName: relation.tableName } : {}),
+        ...(relation.sql.fk.name ? { name: relation.sql.fk.name } : {}),
+        ...(relation.sql.fk.onDelete ? { onDelete: relation.sql.fk.onDelete } : {}),
+        ...(relation.sql.fk.onUpdate ? { onUpdate: relation.sql.fk.onUpdate } : {}),
+        ...(relation.sql.fk.constraint !== undefined
+          ? { constraint: relation.sql.fk.constraint }
+          : {}),
+        ...(relation.sql.fk.index !== undefined ? { index: relation.sql.fk.index } : {}),
+      });
+      continue;
+    }
+
     if (!allSpecs.has(targetModelName)) {
       throw new Error(
         `Relation "${spec.modelName}.${relationName}" references unknown model "${targetModelName}"`,
@@ -308,17 +352,12 @@ function lowerBelongsToRelation(
   relation: Extract<RelationState, { kind: 'belongsTo' }>,
   currentSpec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
+  extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
 ): RelationNode {
   const targetModelName = resolveRelationModelName(relation.toModel);
-  const targetSpec = allSpecs.get(targetModelName);
-  if (!targetSpec) {
-    throw new Error(
-      `Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`,
-    );
-  }
-
   const fromFields = normalizeRelationFieldNames(relation.from);
   const toFields = normalizeRelationFieldNames(relation.to);
+
   assertRelationFieldArity({
     modelName: currentSpec.modelName,
     relationName,
@@ -328,6 +367,48 @@ function lowerBelongsToRelation(
     rightFields: toFields,
   });
 
+  // Cross-space path: the target lives in a different contract space.
+  // Resolve from the brand carried on the BelongsToRelation instead of
+  // requiring a local model spec — matching how the FK lowering works.
+  if (relation.spaceId !== undefined) {
+    assertKnownExtensionPack(
+      extensionPacks,
+      relation.spaceId,
+      `Relation "${currentSpec.modelName}.${relationName}"`,
+    );
+    const targetTable = relation.tableName ?? targetModelName.toLowerCase();
+    const parentColumns = mapFieldNamesToColumnNames(
+      currentSpec.modelName,
+      fromFields,
+      currentSpec.fieldToColumn,
+    );
+    // For cross-space relations, the `to` field names map directly to column
+    // names because we have no fieldToColumn map for the remote model.
+    // (The brand carries the table name; field→column resolution on the remote
+    // side is deferred to the planner which has access to the remote contract.)
+    return {
+      fieldName: relationName,
+      toModel: targetModelName,
+      toTable: targetTable,
+      cardinality: 'N:1',
+      spaceId: relation.spaceId,
+      ...(relation.namespaceId !== undefined ? { namespaceId: relation.namespaceId } : {}),
+      on: {
+        parentTable: currentSpec.tableName,
+        parentColumns,
+        childTable: targetTable,
+        childColumns: toFields,
+      },
+    };
+  }
+
+  const targetSpec = allSpecs.get(targetModelName);
+  if (!targetSpec) {
+    throw new Error(
+      `Relation "${currentSpec.modelName}.${relationName}" references unknown model "${targetModelName}"`,
+    );
+  }
+
   return {
     fieldName: relationName,
     toModel: targetModelName,
@@ -472,9 +553,10 @@ function resolveRelationNode(
   relation: RelationState,
   currentSpec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
+  extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
 ): RelationNode {
   if (relation.kind === 'belongsTo') {
-    return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs);
+    return lowerBelongsToRelation(relationName, relation, currentSpec, allSpecs, extensionPacks);
   }
 
   if (relation.kind === 'hasMany' || relation.kind === 'hasOne') {
@@ -484,7 +566,7 @@ function resolveRelationNode(
   return lowerManyToManyRelation(relationName, relation, currentSpec, allSpecs);
 }
 
-function lowerForeignKeyNode(
+function lowerLocalForeignKeyNode(
   spec: RuntimeModelSpec,
   targetSpec: RuntimeModelSpec,
   foreignKey: {
@@ -516,11 +598,74 @@ function lowerForeignKeyNode(
   };
 }
 
+function lowerCrossSpaceForeignKeyNode(
+  spec: RuntimeModelSpec,
+  foreignKey: {
+    readonly fields: readonly string[];
+    readonly targetFields: readonly string[];
+    readonly targetModel: string;
+    readonly targetSpaceId: string;
+    readonly targetNamespaceId?: string;
+    readonly targetTableName?: string;
+    readonly name?: string | undefined;
+    readonly onDelete?: ForeignKeyConstraint['onDelete'] | undefined;
+    readonly onUpdate?: ForeignKeyConstraint['onUpdate'] | undefined;
+    readonly constraint?: boolean | undefined;
+    readonly index?: boolean | undefined;
+  },
+): ForeignKeyNode {
+  return {
+    columns: mapFieldNamesToColumnNames(spec.modelName, foreignKey.fields, spec.fieldToColumn),
+    references: {
+      model: foreignKey.targetModel,
+      table: foreignKey.targetTableName ?? foreignKey.targetModel.toLowerCase(),
+      columns: foreignKey.targetFields,
+      ...(foreignKey.targetNamespaceId !== undefined
+        ? { namespaceId: foreignKey.targetNamespaceId }
+        : {}),
+      spaceId: foreignKey.targetSpaceId,
+    },
+    ...(foreignKey.name ? { name: foreignKey.name } : {}),
+    ...(foreignKey.onDelete ? { onDelete: foreignKey.onDelete } : {}),
+    ...(foreignKey.onUpdate ? { onUpdate: foreignKey.onUpdate } : {}),
+    ...(foreignKey.constraint !== undefined ? { constraint: foreignKey.constraint } : {}),
+    ...(foreignKey.index !== undefined ? { index: foreignKey.index } : {}),
+  };
+}
+
+function assertKnownExtensionPack(
+  extensionPacks: Record<string, ExtensionPackRef<'sql', string>> | undefined,
+  spaceId: string,
+  context: string,
+): void {
+  if (extensionPacks !== undefined && Object.hasOwn(extensionPacks, spaceId)) {
+    return;
+  }
+  throw new Error(
+    `${context} references contract space "${spaceId}" but "${spaceId}" is not declared in extensionPacks. Add the pack to extensionPacks.`,
+  );
+}
+
 function resolveForeignKeyNodes(
   spec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
+  extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
 ): readonly ForeignKeyNode[] {
   const relationForeignKeys = resolveRelationForeignKeys(spec, allSpecs).map((foreignKey) => {
+    // F-relfk: relation-derived FKs for cross-space targets carry targetSpaceId;
+    // route them through the cross-space path, just like explicit sql() FKs.
+    if (foreignKey.targetSpaceId !== undefined) {
+      assertKnownExtensionPack(
+        extensionPacks,
+        foreignKey.targetSpaceId,
+        `Relation-derived foreign key on "${spec.modelName}"`,
+      );
+      return lowerCrossSpaceForeignKeyNode(spec, {
+        ...foreignKey,
+        targetSpaceId: foreignKey.targetSpaceId,
+      });
+    }
+
     const targetSpec = allSpecs.get(foreignKey.targetModel);
     if (!targetSpec) {
       throw new Error(
@@ -528,10 +673,22 @@ function resolveForeignKeyNodes(
       );
     }
 
-    return lowerForeignKeyNode(spec, targetSpec, foreignKey);
+    return lowerLocalForeignKeyNode(spec, targetSpec, foreignKey);
   });
 
   const sqlForeignKeys = (spec.sqlSpec?.foreignKeys ?? []).map((foreignKey) => {
+    if (foreignKey.targetSpaceId !== undefined) {
+      assertKnownExtensionPack(
+        extensionPacks,
+        foreignKey.targetSpaceId,
+        `Foreign key on "${spec.modelName}"`,
+      );
+      return lowerCrossSpaceForeignKeyNode(spec, {
+        ...foreignKey,
+        targetSpaceId: foreignKey.targetSpaceId,
+      });
+    }
+
     const targetSpec = allSpecs.get(foreignKey.targetModel);
     if (!targetSpec) {
       throw new Error(
@@ -539,7 +696,7 @@ function resolveForeignKeyNodes(
       );
     }
 
-    return lowerForeignKeyNode(spec, targetSpec, foreignKey);
+    return lowerLocalForeignKeyNode(spec, targetSpec, foreignKey);
   });
 
   return [...relationForeignKeys, ...sqlForeignKeys];
@@ -550,6 +707,7 @@ function resolveModelNode(
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
   storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
   storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance | PostgresEnumStorageEntry, string>,
+  extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
 ): ModelNode {
   const fields: FieldNode[] = [];
 
@@ -567,6 +725,11 @@ function resolveModelNode(
       throw new Error(`Column name resolution failed for "${spec.modelName}.${fieldName}"`);
     }
 
+    const enumHandle =
+      'typeRef' in fieldState && isEnumTypeHandle(fieldState.typeRef)
+        ? fieldState.typeRef
+        : undefined;
+
     fields.push({
       fieldName,
       columnName,
@@ -574,6 +737,7 @@ function resolveModelNode(
       nullable: fieldState.nullable,
       ...(fieldState.default ? { default: fieldState.default } : {}),
       ...(fieldState.executionDefaults ? { executionDefaults: fieldState.executionDefaults } : {}),
+      ...(enumHandle !== undefined ? { enumTypeHandle: enumHandle } : {}),
     });
   }
 
@@ -588,9 +752,9 @@ function resolveModelNode(
     ...ifDefined('type', index.type),
     ...ifDefined('options', index.options),
   })) satisfies readonly IndexNode[];
-  const foreignKeys = resolveForeignKeyNodes(spec, allSpecs);
+  const foreignKeys = resolveForeignKeyNodes(spec, allSpecs, extensionPacks);
   const relations = Object.entries(spec.relations).map(([relationName, relationBuilder]) =>
-    resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs),
+    resolveRelationNode(relationName, relationBuilder.build(), spec, allSpecs, extensionPacks),
   );
 
   return {
@@ -614,6 +778,7 @@ function resolveModelNode(
     ...(indexes.length > 0 ? { indexes } : {}),
     ...(foreignKeys.length > 0 ? { foreignKeys } : {}),
     ...(relations.length > 0 ? { relations } : {}),
+    ...ifDefined('control', spec.sqlSpec?.control),
   };
 }
 
@@ -687,7 +852,10 @@ function collectRuntimeModelSpecs(definition: ContractInput): RuntimeCollection
   };
 }
 
-function lowerModels(collection: RuntimeCollection): readonly ModelNode[] {
+function lowerModels(
+  collection: RuntimeCollection,
+  extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
+): readonly ModelNode[] {
   emitTypedCrossModelFallbackWarnings(collection);
 
   const storageTypeReverseLookup = buildStorageTypeReverseLookup(collection.storageTypes);
@@ -697,16 +865,18 @@ function lowerModels(collection: RuntimeCollection): readonly ModelNode[] {
       collection.modelSpecs,
       collection.storageTypes,
       storageTypeReverseLookup,
+      extensionPacks,
     ),
   );
 }
 
 export function buildContractDefinition(definition: ContractInput): ContractDefinition {
   const collection = collectRuntimeModelSpecs(definition);
-  const models = lowerModels(collection);
+  const models = lowerModels(collection, definition.extensionPacks);
 
   return {
     target: definition.target,
+    ...ifDefined('defaultControlPolicy', definition.defaultControlPolicy),
     ...(definition.extensionPacks ? { extensionPacks: definition.extensionPacks } : {}),
     ...(definition.storageHash ? { storageHash: definition.storageHash } : {}),
     ...(definition.foreignKeyDefaults ? { foreignKeyDefaults: definition.foreignKeyDefaults } : {}),
@@ -715,6 +885,9 @@ export function buildContractDefinition(definition: ContractInput): ContractDefi
       : {}),
     ...(definition.namespaces ? { namespaces: definition.namespaces } : {}),
     ...(definition.createNamespace ? { createNamespace: definition.createNamespace } : {}),
+    ...(definition.enums && Object.keys(definition.enums).length > 0
+      ? { enums: definition.enums }
+      : {}),
     models,
   };
 }

package/src/contract-types.ts

@@ -6,17 +6,18 @@ import type {
   StorageHashBase,
 } from '@prisma-next/contract/types';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
+import type { StorageType } from '@prisma-next/framework-components/ir';
 import type { IndexTypeRegistration } from '@prisma-next/sql-contract/index-types';
 import type {
   ContractWithTypeMaps,
   Index,
-  PostgresEnumStorageEntry,
   ReferentialAction,
   StorageTypeInstance,
   TypeMaps,
 } from '@prisma-next/sql-contract/types';
 import type { UnionToIntersection } from './authoring-type-utils';
 import type { AttributeStageIdFieldNames, FieldStateOf, ScalarFieldBuilder } from './contract-dsl';
+import type { EnumTypeHandle } from './enum-type';
 
 export type ExtractCodecTypesFromPack<P> = P extends { __codecTypes?: infer C }
   ? C extends Record<string, { output: unknown }>
@@ -144,10 +145,7 @@ type DefinitionNamespaces<Definition> = Definition extends {
 type DefinitionTypes<Definition> = Definition extends {
   readonly types?: unknown;
 }
-  ? Present<Definition['types']> extends Record<
-      string,
-      StorageTypeInstance | PostgresEnumStorageEntry
-    >
+  ? Present<Definition['types']> extends Record<string, StorageType>
     ? Present<Definition['types']>
     : Record<never, never>
   : Record<never, never>;
@@ -311,10 +309,7 @@ type DescriptorTypeRef<Descriptor> = Descriptor extends {
   ? TypeRef
   : undefined;
 
-type LookupNamedStorageTypeKeyByValue<
-  Definition,
-  TypeRef extends StorageTypeInstance | PostgresEnumStorageEntry,
-> = {
+type LookupNamedStorageTypeKeyByValue<Definition, TypeRef extends StorageType> = {
   [TypeName in keyof DefinitionTypes<Definition> & string]: [TypeRef] extends [
     DefinitionTypes<Definition>[TypeName],
   ]
@@ -326,7 +321,7 @@ type LookupNamedStorageTypeKeyByValue<
 
 type ResolveNamedStorageTypeKey<Definition, TypeRef> = TypeRef extends string
   ? TypeRef
-  : TypeRef extends StorageTypeInstance | PostgresEnumStorageEntry
+  : TypeRef extends StorageType
     ? [LookupNamedStorageTypeKeyByValue<Definition, TypeRef>] extends [never]
       ? string
       : LookupNamedStorageTypeKeyByValue<Definition, TypeRef>
@@ -339,17 +334,39 @@ type ResolveNamedStorageType<Definition, TypeRef> =
       : StorageTypeInstance
     : StorageTypeInstance;
 
-type ResolveFieldDescriptor<Definition, FieldState> = [FieldDescriptorOf<FieldState>] extends [
-  never,
-]
-  ? ResolveNamedStorageType<Definition, FieldTypeRefOf<FieldState>>
-  : FieldDescriptorOf<FieldState>;
+// An enum-typed field carries its `EnumTypeHandle` (an object with a `codecId`
+// and `nativeType`, but no `kind`) as the field's `typeRef`. It is neither a
+// string nor a registered `StorageType`, so the named-type lookup cannot reach
+// it; `EnumFieldHandle` short-circuits the resolvers to read codec + native type
+// straight off the handle, with no column type-ref (the enum name is carried
+// elsewhere). The `[...] extends [never]` guard excludes plain column fields,
+// whose `typeRef` is `never`.
+type EnumFieldHandle<FieldState> = [FieldTypeRefOf<FieldState>] extends [never]
+  ? never
+  : FieldTypeRefOf<FieldState> extends EnumTypeHandle
+    ? FieldTypeRefOf<FieldState>
+    : never;
 
-type ResolveFieldColumnTypeRef<Definition, FieldState> = [FieldTypeRefOf<FieldState>] extends [
+type EnumHandleDescriptor<Handle> = Handle extends {
+  readonly codecId: infer CodecId extends string;
+  readonly nativeType: infer NativeType extends string;
+}
+  ? { readonly codecId: CodecId; readonly nativeType: NativeType }
+  : never;
+
+type ResolveFieldDescriptor<Definition, FieldState> = [EnumFieldHandle<FieldState>] extends [never]
+  ? [FieldDescriptorOf<FieldState>] extends [never]
+    ? ResolveNamedStorageType<Definition, FieldTypeRefOf<FieldState>>
+    : FieldDescriptorOf<FieldState>
+  : EnumHandleDescriptor<EnumFieldHandle<FieldState>>;
+
+type ResolveFieldColumnTypeRef<Definition, FieldState> = [EnumFieldHandle<FieldState>] extends [
   never,
 ]
-  ? DescriptorTypeRef<FieldDescriptorOf<FieldState>>
-  : ResolveNamedStorageTypeKey<Definition, FieldTypeRefOf<FieldState>>;
+  ? [FieldTypeRefOf<FieldState>] extends [never]
+    ? DescriptorTypeRef<FieldDescriptorOf<FieldState>>
+    : ResolveNamedStorageTypeKey<Definition, FieldTypeRefOf<FieldState>>
+  : undefined;
 
 type ResolveFieldColumnTypeParams<Definition, FieldState> = [
   ResolveFieldColumnTypeRef<Definition, FieldState>,
@@ -540,6 +557,7 @@ type BuiltStorageTables<Definition> = {
       };
       readonly target: {
         readonly namespaceId: NamespaceId;
+        readonly spaceId?: string;
         readonly tableName: string;
         readonly columns: readonly string[];
       };
@@ -563,10 +581,41 @@ type BuiltStorageTables<Definition> = {
     : Record<string, never>);
 };
 
+type DefinitionEnums<Definition> = Definition extends {
+  readonly enums?: infer E;
+}
+  ? Present<E> extends Record<string, EnumTypeHandle>
+    ? // A bare `Record<string, EnumTypeHandle>` (no literal keys) is the
+      // widened default for a contract authored without enums; treat it as
+      // empty so `db.enums` carries only literally-authored enums.
+      string extends keyof Present<E>
+      ? Record<never, never>
+      : Present<E>
+    : Record<never, never>
+  : Record<never, never>;
+
+type EnumHandleAccessorType<Handle> =
+  Handle extends EnumTypeHandle<infer _Name, infer Values, infer Names, infer MembersMap>
+    ? {
+        readonly values: Values;
+        readonly names: Names;
+        readonly members: MembersMap;
+        has(v: Values[number]): boolean;
+        nameOf(v: Values[number]): string | undefined;
+        ordinalOf(v: Values[number]): number;
+      }
+    : never;
+
+type BuiltEnumAccessors<Definition> = {
+  readonly [K in keyof DefinitionEnums<Definition>]: EnumHandleAccessorType<
+    DefinitionEnums<Definition>[K]
+  >;
+};
+
 type BuiltDocumentScopedTypes<Definition> = {
-  readonly [K in keyof DefinitionTypes<Definition> as DefinitionTypes<Definition>[K] extends PostgresEnumStorageEntry
-    ? never
-    : K]: DefinitionTypes<Definition>[K];
+  readonly [K in keyof DefinitionTypes<Definition> as DefinitionTypes<Definition>[K] extends StorageTypeInstance
+    ? K
+    : never]: DefinitionTypes<Definition>[K];
 };
 
 type BuiltDomain<Definition> =
@@ -586,19 +635,20 @@ type BuiltStorage<Definition> = {
   readonly types?: BuiltDocumentScopedTypes<Definition>;
   // The primary namespace key is target-specific: Postgres uses `public` (the
   // default schema), all other SQL targets use `__unbound__`. The namespace
-  // carries the narrowed tables shape so downstream DSL surfaces keep
+  // carries the narrowed `entries.table` shape so downstream DSL surfaces keep
   // literal-keyed access without an optional-narrowing dance. The shape is
   // described inline (rather than intersecting with `SqlStorage['namespaces']`)
   // so its `Readonly<Record<string, Namespace>>` index signature doesn't
-  // collapse `keyof tables` to `string`. The literal object is still
-  // structurally assignable to `SqlStorage['namespaces']` because every value
-  // satisfies the framework `Namespace` interface.
+  // collapse slot keys to `string`. The literal object is still structurally
+  // assignable to `SqlStorage['namespaces']` because every value satisfies the
+  // framework `Namespace` interface.
   readonly namespaces: {
     readonly [K in DefaultStorageNamespaceId<Definition>]: {
       readonly id: K;
       readonly kind: string;
-      readonly tables: BuiltStorageTables<Definition>;
-      readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
+      readonly entries: {
+        readonly table: BuiltStorageTables<Definition>;
+      };
     };
   } & {
     readonly [Ns in Exclude<
@@ -607,35 +657,60 @@ type BuiltStorage<Definition> = {
     >]: {
       readonly id: Ns;
       readonly kind: string;
-      readonly tables: Record<never, never>;
-      readonly enum?: Readonly<Record<string, PostgresEnumStorageEntry>>;
+      readonly entries: {
+        readonly table: Record<never, never>;
+      };
     };
   };
 };
 
-type FieldOutputType<
+// The enum value union for an enum-typed field, or `never` for a non-enum
+// field. The field's `typeRef` carries the authored `EnumTypeHandle`, whose
+// `Values` tuple preserves the literal member values (text or numeric).
+type EnumValueUnion<FieldState> = [FieldTypeRefOf<FieldState>] extends [
+  EnumTypeHandle<string, infer Values>,
+]
+  ? readonly unknown[] extends Values
+    ? never
+    : Values[number]
+  : never;
+
+// The codec's `output` / `input` JS type for a field's column, before
+// nullability. `unknown` when the codec is not in the definition's codec map.
+type CodecChannelType<
   Definition,
   ModelName extends ModelNames<Definition>,
   FieldName extends ModelFieldNames<Definition, ModelName>,
+  Channel extends 'output' | 'input',
+> = ModelStorageColumn<Definition, ModelName, FieldName>['codecId'] extends infer Id extends
+  keyof CodecTypesFromDefinition<Definition>
+  ? CodecTypesFromDefinition<Definition>[Id] extends { readonly [K in Channel]: infer T }
+    ? T
+    : unknown
+  : unknown;
+
+// A field's read/write JS type: the enum value union when the field is
+// enum-typed, otherwise the codec channel type, with column nullability applied.
+type FieldChannelType<
+  Definition,
+  ModelName extends ModelNames<Definition>,
+  FieldName extends ModelFieldNames<Definition, ModelName>,
+  Channel extends 'output' | 'input',
 > =
-  ModelStorageColumn<Definition, ModelName, FieldName> extends infer Col
-    ? Col extends { readonly codecId: infer Id extends string }
-      ? Id extends keyof CodecTypesFromDefinition<Definition>
-        ? CodecTypesFromDefinition<Definition>[Id] extends { readonly output: infer O }
-          ? Col extends { readonly nullable: true }
-            ? O | null
-            : O
-          : unknown
-        : unknown
-      : unknown
-    : unknown;
-
-type FieldOutputTypes<Definition> = {
+  | ([EnumValueUnion<ModelFieldState<Definition, ModelName, FieldName>>] extends [never]
+      ? CodecChannelType<Definition, ModelName, FieldName, Channel>
+      : EnumValueUnion<ModelFieldState<Definition, ModelName, FieldName>>)
+  | (FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>> extends true
+      ? null
+      : never);
+
+type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = {
   readonly [ModelName in ModelNames<Definition>]: {
-    readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldOutputType<
+    readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldChannelType<
       Definition,
       ModelName,
-      FieldName
+      FieldName,
+      Channel
     >;
   };
 };
@@ -649,11 +724,12 @@ export type SqlContractResult<Definition> = ContractWithTypeMaps<
       ? Record<string, never>
       : DefinitionExtensionPacks<Definition>;
     readonly capabilities: DerivedCapabilities<Definition>;
+    readonly enumAccessors: BuiltEnumAccessors<Definition>;
   },
   TypeMaps<
     CodecTypesFromDefinition<Definition>,
     Record<string, never>,
-    Record<string, never>,
-    FieldOutputTypes<Definition>
+    FieldChannelTypes<Definition, 'output'>,
+    FieldChannelTypes<Definition, 'input'>
   >
 >;