@prisma-next/sql-contract-ts 0.13.0-dev.2 → 0.13.0-dev.20

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@prisma-next/sql-contract-ts",
-  "version": "0.13.0-dev.2",
+  "version": "0.13.0-dev.20",
   "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.2",
-    "@prisma-next/contract": "0.13.0-dev.2",
-    "@prisma-next/contract-authoring": "0.13.0-dev.2",
-    "@prisma-next/framework-components": "0.13.0-dev.2",
-    "@prisma-next/sql-contract": "0.13.0-dev.2",
-    "@prisma-next/utils": "0.13.0-dev.2",
+    "@prisma-next/config": "0.13.0-dev.20",
+    "@prisma-next/contract": "0.13.0-dev.20",
+    "@prisma-next/contract-authoring": "0.13.0-dev.20",
+    "@prisma-next/framework-components": "0.13.0-dev.20",
+    "@prisma-next/sql-contract": "0.13.0-dev.20",
+    "@prisma-next/utils": "0.13.0-dev.20",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3",
     "ts-toolbelt": "^9.6.0"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.13.0-dev.2",
-    "@prisma-next/tsconfig": "0.13.0-dev.2",
+    "@prisma-next/test-utils": "0.13.0-dev.20",
+    "@prisma-next/tsconfig": "0.13.0-dev.20",
     "@types/pg": "8.20.0",
     "pg": "8.21.0",
-    "@prisma-next/tsdown": "0.13.0-dev.2",
+    "@prisma-next/tsdown": "0.13.0-dev.20",
     "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,
@@ -63,16 +62,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 +83,7 @@ function encodeColumnDefault(
   }
   return {
     kind: 'literal',
-    value: encodeDefaultLiteralValue(defaultInput.value, codecId, codecLookup),
+    value: encodeViaCodec(defaultInput.value, codecId, codecLookup),
   };
 }
 
@@ -451,9 +449,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 +460,7 @@ export function buildSqlContractFromDefinition(
               plane: 'domain',
               entityKind: 'enum',
               namespaceId: defaultNamespaceId,
-              name: enumHandle.enumName,
+              entityName: enumHandle.enumName,
             }
           : undefined;
 
@@ -771,7 +769,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 +781,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)),
     };
   }
 

package/src/contract-builder.ts

@@ -62,6 +62,7 @@ type ContractDefinition<
   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 +76,7 @@ type ContractDefinition<
   readonly types?: Types;
   readonly models?: Models;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractScaffold<
@@ -86,6 +87,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,7 +101,7 @@ type ContractScaffold<
   readonly types?: never;
   readonly models?: never;
   readonly codecLookup?: CodecLookup;
-  readonly enums?: Record<string, EnumTypeHandle>;
+  readonly enums?: Enums;
 };
 
 type ContractFactory<
@@ -108,9 +110,11 @@ type ContractFactory<
   Types extends Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
   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(
@@ -324,6 +328,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,
@@ -375,6 +393,7 @@ export function buildBoundContract<
   const Built extends {
     readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
     readonly models?: Record<string, ModelLike>;
+    readonly enums?: Record<string, EnumTypeHandle>;
   },
 >(
   family: F,
@@ -399,6 +418,7 @@ export function buildBoundContract(
       ) => {
         readonly types?: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
         readonly models?: Record<string, ModelLike>;
+        readonly enums?: Record<string, EnumTypeHandle>;
       })
     | undefined,
 ) {
@@ -412,10 +432,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),
     });
   }
 
@@ -437,6 +459,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 +470,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >,
 ): SqlContractResult<
   ContractDefinition<
@@ -459,7 +483,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    Enums
   >
 >;
 export function defineContract<
@@ -477,6 +502,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 +512,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 +526,8 @@ export function defineContract<
     Naming,
     StorageHash,
     ForeignKeyDefaults,
-    Namespaces
+    Namespaces,
+    MergeEnums<ScaffoldEnums, FactoryEnums>
   >
 >;
 export function defineContract(

package/src/contract-dsl.ts

@@ -338,6 +338,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>> {
@@ -373,16 +403,17 @@ function namedTypeField<TypeRef extends PostgresEnumStorageEntry>(
 ): 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',

package/src/contract-types.ts

@@ -17,6 +17,7 @@ import type {
 } 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 }>
@@ -333,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 EnumHandleDescriptor<Handle> = Handle extends {
+  readonly codecId: infer CodecId extends string;
+  readonly nativeType: infer NativeType extends string;
+}
+  ? { readonly codecId: CodecId; readonly nativeType: NativeType }
+  : never;
 
-type ResolveFieldColumnTypeRef<Definition, FieldState> = [FieldTypeRefOf<FieldState>] extends [
+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>,
@@ -558,6 +581,37 @@ 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 StorageTypeInstance
     ? K
@@ -610,29 +664,53 @@ type BuiltStorage<Definition> = {
   };
 };
 
-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
     >;
   };
 };
@@ -646,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'>
   >
 >;