fix: prevent returning class property names when using Expose() with Map (#405)

Author: cvlvxi

src/TransformOperationExecutor.ts

@@ -127,7 +127,7 @@ export class TransformOperationExecutor {
         this.recursionStack.add(value);
       }
 
-      const keys = this.getKeys(targetType as Function, value);
+      const keys = this.getKeys(targetType as Function, value, isMap);
       let newValue: any = source ? source : {};
       if (
         !source &&
@@ -390,21 +390,26 @@ export class TransformOperationExecutor {
     return meta ? meta.reflectedType : undefined;
   }
 
-  private getKeys(target: Function, object: Record<string, any>): string[] {
+  private getKeys(target: Function, object: Record<string, any>, isMap: boolean): string[] {
     // determine exclusion strategy
     let strategy = defaultMetadataStorage.getStrategy(target);
     if (strategy === 'none') strategy = this.options.strategy || 'exposeAll'; // exposeAll is default strategy
 
     // get all keys that need to expose
     let keys: any[] = [];
-    if (strategy === 'exposeAll') {
+    if (strategy === 'exposeAll' || isMap) {
       if (object instanceof Map) {
         keys = Array.from(object.keys());
       } else {
         keys = Object.keys(object);
       }
     }
 
+    if (isMap) {
+      // expose & exclude do not apply for map keys only to fields
+      return keys;
+    }
+
     if (!this.options.ignoreDecorators && target) {
       // add all exposed to list of keys
       let exposedProperties = defaultMetadataStorage.getExposedProperties(target, this.transformationType);

test/functional/es6-data-types.spec.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { classToPlain, plainToClass } from '../../src/index';
+import { classToPlain, plainToClass, Expose } from '../../src/index';
 import { defaultMetadataStorage } from '../../src/storage';
 import { Type } from '../../src/decorators';
 
@@ -252,4 +252,98 @@ describe('es6 data types', () => {
       ],
     });
   });
+
+  it('using Map with objects with Expose', () => {
+    defaultMetadataStorage.clear();
+
+    class Weapon {
+      constructor(public model: string, public range: number) {}
+    }
+
+    class User {
+      @Expose() id: number;
+      @Expose() name: string;
+      @Expose()
+      @Type(() => Weapon)
+      weapons: Map<string, Weapon>;
+    }
+
+    const plainUser = {
+      id: 1,
+      name: 'Max Pain',
+      weapons: {
+        firstWeapon: {
+          model: 'knife',
+          range: 1,
+        },
+        secondWeapon: {
+          model: 'eagle',
+          range: 200,
+        },
+        thirdWeapon: {
+          model: 'ak-47',
+          range: 800,
+        },
+      },
+    };
+
+    const weapons = new Map<string, Weapon>();
+    weapons.set('firstWeapon', new Weapon('knife', 1));
+    weapons.set('secondWeapon', new Weapon('eagle', 200));
+    weapons.set('thirdWeapon', new Weapon('ak-47', 800));
+
+    const user = new User();
+    user.id = 1;
+    user.name = 'Max Pain';
+    user.weapons = weapons;
+    const plainedUser = classToPlain(user);
+    expect(plainedUser).not.toBeInstanceOf(User);
+    expect(plainedUser).toEqual({
+      id: 1,
+      name: 'Max Pain',
+      weapons: {
+        firstWeapon: {
+          model: 'knife',
+          range: 1,
+        },
+        secondWeapon: {
+          model: 'eagle',
+          range: 200,
+        },
+        thirdWeapon: {
+          model: 'ak-47',
+          range: 800,
+        },
+      },
+    });
+
+    function checkPlainToClassUser(classUser: User) {
+      expect(classedUser).toBeInstanceOf(User);
+      expect(classedUser.id).toEqual(1);
+      expect(classedUser.name).toEqual('Max Pain');
+      expect(classedUser.weapons).toBeInstanceOf(Map);
+      expect(classedUser.weapons.size).toEqual(3);
+      expect(classedUser.weapons.get('firstWeapon')).toBeInstanceOf(Weapon);
+      expect(classedUser.weapons.get('firstWeapon')).toEqual({
+        model: 'knife',
+        range: 1,
+      });
+      expect(classedUser.weapons.get('secondWeapon')).toBeInstanceOf(Weapon);
+      expect(classedUser.weapons.get('secondWeapon')).toEqual({
+        model: 'eagle',
+        range: 200,
+      });
+      expect(classedUser.weapons.get('thirdWeapon')).toBeInstanceOf(Weapon);
+      expect(classedUser.weapons.get('thirdWeapon')).toEqual({
+        model: 'ak-47',
+        range: 800,
+      });
+    }
+
+    const classedUser = plainToClass(User, plainUser, { excludeExtraneousValues: false });
+    checkPlainToClassUser(classedUser);
+
+    const classedUser2 = plainToClass(User, plainUser, { excludeExtraneousValues: true });
+    checkPlainToClassUser(classedUser2);
+  });
 });