@tsed/json-mapper 8.44.11 → 8.44.12

package/lib/esm/domain/JsonDeserializer.js

@@ -39,6 +39,9 @@ function isDeserializable(obj, options) {
 function varKey(k) {
     return `__${k}`;
 }
+function ignoredKey(k) {
+    return `__${k}_ignored`;
+}
 function mapParamStoreOptions(store, options) {
     return {
         ...options,
@@ -110,6 +113,7 @@ export class JsonDeserializer extends JsonMapperCompiler {
     createMapper(model, id, groups) {
         const entity = s.store(model);
         const properties = new Set();
+        const fallbacks = new Map();
         const schemaProperties = [...getPropertiesStores(entity).values()];
         const writer = new Writer().arrow("input", "options");
         writer.if("isNil(input)").return("input");
@@ -126,17 +130,26 @@ export class JsonDeserializer extends JsonMapperCompiler {
         // properties
         writer.add(...schemaProperties.flatMap((propertyStore) => {
             const key = propertyStore.propertyName;
+            const alias = String(propertyStore.parent.schema.getAliasOf(key) || key);
             // TODO V8 add this line: properties.add(key as string);
-            properties.add(String(propertyStore.parent.schema.getAliasOf(key) || key));
+            properties.add(alias);
             if ((propertyStore.schema?.$ignore && isBoolean(propertyStore.schema?.$ignore)) ||
                 propertyStore.isGetterOnly() ||
                 (propertyStore.schema?.$hooks?.has("groups") && this.alterGroups(propertyStore.schema, groups))) {
+                // an excluded property must not be filled from its declared name either
+                properties.add(key);
                 return;
             }
+            // the declared name of an aliased property is still read as an additional property (fallback when the
+            // property mapped nothing), but it must not overwrite the value the property mapped
+            if (alias !== key) {
+                const mappedNothing = `${varKey(key)} === undefined`;
+                fallbacks.set(key, propertyStore.schema?.$hooks?.has("ignore") ? `!${ignoredKey(key)} && ${mappedNothing}` : mappedNothing);
+            }
             return this.mapProperty(propertyStore, id, groups);
         }));
         // additional properties
-        writer.add(this.mapAdditionalProperties(entity, properties, groups));
+        writer.add(this.mapAdditionalProperties(entity, properties, fallbacks, groups));
         // post hook
         if (entity.schema.$hooks?.has("afterDeserialize")) {
             this.schemes[id] = entity.schema;
@@ -165,10 +178,15 @@ export class JsonDeserializer extends JsonMapperCompiler {
         const formatOpts = format && `options: {format: '${format}'}`;
         let writer = new Writer().add(`// Map ${key} ${id} ${groups || ""}`);
         const pick = key !== aliasKey ? `options.useAlias ? '${aliasKey}' : '${key}'` : `'${key}'`;
+        let declare = `let ${varKey(key)}`;
         // ignore hook (deprecated)
         if (propertyStore.schema?.$hooks?.has("ignore")) {
             this.schemes[schemaId] = propertyStore.schema;
-            writer = writer.if(`!alterIgnore('${schemaId}', {...options, self: input})`);
+            // declared outside the branch: the additional properties loop reads them
+            writer.add(`${declare};`);
+            declare = varKey(key);
+            writer.const(ignoredKey(key), `alterIgnore('${schemaId}', {...options, self: input})`);
+            writer = writer.if(`!${ignoredKey(key)}`);
         }
         // pre hook
         const hasDeserializer = propertyStore.schema?.$hooks?.has("onDeserialize");
@@ -178,7 +196,7 @@ export class JsonDeserializer extends JsonMapperCompiler {
             const opts = Writer.options(formatOpts);
             getter = `alterValue('${schemaId}', input[${pick}], ${opts})`;
         }
-        const ifWriter = writer.set(`let ${varKey(key)}`, getter).if(`${varKey(key)} !== undefined`);
+        const ifWriter = writer.set(declare, getter).if(`${varKey(key)} !== undefined`);
         const fill = this.getPropertyFiller(propertyStore, id, groups, formatOpts);
         if (hasDeserializer) {
             fill(ifWriter.if(`${varKey(key)} === input.${key}`));
@@ -238,14 +256,29 @@ export class JsonDeserializer extends JsonMapperCompiler {
             generics: options.generics || {}
         };
     }
-    mapAdditionalProperties(entity, properties, groups) {
+    /**
+     * @param properties The keys never copied: the keys declared by the model (aliases included), and the declared names of
+     * the excluded properties.
+     * @param fallbacks The condition to copy the declared name, by declared name of the aliased properties: the property
+     * was not ignored and mapped nothing (no input value, or a hook returned `undefined`). A declared name is copied only
+     * when the alias is used and this condition is true. The mapped value is checked, not the instance, which may hold a
+     * field initializer.
+     */
+    mapAdditionalProperties(entity, properties, fallbacks, groups) {
         const additionalProperties = entity.schema.get("additionalProperties");
-        const exclude = [...properties.values()].map((key) => `'${key}'`).join(", ");
         const writer = new Writer();
         writer.add("// add additional properties");
-        let each = writer.each("objectKeys(input)", ["key"]);
-        if (exclude.length) {
-            each = each.if(`![${exclude}].includes(key)`);
+        // dynamic additional properties option: the keys are read only when it is enabled, it is disabled by default
+        const scope = additionalProperties ? writer : writer.if("options.additionalProperties");
+        let each = scope.each("objectKeys(input)", ["key"]);
+        if (properties.size) {
+            each = each.if(Writer.notOneOf("key", properties));
+        }
+        if (additionalProperties && fallbacks.size) {
+            const conditions = Array.from(fallbacks, ([name, fallback]) => {
+                return `(key !== '${name}' || (options.useAlias && ${fallback}))`;
+            });
+            each = each.if(conditions.join(" && "));
         }
         if (additionalProperties && additionalProperties instanceof JsonSchema) {
             const nestedMapper = this.compile(additionalProperties.class, groups);
@@ -256,8 +289,7 @@ export class JsonDeserializer extends JsonMapperCompiler {
             each.set("obj[key]", "input[key]");
             return writer;
         }
-        // dynamic additional properties options
-        each.if(`options.additionalProperties && obj[key] === undefined`).set("obj[key]", "input[key]");
+        each.if("obj[key] === undefined").set("obj[key]", "input[key]");
         return writer;
     }
     mapObject(input, options) {

package/lib/esm/domain/JsonSerializer.js

@@ -236,10 +236,9 @@ export class JsonSerializer extends JsonMapperCompiler {
     mapAdditionalProperties(entity, properties) {
         const additionalProperties = !!entity.schema.get("additionalProperties");
         if (additionalProperties) {
-            const exclude = [...properties.values()].map((key) => `'${key}'`).join(", ");
             const writer = new Writer();
             writer.add("// add additional properties");
-            writer.each("objectKeys(input)", ["key"]).if(`![${exclude}].includes(key)`).set("obj[key]", "input[key]");
+            writer.each("objectKeys(input)", ["key"]).if(Writer.notOneOf("key", properties)).set("obj[key]", "input[key]");
             return writer;
         }
     }

package/lib/esm/domain/Writer.js

@@ -22,6 +22,13 @@ export class Writer {
     static mapperFrom(key, options) {
         return `execMapper(nameOf(classOf(${key})), ${key}, ${options})`;
     }
+    /**
+     * Condition true when `key` is none of the given values. It compares the key to each value instead of
+     * calling `[...].includes(key)`, which allocates an array for every key it checks.
+     */
+    static notOneOf(key, values) {
+        return Array.from(values, (value) => `${key} !== '${value}'`).join(" && ");
+    }
     static options(...args) {
         args = args.filter(Boolean);
         return !args.length ? "options" : Writer.object.assign("...options", ...args);

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

@@ -27,6 +27,14 @@ export declare class JsonDeserializer extends JsonMapperCompiler<JsonDeserialize
     private mapProperty;
     private getPropertyFiller;
     private mapOptions;
+    /**
+     * @param properties The keys never copied: the keys declared by the model (aliases included), and the declared names of
+     * the excluded properties.
+     * @param fallbacks The condition to copy the declared name, by declared name of the aliased properties: the property
+     * was not ignored and mapped nothing (no input value, or a hook returned `undefined`). A declared name is copied only
+     * when the alias is used and this condition is true. The mapped value is checked, not the instance, which may hold a
+     * field initializer.
+     */
     private mapAdditionalProperties;
     private mapObject;
     private mapSet;

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

@@ -13,6 +13,11 @@ export declare class Writer {
     static indent(lines: string[]): string[];
     static mapper(mapperId: string, key: string, options: string): string;
     static mapperFrom(key: string, options: string): string;
+    /**
+     * Condition true when `key` is none of the given values. It compares the key to each value instead of
+     * calling `[...].includes(key)`, which allocates an array for every key it checks.
+     */
+    static notOneOf(key: string, values: Iterable<string>): string;
     static options(...args: string[]): string;
     add(...lines: (undefined | string | Writer)[]): this;
     arrow(...args: string[]): Writer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/json-mapper",
-  "version": "8.44.11",
+  "version": "8.44.12",
   "description": "Json mapper module for Ts.ED Framework",
   "keywords": [
     "TypeScript",
@@ -41,10 +41,10 @@
     "tslib": ">=2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.44.11",
-    "@tsed/core": "8.44.11",
-    "@tsed/schema": "8.44.11",
-    "@tsed/typescript": "8.44.11",
+    "@tsed/barrels": "8.44.12",
+    "@tsed/core": "8.44.12",
+    "@tsed/schema": "8.44.12",
+    "@tsed/typescript": "8.44.12",
     "temporal-polyfill": "1.0.1",
     "typescript": "6.0.2",
     "vitest": "4.1.4"