@deepkit/http 1.0.1-alpha.100

package/src/router.ts

@@ -0,0 +1,747 @@
+/*
+ * Deepkit Framework
+ * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the MIT License.
+ *
+ * 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 { HttpAction, httpClass, HttpController, HttpDecorator } from './decorator.js';
+import { HttpRequest, HttpRequestPositionedParameters, HttpRequestQuery, HttpRequestResolvedParameters } from './model.js';
+import { InjectorContext, InjectorModule, TagRegistry } 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, HttpParserOptions } 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 }[];
+}
+
+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;
+}
+
+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 class RouteConfig {
+    public baseUrl: 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>();
+
+    constructor(
+        public readonly name: string,
+        public readonly httpMethods: string[],
+        public readonly path: string,
+        public readonly action: RouteClassControllerAction | RouteFunctionControllerAction,
+        public internal: boolean = false,
+    ) {
+    }
+
+    getReflectionFunction(): ReflectionFunction {
+        return this.action.type === 'controller' ?
+            ReflectionClass.from(this.action.controller).getMethod(this.action.methodName)
+            : ReflectionFunction.from(this.action.fn);
+    }
+
+    getSchemaForResponse(statusCode: number): Type | undefined {
+        if (!this.responses.length) return;
+        for (const response of this.responses) {
+            if (response.statusCode === statusCode) return response.type;
+        }
+        return;
+    }
+
+    getFullPath(): string {
+        let path = this.baseUrl ? urlJoin(this.baseUrl, this.path) : this.path;
+        if (!path.startsWith('/')) path = '/' + path;
+        return path;
+    }
+}
+
+class ParsedRoute {
+    public regex?: string;
+
+    public pathParameterNames: { [name: string]: number } = {};
+
+    protected parameters: ParameterForRequestParser[] = [];
+
+    constructor(public routeConfig: RouteConfig) {
+    }
+
+    addParameter(property: ReflectionParameter): ParameterForRequestParser {
+        const parameter = new ParameterForRequestParser(property);
+        this.parameters.push(parameter);
+        return parameter;
+    }
+
+    getParameters(): ParameterForRequestParser[] {
+        return this.parameters;
+    }
+
+    getParameter(name: string): ParameterForRequestParser {
+        for (const parameter of this.parameters) {
+            if (parameter.getName() === name) return parameter;
+        }
+        throw new Error(`No route parameter with name ${name} defined.`);
+    }
+}
+
+export function parseRouteControllerAction(routeConfig: RouteConfig): ParsedRoute {
+    const parsedRoute = new ParsedRoute(routeConfig);
+
+    const parameters = routeConfig.getReflectionFunction().getParameters();
+    const parsedPath = parseRoutePathToRegex(routeConfig.getFullPath(), parameters);
+    parsedRoute.regex = parsedPath.regex;
+    parsedRoute.pathParameterNames = parsedPath.parameterNames;
+
+    for (const property of parameters) {
+        const parsedParameter = parsedRoute.addParameter(property);
+        parsedParameter.regexPosition = parsedPath.parameterNames[property.name];
+    }
+
+    return parsedRoute;
+}
+
+export function dotToUrlPath(dotPath: string): string {
+    if (-1 === dotPath.indexOf('.')) return dotPath;
+
+    return dotPath.replace(/\./g, '][').replace('][', '[') + ']';
+}
+
+export interface RouteParameterResolver {
+    resolve(context: RouteParameterResolverContext): any | Promise<any>;
+}
+
+export interface RouteParameterResolverContext {
+    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;
+}
+
+function filterMiddlewaresForRoute(middlewareRawConfigs: MiddlewareRegistryEntry[], routeConfig: RouteConfig, fullPath: string): {
+    config: HttpMiddlewareConfig,
+    module: InjectorModule<any>
+}[] {
+    const middlewares = middlewareRawConfigs.slice(0);
+    middlewares.push(...routeConfig.middlewares as any[]);
+
+    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);
+    }
+
+    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);
+    }
+}
+
+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;
+
+    public getBuildId(): number {
+        return this.buildId;
+    }
+
+    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 controllerData.getActions()) {
+            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: LoggerInterface,
+        private config: HttpConfig,
+        private middlewareRegistry: MiddlewareRegistry = new MiddlewareRegistry,
+        private registry: HttpRouterRegistry = new HttpRouterRegistry,
+    ) {
+        for (const controller of controllers.controllers) {
+            this.addRouteForController(controller.controller, controller.module);
+        }
+    }
+
+    getRoutes(): RouteConfig[] {
+        return this.registry.getRoutes();
+    }
+
+    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 parsedRoute = parseRouteControllerAction(routeConfig);
+        const path = routeConfig.getFullPath();
+        const pathParamStarter = path.indexOf(':');
+        const prefix = path.substr(0, pathParamStarter);
+
+        const regexVar = compiler.reserveVariable('regex', new RegExp('^' + parsedRoute.regex + '$'));
+
+        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 {
+                        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(v => {
+                return `_method === '${v.toUpperCase()}'`;
+            }).join(' || ') + ') && ';
+        }
+
+        const routeConfigVar = compiler.reserveVariable('routeConfigVar', routeConfig);
+        return `
+            //=> ${routeConfig.httpMethods.join(',')} ${path}
+            if (${methodCheck}${matcher}) {
+                return {routeConfig: ${routeConfigVar}, parameters: ${parametersLoader}, uploadedFiles: uploadedFiles, middlewares: ${middlewares}};
+            }
+        `;
+    }
+
+    protected getRouteUrlResolveCode(compiler: CompilerContext, routeConfig: RouteConfig): string {
+        const parsedRoute = parseRouteControllerAction(routeConfig);
+
+        let url = routeConfig.getFullPath();
+        url = url.replace(/:(\w+)/g, (a, name) => {
+            return `\${parameters.${name}}`;
+        });
+
+        const modify: string[] = [];
+        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 === 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}))`);
+                    }
+                } else {
+                    modify.push(`parameters.${parameter.getName()} !== undefined && query.push(${JSON.stringify(dotToUrlPath(queryPath))} + '=' + encodeURIComponent(parameters.${parameter.getName()}))`);
+
+                }
+            }
+        }
+
+        return `
+            case ${JSON.stringify(routeConfig.name)}: {
+                let url = \`${url}\`;
+                let query = [];
+                ${modify.join('\n')}
+                return url + (query.length ? '?'+query.join('&') : '');
+            }
+        `;
+    }
+
+    public addRoute(routeConfig: RouteConfig) {
+        this.registry.addRoute(routeConfig);
+    }
+
+    public addRouteForController(controller: ClassType, module: InjectorModule<any>) {
+        this.registry.addRouteForController(controller, module);
+    }
+
+    protected build(): (request: HttpRequest) => ResolvedController | undefined {
+        this.buildId = this.registry.getBuildId();
+        const compiler = new CompilerContext;
+        compiler.context.set('ValidationError', ValidationError);
+        compiler.context.set('qs', qs);
+
+        const code: string[] = [];
+
+        for (const route of this.getRoutes()) {
+            code.push(this.getRouteCode(compiler, route));
+        }
+
+        return compiler.build(`
+            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 ? {} : qs.parse(_url.substr(_qPosition + 1));
+            ${code.join('\n')}
+        `, 'request') as any;
+    }
+
+    protected buildUrlResolver(): any {
+        const compiler = new CompilerContext;
+        const code: string[] = [];
+
+        for (const route of this.getRoutes()) {
+            code.push(this.getRouteUrlResolveCode(compiler, route));
+        }
+
+        return compiler.build(`
+        switch (name) {
+            ${code.join('\n')}
+        }
+        throw new Error('No route for name ' + name + ' found');
+        `, 'name', 'parameters') as any;
+    }
+
+    public resolveUrl(routeName: string, parameters: { [name: string]: any } = {}): string {
+        if (!this.resolveFn) {
+            this.resolveFn = this.buildUrlResolver();
+        }
+
+        return this.resolveFn!(routeName, parameters);
+    }
+
+    public resolveRequest(request: HttpRequest): ResolvedController | undefined {
+        if (!this.fn || this.buildId !== this.registry.getBuildId()) {
+            this.fn = this.build();
+        }
+
+        return this.fn(request);
+    }
+
+    public resolve(method: string, url: string): ResolvedController | undefined {
+        method = method.toUpperCase();
+        return this.resolveRequest({ url, method } as any);
+    }
+}