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

package/dist/esm/src/router.js

@@ -1,3 +1,33 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+const __ΩPartial = ['T', 'Partial', 'l+e#!e"!fRb!Pde"!gN#"w"y'];
+const __ΩRecord = ['K', 'T', 'Record', 'l\'e#"Rb!b"Pde"!N#!w#y'];
+/*@ts-ignore*/
+import { __ΩSerializationOptions } from '@deepkit/type';
+/*@ts-ignore*/
+import { __ΩClassType } from '@deepkit/core';
+/*@ts-ignore*/
+import { __ΩMiddlewareRegistryEntry } from '@deepkit/app';
+/*@ts-ignore*/
+import { __ΩHttpDecorator } from './decorator.js';
+/*@ts-ignore*/
+import { __ΩLoggerInterface } from '@deepkit/logger';
+/*@ts-ignore*/
+import { __ΩHttpRequestPositionedParameters } from './model.js';
+/*@ts-ignore*/
+import { __ΩHttpMiddlewareFn } from './middleware.js';
+/*@ts-ignore*/
+import { __ΩHttpRequestQuery } from './model.js';
+/*@ts-ignore*/
+import { __ΩHttpRequestResolvedParameters } from './model.js';
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
 /*
  * Deepkit Framework
  * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt
@@ -7,96 +37,95 @@
  *
  * You should have received a copy of the MIT License along with this program.
  */
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { asyncOperation, CompilerContext } from '@deepkit/core';
-import { getClassSchema, getPropertyXtoClassFunction, jitValidateProperty, jsonSerializer, ValidationFailed } from '@deepkit/type';
-// @ts-ignore
-import formidable from 'formidable';
-import { join } from 'path';
-import querystring from 'querystring';
-import { httpClass } from './decorator';
-import { injectable, Tag } from '@deepkit/injector';
+import { CompilerContext, getClassName, isArray, isClass, urlJoin } from '@deepkit/core';
+import { entity, ReflectionClass, ReflectionFunction, ReflectionKind, ReflectionParameter, serializer, Serializer, ValidationError, } from '@deepkit/type';
+import { getActions, HttpAction, httpClass, HttpController } from './decorator.js';
+import { HttpRequest } from './model.js';
+import { InjectorContext, InjectorModule } from '@deepkit/injector';
 import { Logger } from '@deepkit/logger';
-import { TagProviders } from '@deepkit/app';
-import { HttpControllers } from './controllers';
-function parseBody(form, req) {
-    return asyncOperation((resolve, reject) => {
-        form.parse(req, (err, fields, files) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve({ fields, files });
-            }
-        });
-    });
+import { HttpControllers } from './controllers.js';
+import { MiddlewareRegistry } from '@deepkit/app';
+import { HttpMiddlewareConfig } 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';
+const __ΩRouteParameterResolverForInjector = [() => InjectorContext, 'injector', () => __ΩHttpRequestPositionedParameters, () => __ΩHttpRequestPositionedParameters, '', 'RouteParameterResolverForInjector', 'PP7!2"Pn#n$`J/%w&y'];
+export { __ΩRouteParameterResolverForInjector as __ΩRouteParameterResolverForInjector };
+const __ΩResolvedController = [() => __ΩRouteParameterResolverForInjector, 'parameters', () => RouteConfig, 'routeConfig', () => UploadedFile, 'uploadedFiles', () => InjectorContext, 'injector', () => __ΩHttpMiddlewareFn, 'fn', 'timeout', '', 'middlewares', 'ResolvedController', 'Pn!4"P7#4$P&P7%LM4&PP7\'2(Pn)4*\'4+8MF/,4-8Mw.y'];
+export const UploadedFileSymbol = Symbol('UploadedFile');
+let UploadedFile = class UploadedFile {
+};
+UploadedFile.__type = [() => UploadedFileSymbol, 'validator', 'size', 'path', 'name', 'type', 'lastModifiedDate', 'UploadedFile', 'Pi!,J3"\'3#&3$P&,J3%P&,J3&PT,J3\'5w('];
+UploadedFile = __decorate([
+    entity.name('@deepkit/UploadedFile')
+], UploadedFile);
+export { UploadedFile };
+serializer.typeGuards.getRegistry(1).registerClass(UploadedFile, __assignType((type, state) => {
+    state.setContext({ UploadedFileSymbol });
+    state.addSetterAndReportErrorIfInvalid('uploadSecurity', 'Not an uploaded file', `typeof ${state.accessor} === 'object' && ${state.accessor} !== null && ${state.accessor}.validator === UploadedFileSymbol`);
+}, ['type', 'state', '', 'P"2!"2""/#']));
+const __ΩRouteFunctionControllerAction = ["function", 'type', () => InjectorModule, 'module', 'args', '', 'fn', 'RouteFunctionControllerAction', 'P.!4"P"7#4$8P"@2%"/&4\'Mw(y'];
+export { __ΩRouteFunctionControllerAction as __ΩRouteFunctionControllerAction };
+const __ΩRouteClassControllerAction = ["controller", 'type', () => InjectorModule, 'module', () => __ΩClassType, 'controller', 'methodName', 'RouteClassControllerAction', 'P.!4"P"7#4$8n%4&&4\'Mw(y'];
+export { __ΩRouteClassControllerAction as __ΩRouteClassControllerAction };
+export function getRouteActionLabel(action) {
+    if (action.type === 'controller')
+        return `${getClassName(action.controller)}.${action.methodName}`;
+    return action.fn.name;
 }
+getRouteActionLabel.__type = [() => __ΩRouteClassControllerAction, () => __ΩRouteFunctionControllerAction, 'action', 'getRouteActionLabel', 'PPn!n"J2#&/$'];
 export class RouteConfig {
-    constructor(name, httpMethod, path, action) {
+    constructor(name, httpMethods, path, action, internal = false) {
         this.name = name;
-        this.httpMethod = httpMethod;
+        this.httpMethods = httpMethods;
         this.path = path;
         this.action = action;
+        this.internal = internal;
         this.baseUrl = '';
-        this.parameterRegularExpressions = {};
-        this.throws = [];
+        this.responses = [];
         this.description = '';
         this.groups = [];
         this.category = '';
+        this.resolverForToken = new Map();
+        this.middlewares = [];
+        this.resolverForParameterName = new Map();
         /**
          * An arbitrary data container the user can use to store app specific settings/values.
          */
-        this.data = new Map();
-        this.parameters = {};
+        this.data = (Map.Ω = [['"'], ['"']], new Map());
+    }
+    getReflectionFunction() {
+        return this.action.type === 'controller' ?
+            ReflectionClass.from(this.action.controller).getMethod(this.action.methodName)
+            : ReflectionFunction.from(this.action.fn);
+    }
+    getSchemaForResponse(statusCode) {
+        if (!this.responses.length)
+            return;
+        for (const response of this.responses) {
+            if (response.statusCode === statusCode)
+                return response.type;
+        }
+        return;
     }
     getFullPath() {
-        let path = this.baseUrl ? join(this.baseUrl, this.path) : this.path;
+        let path = this.baseUrl ? urlJoin(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(errors = []) {
-        this.errors = errors;
-    }
-    hasErrors(prefix) {
-        return this.getErrors(prefix).length > 0;
-    }
-    getErrors(prefix) {
-        if (prefix)
-            return this.errors.filter(v => v.path.startsWith(prefix));
-        return this.errors;
-    }
-    getErrorsForPath(path) {
-        return this.errors.filter(v => v.path === path);
-    }
-    getErrorMessageForPath(path) {
-        return this.getErrorsForPath(path).map(v => v.message).join(', ');
-    }
-}
-class ParsedRoute {
+RouteConfig.__type = ['baseUrl', function () { return ''; }, 'statusCode', 'description', 'Type', 'type', 'responses', function () { return []; }, function () { return ''; }, 'groups', function () { return []; }, 'category', function () { return ''; }, 'returnType', () => __ΩSerializationOptions, 'serializationOptions', () => Serializer, 'serializer', () => InjectorModule, 'module', () => __ΩClassType, 'resolverForToken', function () { return new Map(); }, () => HttpMiddlewareConfig, 'config', () => InjectorModule, 'middlewares', function () { return []; }, () => __ΩClassType, 'resolverForParameterName', function () { return new Map(); }, 'data', function () { return (Map.Ω = [['"'], ['"']], new Map()); }, 'name', 'httpMethods', 'path', () => __ΩRouteClassControllerAction, () => __ΩRouteFunctionControllerAction, 'action', 'internal', () => false, 'constructor', () => ReflectionFunction, 'getReflectionFunction', 'getSchemaForResponse', 'getFullPath', 'RouteConfig', '&3!>"P\'4#&4$"w%4&8MF3\'>(&3$>)&F3*>+&3,>-"w%3.8n/308P71328P"73348"n5E36>7PP7849P"7:448MF3;><&n=E3>>?!3@>AP&2B:9&F2C:9&2D:9PnEnFJ2G:9)2H:>I"0JPP7K0LP\'2#P"w%-J0MP&0N5wO'];
+export class ParsedRoute {
     constructor(routeConfig) {
         this.routeConfig = routeConfig;
         this.pathParameterNames = {};
         this.parameters = [];
     }
-    addParameter(property, config) {
-        const parameter = new ParsedRouteParameter(property, config);
+    addParameter(property) {
+        const parameter = new ParameterForRequestParser(property);
         this.parameters.push(parameter);
         return parameter;
     }
@@ -111,220 +140,396 @@ class ParsedRoute {
         throw new Error(`No route parameter with name ${name} defined.`);
     }
 }
-class ParsedRouteParameter {
-    constructor(property, config) {
-        this.property = property;
-        this.config = config;
-    }
-    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() {
-        return this.regexPosition !== undefined;
-    }
-}
-function parseRoutePathToRegex(routeConfig) {
-    const parameterNames = {};
-    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 };
-}
+ParsedRoute.__type = ['regex', 'pathParameterNames', function () { return {}; }, () => ParameterForRequestParser, 'parameters', function () { return []; }, () => RouteConfig, 'routeConfig', 'constructor', () => ReflectionParameter, 'property', () => ParameterForRequestParser, 'addParameter', () => ParameterForRequestParser, 'getParameters', 'name', () => ParameterForRequestParser, 'getParameter', 'ParsedRoute', '&3!8P&\'LM3">#P7$F3%<>&PP7\'2(:"0)PP7*2+P7,0-PP7.F0/P&20P71025w3'];
 export function parseRouteControllerAction(routeConfig) {
-    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];
     }
     return parsedRoute;
 }
+parseRouteControllerAction.__type = [() => RouteConfig, 'routeConfig', () => ParsedRoute, 'parseRouteControllerAction', 'PP7!2"P7#/$'];
 export function dotToUrlPath(dotPath) {
     if (-1 === dotPath.indexOf('.'))
         return dotPath;
     return dotPath.replace(/\./g, '][').replace('][', '[') + ']';
 }
-export class RouteParameterResolverTag extends Tag {
-    constructor(provider) {
-        super(provider);
-        this.provider = provider;
-        this.classTypes = [];
-        if (!this.provider.scope)
-            provider.scope = 'http';
-    }
-    forClassType(...classTypes) {
-        this.classTypes = classTypes;
-        return this;
+dotToUrlPath.__type = ['dotPath', 'dotToUrlPath', 'P&2!&/"'];
+const __ΩRouteParameterResolver = [() => __ΩRouteParameterResolverContext, 'context', 'resolve', 'RouteParameterResolver', 'PPn!2"P""`J1#Mw$y'];
+export { __ΩRouteParameterResolver as __ΩRouteParameterResolver };
+const __ΩRouteParameterResolverContext = [() => __ΩClassType, 'token', () => RouteConfig, 'route', () => HttpRequest, 'request', 'name', 'value', () => __ΩHttpRequestQuery, 'query', () => __ΩHttpRequestResolvedParameters, 'parameters', () => ReflectionParameter, 'type', 'RouteParameterResolverContext', 'PPn!&+"J4"P7#4$P7%4&"4\'"4(n)4*n+4,P7-4.Mw/y'];
+export { __ΩRouteParameterResolverContext as __ΩRouteParameterResolverContext };
+function filterMiddlewaresForRoute(middlewareRawConfigs, routeConfig, fullPath) {
+    const middlewares = middlewareRawConfigs.slice(0);
+    middlewares.push(...routeConfig.middlewares);
+    const middlewareConfigs = middlewares.filter(__assignType((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 = 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;
+    }, ['v', '', 'P"2!"/"']));
+    middlewareConfigs.sort(__assignType((a, b) => {
+        return a.config.order - b.config.order;
+    }, ['a', 'b', '', 'P"2!"2""/#']));
+    return middlewareConfigs;
+}
+filterMiddlewaresForRoute.__type = [() => __ΩMiddlewareRegistryEntry, 'middlewareRawConfigs', () => RouteConfig, 'routeConfig', 'fullPath', () => HttpMiddlewareConfig, 'config', () => InjectorModule, 'module', 'filterMiddlewaresForRoute', 'Pn!F2"P7#2$&2%PP7&4\'P"7(4)MF/*'];
+const __ΩHttpRouterFunctionOptions = ['path', 'name', 'methods', 'description', 'category', 'groups', () => __ΩRecord, 'data', 'baseUrl', () => HttpMiddlewareConfig, '', 'middlewares', () => Serializer, 'serializer', () => __ΩSerializationOptions, 'serializationOptions', () => __ΩClassType, 'resolverForToken', () => __ΩClassType, 'resolverForParameterName', 'statusCode', 'Type', 'type', 'responses', 'HttpRouterFunctionOptions', 'P&4!&4"8&F4#8&4$8&4%8&F4&8""o\'#4(8&4)8PP7*/+F4,8P7-4.8n/408"n1E428&n3E448P\'45&4$"w6478MF488Mw9y'];
+export { __ΩHttpRouterFunctionOptions as __ΩHttpRouterFunctionOptions };
+function convertOptions(methods, pathOrOptions, defaultOptions) {
+    const options = 'string' === typeof pathOrOptions ? { path: pathOrOptions } : pathOrOptions;
+    if (options.methods)
+        return options;
+    return { ...options, methods };
+}
+convertOptions.__type = ['methods', () => __ΩHttpRouterFunctionOptions, 'pathOrOptions', () => __ΩPartial, () => __ΩHttpRouterFunctionOptions, 'defaultOptions', () => __ΩHttpRouterFunctionOptions, 'convertOptions', 'P&F2!P&n"J2#n%o$"2&n\'/('];
+/**
+ * Annotated types like HTMLResponse/JSONResponse are not used for serialization.
+ */
+function filterValidReturnType(type) {
+    if (type.kind === ReflectionKind.class && (type.classType === HtmlResponse || type.classType === JSONResponse || type.classType === Response))
+        return;
+    return type;
+}
+filterValidReturnType.__type = ['Type', 'type', 'filterValidReturnType', 'P"w!2"P"w!-J/#'];
+export class HttpRouterRegistryFunctionRegistrar {
+    constructor() {
+        this.defaultOptions = {};
+    }
+    /**
+     * 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) {
+        var _a;
+        const that = this;
+        return new (_a = class extends HttpRouterRegistryFunctionRegistrar {
+                constructor() {
+                    super(...arguments);
+                    this.defaultOptions = options;
+                }
+                addRoute(routeConfig) {
+                    that.addRoute(routeConfig);
+                }
+            },
+            _a.__type = [() => HttpRouterRegistryFunctionRegistrar, 'defaultOptions', function () { return options; }, () => RouteConfig, 'routeConfig', 'addRoute', 'P7!!3">#PP7$2%"0&5'],
+            _a);
+    }
+    any(pathOrOptions, callback) {
+        this.register(convertOptions([], pathOrOptions, this.defaultOptions), callback);
+    }
+    add(decorator, callback) {
+        const data = decorator(Object, '_');
+        const action = isArray(data) ? data.find(__assignType(v => v instanceof HttpAction, ['v', '', 'P"2!"/"'])) : 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);
+    }
+    get(pathOrOptions, callback) {
+        this.register(convertOptions(['GET'], pathOrOptions, this.defaultOptions), callback);
+    }
+    post(pathOrOptions, callback) {
+        this.register(convertOptions(['POST'], pathOrOptions, this.defaultOptions), callback);
+    }
+    put(pathOrOptions, callback) {
+        this.register(convertOptions(['PUT'], pathOrOptions, this.defaultOptions), callback);
+    }
+    patch(pathOrOptions, callback) {
+        this.register(convertOptions(['PATCH'], pathOrOptions, this.defaultOptions), callback);
+    }
+    delete(pathOrOptions, callback) {
+        this.register(convertOptions(['DELETE'], pathOrOptions, this.defaultOptions), callback);
+    }
+    options(pathOrOptions, callback) {
+        this.register(convertOptions(['OPTIONS'], pathOrOptions, this.defaultOptions), callback);
+    }
+    trace(pathOrOptions, callback) {
+        this.register(convertOptions(['TRACE'], pathOrOptions, this.defaultOptions), callback);
+    }
+    head(pathOrOptions, callback) {
+        this.register(convertOptions(['HEAD'], pathOrOptions, this.defaultOptions), callback);
+    }
+    register(options, callback, module) {
+        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(__assignType(v => {
+                return { config: v(), module };
+            }, ['v', '', 'P"2!"/"']));
+        }
+        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);
     }
 }
-let Router = class Router {
-    constructor(controllers, logger, tagProviders) {
-        this.logger = logger;
+HttpRouterRegistryFunctionRegistrar.__type = [() => __ΩPartial, () => __ΩHttpRouterFunctionOptions, 'defaultOptions', function () { return {}; }, () => RouteConfig, 'routeConfig', 'addRoute', () => __ΩPartial, () => __ΩHttpRouterFunctionOptions, 'options', () => HttpRouterRegistryFunctionRegistrar, 'forOptions', () => __ΩHttpRouterFunctionOptions, 'pathOrOptions', 'args', '', 'callback', 'any', () => __ΩHttpDecorator, 'decorator', 'add', () => __ΩHttpRouterFunctionOptions, 'get', () => __ΩHttpRouterFunctionOptions, 'post', () => __ΩHttpRouterFunctionOptions, 'put', () => __ΩHttpRouterFunctionOptions, 'patch', () => __ΩHttpRouterFunctionOptions, 'delete', () => __ΩHttpRouterFunctionOptions, () => __ΩHttpRouterFunctionOptions, 'trace', () => __ΩHttpRouterFunctionOptions, 'head', () => __ΩHttpRouterFunctionOptions, () => InjectorModule, 'module', 'register', 'HttpRouterRegistryFunctionRegistrar', 'n"o!"3#<>$PP7%2&$0\'=Pn)o("2*P7+0,PP&n-J2.P"@2/"/021"02Pn324P"@2/"/021"05PP&n6J2.P"@2/"/021"07PP&n8J2.P"@2/"/021"09PP&n:J2.P"@2/"/021"0;PP&n<J2.P"@2/"/021"0=PP&n>J2.P"@2/"/021"0?PP&n@J2.P"@2/"/021"0*PP&nAJ2.P"@2/"/021"0BPP&nCJ2.P"@2/"/021"0DPnE2*P"@2/"/021P"7F2G8"0H;5wI'];
+function createRouteConfigFromHttpAction(routeAction, action, module, controller) {
+    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(__assignType(v => {
+            return { config: v(), module };
+        }, ['v', '', 'P"2!"/"']));
+        routeConfig.resolverForToken = new Map(controller.resolverForToken);
+        routeConfig.resolverForParameterName = new Map(controller.resolverForParameterName);
+    }
+    routeConfig.middlewares.push(...action.middlewares.map(__assignType(v => {
+        return { config: v(), module };
+    }, ['v', '', 'P"2!"/"'])));
+    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;
+}
+createRouteConfigFromHttpAction.__type = [() => __ΩRouteClassControllerAction, () => __ΩRouteFunctionControllerAction, 'routeAction', () => HttpAction, 'action', () => InjectorModule, 'module', () => HttpController, 'controller', 'createRouteConfigFromHttpAction', 'PPn!n"J2#P7$2%P"7&2\'8P7(2)8"/*'];
+export class HttpRouterRegistry extends HttpRouterRegistryFunctionRegistrar {
+    constructor() {
+        super(...arguments);
         this.routes = [];
-        this.parameterResolverTags = [];
-        //todo, move some settings to KernelConfig
-        this.form = formidable({
-            multiples: true,
-            hash: 'sha1',
-            enabledPlugins: ['octetstream', 'querystring', 'json'],
-        });
-        this.parameterResolverTags = tagProviders.getProviders(RouteParameterResolverTag);
-        for (const controller of controllers.controllers)
-            this.addRouteForController(controller);
+        this.buildId = 1;
+    }
+    getBuildId() {
+        return this.buildId;
     }
     getRoutes() {
         return this.routes;
     }
-    static forControllers(controllers, tagProviders = new TagProviders()) {
-        return new this(new HttpControllers(controllers), new Logger([], []), tagProviders);
+    addRouteForController(controller, module) {
+        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 = {
+                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);
+        }
+    }
+    addRoute(routeConfig) {
+        this.routes.push(routeConfig);
+        this.buildId++;
+    }
+}
+HttpRouterRegistry.__type = [() => HttpRouterRegistryFunctionRegistrar, () => RouteConfig, 'routes', function () { return []; }, 'buildId', function () { return 1; }, 'getBuildId', () => RouteConfig, 'getRoutes', () => __ΩClassType, 'controller', () => InjectorModule, 'module', 'addRouteForController', () => RouteConfig, 'routeConfig', 'addRoute', 'HttpRouterRegistry', 'P7!P7"F3#<>$\'3%;>&P\'0\'PP7(F0)Pn*2+P"7,2-"0.PP7/20"015w2'];
+export class HttpRouter {
+    constructor(controllers, logger, config, middlewareRegistry = new MiddlewareRegistry, registry = new HttpRouterRegistry) {
+        this.logger = logger;
+        this.config = config;
+        this.middlewareRegistry = middlewareRegistry;
+        this.registry = registry;
+        this.buildId = 0;
+        for (const controller of controllers.controllers) {
+            this.addRouteForController(controller.controller, controller.module);
+        }
+    }
+    getRoutes() {
+        return this.registry.getRoutes();
+    }
+    static forControllers(controllers, middlewareRegistry = new MiddlewareRegistry(), module = new InjectorModule(), config = new HttpConfig()) {
+        return new this(new HttpControllers(controllers.map(__assignType(v => {
+            return isClass(v) ? { controller: v, module } : v;
+        }, ['v', '', 'P"2!"/"']))), new Logger([], []), config, middlewareRegistry);
     }
     getRouteCode(compiler, routeConfig) {
-        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 = [];
-        const parameterNames = [];
-        const parameterValidator = [];
-        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) => v : getPropertyXtoClassFunction(parameter.property, jsonSerializer);
-                const validator = parameter.property.type === 'any' ? (v) => 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) => v : getPropertyXtoClassFunction(parameter.property, jsonSerializer);
-                    const validator = parameter.property.type === 'any' ? (v) => 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);`);
-                }
-                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}`);
-                }
-            }
-        }
-        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;
-        }
+        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 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 middlewares = 'undefined';
+        if (middlewareConfigs.length) {
+            const middlewareItems = [];
+            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 {
+                        middlewareItems.push(`{fn: ${compiler.reserveVariable('middlewareFn', middleware)}, timeout: ${middlewareConfig.config.timeout}}`);
+                    }
+                }
+            }
+            middlewares = `
+                function(_injector) {
+                    return [${middlewareItems.join(', ')}];
+                }
+            `;
         }
+        const parametersLoader = getRequestParserCodeForParameters(compiler, this.config.parser, parameters, {
+            module: routeConfig.module,
+            resolverForToken: routeConfig.resolverForToken,
+            resolverForParameterName: routeConfig.resolverForParameterName,
+            pathParameterNames: parsedRoute.pathParameterNames,
+            routeConfig
+        });
+        let methodCheck = '';
+        if (routeConfig.httpMethods.length) {
+            methodCheck = '(' + routeConfig.httpMethods.map(__assignType(v => {
+                return `_method === '${v.toUpperCase()}'`;
+            }, ['v', '', 'P"2!"/"'])).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}};
             }
         `;
     }
     getRouteUrlResolveCode(compiler, routeConfig) {
         const parsedRoute = parseRouteControllerAction(routeConfig);
         let url = routeConfig.getFullPath();
-        url = url.replace(/:(\w+)/g, (a, name) => {
+        url = url.replace(/:(\w+)/g, __assignType((a, name) => {
             return `\${parameters.${name}}`;
-        });
+        }, ['a', 'name', '', 'P"2!"2""/#']));
         const modify = [];
         for (const parameter of parsedRoute.getParameters()) {
-            if (parameter.query) {
-                const queryPath = parameter.typePath === undefined ? parameter.property.name : parameter.typePath;
-                if (parameter.property.type === 'class') {
-                    for (const property of parameter.property.getResolvedClassSchema().getProperties()) {
+            if (parameter.query || parameter.queries) {
+                const queryPath = parameter.typePath === undefined && parameter.query ? parameter.parameter.name : parameter.typePath || '';
+                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}))`);
@@ -345,51 +550,36 @@ let Router = class Router {
         `;
     }
     addRoute(routeConfig) {
-        this.routes.push(routeConfig);
-        this.fn = undefined;
+        this.registry.addRoute(routeConfig);
     }
-    addRouteForController(controller) {
-        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);
-        }
+    addRouteForController(controller, module) {
+        this.registry.addRouteForController(controller, module);
     }
     build() {
+        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 = [];
-        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');
     }
     buildUrlResolver() {
         const compiler = new CompilerContext;
         const code = [];
-        for (const route of this.routes) {
+        for (const route of this.getRoutes()) {
             code.push(this.getRouteUrlResolveCode(compiler, route));
         }
         return compiler.build(`
@@ -406,27 +596,15 @@ let Router = class Router {
         return this.resolveFn(routeName, parameters);
     }
     resolveRequest(request) {
-        if (!this.fn) {
+        if (!this.fn || this.buildId !== this.registry.getBuildId()) {
             this.fn = this.build();
         }
         return this.fn(request);
     }
     resolve(method, url) {
-        return this.resolveRequest({
-            getUrl() {
-                return url;
-            },
-            getMethod() {
-                return method;
-            },
-        });
+        method = method.toUpperCase();
+        return this.resolveRequest({ url, method });
     }
-};
-Router = __decorate([
-    injectable(),
-    __metadata("design:paramtypes", [HttpControllers,
-        Logger,
-        TagProviders])
-], Router);
-export { Router };
+}
+HttpRouter.__type = [() => HttpRequest, 'request', () => __ΩResolvedController, '', 'fn', 'buildId', function () { return 0; }, 'name', 'parameters', 'resolveFn', () => HttpControllers, 'controllers', () => __ΩLoggerInterface, 'logger', () => HttpConfig, 'config', () => MiddlewareRegistry, 'middlewareRegistry', () => new MiddlewareRegistry, () => HttpRouterRegistry, 'registry', () => new HttpRouterRegistry, 'constructor', () => RouteConfig, 'getRoutes', () => __ΩClassType, () => InjectorModule, 'module', () => __ΩClassType, 'controller', () => MiddlewareRegistry, () => new MiddlewareRegistry(), () => InjectorModule, () => new InjectorModule(), () => HttpConfig, () => new HttpConfig(), () => HttpRouter, 'forControllers', () => CompilerContext, 'compiler', () => RouteConfig, 'routeConfig', 'getRouteCode', () => CompilerContext, () => RouteConfig, 'getRouteUrlResolveCode', () => RouteConfig, 'addRoute', () => __ΩClassType, () => InjectorModule, 'addRouteForController', () => HttpRequest, () => __ΩResolvedController, 'build', 'buildUrlResolver', 'routeName', () => ({}), 'resolveUrl', () => HttpRequest, () => __ΩResolvedController, 'resolveRequest', 'method', 'url', () => __ΩResolvedController, 'resolve', 'HttpRouter', 'PP7!2"Pn#-J/$3%8<\'3&<>\'P&2(P&"LM2)&/$3*8<PP7+2,n-2.;P7/20;P7122;>3P7425;>6"07PP78F09PPn:PP"7;4<n=4>MJF2,P7?22>@P"7A2<>BP7C20>DP7E0FsPP7G2HP7I2J&0K<PP7L2HP7M2J&0N<PP7O2J"0PPnQ2>P"7R2<"0SPPP7T2"PnU-J/$0V<P"0W<P&2XP&"LM2)>Y&0ZPP7[2"Pn\\-J0]P&2^&2_Pn`-J0a5wb'];
 //# sourceMappingURL=router.js.map