@prisma-next/sql-contract-ts 0.13.0 → 0.14.0

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',

package/src/contract-lowering.ts

@@ -1,10 +1,6 @@
 import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef } from '@prisma-next/framework-components/components';
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-  type StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type {
   ContractDefinition,
@@ -59,15 +55,15 @@ type RuntimeModelSpec = {
 };
 
 type RuntimeCollection = {
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly models: Record<string, RuntimeModel>;
   readonly modelSpecs: ReadonlyMap<string, RuntimeModelSpec>;
 };
 
 function buildStorageTypeReverseLookup(
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-): ReadonlyMap<StorageTypeInstance | PostgresEnumStorageEntry, string> {
-  const lookup = new Map<StorageTypeInstance | PostgresEnumStorageEntry, string>();
+  storageTypes: Record<string, StorageTypeInstance>,
+): ReadonlyMap<StorageTypeInstance, string> {
+  const lookup = new Map<StorageTypeInstance, string>();
   for (const [key, instance] of Object.entries(storageTypes)) {
     lookup.set(instance, key);
   }
@@ -78,8 +74,8 @@ function resolveFieldDescriptor(
   modelName: string,
   fieldName: string,
   fieldState: FieldStateOf<ScalarFieldBuilder>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance | PostgresEnumStorageEntry, string>,
+  storageTypes: Record<string, StorageTypeInstance>,
+  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance, string>,
 ): ColumnTypeDescriptor {
   if ('descriptor' in fieldState && fieldState.descriptor) {
     return fieldState.descriptor;
@@ -96,9 +92,7 @@ function resolveFieldDescriptor(
     const typeRef =
       typeof fieldState.typeRef === 'string'
         ? fieldState.typeRef
-        : storageTypeReverseLookup.get(
-            fieldState.typeRef as StorageTypeInstance | PostgresEnumStorageEntry,
-          );
+        : storageTypeReverseLookup.get(fieldState.typeRef as StorageTypeInstance);
 
     if (!typeRef) {
       throw new Error(
@@ -113,11 +107,8 @@ function resolveFieldDescriptor(
       );
     }
 
-    const codecId = isPostgresEnumStorageEntry(referencedType)
-      ? referencedType.codecId
-      : referencedType.codecId;
     return {
-      codecId,
+      codecId: referencedType.codecId,
       nativeType: referencedType.nativeType,
       typeRef,
     };
@@ -520,6 +511,7 @@ function lowerManyToManyRelation(
     cardinality: 'N:M',
     through: {
       table: throughSpec.tableName,
+      ...ifDefined('namespaceId', throughSpec.namespace),
       parentColumns: mapFieldNamesToColumnNames(
         throughSpec.modelName,
         throughFromFields,
@@ -705,8 +697,8 @@ function resolveForeignKeyNodes(
 function resolveModelNode(
   spec: RuntimeModelSpec,
   allSpecs: ReadonlyMap<string, RuntimeModelSpec>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
-  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance | PostgresEnumStorageEntry, string>,
+  storageTypes: Record<string, StorageTypeInstance>,
+  storageTypeReverseLookup: ReadonlyMap<StorageTypeInstance, string>,
   extensionPacks?: Record<string, ExtensionPackRef<'sql', string>>,
 ): ModelNode {
   const fields: FieldNode[] = [];
@@ -783,10 +775,7 @@ function resolveModelNode(
 }
 
 function collectRuntimeModelSpecs(definition: ContractInput): RuntimeCollection {
-  const storageTypes = { ...(definition.types ?? {}) } as Record<
-    string,
-    StorageTypeInstance | PostgresEnumStorageEntry
-  >;
+  const storageTypes = { ...(definition.types ?? {}) } as Record<string, StorageTypeInstance>;
   const models = { ...(definition.models ?? {}) } as Record<string, RuntimeModel>;
 
   emitTypedNamedTypeFallbackWarnings(models, storageTypes);
@@ -805,13 +794,17 @@ function collectRuntimeModelSpecs(definition: ContractInput): RuntimeCollection
     const attributesSpec = modelDefinition.buildAttributesSpec();
     const sqlSpec = modelDefinition.buildSqlSpec();
     const tableName = sqlSpec?.table ?? applyNaming(modelName, definition.naming?.tables);
-    const existingModel = tableOwners.get(tableName);
+    // Table names are unique per namespace, not globally. Key the collision
+    // check by a tuple so namespace/table boundaries remain unambiguous.
+    const namespaceId = modelDefinition.stageOne.namespace ?? definition.target.defaultNamespaceId;
+    const tableKey = JSON.stringify([namespaceId, tableName]);
+    const existingModel = tableOwners.get(tableKey);
     if (existingModel) {
       throw new Error(
         `Models "${existingModel}" and "${modelName}" both map to table "${tableName}".`,
       );
     }
-    tableOwners.set(tableName, modelName);
+    tableOwners.set(tableKey, modelName);
 
     const fieldToColumn: Record<string, string> = {};
     const columnOwners = new Map<string, string>();

package/src/contract-types.ts

@@ -1,7 +1,9 @@
 import type {
   ColumnDefault,
   Contract,
+  ContractEnum,
   ContractRelation,
+  ContractValueObject,
   NamespaceId,
   StorageHashBase,
 } from '@prisma-next/contract/types';
@@ -17,6 +19,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 +336,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 ResolveFieldDescriptor<Definition, FieldState> = [EnumFieldHandle<FieldState>] extends [never]
+  ? [FieldDescriptorOf<FieldState>] extends [never]
+    ? ResolveNamedStorageType<Definition, FieldTypeRefOf<FieldState>>
+    : FieldDescriptorOf<FieldState>
+  : EnumHandleDescriptor<EnumFieldHandle<FieldState>>;
 
-type ResolveFieldColumnTypeRef<Definition, FieldState> = [FieldTypeRefOf<FieldState>] extends [
+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 +583,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
@@ -573,6 +629,17 @@ type BuiltDomain<Definition> =
         };
       };
 
+// Per-namespace domain entry carrying the precise per-model field/storage shapes
+// for DSL inference. Modelled as an index signature (rather than enumerating
+// namespace ids) so that any namespace coordinate resolves the full model map,
+// matching how the authoring path lumps every model under the default storage
+// namespace.
+type BuiltDomainNamespace<Definition> = {
+  readonly models: BuiltModels<Definition>;
+  readonly valueObjects?: Record<string, ContractValueObject>;
+  readonly enum?: Record<string, ContractEnum>;
+};
+
 type DefaultStorageNamespaceId<Definition> =
   DefinitionTargetId<Definition> extends 'postgres' ? 'public' : '__unbound__';
 
@@ -610,47 +677,83 @@ 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> = {
-  readonly [ModelName in ModelNames<Definition>]: {
-    readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldOutputType<
-      Definition,
-      ModelName,
-      FieldName
-    >;
+  | ([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);
+
+// Nested by namespace coordinate (`{ [ns]: { [model]: { [field]: type } } }`)
+// to mirror the emitter's namespace-nested `FieldOutputTypes` (and the
+// `TypeMaps` constraint). The TS authoring path lumps every model under the
+// target's default storage namespace (see `BuiltStorage`), so the per-model
+// field-type map nests under that same coordinate.
+type FieldChannelTypes<Definition, Channel extends 'output' | 'input'> = {
+  readonly [Ns in DefaultStorageNamespaceId<Definition>]: {
+    readonly [ModelName in ModelNames<Definition>]: {
+      readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldChannelType<
+        Definition,
+        ModelName,
+        FieldName,
+        Channel
+      >;
+    };
   };
 };
 
 export type SqlContractResult<Definition> = ContractWithTypeMaps<
-  Contract<BuiltStorage<Definition>, BuiltModels<Definition>> & {
+  Omit<Contract<BuiltStorage<Definition>>, 'domain'> & {
     readonly target: DefinitionTargetId<Definition>;
     readonly targetFamily: 'sql';
-  } & { readonly domain: BuiltDomain<Definition> } & {
+  } & {
+    readonly domain: {
+      readonly namespaces: Readonly<Record<string, BuiltDomainNamespace<Definition>>>;
+    } & BuiltDomain<Definition>;
+  } & {
     readonly extensionPacks: keyof DefinitionExtensionPacks<Definition> extends never
       ? 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'>
   >
 >;

package/src/contract-warnings.ts

@@ -1,7 +1,4 @@
-import type {
-  PostgresEnumStorageEntry,
-  StorageTypeInstance,
-} from '@prisma-next/sql-contract/types';
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import {
   type ContractModelBuilder,
   type ModelAttributesSpec,
@@ -28,7 +25,7 @@ type RuntimeModelSpec = {
 };
 
 type RuntimeCollection = {
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly models: Record<string, RuntimeModel>;
   readonly modelSpecs: ReadonlyMap<string, RuntimeModelSpec>;
 };
@@ -136,7 +133,7 @@ function formatFallbackWarning(location: string, current: string, suggested: str
 
 export function emitTypedNamedTypeFallbackWarnings(
   models: Record<string, RuntimeModel>,
-  storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>,
+  storageTypes: Record<string, StorageTypeInstance>,
 ): void {
   const warnings: string[] = [];
   const warnedFields = new Set<string>();