@tsed/json-mapper 8.25.2 → 8.25.4

package/lib/esm/domain/JsonDeserializer.js

@@ -70,9 +70,11 @@ export class JsonDeserializer extends JsonMapperCompiler {
         }
         return super.compile(model, groups);
     }
-    eval(mapper, { id, groupsId, model }) {
-        this.constructors[id] = model;
-        return super.eval(mapper, { id, groupsId, model });
+    eval(mapper, { id, groupsId, model, storeGroups }) {
+        if (typeof model === "function") {
+            this.constructors[id] = model;
+        }
+        return super.eval(mapper, { id, groupsId, model, storeGroups });
     }
     newInstanceOf(id, obj, options) {
         try {

package/lib/esm/domain/JsonMapperCompiler.js

@@ -69,18 +69,17 @@ export class JsonMapperCompiler {
         this.globals[key] = value;
         return this;
     }
-    eval(mapper, { id, groupsId, model }) {
-        this.addGlobal("cache", this.cache);
+    eval(mapper, { id, groupsId, model, storeGroups }) {
         const { globals, schemes } = this;
         const injectGlobals = Object.keys(globals)
             .map((name) => {
             return `const ${name} = globals.${name};`;
         })
             .join("\n");
-        eval(`${injectGlobals};
-
-    cache.get(model).set(groupsId, { id: '${id}', fn: ${mapper} })`);
-        const store = this.cache.get(model).get(groupsId);
+        const compileMapper = new Function("globals", "storeGroups", "schemes", "groupsId", "id", `${injectGlobals}
+      storeGroups.set(groupsId, {id, fn: (${mapper})});
+      return storeGroups.get(groupsId);`);
+        const store = compileMapper(globals, storeGroups, schemes, groupsId, id);
         this.mappers[id] = store.fn;
         return store;
     }
@@ -111,7 +110,7 @@ export class JsonMapperCompiler {
             });
             const mapper = opts.mapper ? opts.mapper(id, groups) : this.createMapper(token, id, groups);
             try {
-                return this.eval(mapper, { id, model: token, groupsId });
+                return this.eval(mapper, { id, groupsId, model: token, storeGroups });
             }
             catch (err) {
                 throw new Error(`Fail to compile mapper for ${nameOf(model)}. See the error above: ${err.message}.\n${mapper}`);

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

@@ -1,6 +1,6 @@
 import { Type } from "@tsed/core";
 import { JsonDeserializerOptions } from "./JsonDeserializerOptions.js";
-import { CachedJsonMapper, JsonMapperCompiler } from "./JsonMapperCompiler.js";
+import { CachedGroupsJsonMapper, CachedJsonMapper, JsonMapperCompiler } from "./JsonMapperCompiler.js";
 /**
  * Deserializes raw JSON data into class instances based on schema metadata,
  * handling collections, discriminators, hooks, and registered type mappers.
@@ -14,10 +14,11 @@ export declare class JsonDeserializer extends JsonMapperCompiler<JsonDeserialize
     constructor();
     map<Model = any>(input: any, options?: JsonDeserializerOptions): Model;
     compile(model: Type<any>, groups: false | string[]): CachedJsonMapper<JsonDeserializerOptions>;
-    eval(mapper: string, { id, groupsId, model }: {
+    eval(mapper: string, { id, groupsId, model, storeGroups }: {
         id: string;
-        model: Type<any>;
+        model: Type<any> | string;
         groupsId: string;
+        storeGroups: CachedGroupsJsonMapper<JsonDeserializerOptions>;
     }): CachedJsonMapper<JsonDeserializerOptions>;
     protected newInstanceOf(id: string, obj: any, options: any): any;
     protected createMapper(model: Type<any>, id: string, groups: false | string[]): string;

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

@@ -51,10 +51,11 @@ export declare abstract class JsonMapperCompiler<Options extends Record<string,
     addTypeMapper(model: Type<any> | string, fn: any): this;
     removeTypeMapper(model: Type<any> | string): void;
     addGlobal(key: string, value: any): this;
-    eval(mapper: string, { id, groupsId, model }: {
+    eval(mapper: string, { id, groupsId, model, storeGroups }: {
         id: string;
-        model: Type<any> | string;
         groupsId: string;
+        model: Type<any> | string;
+        storeGroups: CachedGroupsJsonMapper<Options>;
     }): CachedJsonMapper<Options>;
     createContext(options: Options): Options & {
         cache: Map<string | Type<any>, CachedGroupsJsonMapper<Options>>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@tsed/json-mapper",
   "description": "Json mapper module for Ts.ED Framework",
   "type": "module",
-  "version": "8.25.2",
+  "version": "8.25.4",
   "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.25.2",
-    "@tsed/core": "8.25.2",
-    "@tsed/schema": "8.25.2",
-    "@tsed/typescript": "8.25.2",
+    "@tsed/barrels": "8.25.4",
+    "@tsed/core": "8.25.4",
+    "@tsed/schema": "8.25.4",
+    "@tsed/typescript": "8.25.4",
     "eslint": "9.12.0",
     "typescript": "5.9.3",
     "vitest": "3.2.4"