fix: prevent error during transformation when object has property with Promise (#262)

Author: Hossein-s

src/TransformOperationExecutor.ts

@@ -1,7 +1,7 @@
 import { defaultMetadataStorage } from './storage';
 import { TypeHelpOptions, TypeOptions, ClassTransformOptions, TypeMetadata } from './interfaces';
 import { TransformationType } from './enums';
-import { getGlobal } from './utils';
+import { getGlobal, isPromise } from './utils';
 
 function instantiateArrayType(arrayType: Function): Array<any> | Set<any> {
   const array = new (arrayType as any)();
@@ -64,6 +64,7 @@ export class TransformOperationExecutor {
               if (!targetType.options.keepDiscriminatorProperty)
                 delete subValue[targetType.options.discriminator.property];
             }
+
             if (this.transformationType === TransformationType.CLASS_TO_CLASS) {
               realTargetType = subValue.constructor;
             }
@@ -116,7 +117,16 @@ export class TransformOperationExecutor {
     } else if (!!getGlobal().Buffer && (targetType === Buffer || value instanceof Buffer) && !isMap) {
       if (value === null || value === undefined) return value;
       return Buffer.from(value);
+    } else if (isPromise(value) && !isMap) {
+      return new Promise((resolve, reject) => {
+        value.then(
+          (data: any) => resolve(this.transform(undefined, data, targetType, undefined, undefined, level + 1)),
+          reject
+        );
+      });
     } else if (!isMap && value !== null && typeof value === 'object' && typeof value.then === 'function') {
+      // Note: We should not enter this, as promise has been handled above
+      // This option simply returns the Promise preventing a JS error from happening and should be an inaccessible path.
       return value; // skip promise transformation
     } else if (typeof value === 'object' && value !== null) {
       // try to guess the type

src/utils/index.ts

@@ -1 +1,2 @@
 export * from './get-global.util';
+export * from './is-promise.util';

src/utils/is-promise.util.ts

@@ -0,0 +1,3 @@
+export function isPromise<T>(p: any): p is Promise<T> {
+  return p !== null && typeof p === 'object' && typeof p.then === 'function';
+}

test/functional/promise-field.spec.ts

@@ -0,0 +1,83 @@
+import 'reflect-metadata';
+import { defaultMetadataStorage } from '../../src/storage';
+import { plainToClass, Type, classToPlain } from '../../src';
+
+describe('promise field', () => {
+  it('should transform plan to class with promise field', async () => {
+    defaultMetadataStorage.clear();
+
+    class PromiseClass {
+      promise: Promise<string>;
+    }
+
+    const plain = {
+      promise: Promise.resolve('hi'),
+    };
+
+    const instance = plainToClass(PromiseClass, plain);
+    expect(instance.promise).toBeInstanceOf(Promise);
+    const value = await instance.promise;
+    expect(value).toBe('hi');
+  });
+
+  it('should transform class with promise field to plain', async () => {
+    class PromiseClass {
+      promise: Promise<string>;
+
+      constructor(promise: Promise<any>) {
+        this.promise = promise;
+      }
+    }
+
+    const instance = new PromiseClass(Promise.resolve('hi'));
+    const plain = classToPlain(instance) as any;
+    expect(plain).toHaveProperty('promise');
+    const value = await plain.promise;
+    expect(value).toBe('hi');
+  });
+
+  it('should clone promise result', async () => {
+    defaultMetadataStorage.clear();
+
+    class PromiseClass {
+      promise: Promise<string[]>;
+    }
+
+    const array = ['hi', 'my', 'name'];
+    const plain = {
+      promise: Promise.resolve(array),
+    };
+
+    const instance = plainToClass(PromiseClass, plain);
+    const value = await instance.promise;
+    expect(value).toEqual(array);
+
+    // modify transformed array to prove it's not referencing original array
+    value.push('is');
+    expect(value).not.toEqual(array);
+  });
+
+  it('should support Type decorator', async () => {
+    class PromiseClass {
+      @Type(() => InnerClass)
+      promise: Promise<InnerClass>;
+    }
+
+    class InnerClass {
+      position: string;
+
+      constructor(position: string) {
+        this.position = position;
+      }
+    }
+
+    const plain = {
+      promise: Promise.resolve(new InnerClass('developer')),
+    };
+
+    const instance = plainToClass(PromiseClass, plain);
+    const value = await instance.promise;
+    expect(value).toBeInstanceOf(InnerClass);
+    expect(value.position).toBe('developer');
+  });
+});