@tsed/json-mapper 8.44.2 → 8.44.4

package/lib/esm/domain/JsonDeserializer.js

@@ -1,12 +1,35 @@
 import { JsonMapperCompiler } from "./JsonMapperCompiler.js";
 import { JsonParameterStore, JsonSchema, VendorKeys, getPropertiesStores, s } from "@tsed/schema";
-import { classOf, isArray, isBoolean, isEmpty, isNil, nameOf, objectKeys } from "@tsed/core";
+import { classOf, isArray, isBoolean, isEmpty, isFunction, isNil, nameOf, objectKeys } from "@tsed/core";
 import { JsonMapperSettings } from "./JsonMapperSettings.js";
 import { Writer } from "./Writer.js";
 import { alterAfterDeserialize } from "../hooks/alterAfterDeserialize.js";
 import { alterBeforeDeserialize } from "../hooks/alterBeforeDeserialize.js";
 import { alterOnDeserialize } from "../hooks/alterOnDeserialize.js";
 import { getJsonMapperTypes } from "./JsonMapperTypesContainer.js";
+/**
+ * Whether the mapper has a callable method named after the type. A property set to another value (e.g. `undefined`
+ * to disable the conversion) falls back to `deserialize()` instead of throwing.
+ */
+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;
@@ -203,21 +226,7 @@ export class JsonDeserializer extends JsonMapperCompiler {
             return this.mapOptions(mapParamStoreOptions(options.store, options));
         }
         const customMappers = {};
-        types = types || getJsonMapperTypes();
-        types.forEach((mapper, model) => {
-            if (![Array, Set, Map].includes(model)) {
-                const typeName = nameOf(model);
-                if (nameOf(model) in mapper) {
-                    this.addTypeMapper(model, mapper[typeName].bind(mapper));
-                }
-                else {
-                    this.addTypeMapper(model, (value, options) => mapper.deserialize(value, {
-                        ...options,
-                        type: model
-                    }));
-                }
-            }
-        });
+        this.syncTypeMappers(types || getJsonMapperTypes(), createTypeMapperEntry, hasTypeMapperChanged);
         const strictGroups = options.strictGroups ?? JsonMapperSettings.strictGroups;
         return {
             ...options,
@@ -254,37 +263,45 @@ export class JsonDeserializer extends JsonMapperCompiler {
     mapObject(input, options) {
         return input;
     }
-    mapSet(input, options) {
+    // The collection mappers strip `id` from the options once, not once per item:
+    // `id` describes the items, it must not leak into the options of a nested mapper.
+    mapSet(input, { id, ...options }) {
         if (isNil(input)) {
             return input;
         }
         const obj = new Set();
-        objectKeys(input).forEach((key) => {
-            obj.add(this.mapItem(input[key], options));
-        });
+        for (const key of objectKeys(input)) {
+            obj.add(this.execMapper(id, input[key], options));
+        }
         return obj;
     }
-    mapArray(input, options) {
+    mapArray(input, { id, ...options }) {
         if (isNil(input)) {
             return input;
         }
-        return [].concat(input).map((item) => {
-            return this.mapItem(item, options);
-        });
+        // a single value is mapped as a one-item array
+        const list = isArray(input) ? input : [input];
+        const out = new Array(list.length);
+        for (let i = 0; i < list.length; i++) {
+            const item = list[i];
+            // keep the holes of a sparse array: the item mapper is not called for them
+            if (item === undefined && !(i in list)) {
+                continue;
+            }
+            out[i] = this.execMapper(id, item, options);
+        }
+        return out;
     }
-    mapMap(input, options) {
+    mapMap(input, { id, ...options }) {
         if (isNil(input)) {
             return input;
         }
         const obj = new Map();
-        objectKeys(input).forEach((key) => {
-            obj.set(key, this.mapItem(input[key], options));
-        });
+        for (const key of objectKeys(input)) {
+            obj.set(key, this.execMapper(id, input[key], options));
+        }
         return obj;
     }
-    mapItem(input, { id, ...options }) {
-        return this.execMapper(id, input, options);
-    }
     alterBeforeDeserialize(schemaId, value, options) {
         return alterBeforeDeserialize(value, this.schemes[schemaId], 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,31 +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];
-        const entryReplaced = this.cache.get(model)?.get("typeMapper")?.fn !== 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

@@ -32,7 +32,6 @@ export declare class JsonDeserializer extends JsonMapperCompiler<JsonDeserialize
     private mapSet;
     private mapArray;
     private mapMap;
-    private mapItem;
     private alterBeforeDeserialize;
     private alterAfterDeserialize;
     private mapGenericsOptions;

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.2",
+  "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.2",
-    "@tsed/core": "8.44.2",
-    "@tsed/schema": "8.44.2",
-    "@tsed/typescript": "8.44.2",
+    "@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"