release: 0.2.2 (#252)

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;
+                        }
                     }
                 }
 
@@ -217,7 +225,7 @@ export class TransformOperationExecutor {
                 if (newValue.constructor.prototype) {
                     const descriptor = Object.getOwnPropertyDescriptor(newValue.constructor.prototype, newValueKey);
                     if ((this.transformationType === TransformationType.PLAIN_TO_CLASS || this.transformationType === TransformationType.CLASS_TO_CLASS)
-                        && ((descriptor && !descriptor.set) || newValue[newValueKey] instanceof Function)) //  || TransformationType === TransformationType.CLASS_TO_CLASS
+                        && ((descriptor && !descriptor.writable) || newValue[newValueKey] instanceof Function)) //  || TransformationType === TransformationType.CLASS_TO_CLASS
                         continue;
                 }
 

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;
+    });
+
+});

test/functional/serialization-deserialization.spec.ts

@@ -107,4 +107,46 @@ describe("serialization and deserialization objects", () => {
         // (<any>result).extra.should.be.undefined;
     });
 
-});
+
+    it("should not overwrite non writable properties on deserialize", () => {
+        class TestObject {
+            get getterOnlyProp(): string {
+                return "I cannot write!";
+            }
+
+            normalProp: string = "Hello!";
+        }
+
+        const payload = {
+            getterOnlyProp: "I CAN write!",
+            normalProp: "Goodbye!"
+        };
+
+        const result = deserialize(TestObject, JSON.stringify(payload));
+
+        result.getterOnlyProp.should.be.eql("I cannot write!");
+        result.normalProp.should.be.eql("Goodbye!");
+
+    });
+
+    it("should overwrite default properties defined in prototype", () => {
+        class TestObject {
+            normalProp: string = "Hello!";
+            prototypedProp: string;
+        }
+
+        TestObject.prototype.prototypedProp = "I'm a BUG!";
+
+
+        const payload = {
+            normalProp: "Goodbye!",
+            prototypedProp: "Goodbye!"
+        };
+
+        const result = deserialize(TestObject, JSON.stringify(payload));
+
+        result.normalProp.should.be.eql("Goodbye!");
+        result.prototypedProp.should.be.eql("Goodbye!");
+    });
+
+});