@prisma-next/contract 0.14.0-dev.3 → 0.14.0-dev.31

package/dist/enum-accessor.d.mts

@@ -22,29 +22,12 @@ interface EnumAccessor {
   ordinalOf(v: JsonValue): number;
 }
 declare function createEnumAccessor(contractEnum: ContractEnum): EnumAccessor;
-/**
- * Build the enum-accessor map for a single namespace, keyed by enum name.
- * Each namespace facet exposes only its own enums — the IR keys enums under
- * `domain.namespaces[ns].enum`, so the same name in two namespaces resolves
- * independently rather than colliding in one flat map.
- */
 declare function buildEnumsMapForNamespace(domain: {
   readonly namespaces: Readonly<Record<string, {
     readonly enum?: Readonly<Record<string, ContractEnum>>;
   }>>;
 }, namespaceId: string): Record<string, EnumAccessor>;
-/**
- * Build the enum-accessor map for every namespace of a domain, keyed by
- * namespace id then enum name. This is the lane-agnostic enum surface the
- * `db.enums` facade member exposes: enums are contract metadata, the same
- * whether reached through the sql lane or the orm lane, so the facade builds
- * this once and projects it per target.
- */
-declare function buildNamespacedEnums(domain: {
-  readonly namespaces: Readonly<Record<string, {
-    readonly enum?: Readonly<Record<string, ContractEnum>>;
-  }>>;
-}): Record<string, Record<string, EnumAccessor>>;
+declare function buildNamespacedEnums<TContract extends Contract>(domain: TContract['domain']): NamespacedEnums<TContract>;
 type Present<T> = Exclude<T, undefined>;
 type EnumMemberEntry = {
   readonly name: string;
@@ -81,12 +64,12 @@ type EnumMemberNames<A> = A extends {
 } ? N : never;
 type EnumEntriesToAccessors<Enums> = { readonly [K in keyof Enums]: Enums[K] extends EnumEntry ? ContractEnumAccessor<Enums[K]> : never };
 type BuiltEnumAccessorsOf<TContract> = TContract extends {
-  readonly enumAccessors: infer A;
-} ? A : Record<never, never>;
+  readonly enumAccessors?: infer A;
+} ? Exclude<A, undefined> : Record<never, never>;
 type NamespaceEnumEntries<TNamespace> = TNamespace extends {
   readonly enum?: infer E;
 } ? unknown extends E ? Record<never, never> : Present<E> : Record<never, never>;
-type NamespaceEnumAccessors<TContract extends Contract, NsId extends keyof TContract['domain']['namespaces']> = EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>> & BuiltEnumAccessorsOf<TContract>;
+type NamespaceEnumAccessors<TContract extends Contract, NsId extends keyof TContract['domain']['namespaces']> = keyof BuiltEnumAccessorsOf<TContract> extends never ? EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>> : BuiltEnumAccessorsOf<TContract>;
 type NamespacedEnums<TContract extends Contract> = { readonly [Ns in keyof TContract['domain']['namespaces']]: NamespaceEnumAccessors<TContract, Ns> };
 //#endregion
 export { type ContractEnumAccessor, type EnumAccessor, type EnumMemberNames, type EnumValues, type NamespaceEnumAccessors, type NamespacedEnums, buildEnumsMapForNamespace, buildNamespacedEnums, createEnumAccessor };

package/dist/enum-accessor.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"enum-accessor.d.mts","names":[],"sources":["../src/enum-accessor.ts"],"mappings":";;;;;AAcA;;;;;;;;;UAAiB,YAAA;EAAA,SACN,MAAA,WAAiB,SAAA;EAAA,SACjB,KAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,SAAA;EAC1C,GAAA,CAAI,CAAA,EAAG,SAAA;EACP,OAAA,CAAQ,IAAA;EACR,MAAA,CAAO,CAAA,EAAG,SAAA;EACV,SAAA,CAAU,CAAA,EAAG,SAAA;AAAA;AAAA,iBAGC,kBAAA,CAAmB,YAAA,EAAc,YAAA,GAAe,YAAY;;;;;;;iBA6B5D,yBAAA,CACd,MAAA;EAAA,SACW,UAAA,EAAY,QAAA,CACnB,MAAA;IAAA,SAA0B,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA;AAAA,GAG7D,WAAA,WACC,MAAA,SAAe,YAAA;;AAvCM;AAGxB;;;;;iBAsDgB,oBAAA,CAAqB,MAAA;EAAA,SAC1B,UAAA,EAAY,QAAA,CACnB,MAAA;IAAA,SAA0B,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA;AAAA,IAEzD,MAAA,SAAe,MAAA,SAAe,YAAA;AAAA,KA0B7B,OAAA,MAAa,OAAO,CAAC,CAAA;AAAA,KAKrB,eAAA;EAAA,SAA6B,IAAA;EAAA,SAAuB,KAAA,EAAO,SAAS;AAAA;AAAA,KACpE,SAAA;EAAA,SAAuB,OAAA,WAAkB,eAAe;AAAA;AAAA,KAExD,eAAA,eAA8B,SAAA,2BACZ,KAAA,cAAmB,KAAA,YAAiB,CAAA,UAAW,eAAA,GAChE,KAAA,YAAiB,CAAA;AAAA,KAIlB,cAAA,eAA6B,SAAA,2BACX,KAAA,cAAmB,KAAA,YAAiB,CAAA,UAAW,eAAA,GAChE,KAAA,YAAiB,CAAA;AAAA,KAIlB,gBAAA,eAA+B,SAAA,qBACnB,KAAA,uBAA4B,CAAA,WAAY,CAAA;AAAA,KAM7C,oBAAA,eAAmC,SAAA;EAAA,SACpC,MAAA,EAAQ,eAAA,CAAgB,KAAA;EAAA,SACxB,KAAA,EAAO,cAAA,CAAe,KAAA;EAAA,SACtB,OAAA,EAAS,gBAAA,CAAiB,KAAA,GA9EnB;EAgFhB,GAAA,CAAI,CAAA,EAAG,SAAA,GAAY,CAAA,IAAK,eAAA,CAAgB,KAAA,WAhFZ;EAkF5B,OAAA,CAAQ,IAAA,WAAe,IAAA,IAAQ,OAAA,CAAQ,cAAA,CAAe,KAAA;EACtD,MAAA,CAAO,CAAA,EAAG,eAAA,CAAgB,KAAA;EAC1B,SAAA,CAAU,CAAA,EAAG,eAAA,CAAgB,KAAA;AAAA;;;;;;KAQnB,UAAA,MAAgB,CAAA;EAAA,SAAqB,MAAA,EAAQ,aAAa;AAAA,IAAc,CAAA;;;;KAKxE,eAAA,MAAqB,CAAA;EAAA,SAAqB,KAAA,EAAO,aAAa;AAAA,IAAc,CAAA;AAAA,KAEnF,sBAAA,iCACkB,KAAA,GAAQ,KAAA,CAAM,CAAA,UAAW,SAAA,GAAY,oBAAA,CAAqB,KAAA,CAAM,CAAA;AAAA,KAGlF,oBAAA,cAAkC,SAAA;EAAA,SAC5B,aAAA;AAAA,IAEP,CAAA,GACA,MAAM;AAAA,KAEL,oBAAA,eAAmC,UAAA;EAAA,SAC7B,IAAA;AAAA,oBAES,CAAA,GACd,MAAA,iBACA,OAAA,CAAQ,CAAA,IACV,MAAA;AAAA,KAKQ,sBAAA,mBACQ,QAAA,qBACC,SAAA,4BACjB,sBAAA,CAAuB,oBAAA,CAAqB,SAAA,yBAAkC,IAAA,MAChF,oBAAA,CAAqB,SAAA;AAAA,KAIX,eAAA,mBAAkC,QAAA,4BACtB,SAAA,2BAAoC,sBAAA,CAAuB,SAAA,EAAW,EAAA"}
+{"version":3,"file":"enum-accessor.d.mts","names":[],"sources":["../src/enum-accessor.ts"],"mappings":";;;;;AAeA;;;;;;;;;UAAiB,YAAA;EAAA,SACN,MAAA,WAAiB,SAAA;EAAA,SACjB,KAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,SAAA;EAC1C,GAAA,CAAI,CAAA,EAAG,SAAA;EACP,OAAA,CAAQ,IAAA;EACR,MAAA,CAAO,CAAA,EAAG,SAAA;EACV,SAAA,CAAU,CAAA,EAAG,SAAA;AAAA;AAAA,iBAGC,kBAAA,CAAmB,YAAA,EAAc,YAAA,GAAe,YAAY;AAAA,iBAuB5D,yBAAA,CACd,MAAA;EAAA,SACW,UAAA,EAAY,QAAA,CACnB,MAAA;IAAA,SAA0B,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA;AAAA,GAG7D,WAAA,WACC,MAAA,SAAe,YAAA;AAAA,iBAWF,oBAAA,mBAAuC,QAAA,EACrD,MAAA,EAAQ,SAAA,aACP,eAAA,CAAgB,SAAA;AAAA,KAWd,OAAA,MAAa,OAAO,CAAC,CAAA;AAAA,KAErB,eAAA;EAAA,SAA6B,IAAA;EAAA,SAAuB,KAAA,EAAO,SAAS;AAAA;AAAA,KACpE,SAAA;EAAA,SAAuB,OAAA,WAAkB,eAAe;AAAA;AAAA,KAExD,eAAA,eAA8B,SAAA,2BACZ,KAAA,cAAmB,KAAA,YAAiB,CAAA,UAAW,eAAA,GAChE,KAAA,YAAiB,CAAA;AAAA,KAIlB,cAAA,eAA6B,SAAA,2BACX,KAAA,cAAmB,KAAA,YAAiB,CAAA,UAAW,eAAA,GAChE,KAAA,YAAiB,CAAA;AAAA,KAIlB,gBAAA,eAA+B,SAAA,qBACnB,KAAA,uBAA4B,CAAA,WAAY,CAAA;AAAA,KAG7C,oBAAA,eAAmC,SAAA;EAAA,SACpC,MAAA,EAAQ,eAAA,CAAgB,KAAA;EAAA,SACxB,KAAA,EAAO,cAAA,CAAe,KAAA;EAAA,SACtB,OAAA,EAAS,gBAAA,CAAiB,KAAA,GApDE;EAsDrC,GAAA,CAAI,CAAA,EAAG,SAAA,GAAY,CAAA,IAAK,eAAA,CAAgB,KAAA,WAvDjB;EAyDvB,OAAA,CAAQ,IAAA,WAAe,IAAA,IAAQ,OAAA,CAAQ,cAAA,CAAe,KAAA;EACtD,MAAA,CAAO,CAAA,EAAG,eAAA,CAAgB,KAAA;EAC1B,SAAA,CAAU,CAAA,EAAG,eAAA,CAAgB,KAAA;AAAA;;;;;;KAQnB,UAAA,MAAgB,CAAA;EAAA,SAAqB,MAAA,EAAQ,aAAa;AAAA,IAAc,CAAA;;;;KAKxE,eAAA,MAAqB,CAAA;EAAA,SAAqB,KAAA,EAAO,aAAa;AAAA,IAAc,CAAA;AAAA,KAEnF,sBAAA,iCACkB,KAAA,GAAQ,KAAA,CAAM,CAAA,UAAW,SAAA,GAAY,oBAAA,CAAqB,KAAA,CAAM,CAAA;AAAA,KAGlF,oBAAA,cAAkC,SAAA;EAAA,SAC5B,aAAA;AAAA,IAEP,OAAA,CAAQ,CAAA,eACR,MAAA;AAAA,KAEC,oBAAA,eAAmC,UAAA;EAAA,SAC7B,IAAA;AAAA,oBAES,CAAA,GACd,MAAA,iBACA,OAAA,CAAQ,CAAA,IACV,MAAA;AAAA,KAIQ,sBAAA,mBACQ,QAAA,qBACC,SAAA,kCACX,oBAAA,CAAqB,SAAA,kBAC3B,sBAAA,CAAuB,oBAAA,CAAqB,SAAA,yBAAkC,IAAA,MAC9E,oBAAA,CAAqB,SAAA;AAAA,KAEb,eAAA,mBAAkC,QAAA,4BACtB,SAAA,2BAAoC,sBAAA,CAAuB,SAAA,EAAW,EAAA"}

package/dist/enum-accessor.mjs

@@ -1,3 +1,4 @@
+import { blindCast } from "@prisma-next/utils/casts";
 //#region src/enum-accessor.ts
 function createEnumAccessor(contractEnum) {
 	const values = Object.freeze(contractEnum.members.map((m) => m.value));
@@ -17,29 +18,16 @@ function createEnumAccessor(contractEnum) {
 		ordinalOf: (v) => valueToOrdinal.get(v) ?? -1
 	};
 }
-/**
-* Build the enum-accessor map for a single namespace, keyed by enum name.
-* Each namespace facet exposes only its own enums — the IR keys enums under
-* `domain.namespaces[ns].enum`, so the same name in two namespaces resolves
-* independently rather than colliding in one flat map.
-*/
 function buildEnumsMapForNamespace(domain, namespaceId) {
 	const result = {};
 	const namespace = domain.namespaces[namespaceId];
 	if (namespace?.enum) for (const [name, contractEnum] of Object.entries(namespace.enum)) result[name] = createEnumAccessor(contractEnum);
 	return result;
 }
-/**
-* Build the enum-accessor map for every namespace of a domain, keyed by
-* namespace id then enum name. This is the lane-agnostic enum surface the
-* `db.enums` facade member exposes: enums are contract metadata, the same
-* whether reached through the sql lane or the orm lane, so the facade builds
-* this once and projects it per target.
-*/
 function buildNamespacedEnums(domain) {
 	const result = {};
 	for (const namespaceId of Object.keys(domain.namespaces)) result[namespaceId] = buildEnumsMapForNamespace(domain, namespaceId);
-	return result;
+	return blindCast(result);
 }
 //#endregion
 export { buildEnumsMapForNamespace, buildNamespacedEnums, createEnumAccessor };

package/dist/enum-accessor.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"enum-accessor.mjs","names":[],"sources":["../src/enum-accessor.ts"],"sourcesContent":["import type { Contract } from './contract-types';\nimport type { ContractEnum } from './domain-types';\nimport type { JsonValue } from './types';\n\n/**\n * Runtime view of a domain enum, built at the client from the emitted\n * `ContractEnum` JSON (codec-encoded `JsonValue` members, literal types erased).\n *\n * This deliberately mirrors the accessor shape of the authoring-time\n * `EnumTypeHandle` (in `contract-ts`) rather than reusing it: that handle carries\n * the literal value generics and lives in the authoring layer, which the\n * foundation layer cannot depend on. The two are the same surface seen from the\n * two planes — authoring (typed) and runtime (validated JSON).\n */\nexport interface EnumAccessor {\n  readonly values: readonly JsonValue[];\n  readonly names: readonly string[];\n  readonly members: Readonly<Record<string, JsonValue>>;\n  has(v: JsonValue): boolean;\n  hasName(name: string): boolean;\n  nameOf(v: JsonValue): string | undefined;\n  ordinalOf(v: JsonValue): number;\n}\n\nexport function createEnumAccessor(contractEnum: ContractEnum): EnumAccessor {\n  const values = Object.freeze(contractEnum.members.map((m) => m.value));\n  const names = Object.freeze(contractEnum.members.map((m) => m.name));\n  const members: Readonly<Record<string, JsonValue>> = Object.freeze(\n    Object.fromEntries(contractEnum.members.map((m) => [m.name, m.value])),\n  );\n\n  const valueSet = new Set(values);\n  const nameSet = Object.freeze(new Set(names));\n  const valueToName = new Map(contractEnum.members.map((m) => [m.value, m.name]));\n  const valueToOrdinal = new Map(values.map((v, i) => [v, i]));\n\n  return {\n    values,\n    names,\n    members,\n    has: (v: JsonValue) => valueSet.has(v),\n    hasName: (name: string) => nameSet.has(name),\n    nameOf: (v: JsonValue) => valueToName.get(v),\n    ordinalOf: (v: JsonValue) => valueToOrdinal.get(v) ?? -1,\n  };\n}\n\n/**\n * Build the enum-accessor map for a single namespace, keyed by enum name.\n * Each namespace facet exposes only its own enums — the IR keys enums under\n * `domain.namespaces[ns].enum`, so the same name in two namespaces resolves\n * independently rather than colliding in one flat map.\n */\nexport function buildEnumsMapForNamespace(\n  domain: {\n    readonly namespaces: Readonly<\n      Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>\n    >;\n  },\n  namespaceId: string,\n): Record<string, EnumAccessor> {\n  const result: Record<string, EnumAccessor> = {};\n  const namespace = domain.namespaces[namespaceId];\n  if (namespace?.enum) {\n    for (const [name, contractEnum] of Object.entries(namespace.enum)) {\n      result[name] = createEnumAccessor(contractEnum);\n    }\n  }\n  return result;\n}\n\n/**\n * Build the enum-accessor map for every namespace of a domain, keyed by\n * namespace id then enum name. This is the lane-agnostic enum surface the\n * `db.enums` facade member exposes: enums are contract metadata, the same\n * whether reached through the sql lane or the orm lane, so the facade builds\n * this once and projects it per target.\n */\nexport function buildNamespacedEnums(domain: {\n  readonly namespaces: Readonly<\n    Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>\n  >;\n}): Record<string, Record<string, EnumAccessor>> {\n  const result: Record<string, Record<string, EnumAccessor>> = {};\n  for (const namespaceId of Object.keys(domain.namespaces)) {\n    result[namespaceId] = buildEnumsMapForNamespace(domain, namespaceId);\n  }\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Type-level projection of the namespaced enum surface.\n//\n// These types derive the literal-preserving accessor shape from the contract,\n// hung off the `db.enums` facade map (`db.enums.<ns>.<Name>`). They are the\n// same accessors the runtime builds above, but typed from the two emission\n// paths:\n//   - Emitted contracts carry the literal enum entries under\n//     `domain.namespaces[ns].enum`; each maps to a `ContractEnumAccessor`.\n//   - The no-emit (built) contract carries them flat on `enumAccessors`\n//     (already accessor-shaped, literal-preserving), since its built domain\n//     type does not narrow `namespaces[ns].enum`. All authored enums land in\n//     the single built namespace, so exposing the flat map per namespace is\n//     correct there.\n// Only `SqlContractResult` carries `enumAccessors`; emitted contracts never\n// do, so the two carriers never overlap.\n// ---------------------------------------------------------------------------\n\ntype Present<T> = Exclude<T, undefined>;\n\n// A domain enum entry as carried in `domain.namespaces[ns].enum[name]`: an\n// ordered member tuple. The no-emit (built) path preserves the literal member\n// values so the derived accessor keeps its literal `values`/`names`/`members`.\ntype EnumMemberEntry = { readonly name: string; readonly value: JsonValue };\ntype EnumEntry = { readonly members: readonly EnumMemberEntry[] };\n\ntype EnumEntryValues<Entry extends EnumEntry> = {\n  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry\n    ? Entry['members'][I]['value']\n    : never;\n};\n\ntype EnumEntryNames<Entry extends EnumEntry> = {\n  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry\n    ? Entry['members'][I]['name']\n    : never;\n};\n\ntype EnumEntryMembers<Entry extends EnumEntry> = {\n  readonly [M in Entry['members'][number] as M['name']]: M['value'];\n};\n\n// The runtime accessor shape for one enum, with literal `values`/`names`/\n// `members` derived from the entry's member tuple. Mirrors `EnumAccessor`'s\n// runtime surface and the authoring `EnumTypeHandle` accessor.\nexport type ContractEnumAccessor<Entry extends EnumEntry> = {\n  readonly values: EnumEntryValues<Entry>;\n  readonly names: EnumEntryNames<Entry>;\n  readonly members: EnumEntryMembers<Entry>;\n  /** Returns true and narrows `v` to the enum's value union when `v` is a declared member value. */\n  has(v: JsonValue): v is EnumEntryValues<Entry>[number];\n  /** Returns true and narrows `name` to the enum's member-name union when `name` is a declared member name. */\n  hasName(name: string): name is Extract<EnumEntryNames<Entry>[number], string>;\n  nameOf(v: EnumEntryValues<Entry>[number]): string | undefined;\n  ordinalOf(v: EnumEntryValues<Entry>[number]): number;\n};\n\n/**\n * The value union for a `ContractEnumAccessor`.\n * Use in function signatures to accept any declared enum value without re-exporting\n * the member type alias from the accessor's generic entry.\n */\nexport type EnumValues<A> = A extends { readonly values: ReadonlyArray<infer V> } ? V : never;\n\n/**\n * The member-name union for a `ContractEnumAccessor`.\n */\nexport type EnumMemberNames<A> = A extends { readonly names: ReadonlyArray<infer N> } ? N : never;\n\ntype EnumEntriesToAccessors<Enums> = {\n  readonly [K in keyof Enums]: Enums[K] extends EnumEntry ? ContractEnumAccessor<Enums[K]> : never;\n};\n\ntype BuiltEnumAccessorsOf<TContract> = TContract extends {\n  readonly enumAccessors: infer A;\n}\n  ? A\n  : Record<never, never>;\n\ntype NamespaceEnumEntries<TNamespace> = TNamespace extends {\n  readonly enum?: infer E;\n}\n  ? unknown extends E\n    ? Record<never, never>\n    : Present<E>\n  : Record<never, never>;\n\n// The per-namespace enum accessors. Each namespace exposes only its own enums\n// (the IR's `domain.namespaces[ns].enum`), so the same enum name in two\n// namespaces resolves to each namespace's own accessor.\nexport type NamespaceEnumAccessors<\n  TContract extends Contract,\n  NsId extends keyof TContract['domain']['namespaces'],\n> = EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>> &\n  BuiltEnumAccessorsOf<TContract>;\n\n// The lane-agnostic enum surface exposed on the `db.enums` facade member: a\n// namespace-keyed map projected per target exactly like `db.sql` / `db.orm`.\nexport type NamespacedEnums<TContract extends Contract> = {\n  readonly [Ns in keyof TContract['domain']['namespaces']]: NamespaceEnumAccessors<TContract, Ns>;\n};\n"],"mappings":";AAwBA,SAAgB,mBAAmB,cAA0C;CAC3E,MAAM,SAAS,OAAO,OAAO,aAAa,QAAQ,KAAK,MAAM,EAAE,KAAK,CAAC;CACrE,MAAM,QAAQ,OAAO,OAAO,aAAa,QAAQ,KAAK,MAAM,EAAE,IAAI,CAAC;CACnE,MAAM,UAA+C,OAAO,OAC1D,OAAO,YAAY,aAAa,QAAQ,KAAK,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CACvE;CAEA,MAAM,WAAW,IAAI,IAAI,MAAM;CAC/B,MAAM,UAAU,OAAO,OAAO,IAAI,IAAI,KAAK,CAAC;CAC5C,MAAM,cAAc,IAAI,IAAI,aAAa,QAAQ,KAAK,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;CAC9E,MAAM,iBAAiB,IAAI,IAAI,OAAO,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;CAE3D,OAAO;EACL;EACA;EACA;EACA,MAAM,MAAiB,SAAS,IAAI,CAAC;EACrC,UAAU,SAAiB,QAAQ,IAAI,IAAI;EAC3C,SAAS,MAAiB,YAAY,IAAI,CAAC;EAC3C,YAAY,MAAiB,eAAe,IAAI,CAAC,KAAK;CACxD;AACF;;;;;;;AAQA,SAAgB,0BACd,QAKA,aAC8B;CAC9B,MAAM,SAAuC,CAAC;CAC9C,MAAM,YAAY,OAAO,WAAW;CACpC,IAAI,WAAW,MACb,KAAK,MAAM,CAAC,MAAM,iBAAiB,OAAO,QAAQ,UAAU,IAAI,GAC9D,OAAO,QAAQ,mBAAmB,YAAY;CAGlD,OAAO;AACT;;;;;;;;AASA,SAAgB,qBAAqB,QAIY;CAC/C,MAAM,SAAuD,CAAC;CAC9D,KAAK,MAAM,eAAe,OAAO,KAAK,OAAO,UAAU,GACrD,OAAO,eAAe,0BAA0B,QAAQ,WAAW;CAErE,OAAO;AACT"}
+{"version":3,"file":"enum-accessor.mjs","names":[],"sources":["../src/enum-accessor.ts"],"sourcesContent":["import { blindCast } from '@prisma-next/utils/casts';\nimport type { Contract } from './contract-types';\nimport type { ContractEnum } from './domain-types';\nimport type { JsonValue } from './types';\n\n/**\n * Runtime view of a domain enum, built at the client from the emitted\n * `ContractEnum` JSON (codec-encoded `JsonValue` members, literal types erased).\n *\n * This deliberately mirrors the accessor shape of the authoring-time\n * `EnumTypeHandle` (in `contract-ts`) rather than reusing it: that handle carries\n * the literal value generics and lives in the authoring layer, which the\n * foundation layer cannot depend on. The two are the same surface seen from the\n * two planes — authoring (typed) and runtime (validated JSON).\n */\nexport interface EnumAccessor {\n  readonly values: readonly JsonValue[];\n  readonly names: readonly string[];\n  readonly members: Readonly<Record<string, JsonValue>>;\n  has(v: JsonValue): boolean;\n  hasName(name: string): boolean;\n  nameOf(v: JsonValue): string | undefined;\n  ordinalOf(v: JsonValue): number;\n}\n\nexport function createEnumAccessor(contractEnum: ContractEnum): EnumAccessor {\n  const values = Object.freeze(contractEnum.members.map((m) => m.value));\n  const names = Object.freeze(contractEnum.members.map((m) => m.name));\n  const members: Readonly<Record<string, JsonValue>> = Object.freeze(\n    Object.fromEntries(contractEnum.members.map((m) => [m.name, m.value])),\n  );\n\n  const valueSet = new Set(values);\n  const nameSet = Object.freeze(new Set(names));\n  const valueToName = new Map(contractEnum.members.map((m) => [m.value, m.name]));\n  const valueToOrdinal = new Map(values.map((v, i) => [v, i]));\n\n  return {\n    values,\n    names,\n    members,\n    has: (v: JsonValue) => valueSet.has(v),\n    hasName: (name: string) => nameSet.has(name),\n    nameOf: (v: JsonValue) => valueToName.get(v),\n    ordinalOf: (v: JsonValue) => valueToOrdinal.get(v) ?? -1,\n  };\n}\n\nexport function buildEnumsMapForNamespace(\n  domain: {\n    readonly namespaces: Readonly<\n      Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>\n    >;\n  },\n  namespaceId: string,\n): Record<string, EnumAccessor> {\n  const result: Record<string, EnumAccessor> = {};\n  const namespace = domain.namespaces[namespaceId];\n  if (namespace?.enum) {\n    for (const [name, contractEnum] of Object.entries(namespace.enum)) {\n      result[name] = createEnumAccessor(contractEnum);\n    }\n  }\n  return result;\n}\n\nexport function buildNamespacedEnums<TContract extends Contract>(\n  domain: TContract['domain'],\n): NamespacedEnums<TContract> {\n  const result: Record<string, Record<string, EnumAccessor>> = {};\n  for (const namespaceId of Object.keys(domain.namespaces)) {\n    result[namespaceId] = buildEnumsMapForNamespace(domain, namespaceId);\n  }\n  return blindCast<\n    NamespacedEnums<TContract>,\n    'built dynamically from domain.namespaces; the mapped-type shape cannot be proven statically'\n  >(result);\n}\n\ntype Present<T> = Exclude<T, undefined>;\n\ntype EnumMemberEntry = { readonly name: string; readonly value: JsonValue };\ntype EnumEntry = { readonly members: readonly EnumMemberEntry[] };\n\ntype EnumEntryValues<Entry extends EnumEntry> = {\n  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry\n    ? Entry['members'][I]['value']\n    : never;\n};\n\ntype EnumEntryNames<Entry extends EnumEntry> = {\n  readonly [I in keyof Entry['members']]: Entry['members'][I] extends EnumMemberEntry\n    ? Entry['members'][I]['name']\n    : never;\n};\n\ntype EnumEntryMembers<Entry extends EnumEntry> = {\n  readonly [M in Entry['members'][number] as M['name']]: M['value'];\n};\n\nexport type ContractEnumAccessor<Entry extends EnumEntry> = {\n  readonly values: EnumEntryValues<Entry>;\n  readonly names: EnumEntryNames<Entry>;\n  readonly members: EnumEntryMembers<Entry>;\n  /** Returns true and narrows `v` to the enum's value union when `v` is a declared member value. */\n  has(v: JsonValue): v is EnumEntryValues<Entry>[number];\n  /** Returns true and narrows `name` to the enum's member-name union when `name` is a declared member name. */\n  hasName(name: string): name is Extract<EnumEntryNames<Entry>[number], string>;\n  nameOf(v: EnumEntryValues<Entry>[number]): string | undefined;\n  ordinalOf(v: EnumEntryValues<Entry>[number]): number;\n};\n\n/**\n * The value union for a `ContractEnumAccessor`.\n * Use in function signatures to accept any declared enum value without re-exporting\n * the member type alias from the accessor's generic entry.\n */\nexport type EnumValues<A> = A extends { readonly values: ReadonlyArray<infer V> } ? V : never;\n\n/**\n * The member-name union for a `ContractEnumAccessor`.\n */\nexport type EnumMemberNames<A> = A extends { readonly names: ReadonlyArray<infer N> } ? N : never;\n\ntype EnumEntriesToAccessors<Enums> = {\n  readonly [K in keyof Enums]: Enums[K] extends EnumEntry ? ContractEnumAccessor<Enums[K]> : never;\n};\n\ntype BuiltEnumAccessorsOf<TContract> = TContract extends {\n  readonly enumAccessors?: infer A;\n}\n  ? Exclude<A, undefined>\n  : Record<never, never>;\n\ntype NamespaceEnumEntries<TNamespace> = TNamespace extends {\n  readonly enum?: infer E;\n}\n  ? unknown extends E\n    ? Record<never, never>\n    : Present<E>\n  : Record<never, never>;\n\n// When `enumAccessors` is present (TS-DSL contract), it is the sole source because merging\n// both carriers would create conflicting `values` types for the same enum key.\nexport type NamespaceEnumAccessors<\n  TContract extends Contract,\n  NsId extends keyof TContract['domain']['namespaces'],\n> = keyof BuiltEnumAccessorsOf<TContract> extends never\n  ? EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>>\n  : BuiltEnumAccessorsOf<TContract>;\n\nexport type NamespacedEnums<TContract extends Contract> = {\n  readonly [Ns in keyof TContract['domain']['namespaces']]: NamespaceEnumAccessors<TContract, Ns>;\n};\n"],"mappings":";;AAyBA,SAAgB,mBAAmB,cAA0C;CAC3E,MAAM,SAAS,OAAO,OAAO,aAAa,QAAQ,KAAK,MAAM,EAAE,KAAK,CAAC;CACrE,MAAM,QAAQ,OAAO,OAAO,aAAa,QAAQ,KAAK,MAAM,EAAE,IAAI,CAAC;CACnE,MAAM,UAA+C,OAAO,OAC1D,OAAO,YAAY,aAAa,QAAQ,KAAK,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CACvE;CAEA,MAAM,WAAW,IAAI,IAAI,MAAM;CAC/B,MAAM,UAAU,OAAO,OAAO,IAAI,IAAI,KAAK,CAAC;CAC5C,MAAM,cAAc,IAAI,IAAI,aAAa,QAAQ,KAAK,MAAM,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;CAC9E,MAAM,iBAAiB,IAAI,IAAI,OAAO,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;CAE3D,OAAO;EACL;EACA;EACA;EACA,MAAM,MAAiB,SAAS,IAAI,CAAC;EACrC,UAAU,SAAiB,QAAQ,IAAI,IAAI;EAC3C,SAAS,MAAiB,YAAY,IAAI,CAAC;EAC3C,YAAY,MAAiB,eAAe,IAAI,CAAC,KAAK;CACxD;AACF;AAEA,SAAgB,0BACd,QAKA,aAC8B;CAC9B,MAAM,SAAuC,CAAC;CAC9C,MAAM,YAAY,OAAO,WAAW;CACpC,IAAI,WAAW,MACb,KAAK,MAAM,CAAC,MAAM,iBAAiB,OAAO,QAAQ,UAAU,IAAI,GAC9D,OAAO,QAAQ,mBAAmB,YAAY;CAGlD,OAAO;AACT;AAEA,SAAgB,qBACd,QAC4B;CAC5B,MAAM,SAAuD,CAAC;CAC9D,KAAK,MAAM,eAAe,OAAO,KAAK,OAAO,UAAU,GACrD,OAAO,eAAe,0BAA0B,QAAQ,WAAW;CAErE,OAAO,UAGL,MAAM;AACV"}

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.14.0-dev.3",
+  "version": "0.14.0-dev.31",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
-    "@prisma-next/utils": "0.14.0-dev.3",
+    "@prisma-next/utils": "0.14.0-dev.31",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0"
   },
   "devDependencies": {
-    "@prisma-next/tsconfig": "0.14.0-dev.3",
-    "@prisma-next/tsdown": "0.14.0-dev.3",
+    "@prisma-next/tsconfig": "0.14.0-dev.31",
+    "@prisma-next/tsdown": "0.14.0-dev.31",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/enum-accessor.ts

@@ -1,3 +1,4 @@
+import { blindCast } from '@prisma-next/utils/casts';
 import type { Contract } from './contract-types';
 import type { ContractEnum } from './domain-types';
 import type { JsonValue } from './types';
@@ -45,12 +46,6 @@ export function createEnumAccessor(contractEnum: ContractEnum): EnumAccessor {
   };
 }
 
-/**
- * Build the enum-accessor map for a single namespace, keyed by enum name.
- * Each namespace facet exposes only its own enums — the IR keys enums under
- * `domain.namespaces[ns].enum`, so the same name in two namespaces resolves
- * independently rather than colliding in one flat map.
- */
 export function buildEnumsMapForNamespace(
   domain: {
     readonly namespaces: Readonly<
@@ -69,48 +64,21 @@ export function buildEnumsMapForNamespace(
   return result;
 }
 
-/**
- * Build the enum-accessor map for every namespace of a domain, keyed by
- * namespace id then enum name. This is the lane-agnostic enum surface the
- * `db.enums` facade member exposes: enums are contract metadata, the same
- * whether reached through the sql lane or the orm lane, so the facade builds
- * this once and projects it per target.
- */
-export function buildNamespacedEnums(domain: {
-  readonly namespaces: Readonly<
-    Record<string, { readonly enum?: Readonly<Record<string, ContractEnum>> }>
-  >;
-}): Record<string, Record<string, EnumAccessor>> {
+export function buildNamespacedEnums<TContract extends Contract>(
+  domain: TContract['domain'],
+): NamespacedEnums<TContract> {
   const result: Record<string, Record<string, EnumAccessor>> = {};
   for (const namespaceId of Object.keys(domain.namespaces)) {
     result[namespaceId] = buildEnumsMapForNamespace(domain, namespaceId);
   }
-  return result;
+  return blindCast<
+    NamespacedEnums<TContract>,
+    'built dynamically from domain.namespaces; the mapped-type shape cannot be proven statically'
+  >(result);
 }
 
-// ---------------------------------------------------------------------------
-// Type-level projection of the namespaced enum surface.
-//
-// These types derive the literal-preserving accessor shape from the contract,
-// hung off the `db.enums` facade map (`db.enums.<ns>.<Name>`). They are the
-// same accessors the runtime builds above, but typed from the two emission
-// paths:
-//   - Emitted contracts carry the literal enum entries under
-//     `domain.namespaces[ns].enum`; each maps to a `ContractEnumAccessor`.
-//   - The no-emit (built) contract carries them flat on `enumAccessors`
-//     (already accessor-shaped, literal-preserving), since its built domain
-//     type does not narrow `namespaces[ns].enum`. All authored enums land in
-//     the single built namespace, so exposing the flat map per namespace is
-//     correct there.
-// Only `SqlContractResult` carries `enumAccessors`; emitted contracts never
-// do, so the two carriers never overlap.
-// ---------------------------------------------------------------------------
-
 type Present<T> = Exclude<T, undefined>;
 
-// A domain enum entry as carried in `domain.namespaces[ns].enum[name]`: an
-// ordered member tuple. The no-emit (built) path preserves the literal member
-// values so the derived accessor keeps its literal `values`/`names`/`members`.
 type EnumMemberEntry = { readonly name: string; readonly value: JsonValue };
 type EnumEntry = { readonly members: readonly EnumMemberEntry[] };
 
@@ -130,9 +98,6 @@ type EnumEntryMembers<Entry extends EnumEntry> = {
   readonly [M in Entry['members'][number] as M['name']]: M['value'];
 };
 
-// The runtime accessor shape for one enum, with literal `values`/`names`/
-// `members` derived from the entry's member tuple. Mirrors `EnumAccessor`'s
-// runtime surface and the authoring `EnumTypeHandle` accessor.
 export type ContractEnumAccessor<Entry extends EnumEntry> = {
   readonly values: EnumEntryValues<Entry>;
   readonly names: EnumEntryNames<Entry>;
@@ -162,9 +127,9 @@ type EnumEntriesToAccessors<Enums> = {
 };
 
 type BuiltEnumAccessorsOf<TContract> = TContract extends {
-  readonly enumAccessors: infer A;
+  readonly enumAccessors?: infer A;
 }
-  ? A
+  ? Exclude<A, undefined>
   : Record<never, never>;
 
 type NamespaceEnumEntries<TNamespace> = TNamespace extends {
@@ -175,17 +140,15 @@ type NamespaceEnumEntries<TNamespace> = TNamespace extends {
     : Present<E>
   : Record<never, never>;
 
-// The per-namespace enum accessors. Each namespace exposes only its own enums
-// (the IR's `domain.namespaces[ns].enum`), so the same enum name in two
-// namespaces resolves to each namespace's own accessor.
+// When `enumAccessors` is present (TS-DSL contract), it is the sole source because merging
+// both carriers would create conflicting `values` types for the same enum key.
 export type NamespaceEnumAccessors<
   TContract extends Contract,
   NsId extends keyof TContract['domain']['namespaces'],
-> = EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>> &
-  BuiltEnumAccessorsOf<TContract>;
+> = keyof BuiltEnumAccessorsOf<TContract> extends never
+  ? EnumEntriesToAccessors<NamespaceEnumEntries<TContract['domain']['namespaces'][NsId]>>
+  : BuiltEnumAccessorsOf<TContract>;
 
-// The lane-agnostic enum surface exposed on the `db.enums` facade member: a
-// namespace-keyed map projected per target exactly like `db.sql` / `db.orm`.
 export type NamespacedEnums<TContract extends Contract> = {
   readonly [Ns in keyof TContract['domain']['namespaces']]: NamespaceEnumAccessors<TContract, Ns>;
 };