@deepkit/http 1.0.1-alpha.68 → 1.0.1-alpha.72

package/dist/esm/src/router.js

@@ -7,10 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { __ΩSerializationOptions as __ΩSerializationOptions } from '@deepkit/type';
 import { __ΩClassType as __ΩClassType } from '@deepkit/core';
 import { __ΩMiddlewareRegistryEntry as __ΩMiddlewareRegistryEntry } from '@deepkit/app';
+import { __ΩHttpDecorator as __ΩHttpDecorator } from './decorator';
 import { __ΩLoggerInterface as __ΩLoggerInterface } from '@deepkit/logger';
 import { __ΩHttpMiddlewareFn as __ΩHttpMiddlewareFn } from './middleware';
 import { __ΩHttpRequestQuery as __ΩHttpRequestQuery } from './model';
 import { __ΩHttpRequestResolvedParameters as __ΩHttpRequestResolvedParameters } from './model';
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
+const __ΩPartial = ['T', 'l+e#!e"!fRb!Pde"!gN#"'];
+const __ΩRecord = ['K', 'T', 'l\'e#"Rb!b"Pde"!N#!'];
 /*
  * Deepkit Framework
  * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt
@@ -21,10 +28,10 @@ import { __ΩHttpRequestResolvedParameters as __ΩHttpRequestResolvedParameters
  * You should have received a copy of the MIT License along with this program.
  */
 import { asyncOperation, CompilerContext, getClassName, isClass, isObject, urlJoin } from '@deepkit/core';
-import { assertType, entity, findMember, getSerializeFunction, getValidatorFunction, metaAnnotation, ReflectionClass, ReflectionParameter, serializer, Serializer, stringifyType, typeToObject, ValidationError } from '@deepkit/type';
+import { assertType, entity, findMember, getSerializeFunction, getValidatorFunction, metaAnnotation, ReflectionClass, ReflectionFunction, ReflectionKind, ReflectionParameter, serializer, Serializer, stringifyType, typeToObject, ValidationError } from '@deepkit/type';
 // @ts-ignore
 import formidable from 'formidable';
-import { httpClass } from './decorator';
+import { HttpAction, httpClass, HttpController } from './decorator';
 import { BodyValidationError, getRegExp, HttpRequest, ValidatedBody } from './model';
 import { InjectorContext, InjectorModule, TagRegistry } from '@deepkit/injector';
 import { Logger } from '@deepkit/logger';
@@ -33,6 +40,7 @@ import { MiddlewareRegistry } from '@deepkit/app';
 import { HttpMiddlewareConfig } from './middleware';
 //@ts-ignore
 import qs from 'qs';
+import { isArray } from '@deepkit/core';
 const __ΩRouteParameterResolverForInjector = [() => InjectorContext, 'injector', '', 'PP7!2"P"F"F`J/#'];
 export { __ΩRouteParameterResolverForInjector as __ΩRouteParameterResolverForInjector };
 const __ΩResolvedController = [() => __ΩRouteParameterResolverForInjector, 'parameters', () => RouteConfig, 'routeConfig', () => UploadedFile, 'uploadedFiles', () => InjectorContext, 'injector', () => __ΩHttpMiddlewareFn, 'fn', 'timeout', '', 'middlewares', 'Pn!4"P7#4$P&P7%LM4&PP7\'2(Pn)4*\'4+MF/,4-8M'];
@@ -43,12 +51,10 @@ UploadedFile = __decorate([
     entity.name('@deepkit/UploadedFile')
 ], UploadedFile);
 export { UploadedFile };
-const __ΩRouteControllerAction = [() => InjectorModule, 'module', () => __ΩClassType, 'controller', 'methodName', 'PP"7!4"8n#4$&4%M'];
-export { __ΩRouteControllerAction as __ΩRouteControllerAction };
-function getRouterControllerActionName(action) {
-    return `${getClassName(action.controller)}.${action.methodName}`;
-}
-getRouterControllerActionName.__type = [() => __ΩRouteControllerAction, 'action', 'getRouterControllerActionName', 'Pn!2"&/#'];
+const __ΩRouteFunctionControllerAction = ["function", 'type', () => InjectorModule, 'module', 'args', '', 'fn', 'P.!4"P"7#4$8P"@2%"/&4\'M'];
+export { __ΩRouteFunctionControllerAction as __ΩRouteFunctionControllerAction };
+const __ΩRouteClassControllerAction = ["controller", 'type', () => InjectorModule, 'module', () => __ΩClassType, 'controller', 'methodName', 'P.!4"P"7#4$8n%4&&4\'M'];
+export { __ΩRouteClassControllerAction as __ΩRouteClassControllerAction };
 export class RouteConfig {
     constructor(name, httpMethods, path, action, internal = false) {
         this.name = name;
@@ -69,6 +75,11 @@ export class RouteConfig {
          */
         this.data = 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;
@@ -85,7 +96,7 @@ export class RouteConfig {
         return path;
     }
 }
-RouteConfig.__type = ['baseUrl', function () { return ''; }, 'statusCode', 'description', '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(); }, 'name', 'httpMethods', 'path', () => __ΩRouteControllerAction, 'action', 'internal', () => false, 'constructor', 'getSchemaForResponse', 'getFullPath', '&3!>"P\'4#&4$"4%8MF3&>\'&3$>(&F3)>*&3+>,"3-8n.3/8P70318P"72338"n4E35>6PP7748P"7943MF3:>;&n<E3=>>P&2?:&F2@:&2A:nB2C:)2D:>E"0FP\'2#P"-J0GP&0H5'];
+RouteConfig.__type = ['baseUrl', function () { return ''; }, 'statusCode', 'description', '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(); }, 'name', 'httpMethods', 'path', () => __ΩRouteClassControllerAction, () => __ΩRouteFunctionControllerAction, 'action', 'internal', () => false, 'constructor', () => ReflectionFunction, 'getReflectionFunction', 'getSchemaForResponse', 'getFullPath', '&3!>"P\'4#&4$"4%8MF3&>\'&3$>(&F3)>*&3+>,"3-8n.3/8P70318P"72338"n4E35>6PP7748P"79438MF3:>;&n<E3=>>P&2?:&F2@:&2A:PnBnCJ2D:)2E:>F"0GPP7H0IP\'2#P"-J0JP&0K5'];
 class ParsedRoute {
     constructor(routeConfig) {
         this.routeConfig = routeConfig;
@@ -121,9 +132,9 @@ class ParsedRouteParameter {
     }
     getType() {
         if (this.bodyValidation) {
-            assertType(this.parameter.type, 20 /* class */);
-            const valueType = findMember('value', this.parameter.type);
-            if (!valueType || valueType.kind !== 15 /* property */)
+            assertType(this.parameter.type, ReflectionKind.class);
+            const valueType = findMember('value', this.parameter.type.types);
+            if (!valueType || valueType.kind !== ReflectionKind.property)
                 throw new Error(`No property value found at ${stringifyType(this.parameter.type)}`);
             return valueType.type;
         }
@@ -155,26 +166,29 @@ ParsedRouteParameter.__type = ['regexPosition', () => ReflectionParameter, 'para
 function parseRoutePathToRegex(routeConfig) {
     const parameterNames = {};
     let path = routeConfig.getFullPath();
-    const method = ReflectionClass.from(routeConfig.action.controller).getMethod(routeConfig.action.methodName);
+    const fn = routeConfig.getReflectionFunction();
     let argumentIndex = 0;
-    path = path.replace(/:(\w+)/g, Object.assign((a, name) => {
+    path = path.replace(/:(\w+)/g, __assignType((a, name) => {
         parameterNames[name] = argumentIndex;
         argumentIndex++;
-        const parameter = method.getParameterOrUndefined(name);
+        const parameter = fn.getParameterOrUndefined(name);
         if (parameter) {
             const regExp = getRegExp(parameter.type);
-            if (regExp)
+            if (regExp instanceof RegExp) {
+                return '(' + regExp.source + ')';
+            }
+            else if (regExp) {
                 return '(' + regExp + ')';
+            }
         }
         return String.raw `([^/]+)`;
-    }, { __type: ['a', 'name', '', 'P"2!"2""/#'] }));
+    }, ['a', 'name', '', 'P"2!"2""/#']));
     return { regex: path, parameterNames };
 }
 parseRoutePathToRegex.__type = [() => RouteConfig, 'routeConfig', 'regex', 'parameterNames', 'parseRoutePathToRegex', 'PP7!2"P&4#P&\'LM4$M/%'];
 export function parseRouteControllerAction(routeConfig) {
-    const schema = ReflectionClass.from(routeConfig.action.controller);
     const parsedRoute = new ParsedRoute(routeConfig);
-    const methodArgumentProperties = schema.getMethodParameters(routeConfig.action.methodName);
+    const methodArgumentProperties = routeConfig.getReflectionFunction().getParameters();
     const parsedPath = parseRoutePathToRegex(routeConfig);
     parsedRoute.regex = parsedPath.regex;
     parsedRoute.pathParameterNames = parsedPath.parameterNames;
@@ -198,14 +212,14 @@ export { __ΩRouteParameterResolverContext as __ΩRouteParameterResolverContext
 function filterMiddlewaresForRoute(middlewareRawConfigs, routeConfig, fullPath) {
     const middlewares = middlewareRawConfigs.slice(0);
     middlewares.push(...routeConfig.middlewares);
-    const middlewareConfigs = middlewares.filter(Object.assign((v) => {
+    const middlewareConfigs = middlewares.filter(__assignType((v) => {
         var _a;
         if (!(v.config instanceof HttpMiddlewareConfig))
             return false;
-        if (v.config.controllers.length && !v.config.controllers.includes(routeConfig.action.controller)) {
+        if (v.config.controllers.length && routeConfig.action.type === 'controller' && !v.config.controllers.includes(routeConfig.action.controller)) {
             return false;
         }
-        if (v.config.excludeControllers.length && v.config.excludeControllers.includes(routeConfig.action.controller)) {
+        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))) {
@@ -219,16 +233,22 @@ function filterMiddlewaresForRoute(middlewareRawConfigs, routeConfig, fullPath)
         if (v.config.selfModule && v.module.id !== ((_a = routeConfig.module) === null || _a === void 0 ? void 0 : _a.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))
-                        return false;
+                    if (regex.test(routeConfig.name)) {
+                        found = true;
+                        break;
+                    }
                 }
-                else if (name !== routeConfig.name) {
-                    return false;
+                else if (name === routeConfig.name) {
+                    found = true;
+                    break;
                 }
             }
+            if (!found)
+                return false;
         }
         if (v.config.excludeRouteNames.length) {
             for (const name of v.config.excludeRouteNames) {
@@ -261,50 +281,251 @@ function filterMiddlewaresForRoute(middlewareRawConfigs, routeConfig, fullPath)
             }
         }
         return true;
-    }, { __type: ['v', '', 'P"2!"/"'] }));
-    middlewareConfigs.sort(Object.assign((a, b) => {
+    }, ['v', '', 'P"2!"/"']));
+    middlewareConfigs.sort(__assignType((a, b) => {
         return a.config.order - b.config.order;
-    }, { __type: ['a', 'b', '', 'P"2!"2""/#'] }));
+    }, ['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/*'];
-export class Router {
-    constructor(controllers, logger, tagRegistry, middlewareRegistry = new MiddlewareRegistry) {
+const __ΩHttpRouterFunctionOptions = ['path', 'name', 'methods', 'description', 'category', 'groups', () => __ΩRecord, 'data', 'baseUrl', () => HttpMiddlewareConfig, '', 'middlewares', () => Serializer, 'serializer', () => __ΩSerializationOptions, 'serializationOptions', () => __ΩClassType, 'resolverForToken', () => __ΩClassType, 'resolverForParameterName', 'statusCode', 'type', 'responses', '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$"468MF478M'];
+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\'/('];
+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, () => RouteConfig, 'routeConfig', 'addRoute', 'P7!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 = 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 = fn.getReturnType();
+        this.addRoute(routeConfig);
+    }
+}
+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', '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;5'];
+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.buildId = 1;
+    }
+    getBuildId() {
+        return this.buildId;
+    }
+    getRoutes() {
+        return this.routes;
+    }
+    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 controllerData.getActions()) {
+            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 = 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', 'P7!P7"F3#<>$\'3%;>&P\'0\'PP7(F0)Pn*2+P"7,2-"0.PP7/20"015'];
+export class HttpRouter {
+    constructor(controllers, logger, tagRegistry, middlewareRegistry = new MiddlewareRegistry, registry = new HttpRouterRegistry) {
         this.logger = logger;
         this.middlewareRegistry = middlewareRegistry;
-        this.routes = [];
+        this.registry = registry;
+        this.buildId = 0;
         for (const controller of controllers.controllers) {
             this.addRouteForController(controller.controller, controller.module);
         }
     }
-    parseBody(req, files) {
+    parseBody(req, foundFiles) {
         const form = formidable({
             multiples: true,
             hash: 'sha1',
-            enabledPlugins: ['octetstream', 'querystring', 'json'],
         });
-        return asyncOperation(Object.assign((resolve, reject) => {
+        return asyncOperation(__assignType((resolve, reject) => {
             if (req.body) {
                 return resolve(req.body);
             }
-            form.parse(req, Object.assign((err, fields, files) => {
+            form.parse(req, __assignType((err, fields, files) => {
                 if (err) {
                     reject(err);
                 }
                 else {
-                    const body = req.body = { ...fields, ...files };
+                    for (const [name, file] of Object.entries(files)) {
+                        if (file.size === 0)
+                            continue;
+                        foundFiles[name] = {
+                            size: file.size,
+                            path: file.filepath,
+                            name: file.originalFilename,
+                            type: file.mimetype,
+                            lastModifiedDate: file.lastModifiedDate,
+                        };
+                    }
+                    const body = req.body = { ...fields, ...foundFiles };
                     resolve(body);
                 }
-            }, { __type: ['err', 'fields', 'files', '', 'P"2!"2""2#"/$'] }));
-        }, { __type: ['resolve', 'reject', '', 'P"2!"2""/#'] }));
+            }, ['err', 'fields', 'files', '', 'P"2!"2""2#"/$']));
+        }, ['resolve', 'reject', '', 'P"2!"2""/#']));
     }
     getRoutes() {
-        return this.routes;
+        return this.registry.getRoutes();
     }
     static forControllers(controllers, tagRegistry = new TagRegistry(), middlewareRegistry = new MiddlewareRegistry(), module = new InjectorModule()) {
-        return new this(new HttpControllers(controllers.map(Object.assign(v => {
+        return new this(new HttpControllers(controllers.map(__assignType(v => {
             return isClass(v) ? { controller: v, module } : v;
-        }, { __type: ['v', '', 'P"2!"/"'] }))), new Logger([], []), tagRegistry, middlewareRegistry);
+        }, ['v', '', 'P"2!"/"']))), new Logger([], []), tagRegistry, middlewareRegistry);
     }
     getRouteCode(compiler, routeConfig) {
         const routeConfigVar = compiler.reserveVariable('routeConfigVar', routeConfig);
@@ -355,7 +576,7 @@ export class Router {
             else {
                 parameterNames.push(`parameters.${parameter.parameter.name}`);
                 if (parameter.isPartOfPath()) {
-                    if (parameter.parameter.type.kind !== 20 /* class */) {
+                    if (parameter.parameter.type.kind !== ReflectionKind.class) {
                         const converted = getSerializeFunction(parameter.parameter.parameter, serializer.deserializeRegistry, undefined, parameter.getName());
                         const converterVar = compiler.reserveVariable('argumentConverter', converted);
                         setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(_match[${1 + (parameter.regexPosition || 0)}], {loosely: true});`);
@@ -367,7 +588,7 @@ export class Router {
                         setParameters.push(`parameters.${parameter.parameter.name} = _match[${1 + (parameter.regexPosition || 0)}];`);
                     }
                 }
-                const injectorToken = parameter.parameter.type.kind === 20 /* class */ ? parameter.parameter.type.classType : undefined;
+                const injectorToken = parameter.parameter.type.kind === ReflectionKind.class ? parameter.parameter.type.classType : undefined;
                 const injectorTokenVar = compiler.reserveVariable('classType', injectorToken);
                 const parameterResolverFoundVar = compiler.reserveVariable('parameterResolverFound', false);
                 setParameters.push(`${parameterResolverFoundVar} = false;`);
@@ -391,7 +612,7 @@ export class Router {
                         ${parameterResolverFoundVar} = true;
                         parameters.${parameter.parameter.name} = await ${instance}.resolve({
                             token: ${injectorTokenVar},
-                            routeConfig: ${routeConfigVar},
+                            route: ${routeConfigVar},
                             request: request,
                             name: ${JSON.stringify(parameter.parameter.name)},
                             value: parameters.${parameter.parameter.name},
@@ -458,9 +679,9 @@ export class Router {
         }
         let methodCheck = '';
         if (routeConfig.httpMethods.length) {
-            methodCheck = '(' + routeConfig.httpMethods.map(Object.assign(v => {
+            methodCheck = '(' + routeConfig.httpMethods.map(__assignType(v => {
                 return `_method === '${v.toUpperCase()}'`;
-            }, { __type: ['v', '', 'P"2!"/"'] })).join(' || ') + ') && ';
+            }, ['v', '', 'P"2!"/"'])).join(' || ') + ') && ';
         }
         return `
             //=> ${routeConfig.httpMethods.join(',')} ${path}
@@ -472,14 +693,14 @@ export class Router {
     getRouteUrlResolveCode(compiler, routeConfig) {
         const parsedRoute = parseRouteControllerAction(routeConfig);
         let url = routeConfig.getFullPath();
-        url = url.replace(/:(\w+)/g, Object.assign((a, name) => {
+        url = url.replace(/:(\w+)/g, __assignType((a, name) => {
             return `\${parameters.${name}}`;
-        }, { __type: ['a', 'name', '', 'P"2!"2""/#'] }));
+        }, ['a', 'name', '', 'P"2!"2""/#']));
         const modify = [];
         for (const parameter of parsedRoute.getParameters()) {
             if (parameter.query || parameter.queries) {
                 const queryPath = parameter.typePath === undefined && parameter.query ? parameter.parameter.name : parameter.typePath || '';
-                if (parameter.parameter.type.kind === 20 /* class */ || parameter.parameter.type.kind === 30 /* objectLiteral */) {
+                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;
@@ -501,55 +722,18 @@ export class Router {
         `;
     }
     addRoute(routeConfig) {
-        this.routes.push(routeConfig);
-        this.fn = undefined;
+        this.registry.addRoute(routeConfig);
     }
     addRouteForController(controller, module) {
-        const data = httpClass._fetch(controller);
-        if (!data)
-            throw new Error(`Http controller class ${getClassName(controller)} has no @http.controller decorator.`);
-        const schema = ReflectionClass.from(controller);
-        for (const action of data.getActions()) {
-            const routeConfig = new RouteConfig(action.name, action.httpMethods, action.path, {
-                controller,
-                module,
-                methodName: action.methodName
-            });
-            routeConfig.module = module;
-            routeConfig.responses = action.responses;
-            routeConfig.description = action.description;
-            routeConfig.category = action.category;
-            routeConfig.groups = action.groups;
-            routeConfig.data = new Map(action.data);
-            routeConfig.baseUrl = data.baseUrl;
-            routeConfig.middlewares = data.middlewares.map(Object.assign(v => {
-                return { config: v(), module };
-            }, { __type: ['v', '', 'P"2!"/"'] }));
-            routeConfig.middlewares.push(...action.middlewares.map(Object.assign(v => {
-                return { config: v(), module };
-            }, { __type: ['v', '', 'P"2!"/"'] })));
-            for (const item of action.resolverForToken)
-                routeConfig.resolverForToken.set(...item);
-            routeConfig.resolverForToken = new Map(data.resolverForToken);
-            for (const item of action.resolverForToken)
-                routeConfig.resolverForToken.set(...item);
-            routeConfig.resolverForParameterName = new Map(data.resolverForParameterName);
-            for (const item of action.resolverForParameterName)
-                routeConfig.resolverForParameterName.set(...item);
-            routeConfig.serializationOptions = action.serializationOptions;
-            routeConfig.serializer = action.serializer;
-            routeConfig.serializer = action.serializer;
-            if (schema.hasMethod(action.methodName))
-                routeConfig.returnType = schema.getMethod(action.methodName).getReturnType();
-            this.addRoute(routeConfig);
-        }
+        this.registry.addRouteForController(controller, module);
     }
     build() {
+        this.buildId = this.registry.getBuildId();
         const compiler = new CompilerContext;
         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(`
@@ -566,7 +750,7 @@ export class Router {
     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(`
@@ -583,7 +767,7 @@ export 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);
@@ -593,5 +777,5 @@ export class Router {
         return this.resolveRequest({ url, method });
     }
 }
-Router.__type = [() => HttpRequest, 'request', () => __ΩResolvedController, '', 'fn', 'name', 'parameters', 'resolveFn', () => RouteConfig, 'routes', function () { return []; }, () => HttpRequest, 'req', () => UploadedFile, 'files', 'parseBody', () => HttpControllers, 'controllers', () => __ΩLoggerInterface, 'logger', () => TagRegistry, 'tagRegistry', () => MiddlewareRegistry, 'middlewareRegistry', () => new MiddlewareRegistry, 'constructor', () => RouteConfig, 'getRoutes', () => __ΩClassType, () => InjectorModule, 'module', () => __ΩClassType, 'controller', () => TagRegistry, () => new TagRegistry(), () => MiddlewareRegistry, () => new MiddlewareRegistry(), () => InjectorModule, () => new InjectorModule(), () => Router, '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', 'PP7!2"Pn#-J/$3%8<P&2&P&"LM2\'&/$3(8<P7)F3*<>+PP7,2-P&P7.LM2/"00;PP7122n324;P7526P7728;>9"0:PP7;F0<PPn=PP"7>4?n@4AMJF22P7B26>CP7D28>EP"7F2?>GP7H0IPP7J2KP7L2M&0N<PP7O2KP7P2M&0Q<PP7R2M"0SPnT2AP"7U2?"0VPPP7W2"PnX-J/$0Y<P"0Z<P&2[P&"LM2\'>\\&0]PP7^2"Pn_-J0`P&2a&2bPnc-J0d5'];
+HttpRouter.__type = [() => HttpRequest, 'request', () => __ΩResolvedController, '', 'fn', 'buildId', function () { return 0; }, 'name', 'parameters', 'resolveFn', () => HttpRequest, 'req', () => UploadedFile, 'foundFiles', 'parseBody', () => HttpControllers, 'controllers', () => __ΩLoggerInterface, 'logger', () => TagRegistry, 'tagRegistry', () => MiddlewareRegistry, 'middlewareRegistry', () => new MiddlewareRegistry, () => HttpRouterRegistry, 'registry', () => new HttpRouterRegistry, 'constructor', () => RouteConfig, 'getRoutes', () => __ΩClassType, () => InjectorModule, 'module', () => __ΩClassType, 'controller', () => TagRegistry, () => new TagRegistry(), () => MiddlewareRegistry, () => new MiddlewareRegistry(), () => InjectorModule, () => new InjectorModule(), () => 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', 'PP7!2"Pn#-J/$3%8<\'3&<>\'P&2(P&"LM2)&/$3*8<PP7+2,P&P7-LM2."0/;PP7021n223;P7425P7627;>8P792:;>;"0<PP7=F0>PPn?PP"7@4AnB4CMJF21P7D25>EP7F27>GP"7H2A>IP7J0KPP7L2MP7N2O&0P<PP7Q2MP7R2O&0S<PP7T2O"0UPnV2CP"7W2A"0XPPP7Y2"PnZ-J/$0[<P"0\\<P&2]P&"LM2)>^&0_PP7`2"Pna-J0bP&2c&2dPne-J0f5'];
 //# sourceMappingURL=router.js.map