Merge branch 'master' into master

sparebytes · web-flow · commit a5df6f1483af · 2018-08-10T10:05:44.000-05:00
diff --git a/.travis.yml b/.travis.yml
@@ -1,9 +1,8 @@
 language: node_js
 node_js:
   - stable
+  - 8
   - 6
-  - 5
-  - 4
 
 after_success:
   - bash <(curl -s https://codecov.io/bash)
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -0,0 +1,75 @@
+# Changelog and release notes
+
+### 0.1.9
+
+#### Fixed
+
+- objects with `null` prototype are converted properly now
+- objects with unknown non primitive properties are converted properly now
+- corrected a typo in the README.md
+- fixed the deserialize example in the README.md
+
+### 0.1.4
+
+#### Added
+
+- added `TransformClassToPlain` and `TransformClassToClass` decorators
+
+### 0.1.0
+
+#### Added
+
+- renamed library from `constructor-utils` to `class-transformer`
+- completely renamed most of names
+- renamed all main methods: `plainToConstructor` now is `plainToClass` and `constructorToPlain` is `classToPlain`, etc.
+- `plainToConstructorArray` method removed - now `plainToClass` handles it
+- `@Skip()` decorator renamed to `@Exclude()`
+- added `@Expose` decorator
+- added lot of new options: groups, versioning, custom names, etc.
+- methods and getters that should be exposed must be decorated with `@Expose` decorator
+- added `excludedPrefix` to class transform options that allows exclude properties that start with one of the given prefix
+
+### 0.0.22
+
+#### Fixed
+
+- fixed array with primitive types being converted
+
+### 0.0.18-0.0.21
+
+#### Fixed
+
+- fixed bugs when getters are not converted with es6 target
+
+### 0.0.17
+
+#### Fixed
+
+- fixed issue #4
+- added type guessing during transformation from constructor to plain object
+- added sample with generics
+
+### 0.0.16
+
+#### Changed
+
+- renamed `constructor-utils/constructor-utils` to `constructor-utils` package namespace
+
+### 0.0.15
+
+#### Removed
+
+- removed code mappings from package
+
+### 0.0.14
+
+#### Removed
+
+- removed `import "reflect-metadata"` from source code. Now reflect metadata should be included like any other shims.
+
+### 0.0.13
+
+#### Changed
+
+- Library has changed its name from `serializer.ts` to `constructor-utils`.
+- Added `constructor-utils` namespace.
diff --git a/LICENSE b/LICENSE
@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015-2016 Umed Khudoiberdiev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/README.md b/README.md
@@ -1,10 +1,10 @@
 # class-transformer
 
-[![Build Status](https://travis-ci.org/pleerock/class-transformer.svg?branch=master)](https://travis-ci.org/pleerock/class-transformer)
-[![codecov](https://codecov.io/gh/pleerock/class-transformer/branch/master/graph/badge.svg)](https://codecov.io/gh/pleerock/class-transformer)
+[![Build Status](https://travis-ci.org/typestack/class-transformer.svg?branch=master)](https://travis-ci.org/typestack/class-transformer)
+[![codecov](https://codecov.io/gh/typestack/class-transformer/branch/master/graph/badge.svg)](https://codecov.io/gh/typestack/class-transformer)
 [![npm version](https://badge.fury.io/js/class-transformer.svg)](https://badge.fury.io/js/class-transformer)
-[![Dependency Status](https://david-dm.org/pleerock/class-transformer.svg)](https://david-dm.org/pleerock/class-transformer)
-[![Join the chat at https://gitter.im/pleerock/class-transformer](https://badges.gitter.im/pleerock/class-transformer.svg)](https://gitter.im/pleerock/class-transformer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Dependency Status](https://david-dm.org/typestack/class-transformer.svg)](https://david-dm.org/typestack/class-transformer)
+[![Join the chat at https://gitter.im/typestack/class-transformer](https://badges.gitter.im/typestack/class-transformer.svg)](https://gitter.im/typestack/class-transformer?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Its ES6 and Typescript era. Nowadays you are working with classes and constructor objects more then ever.
 Class-transformer allows you to transform plain object to some instance of class and versa.
@@ -224,14 +224,14 @@ You can deserialize your model to from a json using `deserialize` method:
 
 ```typescript
 import {deserialize} from "class-transformer";
-let photo = deserialize(photo);
+let photo = deserialize(Photo, photo);
 ```
 
 To make deserialization to work with arrays use `deserializeArray` method:
 
 ```typescript
 import {deserializeArray} from "class-transformer";
-let photos = deserializeArray(photos);
+let photos = deserializeArray(Photo, photos);
 ```
 
 ## Working with nested objects
@@ -658,7 +658,7 @@ the exposed variables. email property is also exposed becuase we metioned the gr
 ## Working with generics
 
 Generics are not supported because TypeScript does not have good reflection abilities yet.
-Once TypeScript team provide us better runtime type reelection tools, generics will be implemented.
+Once TypeScript team provide us better runtime type reflection tools, generics will be implemented.
 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)
 
diff --git a/doc/release-notes.md b/doc/release-notes.md
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "class-transformer",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Proper decorator-based transformation / serialization / deserialization of plain javascript objects to class constructors",
   "license": "MIT",
   "readmeFilename": "README.md",
diff --git a/src/TransformOperationExecutor.ts b/src/TransformOperationExecutor.ts
@@ -80,7 +80,7 @@ export class TransformOperationExecutor {
 
             return new Date(value);
 
-        } else if (value instanceof Object) {
+        } else if (typeof value === "object" && value !== null) {
 
             // try to guess the type
             if (!targetType && value.constructor !== Object/* && TransformationType === TransformationType.CLASS_TO_PLAIN*/) targetType = value.constructor;
diff --git a/src/metadata/MetadataStorage.ts b/src/metadata/MetadataStorage.ts
@@ -146,19 +146,19 @@ export class MetadataStorage {
 
     private getMetadata<T extends { target: Function, propertyName: string }>(metadatas: T[], target: Function): T[] {
         const metadataFromTarget = metadatas.filter(meta => meta.target === target && meta.propertyName !== undefined);
-        const metadataFromChildren = metadatas.filter(meta => target.prototype instanceof meta.target && meta.propertyName !== undefined);
+        const metadataFromChildren = metadatas.filter(meta => target && target.prototype instanceof meta.target && meta.propertyName !== undefined);
         return metadataFromChildren.concat(metadataFromTarget);
     }
 
     private findMetadata<T extends { target: Function, propertyName: string }>(metadatas: T[], target: Function, propertyName: string): T {
         const metadataFromTarget = metadatas.find(meta => meta.target === target && meta.propertyName === propertyName);
-        const metadataFromChildren = metadatas.find(meta => target.prototype instanceof meta.target && meta.propertyName === propertyName);
+        const metadataFromChildren = metadatas.find(meta => target && target.prototype instanceof meta.target && meta.propertyName === propertyName);
         return metadataFromTarget || metadataFromChildren;
     }
 
     private findMetadatas<T extends { target: Function, propertyName: string }>(metadatas: T[], target: Function, propertyName: string): T[] {
         const metadataFromTarget = metadatas.filter(meta => meta.target === target && meta.propertyName === propertyName);
-        const metadataFromChildren = metadatas.filter(meta => target.prototype instanceof meta.target && meta.propertyName === propertyName);
+        const metadataFromChildren = metadatas.filter(meta => target && target.prototype instanceof meta.target && meta.propertyName === propertyName);
         return metadataFromChildren.reverse().concat(metadataFromTarget.reverse());
     }
 
diff --git a/test/functional/basic-functionality.spec.ts b/test/functional/basic-functionality.spec.ts
@@ -1599,7 +1599,7 @@ describe("basic functionality", () => {
 
     });
 
-    it("should be able to transform array too", () => {
+    it("should transform array", () => {
         defaultMetadataStorage.clear();
 
 
@@ -1725,4 +1725,17 @@ describe("basic functionality", () => {
 
     });
 
+    it("should transform objects with null prototype", () => {
+        class TestClass {
+            prop: string;
+        }
+
+        const obj = Object.create(null);
+        obj.a = "JS FTW";
+
+        const transformedClass = plainToClass(TestClass, obj);
+
+        transformedClass.should.be.instanceOf(TestClass);
+    });
+
 });
diff --git a/test/functional/custom-transform.spec.ts b/test/functional/custom-transform.spec.ts
@@ -1,4 +1,5 @@
 import "reflect-metadata";
+import {expect} from "chai";
 import {classToPlain, plainToClass} from "../../src/index";
 import {defaultMetadataStorage} from "../../src/storage";
 import {Expose, Transform, Type} from "../../src/decorators";
@@ -157,5 +158,63 @@ describe("custom transformation decorator", () => {
         objArg.should.be.equal(user);
         typeArg.should.be.equal(TransformationType.CLASS_TO_PLAIN);
     });
+    
+    let model: any;
+    it ("should serialize json into model instance of class Person", () => {
+        expect(() => {
+            const json = {
+                name: "John Doe",
+                address: {
+                    street: "Main Street 25",
+                    tel: "5454-534-645",
+                    zip: 10353,
+                    country: "West Samoa"
+                },
+                age: 25,
+                hobbies: [
+                    { type: "sport", name: "sailing" },
+                    { type: "relax", name: "reading" },
+                    { type: "sport", name: "jogging" },
+                    { type: "relax", name: "movies"  }
+                ]
+            };
+            class Hobby {
+                public type: string;
+                public name: string;
+            }
+            class Address {
+                public street: string;
+                
+                @Expose({ name: "tel" }) 
+                public telephone: string;
+                
+                public zip: number;
+                
+                public country: string;
+            }
+            class Person {
+                public name: string;
+                
+                @Type(() => Address)
+                public address: Address;
+                
+                @Type(() => Hobby)
+                @Transform(value => value.filter((hobby: any) => hobby.type === "sport"), { toClassOnly: true })
+                public hobbies: Hobby[];
+                
+                public age: number;
+            }
+            model = plainToClass(Person, json);
+            expect(model instanceof Person);
+            expect(model.address instanceof Address);
+            model.hobbies.forEach((hobby: Hobby) => expect(hobby instanceof Hobby && hobby.type === "sport"));
+        }).to.not.throw();
+    });
+    
+    it ("should serialize a model into json", () => {
+        expect(() => {
+            classToPlain(model);
+        }).to.not.throw();
+    });
 
 });
diff --git a/test/functional/serialization-deserialization.spec.ts b/test/functional/serialization-deserialization.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "class-transformer",`
`3`		`- "version": "0.1.8",`
	`3`	`+ "version": "0.1.9",`
`4`	`4`	`"description": "Proper decorator-based transformation / serialization / deserialization of plain javascript objects to class constructors",`
`5`	`5`	`"license": "MIT",`
`6`	`6`	`"readmeFilename": "README.md",`
Original file line number	Diff line number	Diff line change
`@@ -146,19 +146,19 @@ export class MetadataStorage {`
`146`	`146`
`147`	`147`	`private getMetadata<T extends { target: Function, propertyName: string }>(metadatas: T[], target: Function): T[] {`
`148`	`148`	`const metadataFromTarget = metadatas.filter(meta => meta.target === target && meta.propertyName !== undefined);`
`149`		`- const metadataFromChildren = metadatas.filter(meta => target.prototype instanceof meta.target && meta.propertyName !== undefined);`
	`149`	`+ const metadataFromChildren = metadatas.filter(meta => target && target.prototype instanceof meta.target && meta.propertyName !== undefined);`
`150`	`150`	`return metadataFromChildren.concat(metadataFromTarget);`
`151`	`151`	`}`
`152`	`152`
`153`	`153`	`private findMetadata<T extends { target: Function, propertyName: string }>(metadatas: T[], target: Function, propertyName: string): T {`
`154`	`154`	`const metadataFromTarget = metadatas.find(meta => meta.target === target && meta.propertyName === propertyName);`
`155`		`- const metadataFromChildren = metadatas.find(meta => target.prototype instanceof meta.target && meta.propertyName === propertyName);`
	`155`	`+ const metadataFromChildren = metadatas.find(meta => target && target.prototype instanceof meta.target && meta.propertyName === propertyName);`
`156`	`156`	`return metadataFromTarget \|\| metadataFromChildren;`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`private findMetadatas<T extends { target: Function, propertyName: string }>(metadatas: T[], target: Function, propertyName: string): T[] {`
`160`	`160`	`const metadataFromTarget = metadatas.filter(meta => meta.target === target && meta.propertyName === propertyName);`
`161`		`- const metadataFromChildren = metadatas.filter(meta => target.prototype instanceof meta.target && meta.propertyName === propertyName);`
	`161`	`+ const metadataFromChildren = metadatas.filter(meta => target && target.prototype instanceof meta.target && meta.propertyName === propertyName);`
`162`	`162`	`return metadataFromChildren.reverse().concat(metadataFromTarget.reverse());`
`163`	`163`	`}`
`164`	`164`