Merge pull request #38 from snirs90/feat/json-view

Adding JsonView decorator

Author: Umed Khudoiberdiev

.gitignore

@@ -1,4 +1,6 @@
 build/
 node_modules/
 coverage/
-npm-debug.log
+npm-debug.log
+.idea
+.vscode

README.md

@@ -590,6 +590,55 @@ Now when you call `plainToClass` and send a plain representation of the Photo ob
 it will convert a date value in your photo object to moment date. 
 `@Transform` decorator also supports groups and versioning.
 
+## Other decorators
+| Signature          | Example                                  | Description
+|--------------------|------------------------------------------|---------------------------------------------|
+| `@TransformClassToPlain` | `@TransformClassToPlain({ groups: ["user"] })` | Transform the method return with classToPlain and expose the properties on the class.
+| `@TransformClassToClass` | `@TransformClassToClass({ groups: ["user"] })` | Transform the method return with classToClass and expose the properties on the class.
+
+The above decorators accept one optional argument:
+ClassTransformOptions - The transform options like groups, version, name
+
+An example:
+
+```typescript
+@Exclude()
+class User {
+
+    id: number;
+
+    @Expose()
+    firstName: string;
+
+    @Expose()
+    lastName: string;
+
+    @Expose({ groups: ['user.email'] })
+    email: string;
+
+    password: string;
+}
+
+class UserController {
+    
+    @TransformClassToPlain({ groups: ['user.email'] })
+    getUser() {
+        const user = new User();
+        user.firstName = "Snir";
+        user.lastName = "Segal";
+        user.password = "imnosuperman";
+
+        return user;
+    }
+}
+
+const controller = new UserController();
+const user = controller.getUser();
+```
+
+the `user` variable will contain only firstName,lastName, email properties becuase they are
+the exposed variables. email property is also exposed becuase we metioned the group "user.email".
+
 ## Working with generics
 
 Generics are not supported because TypeScript does not have good reflection abilities yet.

src/decorators.ts

@@ -1,9 +1,11 @@
+import {ClassTransformer} from "./ClassTransformer";
 import {defaultMetadataStorage} from "./storage";
 import {TypeMetadata} from "./metadata/TypeMetadata";
 import {ExposeMetadata} from "./metadata/ExposeMetadata";
 import {ExposeOptions, ExcludeOptions, TypeOptions, TransformOptions} from "./metadata/ExposeExcludeOptions";
 import {ExcludeMetadata} from "./metadata/ExcludeMetadata";
 import {TransformMetadata} from "./metadata/TransformMetadata";
+import {ClassTransformOptions} from "./ClassTransformOptions";
 
 /**
  * Defines a custom logic for value transformation.
@@ -48,4 +50,40 @@ export function Exclude(options?: ExcludeOptions) {
         const metadata = new ExcludeMetadata(object instanceof Function ? object : object.constructor, propertyName, options || {});
         defaultMetadataStorage.addExcludeMetadata(metadata);
     };
+}
+
+/**
+ * Transform the object from class to plain object and return only with the exposed properties.
+ */
+export function TransformClassToPlain(params?: ClassTransformOptions): Function {
+
+    return function (target: Function, propertyKey: string, descriptor: PropertyDescriptor) {
+        const classTransformer: ClassTransformer = new ClassTransformer();
+        const originalMethod = descriptor.value;
+        
+        descriptor.value = function(...args: any[]) {
+            const result: any = originalMethod.apply(this, args);
+            const isPromise = !!result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function";          
+
+            return isPromise ? result.then((data: any) => classTransformer.classToPlain(data, params)) : classTransformer.classToPlain(result, params);
+        };
+    };
+}
+
+/**
+ * Return the class instance only with the exposed properties.
+ */
+export function TransformClassToClass(params?: ClassTransformOptions): Function {
+
+    return function (target: Function, propertyKey: string, descriptor: PropertyDescriptor) {
+        const classTransformer: ClassTransformer = new ClassTransformer();
+        const originalMethod = descriptor.value;
+        
+        descriptor.value = function(...args: any[]) {
+            const result: any = originalMethod.apply(this, args);
+            const isPromise = !!result && (typeof result === "object" || typeof result === "function") && typeof result.then === "function";
+
+            return isPromise ? result.then((data: any) => classTransformer.classToClass(data, params)) : classTransformer.classToClass(result, params);
+        };
+    };
 }

test/functional/transformer-method.spec.ts

@@ -0,0 +1,223 @@
+import "reflect-metadata";
+import {defaultMetadataStorage} from "../../src/storage";
+import {Exclude, Expose, TransformClassToPlain, TransformClassToClass} from "../../src/decorators";
+import {expect} from "chai";
+
+describe("transformer methods decorator", () => {
+
+    it("should expose non configuration properties and return User instance class", () => {
+        defaultMetadataStorage.clear();
+
+        @Exclude()
+        class User {
+
+            id: number;
+
+            @Expose()
+            firstName: string;
+
+            @Expose()
+            lastName: string;
+
+            password: string;
+        }
+
+        class UserController {
+            
+            @TransformClassToClass()
+            getUser() {
+                const user = new User();
+                user.firstName = "Snir";
+                user.lastName = "Segal";
+                user.password = "imnosuperman";
+
+                return user;
+            }
+        }
+
+        const controller = new UserController();
+
+        const result = controller.getUser();
+        expect(result.password).to.be.undefined;
+
+        const plainUser = {
+            firstName: "Snir",
+            lastName: "Segal"
+        };
+
+
+        expect(result).to.be.eql(plainUser);
+        expect(result).to.be.instanceof(User);
+    });
+
+    it("should expose non configuration properties", () => {
+        defaultMetadataStorage.clear();
+
+        @Exclude()
+        class User {
+
+            id: number;
+
+            @Expose()
+            firstName: string;
+
+            @Expose()
+            lastName: string;
+
+            password: string;
+        }
+
+        class UserController {
+            
+            @TransformClassToPlain()
+            getUser() {
+                const user = new User();
+                user.firstName = "Snir";
+                user.lastName = "Segal";
+                user.password = "imnosuperman";
+
+                return user;
+            }
+        }
+
+        const controller = new UserController();
+
+        const result = controller.getUser();
+            expect(result.password).to.be.undefined;
+
+        const plainUser = {
+            firstName: "Snir",
+            lastName: "Segal"
+        };
+
+        expect(result).to.be.eql(plainUser);
+    });
+
+    it("should expose non configuration properties and properties with specific groups", () => {
+        defaultMetadataStorage.clear();
+
+        @Exclude()
+        class User {
+
+            id: number;
+
+            @Expose()
+            firstName: string;
+
+            @Expose()
+            lastName: string;
+
+            @Expose({ groups: ["user.permissions"] })
+            roles: string[];
+
+            password: string;
+        }
+
+        class UserController {
+            
+            @TransformClassToPlain({ groups: ["user.permissions"] })
+            getUserWithRoles() {
+                const user = new User();
+                user.firstName = "Snir";
+                user.lastName = "Segal";
+                user.password = "imnosuperman";
+                user.roles = ["USER", "MANAGER"];
+
+                return user;
+            }
+
+        }
+
+        const controller = new UserController();
+
+        const result = controller.getUserWithRoles();
+        expect(result.password).to.be.undefined;
+
+        const plainUser = {
+            firstName: "Snir",
+            lastName: "Segal",
+            roles: ["USER", "MANAGER"]
+        };
+
+        expect(result).to.be.eql(plainUser);
+    });
+
+    it("should expose non configuration properties with specific version", () => {
+        defaultMetadataStorage.clear();
+
+        @Exclude()
+        class User {
+
+            id: number;
+
+            @Expose()
+            firstName: string;
+
+            @Expose()
+            lastName: string;
+
+            @Expose({ groups: ["user.permissions"] })
+            roles: string[];
+
+            @Expose({ since: 2 })
+            websiteUrl?: string;
+
+            password: string;
+        }
+
+        class UserController {
+
+            @TransformClassToPlain({ version: 1 })
+            getUserVersion1() {
+                const user = new User();
+                user.firstName = "Snir";
+                user.lastName = "Segal";
+                user.password = "imnosuperman";
+                user.roles = ["USER", "MANAGER"];
+                user.websiteUrl = "http://www.github.com";
+
+                return user;
+            }
+                    
+            @TransformClassToPlain({ version: 2 })
+            getUserVersion2() {
+                const user = new User();
+                user.firstName = "Snir";
+                user.lastName = "Segal";
+                user.password = "imnosuperman";
+                user.roles = ["USER", "MANAGER"];
+                user.websiteUrl = "http://www.github.com";
+
+                return user;
+            }
+
+        }
+
+        const controller = new UserController();
+
+        const resultV2 = controller.getUserVersion2();
+        expect(resultV2.password).to.be.undefined;
+        expect(resultV2.roles).to.be.undefined;
+
+        const plainUserV2 = {
+            firstName: "Snir",
+            lastName: "Segal",
+            websiteUrl: "http://www.github.com"
+        };
+
+        expect(resultV2).to.be.eql(plainUserV2);
+
+        const resultV1 = controller.getUserVersion1();
+        expect(resultV1.password).to.be.undefined;
+        expect(resultV1.roles).to.be.undefined;
+        expect(resultV1.websiteUrl).to.be.undefined;
+
+        const plainUserV1 = {
+            firstName: "Snir",
+            lastName: "Segal"
+        };
+
+        expect(resultV1).to.be.eql(plainUserV1);
+    });
+
+});