Merge branch 'develop' into fix-overwrite-default-values

Author: NoNameProvided

src/TransformOperationExecutor.ts

@@ -166,7 +166,7 @@ export class TransformOperationExecutor {
                     const metadata = defaultMetadataStorage.findTypeMetadata((targetType as Function), propertyName);
                     if (metadata) {
                         const options: TypeHelpOptions = { newObject: newValue, object: value, property: propertyName };
-                        const newType = metadata.typeFunction(options);
+                        const newType = metadata.typeFunction ? metadata.typeFunction(options) : metadata.reflectedType;
                         if (metadata.options && metadata.options.discriminator && metadata.options.discriminator.property && metadata.options.discriminator.subTypes) {
                             if (!(value[valueKey] instanceof Array)) {
                                 if (this.transformationType === TransformationType.PLAIN_TO_CLASS) {
@@ -199,6 +199,14 @@ export class TransformOperationExecutor {
                         this.options.targetMaps
                             .filter(map => map.target === targetType && !!map.properties[propertyName])
                             .forEach(map => type = map.properties[propertyName]);
+                    } else if(this.transformationType === TransformationType.PLAIN_TO_CLASS) {
+                        // if we have no registererd type via the @Type() decorator then we check if we have any
+                        // type declarations in reflect-metadata (type declaration is emited only if some decorator is added to the property.)
+                        const reflectedType = Reflect.getMetadata("design:type", (targetType as Function).prototype, propertyName);
+                        
+                        if (reflectedType) {
+                            type = reflectedType;
+                        }
                     }
                 }
 

src/decorators.ts

@@ -22,7 +22,7 @@ export function Transform(transformFn: (value: any, obj: any, transformationType
  * Specifies a type of the property.
  * The given TypeFunction can return a constructor. A discriminator can be given in the options.
  */
-export function Type(typeFunction: (type?: TypeHelpOptions) => Function, options?: TypeOptions) {
+export function Type(typeFunction?: (type?: TypeHelpOptions) => Function, options?: TypeOptions) {
     return function(target: any, key: string) {
         const type = (Reflect as any).getMetadata("design:type", target, key);
         const metadata = new TypeMetadata(target.constructor, key, type, typeFunction, options);

test/functional/implicit-type-declarations.spec.ts

@@ -0,0 +1,110 @@
+import "reflect-metadata";
+import {
+    plainToClass,
+} from "../../src/index";
+import {defaultMetadataStorage} from "../../src/storage";
+import {Expose, Type} from "../../src/decorators";
+import {expect} from "chai";
+
+describe("implicit and explicity type declarations", () => {
+
+    defaultMetadataStorage.clear();
+
+    class Example {
+        
+        @Expose()
+        readonly implicitTypeViaOtherDecorator: Date;
+
+        @Type()
+        readonly implicitTypeViaEmptyTypeDecorator: number;
+        
+        @Type(() => String) 
+        readonly explicitType: string;
+    }
+    
+    const result: Example = plainToClass(Example, { 
+        implicitTypeViaOtherDecorator: "2018-12-24T12:00:00Z", 
+        implicitTypeViaEmptyTypeDecorator: "100", 
+        explicitType: 100,  
+    });
+
+    it("should use implicitly defined design:type to convert value when no @Type decorator is used", () => {
+        expect(result.implicitTypeViaOtherDecorator).to.be.instanceOf(Date);
+        expect(result.implicitTypeViaOtherDecorator.getTime()).to.be.equal(new Date("2018-12-24T12:00:00Z").getTime());
+    });
+
+    it("should use implicitly defined design:type to convert value when empty @Type() decorator is used", () => {
+        expect(result.implicitTypeViaEmptyTypeDecorator).that.is.a("number");
+        expect(result.implicitTypeViaEmptyTypeDecorator).to.be.equal(100);
+    });
+
+    it("should use explicitly defined type when @Type(() => Construtable) decorator is used", () => {
+        expect(result.explicitType).that.is.a("string");
+        expect(result.explicitType).to.be.equal("100");
+    });
+
+});
+
+describe("plainToClass transforms builtin primitive types properly", () => {
+
+    defaultMetadataStorage.clear();
+
+    class Example {
+
+        @Type()
+        date: Date; 
+
+        @Type()
+        string: string;
+
+        @Type()
+        string2: string;
+
+        @Type()
+        number: number;  
+
+        @Type()
+        number2: number;
+        
+        @Type()
+        boolean: boolean;
+    
+        @Type()
+        boolean2: boolean;
+    }
+    
+    const result: Example = plainToClass(Example, { 
+        date: "2018-12-24T12:00:00Z", 
+        string: "100", 
+        string2: 100, 
+        number: "100",
+        number2: 100,
+        boolean: 1,
+        boolean2: 0,
+    });
+
+    it("should recognize and convert to Date", () => {
+        expect(result.date).to.be.instanceOf(Date);
+        expect(result.date.getTime()).to.be.equal(new Date("2018-12-24T12:00:00Z").getTime());
+    });
+
+    it("should recognize and convert to string", () => {
+        expect(result.string).that.is.a("string");
+        expect(result.string2).that.is.a("string");
+        expect(result.string).to.be.equal("100");
+        expect(result.string2).to.be.equal("100");
+    });
+
+    it("should recognize and convert to number", () => {
+        expect(result.number).that.is.a("number");
+        expect(result.number2).that.is.a("number");
+        expect(result.number).to.be.equal(100);
+        expect(result.number2).to.be.equal(100);
+    });
+
+    it("should recognize and convert to boolean", () => {
+        expect(result.boolean).to.be.true;
+        expect(result.boolean2).to.be.false;
+    });
+
+});