@deepkit/http 1.0.1-alpha.16 → 1.0.1-alpha.160

package/src/router.ts

@@ -7,138 +7,189 @@
  *
  * You should have received a copy of the MIT License along with this program.
  */
+import { ClassType, CompilerContext, getClassName, isArray, isClass, urlJoin } from '@deepkit/core';
+import {
+    entity,
+    ReflectionClass,
+    ReflectionFunction,
+    ReflectionKind,
+    ReflectionParameter,
+    SerializationOptions,
+    serializer,
+    Serializer,
+    Type,
+    ValidationError,
+} from '@deepkit/type';
+import { getActions, HttpAction, httpClass, HttpController, HttpDecorator } from './decorator.js';
+import { HttpRequest, HttpRequestPositionedParameters, HttpRequestQuery, HttpRequestResolvedParameters } from './model.js';
+import { InjectorContext, InjectorModule } from '@deepkit/injector';
+import { Logger, LoggerInterface } from '@deepkit/logger';
+import { HttpControllers } from './controllers.js';
+import { MiddlewareRegistry, MiddlewareRegistryEntry } from '@deepkit/app';
+import { HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
+
+//@ts-ignore
+import qs from 'qs';
+import { HtmlResponse, JSONResponse, Response } from './http.js';
+import { getRequestParserCodeForParameters, ParameterForRequestParser, parseRoutePathToRegex } from './request-parser.js';
+import { HttpConfig } from './module.config.js';
+
+export type RouteParameterResolverForInjector = ((injector: InjectorContext) => HttpRequestPositionedParameters | Promise<HttpRequestPositionedParameters>);
+
+interface ResolvedController {
+    parameters: RouteParameterResolverForInjector;
+    routeConfig: RouteConfig;
+    uploadedFiles: { [name: string]: UploadedFile };
+    middlewares?: (injector: InjectorContext) => { fn: HttpMiddlewareFn, timeout?: number }[];
+}
 
-import { asyncOperation, ClassType, CompilerContext } from '@deepkit/core';
-import { getClassSchema, getPropertyXtoClassFunction, jitValidateProperty, jsonSerializer, PropertySchema, ValidationFailed, ValidationFailedItem } from '@deepkit/type';
-// @ts-ignore
-import formidable from 'formidable';
-import { IncomingMessage } from 'http';
-import { join } from 'path';
-import querystring from 'querystring';
-import { httpClass } from './decorator';
-import { HttpRequest, HttpRequestQuery, HttpRequestResolvedParameters } from './model';
-import { BasicInjector, injectable, NormalizedProvider, Tag } from '@deepkit/injector';
-import { Logger } from '@deepkit/logger';
-import { TagProviders } from '@deepkit/app';
-import { HttpControllers } from './controllers';
-
-export type RouteParameterResolverForInjector = ((injector: BasicInjector) => any[] | Promise<any[]>);
-type ResolvedController = { parameters: RouteParameterResolverForInjector, routeConfig: RouteConfig };
-
-
-function parseBody(form: any, req: IncomingMessage) {
-    return asyncOperation((resolve, reject) => {
-        form.parse(req, (err: any, fields: any, files: any) => {
-            if (err) {
-                reject(err);
-            } else {
-                resolve({ fields, files });
-            }
-        });
-    });
+export const UploadedFileSymbol = Symbol('UploadedFile');
+
+@entity.name('@deepkit/UploadedFile')
+export class UploadedFile {
+    /**
+     * Validator to ensure the file was provided by the framework, and not the user spoofing it.
+     */
+    validator!: typeof UploadedFileSymbol | null;
+
+    /**
+     * The size of the uploaded file in bytes.
+     */
+    size!: number;
+
+    /**
+     * The local path this file is being written to. Will be deleted when request is handled.
+     */
+    path!: string;
+
+    /**
+     * The name this file had according to the uploading client.
+     */
+    name!: string | null;
+
+    /**
+     * The mime type of this file, according to the uploading client.
+     */
+    type!: string | null;
+
+    /**
+     * A Date object (or `null`) containing the time this file was last written to.
+     * Mostly here for compatibility with the [W3C File API Draft](http://dev.w3.org/2006/webapi/FileAPI/).
+     */
+    lastModifiedDate!: Date | null;
+
+    // /**
+    //  * If `options.hash` calculation was set, you can read the hex digest out of this var.
+    //  */
+    // hash!: string | 'sha1' | 'md5' | 'sha256' | null;
 }
 
-export interface RouteControllerAction {
+serializer.typeGuards.getRegistry(1).registerClass(UploadedFile, (type, state) => {
+    state.setContext({ UploadedFileSymbol });
+    state.addSetterAndReportErrorIfInvalid('uploadSecurity', 'Not an uploaded file', `typeof ${state.accessor} === 'object' && ${state.accessor} !== null && ${state.accessor}.validator === UploadedFileSymbol`);
+});
+
+export interface RouteFunctionControllerAction {
+    type: 'function';
+    //if not set, the root module is used
+    module?: InjectorModule<any>;
+    fn: (...args: any[]) => any;
+}
+
+export interface RouteClassControllerAction {
+    type: 'controller';
+    //if not set, the root module is used
+    module?: InjectorModule<any>;
     controller: ClassType;
     methodName: string;
 }
 
-export interface RouteParameterConfig {
-    type?: 'body' | 'query';
-    /**
-     * undefined = propertyName, '' === root, else given path
-     */
-    typePath?: string;
-
-    optional: boolean;
-    name: string;
+export function getRouteActionLabel(action: RouteClassControllerAction | RouteFunctionControllerAction): string {
+    if (action.type === 'controller') return `${getClassName(action.controller)}.${action.methodName}`;
+    return action.fn.name;
 }
 
 export class RouteConfig {
     public baseUrl: string = '';
-    public parameterRegularExpressions: { [name: string]: any } = {};
-    public throws: { errorType: ClassType, message?: string }[] = [];
+
+    public responses: { statusCode: number, description: string, type?: Type }[] = [];
+
     public description: string = '';
     public groups: string[] = [];
     public category: string = '';
 
+    public returnType?: Type;
+
+    public serializationOptions?: SerializationOptions;
+    public serializer?: Serializer;
+
+    /**
+     * When assigned defines where this route came from.
+     */
+    public module?: InjectorModule<any>;
+
+    resolverForToken: Map<any, ClassType> = new Map();
+
+    middlewares: { config: HttpMiddlewareConfig, module?: InjectorModule<any> }[] = [];
+
+    resolverForParameterName: Map<string, ClassType> = new Map();
+
     /**
      * An arbitrary data container the user can use to store app specific settings/values.
      */
     data = new Map<any, any>();
 
-    public parameters: {
-        [name: string]: RouteParameterConfig
-    } = {};
-
     constructor(
         public readonly name: string,
-        public readonly httpMethod: string,
+        public readonly httpMethods: string[],
         public readonly path: string,
-        public readonly action: RouteControllerAction,
-    ) {
-    }
-
-    getFullPath(): string {
-        let path = this.baseUrl ? join(this.baseUrl, this.path) : this.path;
-        if (!path.startsWith('/')) path = '/' + path;
-        return path;
-    }
-}
-
-/**
- * When this class is injected into a route, then validation errors are not automatically thrown (using onHttpControllerValidationError event),
- * but injected to the route itself. The user is then responsible to handle the errors.
- *
- * Note: The body parameter is still passed, however it might contain now invalid data. The BodyValidation tells what data is invalid.
- */
-export class BodyValidation {
-    constructor(
-        public readonly errors: ValidationFailedItem[] = []
+        public readonly action: RouteClassControllerAction | RouteFunctionControllerAction,
+        public internal: boolean = false,
     ) {
     }
 
-    hasErrors(prefix?: string): boolean {
-        return this.getErrors(prefix).length > 0;
+    getReflectionFunction(): ReflectionFunction {
+        return this.action.type === 'controller' ?
+            ReflectionClass.from(this.action.controller).getMethod(this.action.methodName)
+            : ReflectionFunction.from(this.action.fn);
     }
 
-    getErrors(prefix?: string): ValidationFailedItem[] {
-        if (prefix) return this.errors.filter(v => v.path.startsWith(prefix));
-
-        return this.errors;
-    }
-
-    getErrorsForPath(path: string): ValidationFailedItem[] {
-        return this.errors.filter(v => v.path === path);
+    getSchemaForResponse(statusCode: number): Type | undefined {
+        if (!this.responses.length) return;
+        for (const response of this.responses) {
+            if (response.statusCode === statusCode) return response.type;
+        }
+        return;
     }
 
-    getErrorMessageForPath(path: string): string {
-        return this.getErrorsForPath(path).map(v => v.message).join(', ');
+    getFullPath(): string {
+        let path = this.baseUrl ? urlJoin(this.baseUrl, this.path) : this.path;
+        if (!path.startsWith('/')) path = '/' + path;
+        return path;
     }
 }
 
-class ParsedRoute {
+export class ParsedRoute {
     public regex?: string;
-    public customValidationErrorHandling?: ParsedRouteParameter;
 
     public pathParameterNames: { [name: string]: number } = {};
 
-    protected parameters: ParsedRouteParameter[] = [];
+    protected parameters: ParameterForRequestParser[] = [];
 
     constructor(public routeConfig: RouteConfig) {
     }
 
-    addParameter(property: PropertySchema, config?: RouteParameterConfig): ParsedRouteParameter {
-        const parameter = new ParsedRouteParameter(property, config);
+    addParameter(property: ReflectionParameter): ParameterForRequestParser {
+        const parameter = new ParameterForRequestParser(property);
         this.parameters.push(parameter);
         return parameter;
     }
 
-    getParameters(): ParsedRouteParameter[] {
+    getParameters(): ParameterForRequestParser[] {
         return this.parameters;
     }
 
-    getParameter(name: string): ParsedRouteParameter {
+    getParameter(name: string): ParameterForRequestParser {
         for (const parameter of this.parameters) {
             if (parameter.getName() === name) return parameter;
         }
@@ -146,68 +197,16 @@ class ParsedRoute {
     }
 }
 
-class ParsedRouteParameter {
-    regexPosition?: number;
-
-    constructor(
-        public property: PropertySchema,
-        public config?: RouteParameterConfig,
-    ) {
-    }
-
-    get body() {
-        return this.config ? this.config.type === 'body' : false;
-    }
-
-    get query() {
-        return this.config ? this.config.type === 'query' : false;
-    }
-
-    get typePath() {
-        return this.config ? this.config.typePath : undefined;
-    }
-
-    getName() {
-        return this.property.name;
-    }
-
-    isPartOfPath(): boolean {
-        return this.regexPosition !== undefined;
-    }
-}
-
-function parseRoutePathToRegex(routeConfig: RouteConfig): { regex: string, parameterNames: { [name: string]: number } } {
-    const parameterNames: { [name: string]: number } = {};
-    let path = routeConfig.getFullPath();
-
-    let argumentIndex = 0;
-    path = path.replace(/:(\w+)/g, (a, name) => {
-        parameterNames[name] = argumentIndex;
-        argumentIndex++;
-        return routeConfig.parameterRegularExpressions[name] ? '(' + routeConfig.parameterRegularExpressions[name] + ')' : String.raw`([^/]+)`;
-    });
-
-    return { regex: path, parameterNames };
-}
-
 export function parseRouteControllerAction(routeConfig: RouteConfig): ParsedRoute {
-    const schema = getClassSchema(routeConfig.action.controller);
     const parsedRoute = new ParsedRoute(routeConfig);
 
-    const methodArgumentProperties = schema.getMethodProperties(routeConfig.action.methodName);
-    const parsedPath = parseRoutePathToRegex(routeConfig);
+    const parameters = routeConfig.getReflectionFunction().getParameters();
+    const parsedPath = parseRoutePathToRegex(routeConfig.getFullPath(), parameters);
     parsedRoute.regex = parsedPath.regex;
     parsedRoute.pathParameterNames = parsedPath.parameterNames;
 
-    for (const property of methodArgumentProperties) {
-        const decoratorData = routeConfig.parameters[property.name];
-        const parsedParameter = parsedRoute.addParameter(property, decoratorData);
-
-        if (decoratorData && decoratorData.optional) property.isOptional = true;
-
-        if (property.type === 'class' && property.classType === BodyValidation) {
-            parsedRoute.customValidationErrorHandling = parsedParameter;
-        }
+    for (const property of parameters) {
+        const parsedParameter = parsedRoute.addParameter(property);
         parsedParameter.regexPosition = parsedPath.parameterNames[property.name];
     }
 
@@ -225,182 +224,433 @@ export interface RouteParameterResolver {
 }
 
 export interface RouteParameterResolverContext {
-    classType: ClassType;
+    token: ClassType | string | symbol | any;
     route: RouteConfig;
     request: HttpRequest;
+
+    /**
+     * The parameter name (variable name).
+     */
+    name: any;
+
+    /**
+     * The raw parameter value from the path, if the parameter is defined in the path (e.g. /user/:name).
+     * If not in the path, you have to use `parameters.<name>` instead.
+     */
+    value: any;
+
     query: HttpRequestQuery;
     parameters: HttpRequestResolvedParameters;
+    type: ReflectionParameter;
 }
 
-export class RouteParameterResolverTag extends Tag<RouteParameterResolver> {
-    public classTypes: ClassType[] = [];
+function filterMiddlewaresForRoute(middlewareRawConfigs: MiddlewareRegistryEntry[], routeConfig: RouteConfig, fullPath: string): {
+    config: HttpMiddlewareConfig,
+    module: InjectorModule<any>
+}[] {
+    const middlewares = middlewareRawConfigs.slice(0);
+    middlewares.push(...routeConfig.middlewares as any[]);
 
-    constructor(
-        public provider: NormalizedProvider,
-    ) {
-        super(provider);
-        if (!this.provider.scope) provider.scope = 'http';
+    const middlewareConfigs = middlewares.filter((v) => {
+        if (!(v.config instanceof HttpMiddlewareConfig)) return false;
+
+        if (v.config.controllers.length && routeConfig.action.type === 'controller' && !v.config.controllers.includes(routeConfig.action.controller)) {
+            return false;
+        }
+
+        if (v.config.excludeControllers.length && routeConfig.action.type === 'controller' && v.config.excludeControllers.includes(routeConfig.action.controller)) {
+            return false;
+        }
+
+        if (v.config.modules.length && (!routeConfig.module || !v.config.modules.includes(routeConfig.module))) {
+            if (!routeConfig.module) return false;
+            for (const module of v.config.modules) {
+                if (routeConfig.module.id !== module.id) return false;
+            }
+        }
+
+        if (v.config.selfModule && v.module.id !== routeConfig.module?.id) return false;
+
+        if (v.config.routeNames.length) {
+            let found: boolean = false;
+            for (const name of v.config.routeNames) {
+                if (name.includes('*')) {
+                    const regex = new RegExp('^' + name.replace(/\*/g, '.*') + '$');
+                    if (regex.test(routeConfig.name)) {
+                        found = true;
+                        break;
+                    }
+                } else if (name === routeConfig.name) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) return false;
+        }
+
+        if (v.config.excludeRouteNames.length) {
+            for (const name of v.config.excludeRouteNames) {
+                if (name.includes('*')) {
+                    const regex = new RegExp('^' + name.replace(/\*/g, '.*') + '$');
+                    if (regex.test(routeConfig.name)) return false;
+                } else if (name == routeConfig.name) {
+                    return false;
+                }
+            }
+        }
+
+        for (const route of v.config.routes) {
+            if (route.httpMethod && !routeConfig.httpMethods.includes(route.httpMethod)) return false;
+
+            if (route.category && route.category !== routeConfig.category) return false;
+            if (route.excludeCategory && route.excludeCategory === routeConfig.category) return false;
+
+            if (route.group && !routeConfig.groups.includes(route.group)) return false;
+            if (route.excludeGroup && routeConfig.groups.includes(route.excludeGroup)) return false;
+
+            if (route.path || route.pathRegExp) {
+                if (!route.pathRegExp && route.path) route.pathRegExp = new RegExp('^' + route.path.replace(/\*/g, '.*') + '$');
+                if (route.pathRegExp && !route.pathRegExp.test(fullPath)) return false;
+            }
+        }
+
+        return true;
+    }) as { config: HttpMiddlewareConfig, module: any }[];
+
+    middlewareConfigs.sort((a, b) => {
+        return a.config.order - b.config.order;
+    });
+
+    return middlewareConfigs;
+}
+
+export interface HttpRouterFunctionOptions {
+    path: string;
+    name?: string;
+    methods?: string[];
+    description?: string;
+    category?: string;
+    groups?: string[];
+
+    /**
+     * An arbitrary data container the user can use to store app specific settings/values.
+     */
+    data?: Record<any, any>;
+
+    baseUrl?: string;
+    middlewares?: (() => HttpMiddlewareConfig)[];
+
+    serializer?: Serializer;
+    serializationOptions?: SerializationOptions;
+
+    resolverForToken?: Map<any, ClassType>;
+    resolverForParameterName?: Map<string, ClassType>;
+
+    responses?: { statusCode: number, description: string, type?: Type }[];
+}
+
+function convertOptions(methods: string[], pathOrOptions: string | HttpRouterFunctionOptions, defaultOptions: Partial<HttpRouterFunctionOptions>): HttpRouterFunctionOptions {
+    const options = 'string' === typeof pathOrOptions ? { path: pathOrOptions } : pathOrOptions;
+    if (options.methods) return options;
+    return { ...options, methods };
+}
+
+/**
+ * Annotated types like HTMLResponse/JSONResponse are not used for serialization.
+ */
+function filterValidReturnType(type: Type): Type | undefined {
+    if (type.kind === ReflectionKind.class && (type.classType === HtmlResponse || type.classType === JSONResponse || type.classType === Response)) return;
+    return type;
+}
+
+export abstract class HttpRouterRegistryFunctionRegistrar {
+    protected defaultOptions: Partial<HttpRouterFunctionOptions> = {};
+
+    abstract addRoute(routeConfig: RouteConfig): void;
+
+    /**
+     * Returns a new registrar object with default options that apply to each registered route through this registrar.
+     *
+     * ```typescript
+     * const registry: HttpRouterRegistry = ...;
+     *
+     * const secretRegistry = registry.forOptions({groups: ['secret']});
+     *
+     * secretRegistry.get('/admin/groups', () => {
+     * });
+     *
+     * secretRegistry.get('/admin/users', () => {
+     * });
+     * ```
+     */
+    forOptions(options: Partial<HttpRouterFunctionOptions>): HttpRouterRegistryFunctionRegistrar {
+        const that = this;
+        return new class extends HttpRouterRegistryFunctionRegistrar {
+            defaultOptions = options;
+
+            addRoute(routeConfig: RouteConfig) {
+                that.addRoute(routeConfig);
+            }
+        };
+    }
+
+    public any(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions([], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public add(decorator: HttpDecorator, callback: (...args: any[]) => any) {
+        const data = decorator(Object, '_');
+        const action = isArray(data) ? data.find(v => v instanceof HttpAction) : undefined;
+        if (!action) throw new Error('No HttpAction available');
+
+        const fn = ReflectionFunction.from(callback);
+        const routeConfig = createRouteConfigFromHttpAction({
+            type: 'function',
+            fn: callback,
+        }, action);
+        routeConfig.returnType = filterValidReturnType(fn.getReturnType());
+        this.addRoute(routeConfig);
     }
 
-    forClassType(...classTypes: ClassType[]): this {
-        this.classTypes = classTypes;
-        return this;
+    public get(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['GET'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public post(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['POST'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public put(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['PUT'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public patch(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['PATCH'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public delete(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['DELETE'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public options(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['OPTIONS'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public trace(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['TRACE'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    public head(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any) {
+        this.register(convertOptions(['HEAD'], pathOrOptions, this.defaultOptions), callback);
+    }
+
+    private register(options: HttpRouterFunctionOptions, callback: (...args: any[]) => any, module?: InjectorModule<any>) {
+        const fn = ReflectionFunction.from(callback);
+
+        const routeConfig = new RouteConfig(options.name || '', options.methods || [], options.path, {
+            type: 'function',
+            fn: callback,
+        });
+        routeConfig.module = module;
+        if (options.responses) routeConfig.responses = options.responses;
+        if (options.description) routeConfig.description = options.description;
+        if (options.category) routeConfig.category = options.category;
+        if (options.groups) routeConfig.groups = options.groups;
+        if (options.data) routeConfig.data = new Map(Object.entries(options.data));
+        if (options.baseUrl) routeConfig.baseUrl = options.baseUrl;
+        if (options.middlewares) {
+            routeConfig.middlewares = options.middlewares.map(v => {
+                return { config: v(), module };
+            });
+        }
+
+        if (options.resolverForToken) {
+            for (const item of options.resolverForToken) routeConfig.resolverForToken.set(...item);
+        }
+
+        if (options.resolverForToken) {
+            for (const item of options.resolverForToken) routeConfig.resolverForToken.set(...item);
+        }
+
+        if (options.resolverForParameterName) {
+            for (const item of options.resolverForParameterName) routeConfig.resolverForParameterName.set(...item);
+        }
+
+        routeConfig.serializer = options.serializer;
+        routeConfig.serializationOptions = options.serializationOptions;
+
+        routeConfig.returnType = filterValidReturnType(fn.getReturnType());
+        this.addRoute(routeConfig);
     }
 }
 
-@injectable()
-export class Router {
-    protected fn?: (request: HttpRequest) => ResolvedController | undefined;
-    protected resolveFn?: (name: string, parameters: { [name: string]: any }) => string;
+function createRouteConfigFromHttpAction(routeAction: RouteClassControllerAction | RouteFunctionControllerAction, action: HttpAction, module?: InjectorModule<any>, controller?: HttpController) {
+    const routeConfig = new RouteConfig(action.name, action.httpMethods, action.path, routeAction);
+    routeConfig.responses = action.responses;
+    routeConfig.description = action.description;
+    routeConfig.category = action.category;
+    routeConfig.groups = action.groups;
+    routeConfig.data = new Map(action.data);
+    if (controller) {
+        routeConfig.baseUrl = controller.baseUrl;
+
+        routeConfig.middlewares = controller.middlewares.map(v => {
+            return { config: v(), module };
+        });
+        routeConfig.resolverForToken = new Map(controller.resolverForToken);
+        routeConfig.resolverForParameterName = new Map(controller.resolverForParameterName);
+    }
+
+    routeConfig.middlewares.push(...action.middlewares.map(v => {
+        return { config: v(), module };
+    }));
+
+    for (const item of action.resolverForToken) routeConfig.resolverForToken.set(...item);
+
+    for (const item of action.resolverForParameterName) routeConfig.resolverForParameterName.set(...item);
+
+    routeConfig.serializer = action.serializer;
+    routeConfig.serializationOptions = action.serializationOptions;
+    return routeConfig;
+}
 
+export class HttpRouterRegistry extends HttpRouterRegistryFunctionRegistrar {
     protected routes: RouteConfig[] = [];
+    private buildId: number = 1;
 
-    protected parameterResolverTags: RouteParameterResolverTag[] = [];
+    public getBuildId(): number {
+        return this.buildId;
+    }
 
-    //todo, move some settings to KernelConfig
-    protected form = formidable({
-        multiples: true,
-        hash: 'sha1',
-        enabledPlugins: ['octetstream', 'querystring', 'json'],
-    });
+    public getRoutes(): RouteConfig[] {
+        return this.routes;
+    }
+
+    public addRouteForController(controller: ClassType, module: InjectorModule<any>) {
+        const controllerData = httpClass._fetch(controller);
+        if (!controllerData) throw new Error(`Http controller class ${getClassName(controller)} has no @http.controller decorator.`);
+        const schema = ReflectionClass.from(controller);
+
+        for (const action of getActions(controller)) {
+            const routeAction: RouteClassControllerAction = {
+                type: 'controller',
+                controller,
+                module,
+                methodName: action.methodName
+            };
+            const routeConfig = createRouteConfigFromHttpAction(routeAction, action, module, controllerData);
+
+            routeConfig.module = module;
+
+            if (schema.hasMethod(action.methodName)) routeConfig.returnType = filterValidReturnType(schema.getMethod(action.methodName).getReturnType());
+            this.addRoute(routeConfig);
+        }
+    }
+
+    public addRoute(routeConfig: RouteConfig) {
+        this.routes.push(routeConfig);
+        this.buildId++;
+    }
+}
+
+export class HttpRouter {
+    protected fn?: (request: HttpRequest) => ResolvedController | undefined;
+    protected buildId: number = 0;
+    protected resolveFn?: (name: string, parameters: { [name: string]: any }) => string;
 
     constructor(
         controllers: HttpControllers,
-        private logger: Logger,
-        tagProviders: TagProviders,
+        private logger: LoggerInterface,
+        private config: HttpConfig,
+        private middlewareRegistry: MiddlewareRegistry = new MiddlewareRegistry,
+        private registry: HttpRouterRegistry = new HttpRouterRegistry,
     ) {
-        this.parameterResolverTags = tagProviders.getProviders(RouteParameterResolverTag);
-
-        for (const controller of controllers.controllers) this.addRouteForController(controller);
+        for (const controller of controllers.controllers) {
+            this.addRouteForController(controller.controller, controller.module);
+        }
     }
 
     getRoutes(): RouteConfig[] {
-        return this.routes;
+        return this.registry.getRoutes();
     }
 
-    static forControllers(controllers: ClassType[], tagProviders: TagProviders = new TagProviders()): Router {
-        return new this(new HttpControllers(controllers), new Logger([], []), tagProviders);
+    static forControllers(
+        controllers: (ClassType | { module: InjectorModule<any>, controller: ClassType })[],
+        middlewareRegistry: MiddlewareRegistry = new MiddlewareRegistry(),
+        module: InjectorModule<any> = new InjectorModule(),
+        config: HttpConfig = new HttpConfig()
+    ): HttpRouter {
+        return new this(new HttpControllers(controllers.map(v => {
+            return isClass(v) ? { controller: v, module } : v;
+        })), new Logger([], []), config, middlewareRegistry);
     }
 
     protected getRouteCode(compiler: CompilerContext, routeConfig: RouteConfig): string {
-        const routeConfigVar = compiler.reserveVariable('routeConfigVar', routeConfig);
         const parsedRoute = parseRouteControllerAction(routeConfig);
         const path = routeConfig.getFullPath();
-        const prefix = path.substr(0, path.indexOf(':'));
+        const pathParamStarter = path.indexOf(':');
+        const prefix = path.substr(0, pathParamStarter);
 
         const regexVar = compiler.reserveVariable('regex', new RegExp('^' + parsedRoute.regex + '$'));
-        const setParameters: string[] = [];
-        const parameterNames: string[] = [];
-        const parameterValidator: string[] = [];
-        let bodyValidationErrorHandling = `if (bodyErrors.length) throw ValidationFailed.from(bodyErrors);`;
-
-        let enableParseBody = false;
-        const hasParameters = parsedRoute.getParameters().length > 0;
-        let requiresAsyncParameters = false;
-        let setParametersFromPath = '';
-
-        params:
-            for (const parameter of parsedRoute.getParameters()) {
-                if (parameter.isPartOfPath()) {
-                    const converted = parameter.property.type === 'any' ? (v: any) => v : getPropertyXtoClassFunction(parameter.property, jsonSerializer);
-                    const validator = parameter.property.type === 'any' ? (v: any) => undefined : jitValidateProperty(parameter.property);
-                    const converterVar = compiler.reserveVariable('argumentConverter', converted);
-                    const validatorVar = compiler.reserveVariable('argumentValidator', validator);
-
-                    setParameters.push(`parameters.${parameter.property.name} = ${converterVar}(_match[${1 + (parameter.regexPosition || 0)}]);`);
-                    parameterValidator.push(`${validatorVar}(_match[1 + ${parameter.regexPosition}], ${JSON.stringify(parameter.getName())}, validationErrors);`);
-                    parameterNames.push(`parameters.${parameter.property.name}`);
-                } else {
-                    if (parsedRoute.customValidationErrorHandling === parameter) {
-                        compiler.context.set('BodyValidation', BodyValidation);
-                        bodyValidationErrorHandling = '';
-                        setParameters.push(`parameters.${parameter.property.name} = new BodyValidation(bodyErrors);`);
-                        parameterNames.push(`parameters.${parameter.property.name}`);
-                    } else if (parameter.body) {
-                        const bodyVar = compiler.reserveVariable('body');
-
-                        const validatorVar = compiler.reserveVariable('argumentValidator', jitValidateProperty(parameter.property));
-                        const converterVar = compiler.reserveVariable('argumentConverter', getPropertyXtoClassFunction(parameter.property, jsonSerializer));
-
-                        enableParseBody = true;
-                        parameterValidator.push(`
-                        ${bodyVar} = ${converterVar}(bodyFields);
-                        ${validatorVar}(${bodyVar}, ${JSON.stringify(parameter.typePath || '')}, bodyErrors);
-                `);
-                        setParameters.push(`parameters.${parameter.property.name} = ${bodyVar};`);
-                        parameterNames.push(`parameters.${parameter.property.name}`);
-                    } else if (parameter.query) {
-                        const converted = parameter.property.type === 'any' ? (v: any) => v : getPropertyXtoClassFunction(parameter.property, jsonSerializer);
-                        const validator = parameter.property.type === 'any' ? (v: any) => undefined : jitValidateProperty(parameter.property);
-                        const converterVar = compiler.reserveVariable('argumentConverter', converted);
-                        const validatorVar = compiler.reserveVariable('argumentValidator', validator);
-
-                        const queryPath = parameter.typePath === undefined ? parameter.property.name : parameter.typePath;
-                        const accessor = queryPath ? `['` + (queryPath.replace(/\./g, `']['`)) + `']` : '';
-                        const queryAccessor = queryPath ? `_query${accessor}` : '_query';
-                        setParameters.push(`parameters.${parameter.property.name} = ${converterVar}(${queryAccessor});`);
-                        parameterNames.push(`parameters.${parameter.property.name}`);
-                        parameterValidator.push(`${validatorVar}(${queryAccessor}, ${JSON.stringify(parameter.typePath)}, validationErrors);`);
+
+        const hasParameters = pathParamStarter !== -1 || parsedRoute.getParameters().length > 0;
+
+        const fullPath = routeConfig.getFullPath();
+        const middlewareConfigs = filterMiddlewaresForRoute(this.middlewareRegistry.configs, routeConfig, fullPath);
+
+        const parameters = [...parsedRoute.getParameters()];
+
+        //look through all http listeners and check if they need any http parameters.
+        //the router then parses
+
+        let matcher = `_path.startsWith(${JSON.stringify(prefix)}) && (_match = _path.match(${regexVar}))`;
+        if (!hasParameters) {
+            matcher = `_path === ${JSON.stringify(path)}`;
+        }
+
+        let middlewares = 'undefined';
+        if (middlewareConfigs.length) {
+            const middlewareItems: string[] = [];
+            for (const middlewareConfig of middlewareConfigs) {
+                const moduleVar = middlewareConfig.module ? ', ' + compiler.reserveVariable('module', middlewareConfig.module) : '';
+
+                for (const middleware of middlewareConfig.config.middlewares) {
+                    if (isClass(middleware)) {
+                        const classVar = compiler.reserveVariable('middlewareClassType', middleware);
+                        middlewareItems.push(`{fn: function() {return _injector.get(${classVar}${moduleVar}).execute(...arguments) }, timeout: ${middlewareConfig.config.timeout}}`);
                     } else {
-                        const classType = parameter.property.getResolvedClassType();
-                        const classTypeVar = compiler.reserveVariable('classType', classType);
-
-                        for (const resolverTag of this.parameterResolverTags) {
-                            if (resolverTag.classTypes.includes(classType)) {
-                                const resolverProvideTokenVar = compiler.reserveVariable('resolverProvideToken', resolverTag.provider.provide);
-                                requiresAsyncParameters = true;
-                                if (!setParametersFromPath) {
-                                    for (const i in parsedRoute.pathParameterNames) {
-                                        setParametersFromPath += `parameters.${i} = _match[${1 + parsedRoute.pathParameterNames[i]}];`;
-                                    }
-                                }
-                                setParameters.push(`parameters.${parameter.property.name} = await _injector.get(${resolverProvideTokenVar}).resolve(
-                                {classType: ${classTypeVar}, routeConfig: ${routeConfigVar}, request: request, query: _query, parameters: parameters}
-                            );`);
-                                parameterNames.push(`parameters.${parameter.property.name}`);
-                                continue params;
-                            }
-                        }
-
-                        setParameters.push(`parameters.${parameter.property.name} = _injector.get(${classTypeVar});`);
-                        parameterNames.push(`parameters.${parameter.property.name}`);
+                        middlewareItems.push(`{fn: ${compiler.reserveVariable('middlewareFn', middleware)}, timeout: ${middlewareConfig.config.timeout}}`);
                     }
                 }
             }
 
-        let parseBodyLoading = '';
-        if (enableParseBody) {
-            const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
-            const formVar = compiler.reserveVariable('form', this.form);
-            parseBodyLoading = `const bodyFields = (await ${parseBodyVar}(${formVar}, request)).fields;`;
-            requiresAsyncParameters = true;
+            middlewares = `
+                function(_injector) {
+                    return [${middlewareItems.join(', ')}];
+                }
+            `;
         }
 
-        let matcher = `_path.startsWith(${JSON.stringify(prefix)}) && (_match = _path.match(${regexVar}))`;
-        if (!hasParameters) {
-            matcher = `_path === ${JSON.stringify(path)}`;
-        }
+        const parametersLoader = getRequestParserCodeForParameters(compiler, this.config.parser, parameters, {
+            module: routeConfig.module,
+            resolverForToken: routeConfig.resolverForToken,
+            resolverForParameterName: routeConfig.resolverForParameterName,
+            pathParameterNames: parsedRoute.pathParameterNames,
+            routeConfig
+        });
 
-        let parameters = '() => []';
-        if (setParameters.length) {
-            parameters = `${requiresAsyncParameters ? 'async' : ''} function(_injector){
-                const validationErrors = [];
-                const bodyErrors = [];
-                const parameters = {};
-                ${setParametersFromPath}
-                ${parseBodyLoading}
-                ${parameterValidator.join('\n')}
-                ${bodyValidationErrorHandling}
-                ${setParameters.join('\n')}
-                if (validationErrors.length) throw ValidationFailed.from(validationErrors);
-                return [${parameterNames.join(',')}];
-            }`;
+        let methodCheck = '';
+        if (routeConfig.httpMethods.length) {
+            methodCheck = '(' + routeConfig.httpMethods.map(v => {
+                return `_method === '${v.toUpperCase()}'`;
+            }).join(' || ') + ') && ';
         }
 
+        const routeConfigVar = compiler.reserveVariable('routeConfigVar', routeConfig);
         return `
-            //=> ${path}
-            if (_method === '${routeConfig.httpMethod.toLowerCase()}' && ${matcher}) {
-                return {routeConfig: ${routeConfigVar}, parameters: ${parameters}};
+            //=> ${routeConfig.httpMethods.join(',')} ${path}
+            if (${methodCheck}${matcher}) {
+                return {routeConfig: ${routeConfigVar}, parameters: ${parametersLoader}, uploadedFiles: uploadedFiles, middlewares: ${middlewares}};
             }
         `;
     }
@@ -415,11 +665,11 @@ export class Router {
 
         const modify: string[] = [];
         for (const parameter of parsedRoute.getParameters()) {
-            if (parameter.query) {
-                const queryPath = parameter.typePath === undefined ? parameter.property.name : parameter.typePath;
+            if (parameter.query || parameter.queries) {
+                const queryPath = parameter.typePath === undefined && parameter.query ? parameter.parameter.name : parameter.typePath || '';
 
-                if (parameter.property.type === 'class') {
-                    for (const property of parameter.property.getResolvedClassSchema().getProperties()) {
+                if (parameter.parameter.type.kind === ReflectionKind.class || parameter.parameter.type.kind === ReflectionKind.objectLiteral) {
+                    for (const property of ReflectionClass.from(parameter.parameter.type).getProperties()) {
                         const accessor = `parameters.${parameter.getName()}?.${property.name}`;
                         const thisPath = queryPath ? queryPath + '.' + property.name : property.name;
                         modify.push(`${accessor} !== undefined && query.push(${JSON.stringify(dotToUrlPath(thisPath))} + '=' + encodeURIComponent(${accessor}))`);
@@ -442,49 +692,34 @@ export class Router {
     }
 
     public addRoute(routeConfig: RouteConfig) {
-        this.routes.push(routeConfig);
-        this.fn = undefined;
+        this.registry.addRoute(routeConfig);
     }
 
-    public addRouteForController(controller: ClassType) {
-        const data = httpClass._fetch(controller);
-        if (!data) return;
-
-        for (const action of data.getActions()) {
-            const routeConfig = new RouteConfig(action.name, action.httpMethod, action.path, {
-                controller,
-                methodName: action.methodName
-            });
-            routeConfig.parameterRegularExpressions = action.parameterRegularExpressions;
-            routeConfig.throws = action.throws;
-            routeConfig.description = action.description;
-            routeConfig.category = action.category;
-            routeConfig.groups = action.groups;
-            routeConfig.data = new Map(action.data);
-            routeConfig.baseUrl = data.baseUrl;
-            routeConfig.parameters = { ...action.parameters };
-            this.addRoute(routeConfig);
-        }
+    public addRouteForController(controller: ClassType, module: InjectorModule<any>) {
+        this.registry.addRouteForController(controller, module);
     }
 
-    protected build(): any {
+    protected build(): (request: HttpRequest) => ResolvedController | undefined {
+        this.buildId = this.registry.getBuildId();
         const compiler = new CompilerContext;
-        compiler.context.set('_match', null);
-        compiler.context.set('ValidationFailed', ValidationFailed);
-        compiler.context.set('parseQueryString', querystring.parse);
+        compiler.context.set('ValidationError', ValidationError);
+        compiler.context.set('qs', qs);
 
         const code: string[] = [];
 
-        for (const route of this.routes) {
+        for (const route of this.getRoutes()) {
             code.push(this.getRouteCode(compiler, route));
         }
 
         return compiler.build(`
-            const _method = request.getMethod().toLowerCase();
-            const _url = request.getUrl();
+            let _match;
+            const _method = request.method || 'GET';
+            const _url = request.url || '/';
+            const _headers = request.headers || {};
             const _qPosition = _url.indexOf('?');
+            let uploadedFiles = {};
             const _path = _qPosition === -1 ? _url : _url.substr(0, _qPosition);
-            const _query = _qPosition === -1 ? {} : parseQueryString(_url.substr(_qPosition + 1));
+            const _query = _qPosition === -1 ? {} : qs.parse(_url.substr(_qPosition + 1));
             ${code.join('\n')}
         `, 'request') as any;
     }
@@ -493,7 +728,7 @@ export class Router {
         const compiler = new CompilerContext;
         const code: string[] = [];
 
-        for (const route of this.routes) {
+        for (const route of this.getRoutes()) {
             code.push(this.getRouteUrlResolveCode(compiler, route));
         }
 
@@ -514,21 +749,15 @@ export class Router {
     }
 
     public resolveRequest(request: HttpRequest): ResolvedController | undefined {
-        if (!this.fn) {
+        if (!this.fn || this.buildId !== this.registry.getBuildId()) {
             this.fn = this.build();
         }
 
-        return this.fn!(request);
+        return this.fn(request);
     }
 
     public resolve(method: string, url: string): ResolvedController | undefined {
-        return this.resolveRequest({
-            getUrl() {
-                return url;
-            },
-            getMethod() {
-                return method;
-            },
-        } as any);
+        method = method.toUpperCase();
+        return this.resolveRequest({ url, method } as any);
     }
 }