Merge branch 'develop'

Author: NoNameProvided

CHANGELOG.md

@@ -1,7 +1,27 @@
 # Changelog and release notes
 
+
+### 0.2.3 [BREAKING CHANGE]
+
+#### Changed
+
+- `enableImplicitConversion` has been added and imlplicit value conversion is disabled by default.
+- reverted #234 - fix: write properties with defined default values on prototype which broke the `@Exclude` decorator.
+
+### 0.2.2 [BREAKING CHANGE]
+
+> **NOTE:** This version is deprecated.
+
+This version has introduced a breaking-change when this library is used with class-validator. See #257 for details.
+
+#### Added
+
+- implicity type conversion between values.
+
 ### 0.2.1
 
+> **NOTE:** This version is deprecated.
+
 #### Added
 
 -   add option to strip unkown properties via using the `excludeExtraneousValues` option

README.md

@@ -11,7 +11,7 @@ Class-transformer allows you to transform plain object to some instance of class
 Also it allows to serialize / deserialize object based on criteria.
 This tool is super useful on both frontend and backend.
 
-Example how to use with angular 2 in [plunker](http://plnkr.co/edit/Mja1ZYAjVySWASMHVB9R). 
+Example how to use with angular 2 in [plunker](http://plnkr.co/edit/Mja1ZYAjVySWASMHVB9R).
 Source code is available [here](https://github.com/pleerock/class-transformer-demo).
 
 ## What is class-transformer
@@ -103,7 +103,7 @@ Here is example how it will look like:
 ```typescript
 fetch("users.json").then((users: Object[]) => {
     const realUsers = plainToClass(User, users);
-    // now each user in realUsers is instance of User class 
+    // now each user in realUsers is instance of User class
 });
 ```
 
@@ -247,7 +247,7 @@ let photos = deserializeArray(Photo, photos);
 
 ## Enforcing type-safe instance
 
-The default behaviour of the `plainToClass` method is to set *all* properties from the plain object, 
+The default behaviour of the `plainToClass` method is to set *all* properties from the plain object,
 even those which are not specified in the class.
 
 ```typescript
@@ -274,7 +274,7 @@ console.log(plainToClass(User, fromPlainUser))
 // }
 ```
 
-If this behaviour does not suit your needs, you can use the `excludeExtraneousValues` option 
+If this behaviour does not suit your needs, you can use the `excludeExtraneousValues` option
 in the `plainToClass` method while *exposing all your class properties* as a requirement.
 
 ```typescript
@@ -297,7 +297,7 @@ console.log(plainToClass(User, fromPlainUser, { excludeExtraneousValues: true })
 // User {
 //   id: undefined,
 //   firstName: 'Umed',
-//   lastName: 'Khudoiberdiev' 
+//   lastName: 'Khudoiberdiev'
 // }
 ```
 
@@ -309,7 +309,7 @@ Since Typescript does not have good reflection abilities yet,
 we should implicitly specify what type of object each property contain.
 This is done using `@Type` decorator.
 
-Lets say we have an album with photos. 
+Lets say we have an album with photos.
 And we are trying to convert album plain object to class object:
 
 ```typescript
@@ -532,7 +532,7 @@ In this case you don't need to `@Exclude()` a whole class.
 
 ## Skipping private properties, or some prefixed properties
 
-If you name your private properties with a prefix, lets say with `_`, 
+If you name your private properties with a prefix, lets say with `_`,
 then you can exclude such properties from transformation too:
 
 ```typescript
@@ -563,7 +563,7 @@ export class User {
     get name() {
         return this.firstName + " " + this.lastName;
     }
-    
+
 }
 
 const user = new User();
@@ -750,8 +750,8 @@ export class Photo {
 }
 ```
 
-Now when you call `plainToClass` and send a plain representation of the Photo object, 
-it will convert a date value in your photo object to moment date. 
+Now when you call `plainToClass` and send a plain representation of the Photo object,
+it will convert a date value in your photo object to moment date.
 `@Transform` decorator also supports groups and versioning.
 
 ### Advanced usage
@@ -765,7 +765,7 @@ The `@Transform` decorator is given more arguments to let you configure how you
 | Argument          | Description
 |--------------------|---------------------------------------------------------------------------------|
 | `value` | The property value before the transformation.
-| `obj` | The transformation source object. 
+| `obj` | The transformation source object.
 | `type` | The transformation type.
 
 ## Other decorators
@@ -799,7 +799,7 @@ class User {
 }
 
 class UserController {
-    
+
     @TransformClassToPlain({ groups: ['user.email'] })
     getUser() {
         const user = new User();
@@ -825,6 +825,31 @@ Once TypeScript team provide us better runtime type reflection tools, generics w
 There are some tweaks however you can use, that maybe can solve your problem.
 [Checkout this example.](https://github.com/pleerock/class-transformer/tree/master/sample/sample4-generics)
 
+## Implicit type conversion
+
+> **NOTE** If you use class-validator together with class-transformer you propably DON'T want to enable this function.
+
+Enables automatic conversion between built-in types based on type information provided by Typescript. Disabled by default.
+
+```ts
+import { IsString } from 'class-validator'
+
+class MyPayload {
+
+  @IsString()
+  prop: string
+}
+
+
+const result1 = plainToClass(MyPayload, { prop: 1234 }, { enableImplicitConversion: true });
+const result2 = plainToClass(MyPayload, { prop: 1234 }, { enableImplicitConversion: false });
+
+/**
+ *  result1 will be `{ prop: "1234" }` - notice how the prop value has been converted to string.
+ *  result2 will be `{ prop: 1234 }` - default behaviour
+ */
+```
+
 ## How does it handle circular references?
 
 Circular references are ignored.
@@ -851,7 +876,7 @@ this.http
 
 You can also inject a class `ClassTransformer` as a service in `providers`, and use its methods.
 
-Example how to use with angular 2 in [plunker](http://plnkr.co/edit/Mja1ZYAjVySWASMHVB9R). 
+Example how to use with angular 2 in [plunker](http://plnkr.co/edit/Mja1ZYAjVySWASMHVB9R).
 Source code is [here](https://github.com/pleerock/class-transformer-demo).
 
 ## Samples

src/ClassTransformOptions.ts

@@ -67,4 +67,11 @@ export interface ClassTransformOptions {
      * This option is useful when you know for sure that your types might have a circular dependency.
      */
     enableCircularCheck?: boolean;
+
+    /**
+     * If set to true then class transformer will try to convert properties implicitly to their target type based on their typing information.
+     *
+     * DEFAULT: `false`
+     */
+    enableImplicitConversion?: boolean;
 }

src/TransformOperationExecutor.ts

@@ -199,11 +199,11 @@ 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) {
+                    } else if(this.options.enableImplicitConversion && 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;
                         }
@@ -225,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.writable) || newValue[newValueKey] instanceof Function)) //  || TransformationType === TransformationType.CLASS_TO_CLASS
+                        && ((descriptor && !descriptor.set) || newValue[newValueKey] instanceof Function)) //  || TransformationType === TransformationType.CLASS_TO_CLASS
                         continue;
                 }
 

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

@@ -6,27 +6,55 @@ import {defaultMetadataStorage} from "../../src/storage";
 import {Expose, Type} from "../../src/decorators";
 import {expect} from "chai";
 
+describe("implicit type conversion", () => {
+    it("should run only when enabled", () => {
+        defaultMetadataStorage.clear();
+
+        class SimpleExample {
+
+        @Expose()
+        readonly implicitTypeNumber: number;
+
+        @Expose()
+        readonly implicitTypeString: string;
+        }
+
+        const result1: SimpleExample = plainToClass(SimpleExample, {
+            implicitTypeNumber: "100",
+            implicitTypeString: 133123,
+        }, { enableImplicitConversion: true });
+
+        const result2: SimpleExample = plainToClass(SimpleExample, {
+            implicitTypeNumber: "100",
+            implicitTypeString: 133123,
+        }, { enableImplicitConversion: false });
+
+        expect(result1).to.deep.equal({ implicitTypeNumber: 100, implicitTypeString: "133123" });
+        expect(result2).to.deep.equal({ implicitTypeNumber: "100", implicitTypeString: 133123 });
+    });
+});
+
 describe("implicit and explicity type declarations", () => {
 
     defaultMetadataStorage.clear();
 
     class Example {
-        
+
         @Expose()
         readonly implicitTypeViaOtherDecorator: Date;
 
         @Type()
         readonly implicitTypeViaEmptyTypeDecorator: number;
-        
-        @Type(() => String) 
+
+        @Type(() => String)
         readonly explicitType: string;
     }
-    
-    const result: Example = plainToClass(Example, { 
-        implicitTypeViaOtherDecorator: "2018-12-24T12:00:00Z", 
-        implicitTypeViaEmptyTypeDecorator: "100", 
-        explicitType: 100,  
-    });
+
+    const result: Example = plainToClass(Example, {
+        implicitTypeViaOtherDecorator: "2018-12-24T12:00:00Z",
+        implicitTypeViaEmptyTypeDecorator: "100",
+        explicitType: 100,
+    }, { enableImplicitConversion: true });
 
     it("should use implicitly defined design:type to convert value when no @Type decorator is used", () => {
         expect(result.implicitTypeViaOtherDecorator).to.be.instanceOf(Date);
@@ -45,14 +73,14 @@ describe("implicit and explicity type declarations", () => {
 
 });
 
-describe("plainToClass transforms builtin primitive types properly", () => {
+describe("plainToClass transforms built-in primitive types properly", () => {
 
     defaultMetadataStorage.clear();
 
     class Example {
 
         @Type()
-        date: Date; 
+        date: Date;
 
         @Type()
         string: string;
@@ -61,27 +89,27 @@ describe("plainToClass transforms builtin primitive types properly", () => {
         string2: string;
 
         @Type()
-        number: number;  
+        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, 
+
+    const result: Example = plainToClass(Example, {
+        date: "2018-12-24T12:00:00Z",
+        string: "100",
+        string2: 100,
         number: "100",
         number2: 100,
         boolean: 1,
         boolean2: 0,
-    });
+    }, { enableImplicitConversion: true });
 
     it("should recognize and convert to Date", () => {
         expect(result.date).to.be.instanceOf(Date);

test/functional/prototype-inheritance.spec.ts

@@ -0,0 +1,28 @@
+// import { expect } from "chai";
+
+// import { plainToClass } from "../../src";
+
+// describe("Prototype inheritance", () => {
+
+//   // https://github.com/typestack/class-transformer/issues/233
+//   it("should set value if property has default value in prototype chain.", () => {
+//     class TestObject {
+//       normalProp: string = "Hello!";
+//       prototypedProp: string;
+//     }
+
+//     TestObject.prototype.prototypedProp = "I'm a BUG!";
+
+//     const payload = {
+//       normalProp: "Goodbye!",
+//       prototypedProp: "Goodbye!"
+//     };
+
+//     const result = plainToClass(TestObject, payload);
+
+//     expect(result).to.eql({
+//       normalProp: "Goodbye!",
+//       prototypedProp: "Goodbye!"
+//     });
+//   });
+// });

test/functional/serialization-deserialization.spec.ts

@@ -129,24 +129,24 @@ describe("serialization and deserialization objects", () => {
 
     });
 
-    it("should overwrite default properties defined in prototype", () => {
-        class TestObject {
-            normalProp: string = "Hello!";
-            prototypedProp: string;
-        }
+    // it("should overwrite default properties defined in prototype", () => {
+    //     class TestObject {
+    //         normalProp: string = "Hello!";
+    //         prototypedProp: string;
+    //     }
 
-        TestObject.prototype.prototypedProp = "I'm a BUG!";
+    //     TestObject.prototype.prototypedProp = "I'm a BUG!";
 
 
-        const payload = {
-            normalProp: "Goodbye!",
-            prototypedProp: "Goodbye!"
-        };
+    //     const payload = {
+    //         normalProp: "Goodbye!",
+    //         prototypedProp: "Goodbye!"
+    //     };
 
-        const result = deserialize(TestObject, JSON.stringify(payload));
+    //     const result = deserialize(TestObject, JSON.stringify(payload));
 
-        result.normalProp.should.be.eql("Goodbye!");
-        result.prototypedProp.should.be.eql("Goodbye!");
-    });
+    //     result.normalProp.should.be.eql("Goodbye!");
+    //     result.prototypedProp.should.be.eql("Goodbye!");
+    // });
 
 });