feat: add option to ignore unset fields during class to plain transformation

Author: NoNameProvided

src/ClassTransformer.ts

@@ -2,6 +2,7 @@ import { ClassTransformOptions } from './interfaces';
 import { TransformOperationExecutor } from './TransformOperationExecutor';
 import { TransformationType } from './enums';
 import { ClassConstructor } from './interfaces';
+import { defaultOptions } from './constants/default-options.constant';
 
 export class ClassTransformer {
   // -------------------------------------------------------------------------
@@ -17,7 +18,10 @@ export class ClassTransformer {
     object: T | T[],
     options?: ClassTransformOptions
   ): Record<string, any> | Record<string, any>[] {
-    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, options || {});
+    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, {
+      ...defaultOptions,
+      ...options,
+    });
     return executor.transform(undefined, object, undefined, undefined, undefined, undefined);
   }
 
@@ -41,7 +45,10 @@ export class ClassTransformer {
     plainObject: P | P[],
     options?: ClassTransformOptions
   ): T | T[] {
-    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, options || {});
+    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_PLAIN, {
+      ...defaultOptions,
+      ...options,
+    });
     return executor.transform(plainObject, object, undefined, undefined, undefined, undefined);
   }
 
@@ -63,7 +70,10 @@ export class ClassTransformer {
     plain: V | V[],
     options?: ClassTransformOptions
   ): T | T[] {
-    const executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, options || {});
+    const executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, {
+      ...defaultOptions,
+      ...options,
+    });
     return executor.transform(undefined, plain, cls, undefined, undefined, undefined);
   }
 
@@ -83,7 +93,10 @@ export class ClassTransformer {
     plain: V | V[],
     options?: ClassTransformOptions
   ): T | T[] {
-    const executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, options || {});
+    const executor = new TransformOperationExecutor(TransformationType.PLAIN_TO_CLASS, {
+      ...defaultOptions,
+      ...options,
+    });
     return executor.transform(clsObject, plain, undefined, undefined, undefined, undefined);
   }
 
@@ -93,7 +106,10 @@ export class ClassTransformer {
   classToClass<T>(object: T, options?: ClassTransformOptions): T;
   classToClass<T>(object: T[], options?: ClassTransformOptions): T[];
   classToClass<T>(object: T | T[], options?: ClassTransformOptions): T | T[] {
-    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, options || {});
+    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, {
+      ...defaultOptions,
+      ...options,
+    });
     return executor.transform(undefined, object, undefined, undefined, undefined, undefined);
   }
 
@@ -105,7 +121,10 @@ export class ClassTransformer {
   classToClassFromExist<T>(object: T, fromObject: T, options?: ClassTransformOptions): T;
   classToClassFromExist<T>(object: T, fromObjects: T[], options?: ClassTransformOptions): T[];
   classToClassFromExist<T>(object: T, fromObject: T | T[], options?: ClassTransformOptions): T | T[] {
-    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, options || {});
+    const executor = new TransformOperationExecutor(TransformationType.CLASS_TO_CLASS, {
+      ...defaultOptions,
+      ...options,
+    });
     return executor.transform(fromObject, object, undefined, undefined, undefined, undefined);
   }
 

src/TransformOperationExecutor.ts

@@ -321,10 +321,12 @@ export class TransformOperationExecutor {
             }
           }
 
-          if (newValue instanceof Map) {
-            newValue.set(newValueKey, finalValue);
-          } else {
-            newValue[newValueKey] = finalValue;
+          if (finalValue !== undefined || this.options.exposeUnsetFields) {
+            if (newValue instanceof Map) {
+              newValue.set(newValueKey, finalValue);
+            } else {
+              newValue[newValueKey] = finalValue;
+            }
           }
         } else if (this.transformationType === TransformationType.CLASS_TO_CLASS) {
           let finalValue = subValue;
@@ -335,10 +337,12 @@ export class TransformOperationExecutor {
             value,
             this.transformationType
           );
-          if (newValue instanceof Map) {
-            newValue.set(newValueKey, finalValue);
-          } else {
-            newValue[newValueKey] = finalValue;
+          if (finalValue !== undefined || this.options.exposeUnsetFields) {
+            if (newValue instanceof Map) {
+              newValue.set(newValueKey, finalValue);
+            } else {
+              newValue[newValueKey] = finalValue;
+            }
           }
         }
       }

src/constants/default-options.constant.ts

@@ -0,0 +1,18 @@
+import { ClassTransformOptions } from '../interfaces/class-transformer-options.interface';
+
+/**
+ * These are the default options used by any transformation operation.
+ */
+export const defaultOptions: Partial<ClassTransformOptions> = {
+  enableCircularCheck: false,
+  enableImplicitConversion: false,
+  excludeExtraneousValues: false,
+  excludePrefixes: undefined,
+  exposeDefaultValues: false,
+  exposeUnsetFields: true,
+  groups: undefined,
+  ignoreDecorators: false,
+  strategy: undefined,
+  targetMaps: undefined,
+  version: undefined,
+};

src/interfaces/class-transformer-options.interface.ts

@@ -63,4 +63,11 @@ export interface ClassTransformOptions {
    * This is useful when you convert a plain object to a class and have an optional field with a default value.
    */
   exposeDefaultValues?: boolean;
+
+  /**
+   * When set to true `undefined` fields will be ignored during class to plain transformation.
+   *
+   * DEFAULT: `true`
+   */
+  exposeUnsetFields?: boolean;
 }

test/functional/custom-transform.spec.ts

@@ -149,7 +149,8 @@ describe('custom transformation decorator', () => {
     expect(keyArg).toBe('name');
     expect(objArg).toEqual(plainUser);
     expect(typeArg).toEqual(TransformationType.PLAIN_TO_CLASS);
-    expect(optionsArg).toBe(options);
+    expect(optionsArg.groups).toBe(options.groups);
+    expect(optionsArg.version).toBe(options.version);
 
     const user = new User();
     user.name = 'Johny Cage';
@@ -159,7 +160,8 @@ describe('custom transformation decorator', () => {
     expect(keyArg).toBe('name');
     expect(objArg).toEqual(user);
     expect(typeArg).toEqual(TransformationType.CLASS_TO_PLAIN);
-    expect(optionsArg).toBe(options);
+    expect(optionsArg.groups).toBe(options.groups);
+    expect(optionsArg.version).toBe(options.version);
   });
 
   let model: any;

test/functional/transformation-option.spec.ts

@@ -161,4 +161,30 @@ describe('filtering by transformation option', () => {
       lastName: 'Khudoiberdiev',
     });
   });
+
+  it('should ignore undefined properties when exposeUnsetFields is set to false during class to plain', () => {
+    defaultMetadataStorage.clear();
+
+    @Exclude()
+    class User {
+      @Expose()
+      firstName: string;
+
+      @Expose()
+      lastName: string;
+    }
+
+    expect(classToPlain(new User(), { exposeUnsetFields: false })).toEqual({});
+    expect(classToPlain(new User(), { exposeUnsetFields: true })).toEqual({
+      firstName: undefined,
+      lastName: undefined,
+    });
+
+    const classedUser = plainToClass(User, { exposeUnsetFields: false });
+    expect(classedUser).toBeInstanceOf(User);
+    expect(classedUser).toEqual({
+      firstName: undefined,
+      lastName: undefined,
+    });
+  });
 });