@tsed/json-mapper 8.44.1 → 8.44.3

package/lib/esm/components/DateMapper.js

@@ -1,6 +1,7 @@
 import { __decorate } from "tslib";
 import { JsonMapper } from "../decorators/jsonMapper.js";
 import { isBoolean } from "@tsed/core";
+const toISOString = Date.prototype.toISOString;
 /**
  * Mapper for `Date` type.
  * @jsonmapper
@@ -17,7 +18,7 @@ let DateMapper = class DateMapper {
         return new Date(data);
     }
     serialize(object) {
-        return object ? new Date(object).toISOString() : object;
+        return object ? (object instanceof Date ? toISOString.call(object) : new Date(object).toISOString()) : object;
     }
 };
 DateMapper = __decorate([

package/lib/esm/components/PrimitiveMapper.js

@@ -2,7 +2,7 @@ import { __decorate } from "tslib";
 import { JsonMapper } from "../decorators/jsonMapper.js";
 import { nameOf } from "@tsed/core";
 function isNullish(data) {
-    return [null, "null"].includes(data);
+    return data === null || data === "null";
 }
 /**
  * Error thrown when a primitive conversion cannot be performed safely.
@@ -23,15 +23,17 @@ let PrimitiveMapper = class PrimitiveMapper {
         return this[nameOf(ctx.type)] ? this[nameOf(ctx.type)](data, ctx) : undefined;
     }
     serialize(object, ctx) {
-        return this[nameOf(ctx?.type)] && typeof object !== "object" ? this[nameOf(ctx.type)](object, ctx) : object;
+        const name = nameOf(ctx?.type);
+        // inline typeof on purpose: hot path for every primitive value, cheaper than calling isObject()
+        return this[name] && typeof object !== "object" ? this[name](object, ctx) : object;
     }
     String(data) {
         return data === null ? null : "" + data;
     }
     Boolean(data) {
-        if (["true", "1", true].includes(data))
+        if (data === "true" || data === "1" || data === true)
             return true;
-        if (["false", "0", false].includes(data))
+        if (data === "false" || data === "0" || data === false)
             return false;
         if (isNullish(data))
             return null;

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/JsonMapperCompiler.js

@@ -11,6 +11,12 @@ export class JsonMapperCompiler {
          * @protected
          */
         this.cache = new Map();
+        /**
+         * Cached result of `getType()` by model. `getType()` walks the class ancestors
+         * and runs for every value serialized without a schema, so it is resolved once per model.
+         * @protected
+         */
+        this.types = new Map();
         /**
          * Cached executable mappers by his id
          * @protected
@@ -91,7 +97,7 @@ export class JsonMapperCompiler {
         };
     }
     compile(model, groups, opts = {}) {
-        const token = isString(model) ? model : this.getType(model);
+        const token = isString(model) ? model : this.resolveType(model);
         const groupsId = this.getGroupsId(groups);
         let storeGroups = this.cache.get(token) || this.cache.get(nameOf(token));
         if (!storeGroups) {
@@ -124,6 +130,14 @@ export class JsonMapperCompiler {
         }
         return this.mappers[id || nameOf(classOf(value))](value, options);
     }
+    resolveType(model) {
+        let type = this.types.get(model);
+        if (type === undefined) {
+            type = this.getType(model);
+            this.types.set(model, type);
+        }
+        return type;
+    }
     getType(model) {
         if (!model) {
             return Object;

package/lib/esm/domain/JsonSerializer.js

@@ -1,14 +1,27 @@
 import { getPropertiesStores, s } from "@tsed/schema";
-import { classOf, hasJsonMethod, isArray, isBoolean, isClassObject, isCollection, isDate, isMomentObject, isMongooseObject, isNil, isObject, isPrimitive, nameOf } from "@tsed/core";
+import { classOf, hasJsonMethod, isArray, isBoolean, isClassObject, isCollection, isDate, isFunction, isMomentObject, isMongooseObject, isNil, isObject, isPrimitive, nameOf } from "@tsed/core";
+import { DateMapper } from "../components/DateMapper.js";
+import { PrimitiveMapper } from "../components/PrimitiveMapper.js";
 import { JsonMapperCompiler } from "./JsonMapperCompiler.js";
 import { JsonMapperSettings } from "./JsonMapperSettings.js";
 import { Writer } from "./Writer.js";
 import { alterOnSerialize } from "../hooks/alterOnSerialize.js";
 import { getJsonMapperTypes } from "./JsonMapperTypesContainer.js";
-import { getObjectProperties } from "../utils/getObjectProperties.js";
 const getCollectionType = (input) => {
     return isArray(input) ? "Array" : input instanceof Set ? "Set" : input instanceof Map ? "Map" : undefined;
 };
+/**
+ * Assign a mapped value on a plain output object. A `__proto__` key is defined as an own property:
+ * a plain assignment would call the `__proto__` setter, change the prototype and drop the key.
+ */
+function setKey(obj, key, value) {
+    if (key === "__proto__") {
+        Object.defineProperty(obj, key, { value, enumerable: true, writable: true, configurable: true });
+    }
+    else {
+        obj[key] = value;
+    }
+}
 function getBestType(type, obj) {
     const dataType = classOf(obj);
     if (dataType && !isClassObject(dataType) && !isCollection(obj)) {
@@ -19,6 +32,29 @@ function getBestType(type, obj) {
 function varKey(k) {
     return `__${k}`;
 }
+/**
+ * The function a type mapper is registered with. The built-in Date and primitive mappers do not read the
+ * context, so they are called without building one: a copy of the options for every Date, string and number
+ * the payload holds was most of the time of a serialization.
+ */
+function createTypeMapper(mapper, model, name) {
+    const kind = mapper.constructor;
+    const conversion = mapper[name];
+    if (kind === PrimitiveMapper &&
+        mapper.serialize === PrimitiveMapper.prototype.serialize &&
+        isFunction(conversion) &&
+        conversion === PrimitiveMapper.prototype[name]) {
+        // inline typeof on purpose: this runs for every primitive value, and calling isObject() here was ~15% slower on the serializer benchmark
+        return (value) => (typeof value !== "object" ? conversion.call(mapper, value) : value);
+    }
+    if (kind === DateMapper && mapper.serialize === DateMapper.prototype.serialize) {
+        return (value) => mapper.serialize(value);
+    }
+    return (value, options) => mapper.serialize(value, {
+        ...options,
+        type: model
+    });
+}
 /**
  * Serializes data structures according to the metadata captured by `@tsed/schema`.
  *
@@ -28,6 +64,11 @@ function varKey(k) {
 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));
@@ -76,15 +117,30 @@ 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.addTypeMapper(model, (value, options) => mapper.serialize(value, {
-                    ...options,
-                    type: 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 });
             }
         });
         const strictGroups = options.strictGroups ?? JsonMapperSettings.strictGroups;
@@ -211,50 +267,60 @@ export class JsonSerializer extends JsonMapperCompiler {
         if (hasJsonMethod(input)) {
             return this.mapJSON(input, options);
         }
-        return getObjectProperties(input)
-            .filter(([, value]) => value !== undefined)
-            .reduce((obj, [key, value]) => {
-            if (isNil(value)) {
-                return {
-                    ...obj,
-                    [key]: value
-                };
+        const obj = {};
+        // own enumerable keys only, like Object.entries(); functions and undefined values are skipped
+        for (const key in input) {
+            if (!Object.hasOwn(input, key)) {
+                continue;
+            }
+            const value = input[key];
+            if (value === undefined || isFunction(value)) {
+                continue;
             }
-            const mapper = this.compile(classOf(value), options.groups);
-            return {
-                ...obj,
-                [key]: mapper.fn(value, options)
-            };
-        }, {});
+            setKey(obj, key, value === null ? value : this.compile(classOf(value), options.groups).fn(value, options));
+        }
+        return obj;
     }
-    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 object mapper.
+    mapSet(input, { id, ...options }) {
         if (isNil(input)) {
             return input;
         }
-        return [...input.values()].map((item) => {
-            return this.mapItem(item, options);
-        });
+        const out = [];
+        for (const item of input) {
+            out.push(this.mapItem(item, id, options));
+        }
+        return out;
     }
-    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, like the former [].concat(input)
+        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, like the former .map(): the item mapper is not called for them
+            if (item === undefined && !(i in list)) {
+                continue;
+            }
+            out[i] = this.mapItem(item, id, options);
+        }
+        return out;
     }
-    mapMap(input, options) {
+    mapMap(input, { id, ...options }) {
         if (isNil(input)) {
             return input;
         }
-        return [...input.entries()].reduce((obj, [key, item]) => {
-            return {
-                ...obj,
-                [key]: this.mapItem(item, options)
-            };
-        }, {});
+        const obj = {};
+        for (const [key, item] of input) {
+            setKey(obj, key, this.mapItem(item, id, options));
+        }
+        return obj;
     }
-    mapItem(input, { id, ...options }) {
+    mapItem(input, id, options) {
         if (!id && input) {
             return this.compile(classOf(input), options.groups).fn(input, 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/lib/types/domain/JsonMapperCompiler.d.ts

@@ -27,6 +27,12 @@ export declare abstract class JsonMapperCompiler<Options extends Record<string,
      * @protected
      */
     protected cache: Map<string | Type<any>, CachedGroupsJsonMapper<Options>>;
+    /**
+     * Cached result of `getType()` by model. `getType()` walks the class ancestors
+     * and runs for every value serialized without a schema, so it is resolved once per model.
+     * @protected
+     */
+    protected types: Map<Type<any>, Type<any>>;
     /**
      * Cached executable mappers by his id
      * @protected
@@ -67,6 +73,7 @@ export declare abstract class JsonMapperCompiler<Options extends Record<string,
     protected abstract map(input: any, options: Options): any;
     protected abstract alterValue(schemaId: string, value: any, options: Options): any;
     protected abstract createMapper(model: Type<any>, id: string, groups: false | string[]): string;
+    protected resolveType(model: Type<any>): Type<any>;
     protected getType(model: Type<any>): Type<any> | MapConstructor | ObjectConstructor | ArrayConstructor | SetConstructor;
     protected alterIgnore(id: string, options: Options): any;
     protected alterGroups(schema: JsonSchema, groups: false | string[]): boolean;

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

@@ -1,6 +1,14 @@
 import { Type } from "@tsed/core";
-import { JsonMapperCompiler } from "./JsonMapperCompiler.js";
+import { JsonMapperMethods } from "../interfaces/JsonMapperMethods.js";
+import { JsonMapperCompiler, JsonMapperCallback } 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`.
  *
@@ -8,10 +16,20 @@ import { JsonSerializerOptions } from "./JsonSerializerOptions.js";
  * 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;
@@ -26,3 +44,4 @@ 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.1",
+  "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.1",
-    "@tsed/core": "8.44.1",
-    "@tsed/schema": "8.44.1",
-    "@tsed/typescript": "8.44.1",
+    "@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"