Merge branch 'next' into fix-double-exec

Author: Elassyo

README.md

@@ -42,6 +42,7 @@ You can use routing-controllers with [express.js][1] or [koa.js][2].
       - [Throw HTTP errors](#throw-http-errors)
       - [Enable CORS](#enable-cors)
       - [Default settings](#default-settings)
+      - [Selectively disabling request/response transform](#selectively-disable-requestresponse-transforming)
   * [Using middlewares](#using-middlewares)
     + [Use exist middleware](#use-exist-middleware)
     + [Creating your own express middleware](#creating-your-own-express-middleware)
@@ -262,10 +263,19 @@ import {Controller, Req, Res, Get} from "routing-controllers";
 export class UserController {
 
     @Get("/users")
-    getAll(@Req() request: any, @Res() response: any) {
+    getAllUsers(@Req() request: any, @Res() response: any) {
         return response.send("Hello response!");
     }
 
+    @Get("/posts")
+    getAllPosts(@Req() request: any, @Res() response: any) {
+        // some response functions don't return the response object,
+        // so it needs to be returned explicitly
+        response.redirect("/users");
+
+        return response;
+    }
+
 }
 ```
 
@@ -733,7 +743,7 @@ There are set of prepared errors you can use:
 * UnauthorizedError
 
 
-You can also create and use your own errors by extending `HttpError` class.  
+You can also create and use your own errors by extending `HttpError` class.
 To define the data returned to the client, you could define a toJSON method in your error.
 
 ```typescript
@@ -755,7 +765,7 @@ class DbError extends HttpError {
         }
     }
 }
-``` 
+```
 
 #### Enable CORS
 
@@ -796,7 +806,7 @@ app.listen(3000);
 
 #### Default settings
 
-You can override default status code in routing-controllers options. 
+You can override default status code in routing-controllers options.
 
 ```typescript
 import "reflect-metadata";
@@ -809,9 +819,9 @@ const app = createExpressServer({
         //with this option, null will return 404 by default
         nullResultCode: 404,
 
-        //with this option, void or Promise<void> will return 204 by default 
+        //with this option, void or Promise<void> will return 204 by default
         undefinedResultCode: 204,
-        
+
         paramOptions: {
             //with this option, argument will be required by default
             required: true
@@ -822,6 +832,20 @@ const app = createExpressServer({
 app.listen(3000);
 ```
 
+#### Selectively disable request/response transform
+
+To disable `class-transformer` on a per-controller or per-route basis, use the `transformRequest` and `transformResponse` options on your controller and route decorators:
+
+```typescript
+@Controller("/users", {transformRequest: false, transformResponse: false})
+export class UserController {
+
+    @Get("/", {transformResponse: true}) {
+        // route option overrides controller option
+    }
+}
+```
+
 ## Using middlewares
 
 You can use any existing express / koa middleware, or create your own.
@@ -1210,7 +1234,7 @@ If its a class - then instance of this class will be created.
 This technique works with `@Body`, `@Param`, `@QueryParam`, `@BodyParam`, and other decorators.
 Learn more about class-transformer and how to handle more complex object constructions [here][4].
 This behaviour is enabled by default.
-If you want to disable it simply pass `classTransformer: false` to createExpressServer method.
+If you want to disable it simply pass `classTransformer: false` to createExpressServer method. Alternatively you can disable transforming for [individual controllers or routes](#selectively-disable-requestresponse-transforming).
 
 ## Auto validating action params
 
@@ -1264,7 +1288,7 @@ export class UserController {
 }
 ```
 If the param doesn't satisfy the requirements defined by class-validator decorators,
-an error will be thrown and captured by routing-controller, so the client will receive 400 Bad Request and JSON with nice detailed [Validation errors](https://github.com/pleerock/class-validator#validation-errors) array.
+an error will be thrown and captured by routing-controller, so the client will receive 400 Bad Request and JSON with nice detailed [Validation errors](https://github.com/typestack/class-validator#validation-errors) array.
 
 If you need special options for validation (groups, skipping missing properties, etc.) or transforming (groups, excluding prefixes, versions, etc.), you can pass them as global config as `validation ` in createExpressServer method or as a local `validate` setting for method parameter - `@Body({ validate: localOptions })`.
 
@@ -1486,7 +1510,8 @@ export class QuestionController {
 | `@Patch(route: string\|RegExp)`                                | `@Patch("/users/:id") patch()`         | Methods marked with this decorator will register a request made with PATCH HTTP Method to a given route. In action options you can specify if action should response json or regular text response.               | `app.patch("/users/:id", patch)`     |
 | `@Delete(route: string\|RegExp)`                               | `@Delete("/users/:id") delete()`       | Methods marked with this decorator will register a request made with DELETE HTTP Method to a given route. In action options you can specify if action should response json or regular text response.              | `app.delete("/users/:id", delete)`   |
 | `@Head(route: string\|RegExp)`                                 | `@Head("/users/:id") head()`           | Methods marked with this decorator will register a request made with HEAD HTTP Method to a given route. In action options you can specify if action should response json or regular text response.                | `app.head("/users/:id", head)`       |
-| `@Method(methodName: string, route: string\|RegExp)`            | `@Method("move", "/users/:id") move()` | Methods marked with this decorator will register a request made with given `methodName` HTTP Method to a given route. In action options you can specify if action should response json or regular text response.  | `app.move("/users/:id", move)`       |
+| `@All(route: string\|RegExp)`                                  | `@All("/users/me") rewrite()`          | Methods marked with this decorator will register a request made with any HTTP Method to a given route. In action options you can specify if action should response json or regular text response.                 | `app.all("/users/me", rewrite)`      |
+| `@Method(methodName: string, route: string\|RegExp)`           | `@Method("move", "/users/:id") move()` | Methods marked with this decorator will register a request made with given `methodName` HTTP Method to a given route. In action options you can specify if action should response json or regular text response.  | `app.move("/users/:id", move)`       |
 
 #### Method Parameter Decorators
 

sample/sample17-controllers-inheritance/app.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+import * as express from "express";
+import {useExpressServer} from "../../src/index";
+
+let app = express(); // create express server
+useExpressServer(app, {
+    controllers: [__dirname + "/controllers/*{.js,.ts}"] // register controllers routes in our express app
+});
+app.listen(3001); // run express app
+
+console.log("Express server is running on port 3001. Open http://localhost:3001/blogs/ or http://localhost:3002/posts/");

sample/sample17-controllers-inheritance/controllers/BaseController.ts

@@ -0,0 +1,56 @@
+import {Request} from "express";
+import {Get} from "../../../src/decorator/Get";
+import {Req} from "../../../src/index";
+import {Post} from "../../../src/decorator/Post";
+import {Put} from "../../../src/decorator/Put";
+import {Patch} from "../../../src/decorator/Patch";
+import {Delete} from "../../../src/decorator/Delete";
+
+export class BaseControllerClass {
+    name: string;
+    constructor(name: string) {
+        this.name = name;
+    }
+
+    @Get()
+    getAll() {
+        return [
+            {id: 1, name: `First ${this.name}!`},
+            {id: 2, name: `Second ${this.name}!`}
+        ];
+    }
+
+    @Get("/:id")
+    getOne() {
+        return {id: 1, name: `First ${this.name}!`};
+    }
+
+    @Post("")
+    post(@Req() request: Request) {
+        let entity = JSON.stringify(request.body);
+        return `${this.name}  ${entity} !saved!`;
+    }
+
+    @Put("/:id")
+    put(@Req() request: Request) {
+        return `${this.name} # ${request.params.id} has been putted!`;
+    }
+
+    @Patch("/:id")
+    patch(@Req() request: Request) {
+        return `${this.name} # ${request.params.id} has been patched!`;
+    }
+
+    @Delete("/:id")
+    remove(@Req() request: Request) {
+        return `${this.name} # ${request.params.id} has been removed!`;
+    }
+}
+
+export function BaseController(name: string): { new(): BaseControllerClass } {
+    return class extends BaseControllerClass {
+        constructor() {
+            super(name);
+        }
+    };
+}

sample/sample17-controllers-inheritance/controllers/BlogController.ts

@@ -0,0 +1,19 @@
+import {JsonController} from "../../../src/decorator/JsonController";
+import {BaseController, BaseControllerClass} from "./BaseController";
+import {Get} from "../../../src/decorator/Get";
+
+@JsonController("/blogs")
+export class BlogController extends BaseController("blog") {
+    constructor() {
+        super();
+    }
+
+    @Get()
+    getAll() {
+        return [
+            {id: 1, name: `First ${this.name}!`},
+            {id: 2, name: `Second ${this.name}!`},
+            {id: 3, name: `Third ${this.name}!`}
+        ];
+    }
+}

sample/sample17-controllers-inheritance/controllers/PostController.ts

@@ -0,0 +1,5 @@
+import {JsonController} from "../../../src/decorator/JsonController";
+import {BaseController, BaseControllerClass} from "./BaseController";
+
+@JsonController("/posts")
+export class PostController extends BaseController("post") {}

src/ActionParameterHandler.ts

@@ -209,6 +209,7 @@ export class ActionParameterHandler<T extends BaseDriver> {
      */
     protected transformValue(value: any, paramMetadata: ParamMetadata): any {
         if (this.driver.useClassTransformer &&
+            paramMetadata.actionMetadata.options.transformRequest !== false &&
             paramMetadata.targetType &&
             paramMetadata.targetType !== Object &&
             !(value instanceof paramMetadata.targetType)) {

src/RoutingControllersOptions.ts

@@ -85,7 +85,7 @@ export interface RoutingControllersOptions {
      * Special function used to get currently authorized user.
      */
     currentUserChecker?: CurrentUserChecker;
-    
+
     /**
      * Default settings
      */
@@ -110,4 +110,4 @@ export interface RoutingControllersOptions {
             required?: boolean;
         };
     };
-}
+}

src/decorator-options/ControllerOptions.ts

@@ -0,0 +1,14 @@
+/**
+ * Extra options that apply to each controller action.
+ */
+export interface ControllerOptions {
+    /**
+     * If set to false, class-transformer won't be used to perform request serialization.
+     */
+    transformRequest?: boolean;
+
+    /**
+     * If set to false, class-transformer won't be used to perform response serialization.
+     */
+    transformResponse?: boolean;
+}

src/decorator-options/HandlerOptions.ts

@@ -0,0 +1,14 @@
+/**
+ * Extra handler-specific options.
+ */
+export interface HandlerOptions {
+    /**
+     * If set to false, class-transformer won't be used to perform request serialization.
+     */
+    transformRequest?: boolean;
+
+    /**
+     * If set to false, class-transformer won't be used to perform response serialization.
+     */
+    transformResponse?: boolean;
+}

src/decorator/All.ts

@@ -0,0 +1,30 @@
+import {getMetadataArgsStorage} from "../index";
+import { ControllerOptions } from "../decorator-options/ControllerOptions";
+
+/**
+ * Registers an action to be executed when a request comes on a given route.
+ * Must be applied on a controller action.
+ */
+export function All(route?: RegExp): Function;
+
+/**
+ * Registers an action to be executed when a request comes on a given route.
+ * Must be applied on a controller action.
+ */
+export function All(route?: string): Function;
+
+/**
+ * Registers an action to be executed when a request comes on a given route.
+ * Must be applied on a controller action.
+ */
+export function All(route?: string|RegExp, options?: ControllerOptions): Function {
+    return function (object: Object, methodName: string) {
+        getMetadataArgsStorage().actions.push({
+            type: "all",
+            target: object.constructor,
+            method: methodName,
+            route: route,
+            options,
+        });
+    };
+}