@prisma-next/mongo-codec 0.5.0-dev.60 → 0.5.0-dev.62

package/README.md

@@ -4,10 +4,10 @@ Codec interface and registry for MongoDB value serialization.
 
 ## Responsibilities
 
-- **Codec interface**: `MongoCodec<Id, TTraits, TWire, TInput>` — declares how a JS value translates to and from the BSON-shaped wire format the Mongo driver exchanges, plus the JSON-safe form stored in contract artifacts. Carries trait annotations (`equality`, `order`, `boolean`, `numeric`, `textual`, `vector`) for operator gating. Same four generics as the framework `Codec` base.
+- **Codec interface**: `MongoCodec<Id, TTraits, TWire, TInput>` — declares how a JS value translates to and from the BSON-shaped wire format the Mongo driver exchanges, plus the JSON-safe form stored in contract artifacts. Same four generics as the framework `Codec` base; the codec instance carries only `id` plus the four conversion methods. Trait annotations (`equality`, `order`, `boolean`, `numeric`, `textual`, `vector`) for operator gating live on the unified `CodecDescriptor` (see [ADR 208](../../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md)).
 - **Codec factory**: `mongoCodec()` — creates frozen codec instances from a config object. Both `encode` and `decode` are required so `TInput` and `TWire` are always covered by an explicit author function — the factory installs no identity fallback. `encode` and `decode` may be authored as sync or async functions and are lifted to Promise-returning query-time methods automatically. Build-time methods (`encodeJson`, `decodeJson`) are synchronous and default to identity when omitted.
-- **Codec registry**: `MongoCodecRegistry` and `createMongoCodecRegistry()` — a map-based container that stores and retrieves codecs by ID, with duplicate-ID protection
-- **Type-level helpers**: `MongoCodecInput<T>` and `MongoCodecTraits<T>` for extracting the input JS type and traits from codec types
+- **Codec registry**: `MongoCodecRegistry` and `newMongoCodecRegistry()` — a map-based container that stores and retrieves codecs by ID, with duplicate-ID protection
+- **Type-level helper**: `MongoCodecInput<T>` for extracting the JS application type from a codec type. Trait metadata lives on the unified `CodecDescriptor` (see [ADR 208](../../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md)).
 
 ## Examples
 
@@ -15,7 +15,6 @@ Codec interface and registry for MongoDB value serialization.
 // Sync authoring:
 const intCodec = mongoCodec({
   typeId: 'mongo/int@1',
-  targetTypes: ['int'],
   encode: (v: number) => v,
   decode: (w: number) => w,
   encodeJson: (v: number) => v,
@@ -25,7 +24,6 @@ const intCodec = mongoCodec({
 // Async authoring (e.g. KMS-backed encryption): same factory, same shape.
 const secretCodec = mongoCodec({
   typeId: 'mongo/secret@1',
-  targetTypes: ['string'],
   encode: async (v: string) => encrypt(v, await getKey()),
   decode: async (w: string) => decrypt(w, await getKey()),
   encodeJson: (v: string) => v,
@@ -41,7 +39,6 @@ Codecs receive a second `ctx` options argument; you may ignore it. The Mongo run
 // Forward ctx.signal to a network SDK so aborted queries stop the round-trip.
 const kmsSecretCodec = mongoCodec({
   typeId: 'mongo/kms-secret@1',
-  targetTypes: ['string'],
   encode: async (v: string, ctx) =>
     kms.encrypt({ plaintext: v }, { signal: ctx?.signal }),
   decode: async (w: string, ctx) =>

package/dist/index.d.mts

@@ -4,22 +4,13 @@ import { Codec, CodecCallContext, CodecTrait } from "@prisma-next/framework-comp
 //#region src/codecs.d.ts
 type MongoCodecTrait = CodecTrait;
 /**
- * A codec for the Mongo target. Translates between an application value
- * and the BSON-shaped wire form the Mongo driver exchanges, and between
- * an application value and the JSON form stored in contract artifacts.
+ * A codec for the Mongo target. Translates between an application value and the BSON-shaped wire form the Mongo driver exchanges, and between an application value and the JSON form stored in contract artifacts.
  *
- * Same shape as the framework codec base — see `Codec` in
- * `@prisma-next/framework-components/codec` for the contract. The alias
- * exists so Mongo-specific metadata can be added here in future without
- * touching the framework base.
+ * Same shape as the framework codec base — see `Codec` in `@prisma-next/framework-components/codec` for the contract. Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified {@link import('@prisma-next/framework-components/codec').CodecDescriptor}; Mongo's full migration to descriptor-side registration is tracked under TML-2324.
  */
-type MongoCodec<Id extends string = string, TTraits$1 extends readonly MongoCodecTrait[] = readonly MongoCodecTrait[], TWire = unknown, TInput = unknown> = Codec<Id, TTraits$1, TWire, TInput>;
+interface MongoCodec<Id extends string = string, TTraits extends readonly MongoCodecTrait[] = readonly MongoCodecTrait[], TWire = unknown, TInput = unknown> extends Codec<Id, TTraits, TWire, TInput> {}
 /**
- * Conditional bundle for `encodeJson`/`decodeJson`: when `TInput` is
- * structurally assignable to `JsonValue` the identity defaults are
- * sound and both fields are optional; otherwise both fields are
- * required so an author cannot silently produce a non-JSON-safe
- * contract artifact.
+ * Conditional bundle for `encodeJson`/`decodeJson`: when `TInput` is structurally assignable to `JsonValue` the identity defaults are sound and both fields are optional; otherwise both fields are required so an author cannot silently produce a non-JSON-safe contract artifact.
  */
 type JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue] ? {
   encodeJson?: (value: TInput) => JsonValue;
@@ -31,29 +22,19 @@ type JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue] ? {
 /**
  * Construct a Mongo codec from author functions.
  *
- * Author `encode` and `decode` as sync or async functions; the factory
- * produces a {@link MongoCodec} whose query-time methods follow the
- * boundary contract documented on the framework {@link BaseCodec}.
- * Authors receive a second `ctx` options argument carrying the per-call
- * context; ignore it if you don't need it.
+ * Author `encode` and `decode` as sync or async functions; the factory produces a {@link MongoCodec} whose query-time methods follow the boundary contract documented on the framework {@link BaseCodec}. Authors receive a second `ctx` options argument carrying the per-call context; ignore it if you don't need it.
  *
- * Both `encode` and `decode` are required so `TInput` and `TWire` are
- * always covered by an explicit author function — the factory installs
- * no identity fallback. `encodeJson` and `decodeJson` default to identity
- * **only when `TInput` is assignable to `JsonValue`**; otherwise both are
- * required so the contract artifact stays JSON-safe.
+ * Both `encode` and `decode` are required so `TInput` and `TWire` are always covered by an explicit author function — the factory installs no identity fallback. `encodeJson` and `decodeJson` default to identity **only when `TInput` is assignable to `JsonValue`**; otherwise both are required so the contract artifact stays JSON-safe.
+ *
+ * Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified `CodecDescriptor` rather than on the codec instance itself (TML-2357).
  */
-declare function mongoCodec<Id extends string, const TTraits$1 extends readonly MongoCodecTrait[] = readonly [], TWire = unknown, TInput = unknown>(config: {
+declare function mongoCodec<Id extends string, const TTraits extends readonly MongoCodecTrait[] = readonly [], TWire = unknown, TInput = unknown>(config: {
   typeId: Id;
-  targetTypes: readonly string[];
-  traits?: TTraits$1;
   encode: (value: TInput, ctx: CodecCallContext) => TWire | Promise<TWire>;
   decode: (wire: TWire, ctx: CodecCallContext) => TInput | Promise<TInput>;
-  renderOutputType?: (typeParams: Record<string, unknown>) => string | undefined;
-} & JsonRoundTripConfig<TInput>): MongoCodec<Id, TTraits$1, TWire, TInput>;
+} & JsonRoundTripConfig<TInput>): MongoCodec<Id, TTraits, TWire, TInput>;
 /** Extract the JS application type carried by a Mongo codec — used both as `encode` input and as `decode` output. */
 type MongoCodecInput<T> = T extends MongoCodec<string, readonly MongoCodecTrait[], unknown, infer TInput> ? TInput : never;
-type MongoCodecTraits<T> = T extends MongoCodec<string, infer TTraits> ? TTraits[number] & MongoCodecTrait : never;
 //#endregion
 //#region src/codec-registry.d.ts
 interface MongoCodecRegistry {
@@ -63,7 +44,10 @@ interface MongoCodecRegistry {
   [Symbol.iterator](): Iterator<MongoCodec<string>>;
   values(): IterableIterator<MongoCodec<string>>;
 }
-declare function createMongoCodecRegistry(): MongoCodecRegistry;
+/**
+ * Create a new Mongo codec registry. Inline object literal — no class implementation; the registry is just a private `Map` with the documented surface methods.
+ */
+declare function newMongoCodecRegistry(): MongoCodecRegistry;
 //#endregion
-export { type MongoCodec, type MongoCodecInput, type MongoCodecRegistry, type MongoCodecTrait, type MongoCodecTraits, createMongoCodecRegistry, mongoCodec };
+export { type MongoCodec, type MongoCodecInput, type MongoCodecRegistry, type MongoCodecTrait, mongoCodec, newMongoCodecRegistry };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/codecs.ts","../src/codec-registry.ts"],"sourcesContent":[],"mappings":";;;;KAQY,eAAA,GAAkB;;AAA9B;AAYA;;;;;;;;AAKa,KALD,UAKC,CAAA,WAAA,MAAA,GAAA,MAAA,EAAA,kBAAA,SAHc,eAGd,EAAA,GAAA,SAH2C,eAG3C,EAAA,EAAA,QAAA,OAAA,EAAA,SAAA,OAAA,CAAA,GAAT,KAAS,CAAC,EAAD,EAAK,SAAL,EAAc,KAAd,EAAqB,MAArB,CAAA;AAA6B;;;;;;;KASrC,mBAMqB,CAAA,MAAA,CAAA,GAAA,CANU,MAMV,CAAA,SAAA,CAN2B,SAM3B,CAAA,GAAA;EAAW,UAAA,CAAA,EAAA,CAAA,KAAA,EAJV,MAIU,EAAA,GAJC,SAID;EACZ,UAAA,CAAA,EAAA,CAAA,IAAA,EAJC,SAID,EAAA,GAJe,MAIf;CAAc,GAAA;EAAM,UAAA,EAAA,CAAA,KAAA,EADnB,MACmB,EAAA,GADR,SACQ;EAkB7B,UAAA,EAAA,CAAU,IAAA,EAlBD,SAkBC,EAAA,GAlBa,MAkBb;CAEO;;;;;;;;;;;;;;;;AAYnB,iBAdE,UAcF,CAAA,WAAA,MAAA,EAAA,wBAAA,SAZmB,eAYnB,EAAA,GAAA,SAAA,EAAA,EAAA,QAAA,OAAA,EAAA,SAAA,OAAA,CAAA,CAAA,MAAA,EAAA;EAAI,MAAA,EAPN,EAOM;EAAS,WAAA,EAAA,SAAA,MAAA,EAAA;EAAO,MAAA,CAAA,EALrB,SAKqB;EAA/B,MAAA,EAAA,CAAA,KAAA,EAJiB,MAIjB,EAAA,GAAA,EAJ8B,gBAI9B,EAAA,GAJmD,KAInD,GAJ2D,OAI3D,CAJmE,KAInE,CAAA;EAAU,MAAA,EAAA,CAAA,IAAA,EAHM,KAGN,EAAA,GAAA,EAHkB,gBAGlB,EAAA,GAHuC,MAGvC,GAHgD,OAGhD,CAHwD,MAGxD,CAAA;EA0CD,gBAAA,CAAA,EAAe,CAAA,UAAA,EA5CS,MA4CT,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,MAAA,GAAA,SAAA;CACzB,GA5CI,mBA4CJ,CA5CwB,MA4CxB,CAAA,CAAA,EA3CC,UA2CD,CA3CY,EA2CZ,EA3CgB,SA2ChB,EA3CyB,KA2CzB,EA3CgC,MA2ChC,CAAA;;AAAU,KADA,eACA,CAAA,CAAA,CAAA,GAAV,CAAU,SAAA,UAAA,CAAA,MAAA,EAAA,SAA4B,eAA5B,EAAA,EAAA,OAAA,EAAA,KAAA,OAAA,CAAA,GAAA,MAAA,GAAA,KAAA;AAAU,KAEV,gBAFU,CAAA,CAAA,CAAA,GAGpB,CAHoB,SAGV,UAHU,CAAA,MAAA,EAAA,KAAA,QAAA,CAAA,GAG0B,OAH1B,CAAA,MAAA,CAAA,GAG4C,eAH5C,GAAA,KAAA;;;UClHL,kBAAA;mBACE;;EDKP,QAAA,CAAA,KAAA,ECHM,UDGS,CAAA,MAAG,CAAA,CAAA,EAAA,IAAU;EAY5B,CAAA,MAAA,CAAA,QAAU,GAAA,ECdC,QDcD,CCdU,UDcV,CAAA,MAAA,CAAA,CAAA;EAEK,MAAA,EAAA,ECff,gBDee,CCfE,UDeF,CAAA,MAAA,CAAA,CAAA;;AAGb,iBCYE,wBAAA,CAAA,CDZF,ECY8B,kBDZ9B"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/codecs.ts","../src/codec-registry.ts"],"sourcesContent":[],"mappings":";;;;KAOY,eAAA,GAAkB;;AAA9B;AAOA;;;AAKoB,UALH,UAKG,CAAA,WAAA,MAAA,GAAA,MAAA,EAAA,gBAAA,SAHO,eAGP,EAAA,GAAA,SAHoC,eAGpC,EAAA,EAAA,QAAA,OAAA,EAAA,SAAA,OAAA,CAAA,SAAV,KAAU,CAAA,EAAA,EAAI,OAAJ,EAAa,KAAb,EAAoB,MAApB,CAAA,CAAA;;;;KAKf,mBALc,CAAA,MAAA,CAAA,GAAA,CAKiB,MALjB,CAAA,SAAA,CAKkC,SALlC,CAAA,GAAA;EAKd,UAAA,CAAA,EAAA,CAAA,KAAA,EAEsB,MAFH,EAAA,GAEc,SAFd;EAAY,UAAA,CAAA,EAAA,CAAA,IAAA,EAGV,SAHU,EAAA,GAGI,MAHJ;CAAiB,GAAA;EAE1B,UAAA,EAAA,CAAA,KAAA,EAID,MAJC,EAAA,GAIU,SAJV;EAAW,UAAA,EAAA,CAAA,IAAA,EAKb,SALa,EAAA,GAKC,MALD;CACZ;;;;;;;AAgB1B;;;AAQoB,iBARJ,UAQI,CAAA,WAAA,MAAA,EAAA,sBAAA,SANa,eAMb,EAAA,GAAA,SAAA,EAAA,EAAA,QAAA,OAAA,EAAA,SAAA,OAAA,CAAA,CAAA,MAAA,EAAA;EAAa,MAAA,EADrB,EACqB;EAAqB,MAAA,EAAA,CAAA,KAAA,EAAlC,MAAkC,EAAA,GAAA,EAArB,gBAAqB,EAAA,GAAA,KAAA,GAAQ,OAAR,CAAgB,KAAhB,CAAA;EAAgB,MAAA,EAAA,CAAA,IAAA,EACnD,KADmD,EAAA,GAAA,EACvC,gBADuC,EAAA,GAClB,MADkB,GACT,OADS,CACD,MADC,CAAA;CAAR,GAExD,mBAFwD,CAEpC,MAFoC,CAAA,CAAA,EAG3D,UAH2D,CAGhD,EAHgD,EAG5C,OAH4C,EAGnC,KAHmC,EAG5B,MAH4B,CAAA;;AAC/B,KAiCnB,eAjCmB,CAAA,CAAA,CAAA,GAkC7B,CAlC6B,SAkCnB,UAlCmB,CAAA,MAAA,EAAA,SAkCS,eAlCT,EAAA,EAAA,OAAA,EAAA,KAAA,OAAA,CAAA,GAAA,MAAA,GAAA,KAAA;;;UClDd,kBAAA;mBACE;;EDIP,QAAA,CAAA,KAAA,ECFM,UDES,CAAA,MAAG,CAAA,CAAA,EAAA,IAAU;EAOvB,CAAA,MAAA,CAAA,QAAU,GAAA,ECRJ,QDQI,CCRK,UDQL,CAAA,MAAA,CAAA,CAAA;EAEA,MAAA,EAAA,ECTf,gBDSe,CCTE,UDSF,CAAA,MAAA,CAAA,CAAA;;;;;AAGa,iBCNxB,qBAAA,CAAA,CDMwB,ECNC,kBDMD"}

package/dist/index.mjs

@@ -1,27 +1,21 @@
-import { ifDefined } from "@prisma-next/utils/defined";
-
 //#region src/codec-registry.ts
-var MongoCodecRegistryImpl = class {
-	#byId = /* @__PURE__ */ new Map();
-	get(id) {
-		return this.#byId.get(id);
-	}
-	has(id) {
-		return this.#byId.has(id);
-	}
-	register(codec) {
-		if (this.#byId.has(codec.id)) throw new Error(`Codec with ID '${codec.id}' is already registered`);
-		this.#byId.set(codec.id, codec);
-	}
-	*[Symbol.iterator]() {
-		yield* this.#byId.values();
-	}
-	values() {
-		return this.#byId.values();
-	}
-};
-function createMongoCodecRegistry() {
-	return new MongoCodecRegistryImpl();
+/**
+* Create a new Mongo codec registry. Inline object literal — no class implementation; the registry is just a private `Map` with the documented surface methods.
+*/
+function newMongoCodecRegistry() {
+	const byId = /* @__PURE__ */ new Map();
+	return {
+		get: (id) => byId.get(id),
+		has: (id) => byId.has(id),
+		register: (codec) => {
+			if (byId.has(codec.id)) throw new Error(`Codec with ID '${codec.id}' is already registered`);
+			byId.set(codec.id, codec);
+		},
+		values: () => byId.values(),
+		[Symbol.iterator]: function* () {
+			yield* byId.values();
+		}
+	};
 }
 
 //#endregion
@@ -29,17 +23,11 @@ function createMongoCodecRegistry() {
 /**
 * Construct a Mongo codec from author functions.
 *
-* Author `encode` and `decode` as sync or async functions; the factory
-* produces a {@link MongoCodec} whose query-time methods follow the
-* boundary contract documented on the framework {@link BaseCodec}.
-* Authors receive a second `ctx` options argument carrying the per-call
-* context; ignore it if you don't need it.
+* Author `encode` and `decode` as sync or async functions; the factory produces a {@link MongoCodec} whose query-time methods follow the boundary contract documented on the framework {@link BaseCodec}. Authors receive a second `ctx` options argument carrying the per-call context; ignore it if you don't need it.
+*
+* Both `encode` and `decode` are required so `TInput` and `TWire` are always covered by an explicit author function — the factory installs no identity fallback. `encodeJson` and `decodeJson` default to identity **only when `TInput` is assignable to `JsonValue`**; otherwise both are required so the contract artifact stays JSON-safe.
 *
-* Both `encode` and `decode` are required so `TInput` and `TWire` are
-* always covered by an explicit author function — the factory installs
-* no identity fallback. `encodeJson` and `decodeJson` default to identity
-* **only when `TInput` is assignable to `JsonValue`**; otherwise both are
-* required so the contract artifact stays JSON-safe.
+* Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified `CodecDescriptor` rather than on the codec instance itself (TML-2357).
 */
 function mongoCodec(config) {
 	const identity = (v) => v;
@@ -48,9 +36,6 @@ function mongoCodec(config) {
 	const widenedConfig = config;
 	return {
 		id: config.typeId,
-		targetTypes: config.targetTypes,
-		...ifDefined("traits", config.traits ? Object.freeze([...config.traits]) : void 0),
-		...ifDefined("renderOutputType", config.renderOutputType),
 		encode: (value, ctx) => {
 			try {
 				return Promise.resolve(userEncode(value, ctx));
@@ -71,5 +56,5 @@ function mongoCodec(config) {
 }
 
 //#endregion
-export { createMongoCodecRegistry, mongoCodec };
+export { mongoCodec, newMongoCodecRegistry };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["#byId"],"sources":["../src/codec-registry.ts","../src/codecs.ts"],"sourcesContent":["import type { MongoCodec } from './codecs';\n\nexport interface MongoCodecRegistry {\n  get(id: string): MongoCodec<string> | undefined;\n  has(id: string): boolean;\n  register(codec: MongoCodec<string>): void;\n  [Symbol.iterator](): Iterator<MongoCodec<string>>;\n  values(): IterableIterator<MongoCodec<string>>;\n}\n\nclass MongoCodecRegistryImpl implements MongoCodecRegistry {\n  readonly #byId = new Map<string, MongoCodec<string>>();\n\n  get(id: string): MongoCodec<string> | undefined {\n    return this.#byId.get(id);\n  }\n\n  has(id: string): boolean {\n    return this.#byId.has(id);\n  }\n\n  register(codec: MongoCodec<string>): void {\n    if (this.#byId.has(codec.id)) {\n      throw new Error(`Codec with ID '${codec.id}' is already registered`);\n    }\n    this.#byId.set(codec.id, codec);\n  }\n\n  *[Symbol.iterator](): Iterator<MongoCodec<string>> {\n    yield* this.#byId.values();\n  }\n\n  values(): IterableIterator<MongoCodec<string>> {\n    return this.#byId.values();\n  }\n}\n\nexport function createMongoCodecRegistry(): MongoCodecRegistry {\n  return new MongoCodecRegistryImpl();\n}\n","import type { JsonValue } from '@prisma-next/contract/types';\nimport type {\n  Codec as BaseCodec,\n  CodecCallContext,\n  CodecTrait,\n} from '@prisma-next/framework-components/codec';\nimport { ifDefined } from '@prisma-next/utils/defined';\n\nexport type MongoCodecTrait = CodecTrait;\n\n/**\n * A codec for the Mongo target. Translates between an application value\n * and the BSON-shaped wire form the Mongo driver exchanges, and between\n * an application value and the JSON form stored in contract artifacts.\n *\n * Same shape as the framework codec base — see `Codec` in\n * `@prisma-next/framework-components/codec` for the contract. The alias\n * exists so Mongo-specific metadata can be added here in future without\n * touching the framework base.\n */\nexport type MongoCodec<\n  Id extends string = string,\n  TTraits extends readonly MongoCodecTrait[] = readonly MongoCodecTrait[],\n  TWire = unknown,\n  TInput = unknown,\n> = BaseCodec<Id, TTraits, TWire, TInput>;\n\n/**\n * Conditional bundle for `encodeJson`/`decodeJson`: when `TInput` is\n * structurally assignable to `JsonValue` the identity defaults are\n * sound and both fields are optional; otherwise both fields are\n * required so an author cannot silently produce a non-JSON-safe\n * contract artifact.\n */\ntype JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue]\n  ? {\n      encodeJson?: (value: TInput) => JsonValue;\n      decodeJson?: (json: JsonValue) => TInput;\n    }\n  : {\n      encodeJson: (value: TInput) => JsonValue;\n      decodeJson: (json: JsonValue) => TInput;\n    };\n\n/**\n * Construct a Mongo codec from author functions.\n *\n * Author `encode` and `decode` as sync or async functions; the factory\n * produces a {@link MongoCodec} whose query-time methods follow the\n * boundary contract documented on the framework {@link BaseCodec}.\n * Authors receive a second `ctx` options argument carrying the per-call\n * context; ignore it if you don't need it.\n *\n * Both `encode` and `decode` are required so `TInput` and `TWire` are\n * always covered by an explicit author function — the factory installs\n * no identity fallback. `encodeJson` and `decodeJson` default to identity\n * **only when `TInput` is assignable to `JsonValue`**; otherwise both are\n * required so the contract artifact stays JSON-safe.\n */\nexport function mongoCodec<\n  Id extends string,\n  const TTraits extends readonly MongoCodecTrait[] = readonly [],\n  TWire = unknown,\n  TInput = unknown,\n>(\n  config: {\n    typeId: Id;\n    targetTypes: readonly string[];\n    traits?: TTraits;\n    encode: (value: TInput, ctx: CodecCallContext) => TWire | Promise<TWire>;\n    decode: (wire: TWire, ctx: CodecCallContext) => TInput | Promise<TInput>;\n    renderOutputType?: (typeParams: Record<string, unknown>) => string | undefined;\n  } & JsonRoundTripConfig<TInput>,\n): MongoCodec<Id, TTraits, TWire, TInput> {\n  const identity = (v: unknown) => v;\n  // The runtime allocates one `CodecCallContext` per `runtime.execute()`\n  // call (no caller-supplied `signal` produces `{}` instead of `undefined`)\n  // and threads it as a non-optional reference to every codec call. The\n  // author surface keeps the second parameter optional so single-arg\n  // `(value) => …` authors continue to satisfy the signature via\n  // TypeScript's bivariance for trailing parameters.\n  const userEncode = config.encode;\n  const userDecode = config.decode;\n  const widenedConfig = config as {\n    encodeJson?: (value: TInput) => JsonValue;\n    decodeJson?: (json: JsonValue) => TInput;\n  };\n  return {\n    id: config.typeId,\n    targetTypes: config.targetTypes,\n    ...ifDefined(\n      'traits',\n      config.traits ? (Object.freeze([...config.traits]) as TTraits) : undefined,\n    ),\n    ...ifDefined('renderOutputType', config.renderOutputType),\n    encode: (value, ctx) => {\n      try {\n        return Promise.resolve(userEncode(value, ctx));\n      } catch (error) {\n        return Promise.reject(error);\n      }\n    },\n    decode: (wire, ctx) => {\n      try {\n        return Promise.resolve(userDecode(wire, ctx));\n      } catch (error) {\n        return Promise.reject(error);\n      }\n    },\n    encodeJson: (widenedConfig.encodeJson ?? identity) as (value: TInput) => JsonValue,\n    decodeJson: (widenedConfig.decodeJson ?? identity) as (json: JsonValue) => TInput,\n  };\n}\n\n/** Extract the JS application type carried by a Mongo codec — used both as `encode` input and as `decode` output. */\nexport type MongoCodecInput<T> =\n  T extends MongoCodec<string, readonly MongoCodecTrait[], unknown, infer TInput> ? TInput : never;\n\nexport type MongoCodecTraits<T> =\n  T extends MongoCodec<string, infer TTraits> ? TTraits[number] & MongoCodecTrait : never;\n"],"mappings":";;;AAUA,IAAM,yBAAN,MAA2D;CACzD,CAASA,uBAAQ,IAAI,KAAiC;CAEtD,IAAI,IAA4C;AAC9C,SAAO,MAAKA,KAAM,IAAI,GAAG;;CAG3B,IAAI,IAAqB;AACvB,SAAO,MAAKA,KAAM,IAAI,GAAG;;CAG3B,SAAS,OAAiC;AACxC,MAAI,MAAKA,KAAM,IAAI,MAAM,GAAG,CAC1B,OAAM,IAAI,MAAM,kBAAkB,MAAM,GAAG,yBAAyB;AAEtE,QAAKA,KAAM,IAAI,MAAM,IAAI,MAAM;;CAGjC,EAAE,OAAO,YAA0C;AACjD,SAAO,MAAKA,KAAM,QAAQ;;CAG5B,SAA+C;AAC7C,SAAO,MAAKA,KAAM,QAAQ;;;AAI9B,SAAgB,2BAA+C;AAC7D,QAAO,IAAI,wBAAwB;;;;;;;;;;;;;;;;;;;;ACqBrC,SAAgB,WAMd,QAQwC;CACxC,MAAM,YAAY,MAAe;CAOjC,MAAM,aAAa,OAAO;CAC1B,MAAM,aAAa,OAAO;CAC1B,MAAM,gBAAgB;AAItB,QAAO;EACL,IAAI,OAAO;EACX,aAAa,OAAO;EACpB,GAAG,UACD,UACA,OAAO,SAAU,OAAO,OAAO,CAAC,GAAG,OAAO,OAAO,CAAC,GAAe,OAClE;EACD,GAAG,UAAU,oBAAoB,OAAO,iBAAiB;EACzD,SAAS,OAAO,QAAQ;AACtB,OAAI;AACF,WAAO,QAAQ,QAAQ,WAAW,OAAO,IAAI,CAAC;YACvC,OAAO;AACd,WAAO,QAAQ,OAAO,MAAM;;;EAGhC,SAAS,MAAM,QAAQ;AACrB,OAAI;AACF,WAAO,QAAQ,QAAQ,WAAW,MAAM,IAAI,CAAC;YACtC,OAAO;AACd,WAAO,QAAQ,OAAO,MAAM;;;EAGhC,YAAa,cAAc,cAAc;EACzC,YAAa,cAAc,cAAc;EAC1C"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/codec-registry.ts","../src/codecs.ts"],"sourcesContent":["import type { MongoCodec } from './codecs';\n\nexport interface MongoCodecRegistry {\n  get(id: string): MongoCodec<string> | undefined;\n  has(id: string): boolean;\n  register(codec: MongoCodec<string>): void;\n  [Symbol.iterator](): Iterator<MongoCodec<string>>;\n  values(): IterableIterator<MongoCodec<string>>;\n}\n\n/**\n * Create a new Mongo codec registry. Inline object literal — no class implementation; the registry is just a private `Map` with the documented surface methods.\n */\nexport function newMongoCodecRegistry(): MongoCodecRegistry {\n  const byId = new Map<string, MongoCodec<string>>();\n  return {\n    get: (id) => byId.get(id),\n    has: (id) => byId.has(id),\n    register: (codec) => {\n      if (byId.has(codec.id)) {\n        throw new Error(`Codec with ID '${codec.id}' is already registered`);\n      }\n      byId.set(codec.id, codec);\n    },\n    values: () => byId.values(),\n    [Symbol.iterator]: function* () {\n      yield* byId.values();\n    },\n  };\n}\n","import type { JsonValue } from '@prisma-next/contract/types';\nimport type {\n  Codec as BaseCodec,\n  CodecCallContext,\n  CodecTrait,\n} from '@prisma-next/framework-components/codec';\n\nexport type MongoCodecTrait = CodecTrait;\n\n/**\n * A codec for the Mongo target. Translates between an application value and the BSON-shaped wire form the Mongo driver exchanges, and between an application value and the JSON form stored in contract artifacts.\n *\n * Same shape as the framework codec base — see `Codec` in `@prisma-next/framework-components/codec` for the contract. Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified {@link import('@prisma-next/framework-components/codec').CodecDescriptor}; Mongo's full migration to descriptor-side registration is tracked under TML-2324.\n */\nexport interface MongoCodec<\n  Id extends string = string,\n  TTraits extends readonly MongoCodecTrait[] = readonly MongoCodecTrait[],\n  TWire = unknown,\n  TInput = unknown,\n> extends BaseCodec<Id, TTraits, TWire, TInput> {}\n\n/**\n * Conditional bundle for `encodeJson`/`decodeJson`: when `TInput` is structurally assignable to `JsonValue` the identity defaults are sound and both fields are optional; otherwise both fields are required so an author cannot silently produce a non-JSON-safe contract artifact.\n */\ntype JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue]\n  ? {\n      encodeJson?: (value: TInput) => JsonValue;\n      decodeJson?: (json: JsonValue) => TInput;\n    }\n  : {\n      encodeJson: (value: TInput) => JsonValue;\n      decodeJson: (json: JsonValue) => TInput;\n    };\n\n/**\n * Construct a Mongo codec from author functions.\n *\n * Author `encode` and `decode` as sync or async functions; the factory produces a {@link MongoCodec} whose query-time methods follow the boundary contract documented on the framework {@link BaseCodec}. Authors receive a second `ctx` options argument carrying the per-call context; ignore it if you don't need it.\n *\n * Both `encode` and `decode` are required so `TInput` and `TWire` are always covered by an explicit author function — the factory installs no identity fallback. `encodeJson` and `decodeJson` default to identity **only when `TInput` is assignable to `JsonValue`**; otherwise both are required so the contract artifact stays JSON-safe.\n *\n * Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified `CodecDescriptor` rather than on the codec instance itself (TML-2357).\n */\nexport function mongoCodec<\n  Id extends string,\n  const TTraits extends readonly MongoCodecTrait[] = readonly [],\n  TWire = unknown,\n  TInput = unknown,\n>(\n  config: {\n    typeId: Id;\n    encode: (value: TInput, ctx: CodecCallContext) => TWire | Promise<TWire>;\n    decode: (wire: TWire, ctx: CodecCallContext) => TInput | Promise<TInput>;\n  } & JsonRoundTripConfig<TInput>,\n): MongoCodec<Id, TTraits, TWire, TInput> {\n  const identity = (v: unknown) => v;\n  // The runtime allocates one `CodecCallContext` per `runtime.execute()` call (no caller-supplied `signal` produces `{}` instead of `undefined`) and threads it as a non-optional reference to every codec call. The author surface keeps the second parameter optional so single-arg `(value) => …` authors continue to satisfy the signature via TypeScript's bivariance for trailing parameters.\n  const userEncode = config.encode;\n  const userDecode = config.decode;\n  const widenedConfig = config as {\n    encodeJson?: (value: TInput) => JsonValue;\n    decodeJson?: (json: JsonValue) => TInput;\n  };\n  return {\n    id: config.typeId,\n    encode: (value, ctx) => {\n      try {\n        return Promise.resolve(userEncode(value, ctx));\n      } catch (error) {\n        return Promise.reject(error);\n      }\n    },\n    decode: (wire, ctx) => {\n      try {\n        return Promise.resolve(userDecode(wire, ctx));\n      } catch (error) {\n        return Promise.reject(error);\n      }\n    },\n    encodeJson: (widenedConfig.encodeJson ?? identity) as (value: TInput) => JsonValue,\n    decodeJson: (widenedConfig.decodeJson ?? identity) as (json: JsonValue) => TInput,\n  };\n}\n\n/** Extract the JS application type carried by a Mongo codec — used both as `encode` input and as `decode` output. */\nexport type MongoCodecInput<T> =\n  T extends MongoCodec<string, readonly MongoCodecTrait[], unknown, infer TInput> ? TInput : never;\n"],"mappings":";;;;AAaA,SAAgB,wBAA4C;CAC1D,MAAM,uBAAO,IAAI,KAAiC;AAClD,QAAO;EACL,MAAM,OAAO,KAAK,IAAI,GAAG;EACzB,MAAM,OAAO,KAAK,IAAI,GAAG;EACzB,WAAW,UAAU;AACnB,OAAI,KAAK,IAAI,MAAM,GAAG,CACpB,OAAM,IAAI,MAAM,kBAAkB,MAAM,GAAG,yBAAyB;AAEtE,QAAK,IAAI,MAAM,IAAI,MAAM;;EAE3B,cAAc,KAAK,QAAQ;EAC3B,CAAC,OAAO,WAAW,aAAa;AAC9B,UAAO,KAAK,QAAQ;;EAEvB;;;;;;;;;;;;;;ACeH,SAAgB,WAMd,QAKwC;CACxC,MAAM,YAAY,MAAe;CAEjC,MAAM,aAAa,OAAO;CAC1B,MAAM,aAAa,OAAO;CAC1B,MAAM,gBAAgB;AAItB,QAAO;EACL,IAAI,OAAO;EACX,SAAS,OAAO,QAAQ;AACtB,OAAI;AACF,WAAO,QAAQ,QAAQ,WAAW,OAAO,IAAI,CAAC;YACvC,OAAO;AACd,WAAO,QAAQ,OAAO,MAAM;;;EAGhC,SAAS,MAAM,QAAQ;AACrB,OAAI;AACF,WAAO,QAAQ,QAAQ,WAAW,MAAM,IAAI,CAAC;YACtC,OAAO;AACd,WAAO,QAAQ,OAAO,MAAM;;;EAGhC,YAAa,cAAc,cAAc;EACzC,YAAa,cAAc,cAAc;EAC1C"}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@prisma-next/mongo-codec",
-  "version": "0.5.0-dev.60",
+  "version": "0.5.0-dev.62",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Codec interface and registry for Prisma Next MongoDB support",
   "dependencies": {
-    "@prisma-next/contract": "0.5.0-dev.60",
-    "@prisma-next/framework-components": "0.5.0-dev.60",
-    "@prisma-next/utils": "0.5.0-dev.60"
+    "@prisma-next/contract": "0.5.0-dev.62",
+    "@prisma-next/framework-components": "0.5.0-dev.62",
+    "@prisma-next/utils": "0.5.0-dev.62"
   },
   "devDependencies": {
     "tsdown": "0.18.4",

package/src/codec-registry.ts

@@ -8,33 +8,23 @@ export interface MongoCodecRegistry {
   values(): IterableIterator<MongoCodec<string>>;
 }
 
-class MongoCodecRegistryImpl implements MongoCodecRegistry {
-  readonly #byId = new Map<string, MongoCodec<string>>();
-
-  get(id: string): MongoCodec<string> | undefined {
-    return this.#byId.get(id);
-  }
-
-  has(id: string): boolean {
-    return this.#byId.has(id);
-  }
-
-  register(codec: MongoCodec<string>): void {
-    if (this.#byId.has(codec.id)) {
-      throw new Error(`Codec with ID '${codec.id}' is already registered`);
-    }
-    this.#byId.set(codec.id, codec);
-  }
-
-  *[Symbol.iterator](): Iterator<MongoCodec<string>> {
-    yield* this.#byId.values();
-  }
-
-  values(): IterableIterator<MongoCodec<string>> {
-    return this.#byId.values();
-  }
-}
-
-export function createMongoCodecRegistry(): MongoCodecRegistry {
-  return new MongoCodecRegistryImpl();
+/**
+ * Create a new Mongo codec registry. Inline object literal — no class implementation; the registry is just a private `Map` with the documented surface methods.
+ */
+export function newMongoCodecRegistry(): MongoCodecRegistry {
+  const byId = new Map<string, MongoCodec<string>>();
+  return {
+    get: (id) => byId.get(id),
+    has: (id) => byId.has(id),
+    register: (codec) => {
+      if (byId.has(codec.id)) {
+        throw new Error(`Codec with ID '${codec.id}' is already registered`);
+      }
+      byId.set(codec.id, codec);
+    },
+    values: () => byId.values(),
+    [Symbol.iterator]: function* () {
+      yield* byId.values();
+    },
+  };
 }

package/src/codecs.ts

@@ -4,33 +4,23 @@ import type {
   CodecCallContext,
   CodecTrait,
 } from '@prisma-next/framework-components/codec';
-import { ifDefined } from '@prisma-next/utils/defined';
 
 export type MongoCodecTrait = CodecTrait;
 
 /**
- * A codec for the Mongo target. Translates between an application value
- * and the BSON-shaped wire form the Mongo driver exchanges, and between
- * an application value and the JSON form stored in contract artifacts.
+ * A codec for the Mongo target. Translates between an application value and the BSON-shaped wire form the Mongo driver exchanges, and between an application value and the JSON form stored in contract artifacts.
  *
- * Same shape as the framework codec base — see `Codec` in
- * `@prisma-next/framework-components/codec` for the contract. The alias
- * exists so Mongo-specific metadata can be added here in future without
- * touching the framework base.
+ * Same shape as the framework codec base — see `Codec` in `@prisma-next/framework-components/codec` for the contract. Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified {@link import('@prisma-next/framework-components/codec').CodecDescriptor}; Mongo's full migration to descriptor-side registration is tracked under TML-2324.
  */
-export type MongoCodec<
+export interface MongoCodec<
   Id extends string = string,
   TTraits extends readonly MongoCodecTrait[] = readonly MongoCodecTrait[],
   TWire = unknown,
   TInput = unknown,
-> = BaseCodec<Id, TTraits, TWire, TInput>;
+> extends BaseCodec<Id, TTraits, TWire, TInput> {}
 
 /**
- * Conditional bundle for `encodeJson`/`decodeJson`: when `TInput` is
- * structurally assignable to `JsonValue` the identity defaults are
- * sound and both fields are optional; otherwise both fields are
- * required so an author cannot silently produce a non-JSON-safe
- * contract artifact.
+ * Conditional bundle for `encodeJson`/`decodeJson`: when `TInput` is structurally assignable to `JsonValue` the identity defaults are sound and both fields are optional; otherwise both fields are required so an author cannot silently produce a non-JSON-safe contract artifact.
  */
 type JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue]
   ? {
@@ -45,17 +35,11 @@ type JsonRoundTripConfig<TInput> = [TInput] extends [JsonValue]
 /**
  * Construct a Mongo codec from author functions.
  *
- * Author `encode` and `decode` as sync or async functions; the factory
- * produces a {@link MongoCodec} whose query-time methods follow the
- * boundary contract documented on the framework {@link BaseCodec}.
- * Authors receive a second `ctx` options argument carrying the per-call
- * context; ignore it if you don't need it.
+ * Author `encode` and `decode` as sync or async functions; the factory produces a {@link MongoCodec} whose query-time methods follow the boundary contract documented on the framework {@link BaseCodec}. Authors receive a second `ctx` options argument carrying the per-call context; ignore it if you don't need it.
  *
- * Both `encode` and `decode` are required so `TInput` and `TWire` are
- * always covered by an explicit author function — the factory installs
- * no identity fallback. `encodeJson` and `decodeJson` default to identity
- * **only when `TInput` is assignable to `JsonValue`**; otherwise both are
- * required so the contract artifact stays JSON-safe.
+ * Both `encode` and `decode` are required so `TInput` and `TWire` are always covered by an explicit author function — the factory installs no identity fallback. `encodeJson` and `decodeJson` default to identity **only when `TInput` is assignable to `JsonValue`**; otherwise both are required so the contract artifact stays JSON-safe.
+ *
+ * Codec-id-keyed static metadata (`traits`, `targetTypes`, `renderOutputType`) lives on the unified `CodecDescriptor` rather than on the codec instance itself (TML-2357).
  */
 export function mongoCodec<
   Id extends string,
@@ -65,20 +49,12 @@ export function mongoCodec<
 >(
   config: {
     typeId: Id;
-    targetTypes: readonly string[];
-    traits?: TTraits;
     encode: (value: TInput, ctx: CodecCallContext) => TWire | Promise<TWire>;
     decode: (wire: TWire, ctx: CodecCallContext) => TInput | Promise<TInput>;
-    renderOutputType?: (typeParams: Record<string, unknown>) => string | undefined;
   } & JsonRoundTripConfig<TInput>,
 ): MongoCodec<Id, TTraits, TWire, TInput> {
   const identity = (v: unknown) => v;
-  // The runtime allocates one `CodecCallContext` per `runtime.execute()`
-  // call (no caller-supplied `signal` produces `{}` instead of `undefined`)
-  // and threads it as a non-optional reference to every codec call. The
-  // author surface keeps the second parameter optional so single-arg
-  // `(value) => …` authors continue to satisfy the signature via
-  // TypeScript's bivariance for trailing parameters.
+  // The runtime allocates one `CodecCallContext` per `runtime.execute()` call (no caller-supplied `signal` produces `{}` instead of `undefined`) and threads it as a non-optional reference to every codec call. The author surface keeps the second parameter optional so single-arg `(value) => …` authors continue to satisfy the signature via TypeScript's bivariance for trailing parameters.
   const userEncode = config.encode;
   const userDecode = config.decode;
   const widenedConfig = config as {
@@ -87,12 +63,6 @@ export function mongoCodec<
   };
   return {
     id: config.typeId,
-    targetTypes: config.targetTypes,
-    ...ifDefined(
-      'traits',
-      config.traits ? (Object.freeze([...config.traits]) as TTraits) : undefined,
-    ),
-    ...ifDefined('renderOutputType', config.renderOutputType),
     encode: (value, ctx) => {
       try {
         return Promise.resolve(userEncode(value, ctx));
@@ -115,6 +85,3 @@ export function mongoCodec<
 /** Extract the JS application type carried by a Mongo codec — used both as `encode` input and as `decode` output. */
 export type MongoCodecInput<T> =
   T extends MongoCodec<string, readonly MongoCodecTrait[], unknown, infer TInput> ? TInput : never;
-
-export type MongoCodecTraits<T> =
-  T extends MongoCodec<string, infer TTraits> ? TTraits[number] & MongoCodecTrait : never;

package/src/exports/index.ts

@@ -1,9 +1,4 @@
 export type { MongoCodecRegistry } from '../codec-registry';
-export { createMongoCodecRegistry } from '../codec-registry';
-export type {
-  MongoCodec,
-  MongoCodecInput,
-  MongoCodecTrait,
-  MongoCodecTraits,
-} from '../codecs';
+export { newMongoCodecRegistry } from '../codec-registry';
+export type { MongoCodec, MongoCodecInput, MongoCodecTrait } from '../codecs';
 export { mongoCodec } from '../codecs';