@tsed/json-mapper 8.44.2 → 8.44.3

package/lib/esm/domain/JsonDeserializer.js

@@ -1,12 +1,19 @@
 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]);
+}
 function isDeserializable(obj, options) {
     if ((!!options.collectionType && isNil(obj)) || obj === undefined) {
         return false;
@@ -38,6 +45,11 @@ 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));
@@ -198,6 +210,32 @@ 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));
@@ -205,17 +243,8 @@ export class JsonDeserializer extends JsonMapperCompiler {
         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
-                    }));
-                }
+            if (model !== Array && model !== Set && model !== Map && this.isTypeMapperOutdated(model, mapper)) {
+                this.registerTypeMapper(model, mapper);
             }
         });
         const strictGroups = options.strictGroups ?? JsonMapperSettings.strictGroups;
@@ -254,37 +283,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/JsonSerializer.js

@@ -128,7 +128,8 @@ export class JsonSerializer extends JsonMapperCompiler {
         }
         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;
+        // 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 }) {

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

@@ -1,6 +1,17 @@
-import { CachedGroupsJsonMapper, CachedJsonMapper, JsonMapperCompiler } from "./JsonMapperCompiler.js";
+import { CachedGroupsJsonMapper, CachedJsonMapper, JsonMapperCallback, 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.
@@ -11,6 +22,11 @@ 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>;
@@ -26,14 +42,21 @@ 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;
     private mapSet;
     private mapArray;
     private mapMap;
-    private mapItem;
     private alterBeforeDeserialize;
     private alterAfterDeserialize;
     private mapGenericsOptions;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/json-mapper",
-  "version": "8.44.2",
+  "version": "8.44.3",
   "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.3",
+    "@tsed/core": "8.44.3",
+    "@tsed/schema": "8.44.3",
+    "@tsed/typescript": "8.44.3",
     "temporal-polyfill": "1.0.1",
     "typescript": "6.0.2",
     "vitest": "4.1.4"