@tsed/json-mapper 8.44.3 → 8.44.4

package/lib/esm/domain/JsonDeserializer.js

@@ -14,6 +14,22 @@ import { getJsonMapperTypes } from "./JsonMapperTypesContainer.js";
 function hasConversionMethod(mapper, name) {
     return isFunction(mapper[name]);
 }
+/**
+ * The registered function reads the mapper methods at call time, so a replaced method needs no registration.
+ */
+function createTypeMapperEntry(mapper, model, name) {
+    const hasConversion = hasConversionMethod(mapper, name);
+    const fn = hasConversion
+        ? (value, options) => mapper[name](value, options)
+        : (value, options) => mapper.deserialize(value, { ...options, type: model });
+    return { mapper, name, hasConversion, fn };
+}
+/**
+ * The function must be built again when the mapper gained or lost the method named after the type.
+ */
+function hasTypeMapperChanged(entry, mapper) {
+    return entry.hasConversion !== hasConversionMethod(mapper, entry.name);
+}
 function isDeserializable(obj, options) {
     if ((!!options.collectionType && isNil(obj)) || obj === undefined) {
         return false;
@@ -45,11 +61,6 @@ export class JsonDeserializer extends JsonMapperCompiler {
          * @protected
          */
         this.constructors = {};
-        /**
-         * The type mappers registered from the types container, with the function each one was registered with
-         * @protected
-         */
-        this.typeMappers = new Map();
         this.addGlobal("newInstanceOf", this.newInstanceOf.bind(this));
         this.addGlobal("alterBeforeDeserialize", this.alterBeforeDeserialize.bind(this));
         this.addGlobal("alterAfterDeserialize", this.alterAfterDeserialize.bind(this));
@@ -210,43 +221,12 @@ export class JsonDeserializer extends JsonMapperCompiler {
         }
         return (writer) => writer.callMapper(nestedMapper.id, varKey(key), formatOpts);
     }
-    /**
-     * A type mapper must be registered again when it was never registered, when the mapper changed, when the mapper
-     * gained or lost the method named after the type, or when its entry was replaced or removed from the cache.
-     * The registered function reads the mapper methods at call time, so a replaced method needs no registration.
-     */
-    isTypeMapperOutdated(model, mapper) {
-        const registered = this.typeMappers.get(model);
-        if (!registered) {
-            return true;
-        }
-        const mapperChanged = registered.mapper !== mapper;
-        const hasConversion = hasConversionMethod(mapper, registered.name);
-        const conversionChanged = registered.hasConversion !== hasConversion;
-        // two models with the same name (Date and "Date") share the mapper table entry: the last registered one wins
-        const entryReplaced = this.cache.get(model)?.get("typeMapper")?.fn !== registered.fn || this.mappers[registered.name] !== registered.fn;
-        return mapperChanged || conversionChanged || entryReplaced;
-    }
-    registerTypeMapper(model, mapper) {
-        const name = nameOf(model);
-        const hasConversion = hasConversionMethod(mapper, name);
-        const fn = hasConversion
-            ? (value, options) => mapper[name](value, options)
-            : (value, options) => mapper.deserialize(value, { ...options, type: model });
-        this.addTypeMapper(model, fn);
-        this.typeMappers.set(model, { mapper, name, hasConversion, fn });
-    }
     mapOptions({ groups, useAlias = true, types, ...options }) {
         if (options.store instanceof JsonParameterStore) {
             return this.mapOptions(mapParamStoreOptions(options.store, options));
         }
         const customMappers = {};
-        types = types || getJsonMapperTypes();
-        types.forEach((mapper, model) => {
-            if (model !== Array && model !== Set && model !== Map && this.isTypeMapperOutdated(model, mapper)) {
-                this.registerTypeMapper(model, mapper);
-            }
-        });
+        this.syncTypeMappers(types || getJsonMapperTypes(), createTypeMapperEntry, hasTypeMapperChanged);
         const strictGroups = options.strictGroups ?? JsonMapperSettings.strictGroups;
         return {
             ...options,

package/lib/esm/domain/JsonMapperCompiler.js

@@ -17,6 +17,11 @@ export class JsonMapperCompiler {
          * @protected
          */
         this.types = new Map();
+        /**
+         * The type mappers registered from the types container, with the function each one was registered with
+         * @protected
+         */
+        this.typeMappers = new Map();
         /**
          * Cached executable mappers by his id
          * @protected
@@ -124,6 +129,38 @@ export class JsonMapperCompiler {
         }
         return storeGroups.get(groupsId);
     }
+    /**
+     * Register the type mappers of the types container (Array, Set and Map excepted: the compiler maps them itself).
+     * A type mapper is registered again only when it is outdated, so `map()` does not rebuild them on every call.
+     *
+     * @param types The type mappers by model.
+     * @param create Build the entry, and the function, a type mapper is registered with.
+     * @param hasChanged Tell whether the mapper changed since its entry was built, beyond being replaced by another mapper.
+     */
+    syncTypeMappers(types, create, hasChanged) {
+        types.forEach((mapper, model) => {
+            if (model !== Array && model !== Set && model !== Map && this.isTypeMapperOutdated(model, mapper, hasChanged)) {
+                const entry = create(mapper, model, nameOf(model));
+                this.addTypeMapper(model, entry.fn);
+                this.typeMappers.set(model, entry);
+            }
+        });
+    }
+    /**
+     * A type mapper must be registered again when it was never registered, when the mapper was replaced or changed,
+     * or when its entry was replaced or removed from the cache.
+     */
+    isTypeMapperOutdated(model, mapper, hasChanged) {
+        const registered = this.typeMappers.get(model);
+        if (!registered) {
+            return true;
+        }
+        return (registered.mapper !== mapper ||
+            hasChanged(registered, mapper) ||
+            // two models with the same name (Date and "Date") share the mapper table entry: the last registered one wins
+            this.cache.get(model)?.get("typeMapper")?.fn !== registered.fn ||
+            this.mappers[registered.name] !== registered.fn);
+    }
     execMapper(id, value, options) {
         if (isObjectID(value)) {
             return value.toString();

package/lib/esm/domain/JsonSerializer.js

@@ -55,6 +55,21 @@ function createTypeMapper(mapper, model, name) {
         type: model
     });
 }
+function createTypeMapperEntry(mapper, model, name) {
+    return {
+        mapper,
+        name,
+        serialize: mapper.serialize,
+        conversion: mapper[name],
+        fn: createTypeMapper(mapper, model, name)
+    };
+}
+/**
+ * The function of a type mapper is built from its `serialize` and conversion methods: it must be built again when one changed.
+ */
+function hasTypeMapperChanged(entry, mapper) {
+    return entry.serialize !== mapper.serialize || entry.conversion !== mapper[entry.name];
+}
 /**
  * Serializes data structures according to the metadata captured by `@tsed/schema`.
  *
@@ -64,11 +79,6 @@ function createTypeMapper(mapper, model, name) {
 export class JsonSerializer extends JsonMapperCompiler {
     constructor() {
         super();
-        /**
-         * The type mappers registered from the types container, with the function each one was registered with
-         * @protected
-         */
-        this.typeMappers = new Map();
         this.addTypeMapper(Object, this.mapObject.bind(this));
         this.addTypeMapper(Array, this.mapArray.bind(this));
         this.addTypeMapper(Map, this.mapMap.bind(this));
@@ -117,32 +127,9 @@ export class JsonSerializer extends JsonMapperCompiler {
         writer.add(this.mapAdditionalProperties(entity, properties));
         return writer.return("obj").root().toString();
     }
-    /**
-     * A type mapper must be registered again when it was never registered, when the mapper or one of the
-     * methods its function was built from changed, or when its entry was replaced or removed from the cache.
-     */
-    isTypeMapperOutdated(model, mapper) {
-        const registered = this.typeMappers.get(model);
-        if (!registered) {
-            return true;
-        }
-        const mapperChanged = registered.mapper !== mapper;
-        const methodsChanged = registered.serialize !== mapper.serialize || registered.conversion !== mapper[registered.name];
-        // two models with the same name (Date and "Date") share the mapper table entry: the last registered one wins
-        const entryReplaced = this.cache.get(model)?.get("typeMapper")?.fn !== registered.fn || this.mappers[registered.name] !== registered.fn;
-        return mapperChanged || methodsChanged || entryReplaced;
-    }
     mapOptions({ groups, useAlias = true, types, ...options }) {
         const customMappers = {};
-        types = types || getJsonMapperTypes();
-        types.forEach((mapper, model) => {
-            if (![Array, Set, Map].includes(model) && this.isTypeMapperOutdated(model, mapper)) {
-                const name = nameOf(model);
-                const fn = createTypeMapper(mapper, model, name);
-                this.addTypeMapper(model, fn);
-                this.typeMappers.set(model, { mapper, name, serialize: mapper.serialize, conversion: mapper[name], fn });
-            }
-        });
+        this.syncTypeMappers(types || getJsonMapperTypes(), createTypeMapperEntry, hasTypeMapperChanged);
         const strictGroups = options.strictGroups ?? JsonMapperSettings.strictGroups;
         return {
             ...options,

package/lib/types/domain/JsonDeserializer.d.ts

@@ -1,17 +1,6 @@
-import { CachedGroupsJsonMapper, CachedJsonMapper, JsonMapperCallback, JsonMapperCompiler } from "./JsonMapperCompiler.js";
+import { CachedGroupsJsonMapper, CachedJsonMapper, JsonMapperCompiler } from "./JsonMapperCompiler.js";
 import { Type } from "@tsed/core";
-import { JsonMapperMethods } from "../interfaces/JsonMapperMethods.js";
 import { JsonDeserializerOptions } from "./JsonDeserializerOptions.js";
-/**
- * A registered type mapper. `hasConversion` tells whether the mapper had a method named after the type
- * (e.g. `PrimitiveMapper.String`) when it was registered: the function calls that method, otherwise `deserialize()`.
- */
-type TypeMapperEntry = {
-    mapper: JsonMapperMethods;
-    name: string;
-    hasConversion: boolean;
-    fn: JsonMapperCallback<any>;
-};
 /**
  * Deserializes raw JSON data into class instances based on schema metadata,
  * handling collections, discriminators, hooks, and registered type mappers.
@@ -22,11 +11,6 @@ export declare class JsonDeserializer extends JsonMapperCompiler<JsonDeserialize
      * @protected
      */
     protected constructors: Record<string, Type<any>>;
-    /**
-     * The type mappers registered from the types container, with the function each one was registered with
-     * @protected
-     */
-    protected typeMappers: Map<any, TypeMapperEntry>;
     constructor();
     map<Model = any>(input: any, options?: JsonDeserializerOptions): Model;
     compile(model: Type<any>, groups: false | string[]): CachedJsonMapper<JsonDeserializerOptions>;
@@ -42,13 +26,6 @@ export declare class JsonDeserializer extends JsonMapperCompiler<JsonDeserialize
     private mapDiscriminator;
     private mapProperty;
     private getPropertyFiller;
-    /**
-     * A type mapper must be registered again when it was never registered, when the mapper changed, when the mapper
-     * gained or lost the method named after the type, or when its entry was replaced or removed from the cache.
-     * The registered function reads the mapper methods at call time, so a replaced method needs no registration.
-     */
-    private isTypeMapperOutdated;
-    private registerTypeMapper;
     private mapOptions;
     private mapAdditionalProperties;
     private mapObject;
@@ -59,4 +36,3 @@ export declare class JsonDeserializer extends JsonMapperCompiler<JsonDeserialize
     private alterAfterDeserialize;
     private mapGenericsOptions;
 }
-export {};

package/lib/types/domain/JsonMapperCompiler.d.ts

@@ -1,5 +1,6 @@
 import { Type } from "@tsed/core";
 import { JsonSchema } from "@tsed/schema";
+import type { JsonMapperMethods } from "../interfaces/JsonMapperMethods.js";
 /**
  * Signature exposed by compiled mappers. They accept an input value plus contextual options
  * and return the serialized/deserialized result.
@@ -16,6 +17,15 @@ export type CachedJsonMapper<Options> = {
  * Cached mapper registry keyed by the groups fingerprint generated for a schema.
  */
 export type CachedGroupsJsonMapper<Options> = Map<string, CachedJsonMapper<Options>>;
+/**
+ * A type mapper registered from the types container: the mapper, the name of its model and the function it was
+ * registered with. Subclasses add the values their outdated check compares.
+ */
+export type TypeMapperEntry = {
+    mapper: JsonMapperMethods;
+    name: string;
+    fn: JsonMapperCallback<any>;
+};
 /**
  * Base compiler that turns schema metadata into executable (de)serialization functions.
  * Subclasses supply `map`, `alterValue`, and `createMapper` implementations to specialize
@@ -33,6 +43,11 @@ export declare abstract class JsonMapperCompiler<Options extends Record<string,
      * @protected
      */
     protected types: Map<Type<any>, Type<any>>;
+    /**
+     * The type mappers registered from the types container, with the function each one was registered with
+     * @protected
+     */
+    protected typeMappers: Map<any, TypeMapperEntry>;
     /**
      * Cached executable mappers by his id
      * @protected
@@ -69,6 +84,20 @@ export declare abstract class JsonMapperCompiler<Options extends Record<string,
     compile(model: Type<any> | string, groups: false | string[], opts?: {
         mapper?: any;
     }): CachedJsonMapper<Options>;
+    /**
+     * Register the type mappers of the types container (Array, Set and Map excepted: the compiler maps them itself).
+     * A type mapper is registered again only when it is outdated, so `map()` does not rebuild them on every call.
+     *
+     * @param types The type mappers by model.
+     * @param create Build the entry, and the function, a type mapper is registered with.
+     * @param hasChanged Tell whether the mapper changed since its entry was built, beyond being replaced by another mapper.
+     */
+    protected syncTypeMappers<Entry extends TypeMapperEntry>(types: Map<Type | Symbol | string, JsonMapperMethods>, create: (mapper: JsonMapperMethods, model: any, name: string) => Entry, hasChanged: (entry: Entry, mapper: JsonMapperMethods) => boolean): void;
+    /**
+     * A type mapper must be registered again when it was never registered, when the mapper was replaced or changed,
+     * or when its entry was replaced or removed from the cache.
+     */
+    private isTypeMapperOutdated;
     protected execMapper(id: string, value: any, options: Options): any;
     protected abstract map(input: any, options: Options): any;
     protected abstract alterValue(schemaId: string, value: any, options: Options): any;

package/lib/types/domain/JsonSerializer.d.ts

@@ -1,14 +1,6 @@
 import { Type } from "@tsed/core";
-import { JsonMapperMethods } from "../interfaces/JsonMapperMethods.js";
-import { JsonMapperCompiler, JsonMapperCallback } from "./JsonMapperCompiler.js";
+import { JsonMapperCompiler } from "./JsonMapperCompiler.js";
 import { JsonSerializerOptions } from "./JsonSerializerOptions.js";
-type TypeMapperEntry = {
-    mapper: JsonMapperMethods;
-    name: string;
-    serialize: any;
-    conversion: any;
-    fn: JsonMapperCallback<any>;
-};
 /**
  * Serializes data structures according to the metadata captured by `@tsed/schema`.
  *
@@ -16,20 +8,10 @@ type TypeMapperEntry = {
  * registered type mappers (e.g., components in `src/components`).
  */
 export declare class JsonSerializer extends JsonMapperCompiler<JsonSerializerOptions> {
-    /**
-     * The type mappers registered from the types container, with the function each one was registered with
-     * @protected
-     */
-    protected typeMappers: Map<any, TypeMapperEntry>;
     constructor();
     map(input: any, options?: JsonSerializerOptions): any;
     protected alterValue(schemaId: string, value: any, options: JsonSerializerOptions): any;
     protected createMapper(model: Type<any>, id: string, groups: false | string[]): string;
-    /**
-     * A type mapper must be registered again when it was never registered, when the mapper or one of the
-     * methods its function was built from changed, or when its entry was replaced or removed from the cache.
-     */
-    private isTypeMapperOutdated;
     private mapOptions;
     private mapProperty;
     private getPropertyFiller;
@@ -44,4 +26,3 @@ export declare class JsonSerializer extends JsonMapperCompiler<JsonSerializerOpt
     private mapItem;
     private mapJSON;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/json-mapper",
-  "version": "8.44.3",
+  "version": "8.44.4",
   "description": "Json mapper module for Ts.ED Framework",
   "keywords": [
     "TypeScript",
@@ -41,10 +41,10 @@
     "tslib": ">=2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.44.3",
-    "@tsed/core": "8.44.3",
-    "@tsed/schema": "8.44.3",
-    "@tsed/typescript": "8.44.3",
+    "@tsed/barrels": "8.44.4",
+    "@tsed/core": "8.44.4",
+    "@tsed/schema": "8.44.4",
+    "@tsed/typescript": "8.44.4",
     "temporal-polyfill": "1.0.1",
     "typescript": "6.0.2",
     "vitest": "4.1.4"