0.7.0

README.md

@@ -69,47 +69,37 @@ You can use routing-controllers with [express.js][1] or [koa.js][2].
 
     `npm install reflect-metadata --save`
 
-    and make sure to import it in a global place, like app.ts:
+    and make sure to import it before you use routing-controllers:
 
     ```typescript
     import "reflect-metadata";
     ```
 
-3. ES6 features are used, if you are using old version of node.js you may need to install
- [es6-shim](https://github.com/paulmillr/es6-shim):
-
-    `npm install es6-shim --save`
-
-    and import it in a global place like app.ts:
-
-    ```typescript
-    import "es6-shim";
-    ```
-
-4. Install framework:
+3. Install framework:
 
     **a. If you want to use routing-controllers with *express.js*, then install it and all required dependencies:**
 
     `npm install express body-parser multer --save`
 
-    Optionally you can also install its [typings](https://github.com/typings/typings):
+    Optionally you can also install their typings:
 
-    `typings install dt~express dt~serve-static --save --global`
+    `npm install @types/express @types/body-parser @types/multer --save`
 
     **b. If you want to use routing-controllers with *koa 2*, then install it and all required dependencies:**
 
-    `npm install koa@next koa-router@next koa-bodyparser@next koa-multer --save`
+    `npm install koa koa-router koa-bodyparser koa-multer --save`
 
-    Optionally you can also install its [typings](https://github.com/typings/typings):
+    Optionally you can also install their typings:
 
-    `typings install dt~koa --save --global`
+    `typings install @types/koa --save --global`
 
 5. Its important to set these options in `tsconfig.json` file of your project:
 
     ```json
     {
         "emitDecoratorMetadata": true,
-        "experimentalDecorators": true
+        "experimentalDecorators": true,
+        "lib": ["es6"]
     }
     ```
 
@@ -156,7 +146,6 @@ You can use routing-controllers with [express.js][1] or [koa.js][2].
 2. Create a file `app.ts`
 
     ```typescript
-    import "es6-shim"; // this shim is optional if you are using old version of node
     import "reflect-metadata"; // this shim is required
     import {createExpressServer} from "routing-controllers";
     import "./UserController";  // we need to "load" our controller before call createServer. this is required

gulpfile.ts

@@ -1,4 +1,4 @@
-import {Gulpclass, Task, SequenceTask, MergedTask} from "gulpclass";
+import {Gulpclass, MergedTask, SequenceTask, Task} from "gulpclass";
 
 const gulp = require("gulp");
 const del = require("del");
@@ -171,7 +171,10 @@ export class Gulpfile {
         // chai.use(require("sinon-chai"));
         // chai.use(require("chai-as-promised"));
 
-        return gulp.src(["./build/es5/test/functional/**/*.js"])
+        return gulp.src([
+            "./build/es5/test/functional/**/*.js",
+            "./build/es5/test/issues/**/*.js",
+        ])
             .pipe(mocha())
             .pipe(istanbul.writeReports());
     }

src/ActionParameterHandler.ts

@@ -1,16 +1,14 @@
 import {plainToClass} from "class-transformer";
 import {validateOrReject as validate, ValidationError} from "class-validator";
 import {ActionProperties} from "./ActionProperties";
-import {BodyRequiredError} from "./error/BodyRequiredError";
 import {BadRequestError} from "./http-error/BadRequestError";
 import {Driver} from "./driver/Driver";
 import {ParameterParseJsonError} from "./error/ParameterParseJsonError";
-import {ParameterRequiredError} from "./error/ParameterRequiredError";
 import {ParamMetadata} from "./metadata/ParamMetadata";
-import {NotFoundError} from "./http-error/NotFoundError";
+import {ParamRequiredError} from "./error/ParamRequiredError";
 
 /**
- * Helps to handle parameters.
+ * Handles action parameter.
  */
 export class ActionParameterHandler {
 
@@ -25,59 +23,54 @@ export class ActionParameterHandler {
     // Public Methods
     // -------------------------------------------------------------------------
 
-    handleParam(actionProperties: ActionProperties, param: ParamMetadata): Promise<any>|any {
+    /**
+     * Handles action parameter.
+     */
+    handle(actionProperties: ActionProperties, param: ParamMetadata): Promise<any>|any {
 
         if (param.type === "request")
             return actionProperties.request;
 
         if (param.type === "response")
             return actionProperties.response;
-
-        let value: any, originalValue: any;
-        value = originalValue = this.driver.getParamFromRequest(actionProperties, param);
-
-        const isValueEmpty = value === null || value === undefined || value === "";
-        const isValueEmptyObject = value instanceof Object && Object.keys(value).length === 0;
-
-        if (!isValueEmpty)
-            value = this.handleParamFormat(value, param);
-
-        // check cases when parameter is required but its empty and throw errors in such cases
+
+        // get parameter value from request and normalize it
+        const value = this.normalizeParamValue(this.driver.getParamFromRequest(actionProperties, param), param);
+
+        // check cases when parameter is required but its empty and throw errors in this case
         if (param.required) {
-            if (param.type === "body" && !param.name && (isValueEmpty || isValueEmptyObject)) { // body has a special check
-                return Promise.reject(new BodyRequiredError(actionProperties));
+            const isValueEmpty = value === null || value === undefined || value === "";
+            const isValueEmptyObject = value instanceof Object && Object.keys(value).length === 0;
+
+            if (param.type === "body" && !param.name && (isValueEmpty || isValueEmptyObject)) { // body has a special check and error message
+                return Promise.reject(new ParamRequiredError(actionProperties, param));
 
-            } else if (param.name && isValueEmpty) { // regular check for all other parameters
-                return Promise.reject(new ParameterRequiredError(param, actionProperties));
+            } else if (param.name && isValueEmpty) { // regular check for all other parameters // todo: figure out something with param.name usage and multiple things params (query params, upload files etc.)
+                return Promise.reject(new ParamRequiredError(actionProperties, param));
             }
         }
 
         // if transform function is given for this param then apply it
         if (param.transform)
-            value = param.transform(value, actionProperties.request, actionProperties.response);
-
-        const promiseValue = value instanceof Promise ? value : Promise.resolve(value);
-        return promiseValue.then((value: any) => {
-
-            if (param.required && originalValue !== null && originalValue !== undefined && isValueEmpty) {
-                const contentType = param.reflectedType && param.reflectedType.name ? param.reflectedType.name : "content";
-                const message = param.name ? ` with ${param.name}='${originalValue}'` : ``;
-                return Promise.reject(new NotFoundError(`Requested ${contentType + message} was not found`));
-            }
+            return param.transform(value, actionProperties.request, actionProperties.response);
 
-            return value;
-        });
+        return value;
     }
 
     // -------------------------------------------------------------------------
-    // Private Methods
+    // Protected Methods
     // -------------------------------------------------------------------------
 
-    protected handleParamFormat(value: any, param: ParamMetadata): any {
-        const format = param.format;
-        const formatName = format instanceof Function && format.name ? format.name : format instanceof String ? format : "";
-        switch (formatName.toLowerCase()) {
+    /**
+     * Normalizes parameter value.
+     */
+    protected normalizeParamValue(value: any, param: ParamMetadata): any {
+        if (value === null || value === undefined)
+            return value;
+
+        switch (param.targetName) {
             case "number":
+                if (value === "") return undefined;
                 return +value;
 
             case "string":
@@ -86,48 +79,70 @@ export class ActionParameterHandler {
             case "boolean":
                 if (value === "true") {
                     return true;
-                    
+
                 } else if (value === "false") {
                     return false;
                 }
+
                 return !!value;
 
             default:
-                const isObjectFormat = format instanceof Function || formatName.toLowerCase() === "object";
-                if (value && (param.parse || isObjectFormat))
+                if (value && (param.parse || param.isTargetObject)) {
                     value = this.parseValue(value, param);
+                    value = this.transformValue(value, param);
+                    value = this.validateValue(value, param);
+                }
         }
         return value;
     }
 
-    protected async parseValue(value: any, paramMetadata: ParamMetadata) {
-        try {
-            const valueObject = typeof value === "string" ? JSON.parse(value) : value;
-
-            let parsedValue: any;
-            // If value is already by instance of target class, then skip the plain to class step.
-            if (!(value instanceof paramMetadata.format) && paramMetadata.format !== Object && paramMetadata.format && this.driver.useClassTransformer) {
-                const options = paramMetadata.classTransformOptions || this.driver.plainToClassTransformOptions;
-                parsedValue = plainToClass(paramMetadata.format, valueObject, options);
-            } else {
-                parsedValue = valueObject;
+    /**
+     * Parses string value into a JSON object.
+     */
+    protected parseValue(value: any, paramMetadata: ParamMetadata): any {
+        if (typeof value === "string") {
+            try {
+                return JSON.parse(value);
+            } catch (error) {
+                throw new ParameterParseJsonError(paramMetadata.name, value);
             }
+        }
 
-            if (paramMetadata.validate || this.driver.enableValidation) {
-                const options = paramMetadata.validateOptions || this.driver.validationOptions;
-                return validate(parsedValue, options)
-                    .then(() => parsedValue)
-                    .catch((validationErrors: ValidationError[]) => {
-                        const error: any = new BadRequestError(`Invalid ${paramMetadata.type}, check 'details' property for more info.`);
-                        error.details = validationErrors;
-                        throw error;
-                    });
-            } else {
-                return parsedValue;
-            }
-        } catch (er) {
-            throw new ParameterParseJsonError(paramMetadata.name, value);
+        return value;
+    }
+
+    /**
+     * Perform class-transformation if enabled.
+     */
+    protected transformValue(value: any, paramMetadata: ParamMetadata): any {
+        if (this.driver.useClassTransformer &&
+            paramMetadata.targetType &&
+            paramMetadata.targetType !== Object &&
+            !(value instanceof paramMetadata.targetType)) {
+
+            const options = paramMetadata.classTransform || this.driver.plainToClassTransformOptions;
+            value = plainToClass(paramMetadata.targetType, value, options);
         }
+
+        return value;
+    }
+
+    /**
+     * Perform class-validation if enabled.
+     */
+    protected validateValue(value: any, paramMetadata: ParamMetadata): Promise<any>|any {
+        if (paramMetadata.validate || (this.driver.enableValidation && paramMetadata.validate !== false)) {
+            const options = paramMetadata.validate instanceof Object ? paramMetadata.validate : this.driver.validationOptions;
+            return validate(value, options)
+                .then(() => value)
+                .catch((validationErrors: ValidationError[]) => {
+                    const error: any = new BadRequestError(`Invalid ${paramMetadata.type}, check 'errors' property for more info.`);
+                    error.errors = validationErrors;
+                    throw error;
+                });
+        }
+
+        return value;
     }
 
 }

src/RoutingControllers.ts

@@ -16,7 +16,7 @@ export class RoutingControllers {
     /**
      * Used to check and handle controller action parameters.
      */
-    private paramHandler: ActionParameterHandler;
+    private parameterHandler: ActionParameterHandler;
 
     /**
      * Used to build metadata objects for controllers and middlewares.
@@ -28,7 +28,7 @@ export class RoutingControllers {
     // -------------------------------------------------------------------------
 
     constructor(private driver: Driver) {
-        this.paramHandler = new ActionParameterHandler(driver);
+        this.parameterHandler = new ActionParameterHandler(driver);
         this.metadataBuilder = new MetadataBuilder();
     }
 
@@ -87,7 +87,7 @@ export class RoutingControllers {
         // compute all parameters
         const paramsPromises = action.params
             .sort((param1, param2) => param1.index - param2.index)
-            .map(param => this.paramHandler.handleParam(actionProperties, param));
+            .map(param => this.parameterHandler.handle(actionProperties, param));
 
         // after all parameters are computed
         Promise.all(paramsPromises).then(params => {

src/decorator/Body.ts

@@ -14,13 +14,11 @@ export function Body(options?: BodyOptions): Function {
             method: methodName,
             index: index,
             type: "body",
-            reflectedType: format,
-            format: format,
+            targetType: format,
             parse: false,
             required: options ? options.required : false,
-            classTransformOptions: options ? options.transform : undefined,
-            validate: options && options.validate ? true : false,
-            validateOptions: options && options.validate instanceof Object ? options.validate : undefined
+            classTransform: options ? options.transform : undefined,
+            validate: options ? options.validate : undefined,
         };
         defaultMetadataArgsStorage().params.push(metadata);
     };

src/decorator/BodyParam.ts

@@ -14,14 +14,12 @@ export function BodyParam(name: string, options?: ParamOptions): Function {
             method: methodName,
             index: index,
             type: "body",
-            reflectedType: format,
             name: name,
-            format: format,
+            targetType: format,
             parse: options ? options.parse : false,
             required: options ? options.required : false,
-            classTransformOptions: options ? options.transform : undefined,
-            validate: options && options.validate ? true : false,
-            validateOptions: options && options.validate instanceof Object ? options.validate : undefined
+            classTransform: options ? options.transform : undefined,
+            validate: options ? options.validate : undefined,
         };
         defaultMetadataArgsStorage().params.push(metadata);
     };

src/decorator/CookieParam.ts

@@ -14,14 +14,12 @@ export function CookieParam(name: string, options?: ParamOptions) {
             method: methodName,
             index: index,
             type: "cookie",
-            reflectedType: format,
             name: name,
-            format: format,
+            targetType: format,
             parse: options ? options.parse : false,
             required: options ? options.required : false,
-            classTransformOptions: options ? options.transform : undefined,
-            validate: options && options.validate ? true : false,
-            validateOptions: options && options.validate instanceof Object ? options.validate : undefined
+            classTransform: options ? options.transform : undefined,
+            validate: options ? options.validate : undefined,
         };
         defaultMetadataArgsStorage().params.push(metadata);
     };

src/decorator/CookieParams.ts

@@ -13,8 +13,7 @@ export function CookieParams() {
             method: methodName,
             index: index,
             type: "cookie",
-            reflectedType: format,
-            format: format,
+            targetType: format,
             parse: false,
             required: false,
         };

src/decorator/HeaderParam.ts

@@ -14,14 +14,12 @@ export function HeaderParam(name: string, options?: ParamOptions): Function {
             method: methodName,
             index: index,
             type: "header",
-            reflectedType: format,
             name: name,
-            format: format,
+            targetType: format,
             parse: options ? options.parse : false,
             required: options ? options.required : false,
-            classTransformOptions: options ? options.transform : undefined,
-            validate: options && options.validate ? true : false,
-            validateOptions: options && options.validate instanceof Object ? options.validate : undefined
+            classTransform: options ? options.transform : undefined,
+            validate: options ? options.validate : undefined,
         };
         defaultMetadataArgsStorage().params.push(metadata);
     };