@tsed/json-mapper 8.13.5 → 8.14.0

package/lib/esm/domain/JsonDeserializer.js

@@ -1,5 +1,5 @@
-import { classOf, isArray, isBoolean, isClass, isEmpty, isNil, nameOf, objectKeys } from "@tsed/core";
-import { getPropertiesStores, JsonEntityStore, JsonParameterStore } from "@tsed/schema";
+import { classOf, isArray, isBoolean, isEmpty, isNil, nameOf, objectKeys } from "@tsed/core";
+import { getPropertiesStores, JsonEntityStore, JsonParameterStore, JsonSchema, VendorKeys } from "@tsed/schema";
 import { alterAfterDeserialize } from "../hooks/alterAfterDeserialize.js";
 import { alterBeforeDeserialize } from "../hooks/alterBeforeDeserialize.js";
 import { alterOnDeserialize } from "../hooks/alterOnDeserialize.js";
@@ -22,14 +22,10 @@ function mapParamStoreOptions(store, options) {
         store: undefined,
         type: store.getBestType(),
         collectionType: store.collectionType,
-        groups: store.parameter.groups,
-        // genericTypes: store.nestedGenerics[0],
-        generics: store.nestedGenerics
+        groups: store.parameter.schema().getGroups(),
+        generics: store.parameter.schema().getGenericOf()
     };
 }
-function getGenericIndex(propertyStore) {
-    return propertyStore.parent.schema.genericLabels.indexOf(propertyStore.itemSchema.genericType);
-}
 export class JsonDeserializer extends JsonMapperCompiler {
     constructor() {
         super();
@@ -41,6 +37,7 @@ export class JsonDeserializer extends JsonMapperCompiler {
         this.addGlobal("newInstanceOf", this.newInstanceOf.bind(this));
         this.addGlobal("alterBeforeDeserialize", this.alterBeforeDeserialize.bind(this));
         this.addGlobal("alterAfterDeserialize", this.alterAfterDeserialize.bind(this));
+        this.addGlobal("mapGenericsOptions", this.mapGenericsOptions.bind(this));
         this.addTypeMapper(Object, this.mapObject.bind(this));
         this.addTypeMapper(Array, this.mapArray.bind(this));
         this.addTypeMapper(Map, this.mapMap.bind(this));
@@ -95,14 +92,7 @@ export class JsonDeserializer extends JsonMapperCompiler {
             this.schemes[id] = entity.schema;
             writer.set("input", `alterBeforeDeserialize('${id}', input, options)`);
         }
-        // generics and options
-        writer.const("generics", "options.generics[0]");
-        if (entity.schema.genericLabels?.length) {
-            writer.set("options", "{...options, self: input, generics: [...options.generics].slice(1)}");
-        }
-        else {
-            writer.set("options", "{...options, self: input}");
-        }
+        writer.set("options", "{...options, self: input}");
         writer.const("obj", `newInstanceOf('${id}', input, options)`);
         // properties
         writer.add(...schemaProperties.flatMap((propertyStore) => {
@@ -176,21 +166,29 @@ export class JsonDeserializer extends JsonMapperCompiler {
     getPropertyFiller(propertyStore, id, groups, formatOpts) {
         const key = String(propertyStore.propertyKey);
         const schemaId = this.getSchemaId(id, key);
-        const generics = propertyStore.itemSchema.nestedGenerics;
-        const isGeneric = propertyStore.itemSchema.isGeneric && !generics?.length;
-        if (isGeneric) {
-            const index = getGenericIndex(propertyStore);
-            const opts = Writer.options(formatOpts, `type: generics[${index}]`);
-            return (writer) => writer.set(varKey(key), `compileAndMap(${varKey(key)}, ${opts})`);
+        if (propertyStore.itemSchema.isGeneric) {
+            const label = propertyStore.itemSchema.get(VendorKeys.GENERIC_LABEL);
+            return (writer) => {
+                const opts = Writer.options(formatOpts, `...mapGenericsOptions('${label}', options.generics)`);
+                return writer.set(varKey(key), `compileAndMap(${varKey(key)}, ${opts})`);
+            };
         }
         const type = propertyStore.itemSchema.hasDiscriminator ? propertyStore.itemSchema.discriminator().base : propertyStore.getBestType();
         const nestedMapper = this.compile(type, groups);
         if (propertyStore.isCollection) {
+            if (propertyStore.itemSchema.getGenericOf()) {
+                this.schemes[schemaId] = propertyStore.itemSchema;
+                return (writer) => {
+                    return writer.callMapper(nameOf(propertyStore.collectionType), varKey(key), `id: '${nestedMapper.id}'`, `generics: schemes['${schemaId}'].getGenericOf()`, formatOpts);
+                };
+            }
             return (writer) => writer.callMapper(nameOf(propertyStore.collectionType), varKey(key), `id: '${nestedMapper.id}'`, formatOpts);
         }
-        if (generics?.length) {
+        if (propertyStore.schema.getGenericOf()) {
             this.schemes[schemaId] = propertyStore.schema;
-            return (writer) => writer.callMapper(nestedMapper.id, varKey(key), formatOpts, `generics: schemes['${schemaId}'].nestedGenerics`);
+            return (writer) => {
+                return writer.callMapper(nestedMapper.id, varKey(key), formatOpts, `generics: schemes['${schemaId}'].getGenericOf()`);
+            };
         }
         return (writer) => writer.callMapper(nestedMapper.id, varKey(key), formatOpts);
     }
@@ -222,7 +220,7 @@ export class JsonDeserializer extends JsonMapperCompiler {
             groups: groups === undefined ? (strictGroups ? [] : false) : groups || false,
             useAlias,
             customMappers,
-            generics: options.generics || []
+            generics: options.generics || {}
         };
     }
     mapAdditionalProperties(entity, properties, groups) {
@@ -234,8 +232,8 @@ export class JsonDeserializer extends JsonMapperCompiler {
         if (exclude.length) {
             each = each.if(`![${exclude}].includes(key)`);
         }
-        if (isClass(additionalProperties)) {
-            const nestedMapper = this.compile(additionalProperties.getComputedType(), groups);
+        if (additionalProperties && additionalProperties instanceof JsonSchema) {
+            const nestedMapper = this.compile(additionalProperties.class, groups);
             each.set("obj[key]", Writer.mapper(nestedMapper.id, "input[key]", "options"));
             return writer;
         }
@@ -287,4 +285,15 @@ export class JsonDeserializer extends JsonMapperCompiler {
     alterAfterDeserialize(schemaId, value, options) {
         return alterAfterDeserialize(value, this.schemes[schemaId], options);
     }
+    mapGenericsOptions(label, inputGenerics) {
+        const generics = inputGenerics?.[label];
+        if (!generics) {
+            return {};
+        }
+        const type = generics[0] instanceof JsonSchema ? generics[0].getTarget() : generics[0];
+        return {
+            type,
+            generics: generics[1]
+        };
+    }
 }

package/lib/esm/domain/Writer.js

@@ -27,7 +27,7 @@ export class Writer {
         return this;
     }
     arrow(...args) {
-        this.add(`(${args}) => {`);
+        this.add(`(${args.join(", ")}) => {`);
         const writer = this.new();
         this.add("}");
         return writer;

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

@@ -30,4 +30,5 @@ export declare class JsonDeserializer extends JsonMapperCompiler<JsonDeserialize
     private mapItem;
     private alterBeforeDeserialize;
     private alterAfterDeserialize;
+    private mapGenericsOptions;
 }

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

@@ -1,5 +1,5 @@
 import { MetadataTypes, Type } from "@tsed/core";
-import { JsonEntityStore } from "@tsed/schema";
+import { type GenericsMap, JsonEntityStore } from "@tsed/schema";
 import { JsonMapperMethods } from "../interfaces/JsonMapperMethods.js";
 import { JsonMapperGlobalOptions } from "./JsonMapperGlobalOptions.js";
 export interface JsonDeserializerOptions<T = any, C = any> extends MetadataTypes<T, C>, JsonMapperGlobalOptions {
@@ -21,8 +21,8 @@ export interface JsonDeserializerOptions<T = any, C = any> extends MetadataTypes
      */
     groups?: string[] | false;
     /**
-     * Add types to deserialize a module using generics feature.
+     * Add types to deserialize a module using the generics feature.
      */
-    generics?: Type[][];
+    generics?: GenericsMap;
     [key: string]: any;
 }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/json-mapper",
   "description": "Json mapper module for Ts.ED Framework",
   "type": "module",
-  "version": "8.13.5",
+  "version": "8.14.0",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
@@ -41,10 +41,10 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.13.5",
-    "@tsed/core": "8.13.5",
-    "@tsed/schema": "8.13.5",
-    "@tsed/typescript": "8.13.5",
+    "@tsed/barrels": "8.14.0",
+    "@tsed/core": "8.14.0",
+    "@tsed/schema": "8.14.0",
+    "@tsed/typescript": "8.14.0",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "3.2.4"