fix: ensure [] | undefined union types defaults to array on transform

Author: guscastro

src/TransformOperationExecutor.ts

@@ -1,6 +1,6 @@
 import { ClassTransformOptions } from "./ClassTransformOptions";
 import { defaultMetadataStorage } from "./storage";
-import { TypeHelpOptions, Discriminator, TypeOptions } from "./metadata/ExposeExcludeOptions";
+import { TypeHelpOptions, TypeOptions } from "./metadata/ExposeExcludeOptions";
 import { TypeMetadata } from "./metadata/TypeMetadata";
 
 export enum TransformationType {
@@ -37,7 +37,7 @@ export class TransformOperationExecutor {
         level: number = 0) {
 
         if (Array.isArray(value) || value instanceof Set) {
-            const newValue = arrayType && this.transformationType === TransformationType.PLAIN_TO_CLASS ? new (arrayType as any)() : [];
+            const newValue = arrayType && this.transformationType === TransformationType.PLAIN_TO_CLASS ? instantiateArrayType(arrayType) : [];
             (value as any[]).forEach((subValue, index) => {
                 const subSource = source ? source[index] : undefined;
                 if (!this.options.enableCircularCheck || !this.isCircular(subValue)) {
@@ -402,3 +402,11 @@ export class TransformOperationExecutor {
     }
 
 }
+
+function instantiateArrayType (arrayType: Function): Array<any> | Set<any> {
+    const array = new (arrayType as any)();
+    if (!(array instanceof Set) && !("push" in array)) {
+        return [];
+    }
+    return array;
+}

test/functional/basic-functionality.spec.ts

@@ -1738,4 +1738,33 @@ describe("basic functionality", () => {
         transformedClass.should.be.instanceOf(TestClass);
     });
 
+    it("should default union types where the plain type is an array to an array result", () => {
+        class User {
+            name: string;
+        }
+
+        class TestClass {
+            @Type(() => User)
+            usersDefined: User[] | undefined;
+
+            @Type(() => User)
+            usersUndefined: User[] | undefined;
+        }
+
+        const obj = Object.create(null);
+        obj.usersDefined = [{ name: "a-name" }];
+        obj.usersUndefined = undefined;
+
+        const transformedClass = plainToClass(TestClass, obj as Object);
+
+        transformedClass.should.be.instanceOf(TestClass);
+
+        transformedClass.usersDefined.should.be.instanceOf(Array);
+        transformedClass.usersDefined.length.should.equal(1);
+        transformedClass.usersDefined[0].should.be.instanceOf(User);
+        transformedClass.usersDefined[0].name.should.equal("a-name");
+
+        expect(transformedClass.usersUndefined).to.equal(undefined);
+    });
+
 });