@deepkit/http 1.0.1-alpha.59 → 1.0.1-alpha.63

package/dist/cjs/src/router.js

@@ -5,14 +5,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Router = exports.dotToUrlPath = exports.parseRouteControllerAction = exports.BodyValidation = exports.RouteConfig = exports.UploadedFile = void 0;
+exports.Router = exports.__ΩRouteParameterResolverContext = exports.__ΩRouteParameterResolver = exports.dotToUrlPath = exports.parseRouteControllerAction = exports.RouteConfig = exports.__ΩRouteControllerAction = exports.UploadedFile = exports.__ΩRouteParameterResolverForInjector = void 0;
+var { __ΩSerializationOptions } = require('@deepkit/type');
+var { __ΩClassType } = require('@deepkit/core');
+var { __ΩMiddlewareRegistryEntry } = require('@deepkit/app');
+var { __ΩLoggerInterface } = require('@deepkit/logger');
+var { __ΩHttpMiddlewareFn } = require('./middleware');
+var { __ΩHttpRequestQuery } = require('./model');
+var { __ΩHttpRequestResolvedParameters } = require('./model');
 /*
  * Deepkit Framework
  * Copyright (C) 2021 Deepkit UG, Marc J. Schmidt
@@ -22,46 +26,33 @@ exports.Router = exports.dotToUrlPath = exports.parseRouteControllerAction = exp
  *
  * You should have received a copy of the MIT License along with this program.
  */
-require("reflect-metadata");
 const core_1 = require("@deepkit/core");
 const type_1 = require("@deepkit/type");
 // @ts-ignore
 const formidable_1 = __importDefault(require("formidable"));
 const decorator_1 = require("./decorator");
+const model_1 = require("./model");
 const injector_1 = require("@deepkit/injector");
 const logger_1 = require("@deepkit/logger");
 const controllers_1 = require("./controllers");
 const app_1 = require("@deepkit/app");
 const middleware_1 = require("./middleware");
+var __ΩRouteParameterResolverForInjector = [() => injector_1.InjectorContext, 'injector', '', 'PP7!2"P"F"F`J/#'];
+exports.__ΩRouteParameterResolverForInjector = __ΩRouteParameterResolverForInjector;
+var __ΩResolvedController = [() => __ΩRouteParameterResolverForInjector, 'parameters', () => RouteConfig, 'routeConfig', () => UploadedFile, 'uploadedFiles', () => injector_1.InjectorContext, 'injector', () => __ΩHttpMiddlewareFn, 'fn', 'timeout', '', 'middlewares', 'Pn!4"P7#4$P&P7%LM4&PP7\'2(Pn)4*\'4+MF/,4-8M'];
 let UploadedFile = class UploadedFile {
 };
-__decorate([
-    type_1.t.required,
-    __metadata("design:type", Number)
-], UploadedFile.prototype, "size", void 0);
-__decorate([
-    type_1.t.required,
-    __metadata("design:type", String)
-], UploadedFile.prototype, "path", void 0);
-__decorate([
-    type_1.t.string.required.nullable,
-    __metadata("design:type", Object)
-], UploadedFile.prototype, "name", void 0);
-__decorate([
-    type_1.t.string.required.nullable,
-    __metadata("design:type", Object)
-], UploadedFile.prototype, "type", void 0);
-__decorate([
-    type_1.t.date.required.nullable,
-    __metadata("design:type", Object)
-], UploadedFile.prototype, "lastModifiedDate", void 0);
+UploadedFile.__type = ['size', 'path', 'name', 'type', 'lastModifiedDate', '\'3!&3"P&,J3#P&,J3$PT,J3%5'];
 UploadedFile = __decorate([
     type_1.entity.name('@deepkit/UploadedFile')
 ], UploadedFile);
 exports.UploadedFile = UploadedFile;
+var __ΩRouteControllerAction = [() => injector_1.InjectorModule, 'module', () => __ΩClassType, 'controller', 'methodName', 'PP"7!4"8n#4$&4%M'];
+exports.__ΩRouteControllerAction = __ΩRouteControllerAction;
 function getRouterControllerActionName(action) {
-    return `${core_1.getClassName(action.controller)}.${action.methodName}`;
+    return `${(0, core_1.getClassName)(action.controller)}.${action.methodName}`;
 }
+getRouterControllerActionName.__type = [() => __ΩRouteControllerAction, 'action', 'getRouterControllerActionName', 'Pn!2"&/#'];
 class RouteConfig {
     constructor(name, httpMethods, path, action, internal = false) {
         this.name = name;
@@ -70,7 +61,6 @@ class RouteConfig {
         this.action = action;
         this.internal = internal;
         this.baseUrl = '';
-        this.parameterRegularExpressions = {};
         this.responses = [];
         this.description = '';
         this.groups = [];
@@ -82,7 +72,6 @@ class RouteConfig {
          * An arbitrary data container the user can use to store app specific settings/values.
          */
         this.data = new Map();
-        this.parameters = {};
     }
     getSchemaForResponse(statusCode) {
         if (!this.responses.length)
@@ -94,47 +83,22 @@ class RouteConfig {
         return;
     }
     getFullPath() {
-        let path = this.baseUrl ? core_1.urlJoin(this.baseUrl, this.path) : this.path;
+        let path = this.baseUrl ? (0, core_1.urlJoin)(this.baseUrl, this.path) : this.path;
         if (!path.startsWith('/'))
             path = '/' + path;
         return path;
     }
 }
 exports.RouteConfig = RouteConfig;
-/**
- * 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.
- */
-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(', ');
-    }
-}
-exports.BodyValidation = BodyValidation;
+RouteConfig.__type = ['baseUrl', function () { return ''; }, 'statusCode', 'description', 'type', 'responses', function () { return []; }, function () { return ''; }, 'groups', function () { return []; }, 'category', function () { return ''; }, 'returnType', () => __ΩSerializationOptions, 'serializationOptions', () => type_1.Serializer, 'serializer', () => injector_1.InjectorModule, 'module', () => __ΩClassType, 'resolverForToken', function () { return new Map(); }, () => middleware_1.HttpMiddlewareConfig, 'config', () => injector_1.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'];
 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 ParsedRouteParameter(property);
         this.parameters.push(parameter);
         return parameter;
     }
@@ -149,71 +113,99 @@ class ParsedRoute {
         throw new Error(`No route parameter with name ${name} defined.`);
     }
 }
+ParsedRoute.__type = ['regex', 'pathParameterNames', function () { return {}; }, () => ParsedRouteParameter, 'parameters', function () { return []; }, () => RouteConfig, 'routeConfig', 'constructor', () => type_1.ReflectionParameter, 'property', () => ParsedRouteParameter, 'addParameter', () => ParsedRouteParameter, 'getParameters', 'name', () => ParsedRouteParameter, 'getParameter', '&3!8P&\'LM3">#P7$F3%<>&PP7\'2(:"0)PP7*2+P7,0-PP7.F0/P&20P71025'];
 class ParsedRouteParameter {
-    constructor(property, config) {
-        this.property = property;
-        this.config = config;
+    constructor(parameter) {
+        this.parameter = parameter;
     }
     get body() {
-        return this.config ? this.config.type === 'body' : false;
+        return type_1.metaAnnotation.getForName(this.parameter.type, 'httpBody') !== undefined;
+    }
+    get bodyValidation() {
+        return type_1.metaAnnotation.getForName(this.parameter.type, 'httpBodyValidation') !== undefined;
+    }
+    getType() {
+        if (this.bodyValidation) {
+            (0, type_1.assertType)(this.parameter.type, 20 /* class */);
+            const valueType = (0, type_1.findMember)('value', this.parameter.type);
+            if (!valueType || valueType.kind !== 15 /* property */)
+                throw new Error(`No property value found at ${(0, type_1.stringifyType)(this.parameter.type)}`);
+            return valueType.type;
+        }
+        return this.parameter.type;
     }
     get query() {
-        return this.config ? this.config.type === 'query' : false;
+        return type_1.metaAnnotation.getForName(this.parameter.type, 'httpQuery') !== undefined;
     }
     get queries() {
-        return this.config ? this.config.type === 'queries' : false;
+        return type_1.metaAnnotation.getForName(this.parameter.type, 'httpQueries') !== undefined;
     }
     get typePath() {
-        return this.config ? this.config.typePath : undefined;
+        const typeOptions = type_1.metaAnnotation.getForName(this.parameter.type, 'httpQueries') || type_1.metaAnnotation.getForName(this.parameter.type, 'httpQuery');
+        if (!typeOptions)
+            return;
+        const options = (0, type_1.typeToObject)(typeOptions[0]);
+        if ((0, core_1.isObject)(options))
+            return options.name;
+        return;
     }
     getName() {
-        return this.property.name;
+        return this.parameter.name;
     }
     isPartOfPath() {
         return this.regexPosition !== undefined;
     }
 }
+ParsedRouteParameter.__type = ['regexPosition', () => type_1.ReflectionParameter, 'parameter', 'constructor', 'getType', 'getName', 'isPartOfPath', '\'3!8PP7"2#:"0$!!P"0%!!!P"0&P)0\'5'];
 function parseRoutePathToRegex(routeConfig) {
     const parameterNames = {};
     let path = routeConfig.getFullPath();
+    const method = type_1.ReflectionClass.from(routeConfig.action.controller).getMethod(routeConfig.action.methodName);
     let argumentIndex = 0;
-    path = path.replace(/:(\w+)/g, (a, name) => {
+    path = path.replace(/:(\w+)/g, Object.assign((a, name) => {
         parameterNames[name] = argumentIndex;
         argumentIndex++;
-        return routeConfig.parameterRegularExpressions[name] ? '(' + routeConfig.parameterRegularExpressions[name] + ')' : String.raw `([^/]+)`;
-    });
+        const parameter = method.getParameterOrUndefined(name);
+        if (parameter) {
+            const regExp = (0, model_1.getRegExp)(parameter.type);
+            if (regExp)
+                return '(' + regExp + ')';
+        }
+        return String.raw `([^/]+)`;
+    }, { __type: ['a', 'name', '', 'P"2!"2""/#'] }));
     return { regex: path, parameterNames };
 }
+parseRoutePathToRegex.__type = [() => RouteConfig, 'routeConfig', 'regex', 'parameterNames', 'parseRoutePathToRegex', 'PP7!2"P&4#P&\'LM4$M/%'];
 function parseRouteControllerAction(routeConfig) {
-    const schema = type_1.getClassSchema(routeConfig.action.controller);
+    const schema = type_1.ReflectionClass.from(routeConfig.action.controller);
     const parsedRoute = new ParsedRoute(routeConfig);
-    const methodArgumentProperties = schema.getMethodProperties(routeConfig.action.methodName);
+    const methodArgumentProperties = schema.getMethodParameters(routeConfig.action.methodName);
     const parsedPath = parseRoutePathToRegex(routeConfig);
     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;
-        }
+        const parsedParameter = parsedRoute.addParameter(property);
         parsedParameter.regexPosition = parsedPath.parameterNames[property.name];
     }
     return parsedRoute;
 }
 exports.parseRouteControllerAction = parseRouteControllerAction;
+parseRouteControllerAction.__type = [() => RouteConfig, 'routeConfig', () => ParsedRoute, 'parseRouteControllerAction', 'PP7!2"P7#/$'];
 function dotToUrlPath(dotPath) {
     if (-1 === dotPath.indexOf('.'))
         return dotPath;
     return dotPath.replace(/\./g, '][').replace('][', '[') + ']';
 }
 exports.dotToUrlPath = dotToUrlPath;
+dotToUrlPath.__type = ['dotPath', 'dotToUrlPath', 'P&2!&/"'];
+var __ΩRouteParameterResolver = [() => __ΩRouteParameterResolverContext, 'context', 'resolve', 'PPn!2"P""`J1#M'];
+exports.__ΩRouteParameterResolver = __ΩRouteParameterResolver;
+var __ΩRouteParameterResolverContext = [() => __ΩClassType, 'token', () => RouteConfig, 'route', () => model_1.HttpRequest, 'request', 'name', 'value', () => __ΩHttpRequestQuery, 'query', () => __ΩHttpRequestResolvedParameters, 'parameters', 'PPn!&+"J4"P7#4$P7%4&"4\'"4(n)4*n+4,M'];
+exports.__ΩRouteParameterResolverContext = __ΩRouteParameterResolverContext;
 function filterMiddlewaresForRoute(middlewareRawConfigs, routeConfig, fullPath) {
     const middlewares = middlewareRawConfigs.slice(0);
     middlewares.push(...routeConfig.middlewares);
-    const middlewareConfigs = middlewares.filter((v) => {
+    const middlewareConfigs = middlewares.filter(Object.assign((v) => {
         var _a;
         if (!(v.config instanceof middleware_1.HttpMiddlewareConfig))
             return false;
@@ -276,13 +268,14 @@ function filterMiddlewaresForRoute(middlewareRawConfigs, routeConfig, fullPath)
             }
         }
         return true;
-    });
-    middlewareConfigs.sort((a, b) => {
+    }, { __type: ['v', '', 'P"2!"/"'] }));
+    middlewareConfigs.sort(Object.assign((a, b) => {
         return a.config.order - b.config.order;
-    });
+    }, { __type: ['a', 'b', '', 'P"2!"2""/#'] }));
     return middlewareConfigs;
 }
-let Router = class Router {
+filterMiddlewaresForRoute.__type = [() => __ΩMiddlewareRegistryEntry, 'middlewareRawConfigs', () => RouteConfig, 'routeConfig', 'fullPath', () => middleware_1.HttpMiddlewareConfig, 'config', () => injector_1.InjectorModule, 'module', 'filterMiddlewaresForRoute', 'Pn!F2"P7#2$&2%PP7&4\'P"7(4)MF/*'];
+class Router {
     constructor(controllers, logger, tagRegistry, middlewareRegistry = new app_1.MiddlewareRegistry) {
         this.logger = logger;
         this.middlewareRegistry = middlewareRegistry;
@@ -292,16 +285,16 @@ let Router = class Router {
         }
     }
     parseBody(req, files) {
-        const form = formidable_1.default({
+        const form = (0, formidable_1.default)({
             multiples: true,
             hash: 'sha1',
             enabledPlugins: ['octetstream', 'querystring', 'json'],
         });
-        return core_1.asyncOperation((resolve, reject) => {
+        return (0, core_1.asyncOperation)(Object.assign((resolve, reject) => {
             if (req.body) {
                 return resolve(req.body);
             }
-            form.parse(req, (err, fields, files) => {
+            form.parse(req, Object.assign((err, fields, files) => {
                 if (err) {
                     reject(err);
                 }
@@ -309,16 +302,16 @@ let Router = class Router {
                     const body = req.body = { ...fields, ...files };
                     resolve(body);
                 }
-            });
-        });
+            }, { __type: ['err', 'fields', 'files', '', 'P"2!"2""2#"/$'] }));
+        }, { __type: ['resolve', 'reject', '', 'P"2!"2""/#'] }));
     }
     getRoutes() {
         return this.routes;
     }
-    static forControllers(controllers, tagRegistry = new injector_1.TagRegistry(), middlewareRegistry = new app_1.MiddlewareRegistry(), module = new app_1.AppModule({})) {
-        return new this(new controllers_1.HttpControllers(controllers.map(v => {
-            return core_1.isClass(v) ? { controller: v, module } : v;
-        })), new logger_1.Logger([], []), tagRegistry, middlewareRegistry);
+    static forControllers(controllers, tagRegistry = new injector_1.TagRegistry(), middlewareRegistry = new app_1.MiddlewareRegistry(), module = new injector_1.InjectorModule()) {
+        return new this(new controllers_1.HttpControllers(controllers.map(Object.assign(v => {
+            return (0, core_1.isClass)(v) ? { controller: v, module } : v;
+        }, { __type: ['v', '', 'P"2!"/"'] }))), new logger_1.Logger([], []), tagRegistry, middlewareRegistry);
     }
     getRouteCode(compiler, routeConfig) {
         const routeConfigVar = compiler.reserveVariable('routeConfigVar', routeConfig);
@@ -329,7 +322,7 @@ let Router = class Router {
         const setParameters = [];
         const parameterNames = [];
         const parameterValidator = [];
-        let bodyValidationErrorHandling = `if (bodyErrors.length) throw ValidationFailed.from(bodyErrors);`;
+        let bodyValidationErrorHandling = `if (bodyErrors.length) throw ValidationError.from(bodyErrors);`;
         let enableParseBody = false;
         const hasParameters = parsedRoute.getParameters().length > 0;
         let requiresAsyncParameters = false;
@@ -337,49 +330,51 @@ let Router = class Router {
         const fullPath = routeConfig.getFullPath();
         const middlewareConfigs = filterMiddlewaresForRoute(this.middlewareRegistry.configs, routeConfig, fullPath);
         for (const parameter of parsedRoute.getParameters()) {
-            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 validatorVar = compiler.reserveVariable('argumentValidator', type_1.jitValidateProperty(parameter.property));
-                const converterVar = compiler.reserveVariable('argumentConverter', type_1.getPropertyXtoClassFunction(parameter.property, type_1.jsonSerializer));
+            if (parameter.body || parameter.bodyValidation) {
+                const type = parameter.getType();
+                const validatorVar = compiler.reserveVariable('argumentValidator', (0, type_1.getValidatorFunction)(undefined, type));
+                const converterVar = compiler.reserveVariable('argumentConverter', (0, type_1.getSerializeFunction)(type, type_1.serializer.deserializeRegistry));
                 enableParseBody = true;
-                setParameters.push(`parameters.${parameter.property.name} = ${converterVar}(bodyFields);`);
-                parameterValidator.push(`${validatorVar}(parameters.${parameter.property.name}, ${JSON.stringify(parameter.typePath || '')}, bodyErrors);`);
-                parameterNames.push(`parameters.${parameter.property.name}`);
+                setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(bodyFields, {loosely: true});`);
+                parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: bodyErrors});`);
+                if (parameter.bodyValidation) {
+                    compiler.context.set('BodyValidation', model_1.ValidatedBody);
+                    compiler.context.set('BodyValidationError', model_1.BodyValidationError);
+                    parameterNames.push(`new BodyValidation(new BodyValidationError(bodyErrors), bodyErrors.length === 0 ? parameters.${parameter.parameter.name} : undefined)`);
+                    bodyValidationErrorHandling = '';
+                }
+                else {
+                    parameterNames.push(`parameters.${parameter.parameter.name}`);
+                }
             }
             else if (parameter.query || parameter.queries) {
-                const converted = parameter.property.type === 'any' ? (v) => v : type_1.getPropertyXtoClassFunction(parameter.property, type_1.jsonSerializer);
-                const validator = parameter.property.type === 'any' ? (v) => undefined : type_1.jitValidateProperty(parameter.property);
+                const converted = (0, type_1.getSerializeFunction)(parameter.parameter.parameter, type_1.serializer.deserializeRegistry, undefined, parameter.getName());
+                const validator = (0, type_1.getValidatorFunction)(undefined, parameter.parameter.parameter);
                 const converterVar = compiler.reserveVariable('argumentConverter', converted);
                 const validatorVar = compiler.reserveVariable('argumentValidator', validator);
-                const queryPath = parameter.typePath === undefined ? parameter.property.name : parameter.typePath;
+                const queryPath = parameter.typePath === undefined && parameter.query ? parameter.parameter.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}(parameters.${parameter.property.name}, ${JSON.stringify(parameter.typePath)}, validationErrors);`);
+                setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(${queryAccessor}, {loosely: true});`);
+                parameterNames.push(`parameters.${parameter.parameter.name}`);
+                parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: validationErrors}, ${JSON.stringify(parameter.typePath || parameter.getName())});`);
             }
             else {
-                parameterNames.push(`parameters.${parameter.property.name}`);
+                parameterNames.push(`parameters.${parameter.parameter.name}`);
                 if (parameter.isPartOfPath()) {
-                    if (parameter.property.type !== 'class') {
-                        const converted = parameter.property.type === 'any' ? (v) => v : type_1.getPropertyXtoClassFunction(parameter.property, type_1.jsonSerializer);
+                    if (parameter.parameter.type.kind !== 20 /* class */) {
+                        const converted = (0, type_1.getSerializeFunction)(parameter.parameter.parameter, type_1.serializer.deserializeRegistry, undefined, parameter.getName());
                         const converterVar = compiler.reserveVariable('argumentConverter', converted);
-                        setParameters.push(`parameters.${parameter.property.name} = ${converterVar}(_match[${1 + (parameter.regexPosition || 0)}]);`);
-                        const validator = parameter.property.type === 'any' ? (v) => undefined : type_1.jitValidateProperty(parameter.property);
+                        setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(_match[${1 + (parameter.regexPosition || 0)}], {loosely: true});`);
+                        const validator = (0, type_1.getValidatorFunction)(undefined, parameter.parameter.parameter);
                         const validatorVar = compiler.reserveVariable('argumentValidator', validator);
-                        parameterValidator.push(`${validatorVar}(parameters.${parameter.property.name}, ${JSON.stringify(parameter.getName())}, validationErrors);`);
+                        parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: validationErrors}, ${JSON.stringify(parameter.getName())});`);
                     }
                     else {
-                        setParameters.push(`parameters.${parameter.property.name} = _match[${1 + (parameter.regexPosition || 0)}];`);
+                        setParameters.push(`parameters.${parameter.parameter.name} = _match[${1 + (parameter.regexPosition || 0)}];`);
                     }
                 }
-                const injectorOptions = parameter.property.data['deepkit/inject'];
-                const injectorToken = injectorOptions && injectorOptions.token ? injectorOptions.token : (parameter.property.type === 'class' ? parameter.property.getResolvedClassType() : undefined);
+                const injectorToken = parameter.parameter.type.kind === 20 /* class */ ? parameter.parameter.type.classType : undefined;
                 const injectorTokenVar = compiler.reserveVariable('classType', injectorToken);
                 const parameterResolverFoundVar = compiler.reserveVariable('parameterResolverFound', false);
                 setParameters.push(`${parameterResolverFoundVar} = false;`);
@@ -397,31 +392,25 @@ let Router = class Router {
                     requiresAsyncParameters = true;
                     const instance = compiler.reserveVariable('resolverInstance');
                     setParameters.push(`
-                    //resolver ${core_1.getClassName(resolver)} for ${parameter.getName()}
+                    //resolver ${(0, core_1.getClassName)(resolver)} for ${parameter.getName()}
                     ${instance} = ${injector}.get(${resolverProvideTokenVar}${moduleVar});
                     if (!${parameterResolverFoundVar}) {
                         ${parameterResolverFoundVar} = true;
-                        parameters.${parameter.property.name} = await ${instance}.resolve({
+                        parameters.${parameter.parameter.name} = await ${instance}.resolve({
                             token: ${injectorTokenVar},
                             routeConfig: ${routeConfigVar},
                             request: request,
-                            name: ${JSON.stringify(parameter.property.name)},
-                            value: parameters.${parameter.property.name},
+                            name: ${JSON.stringify(parameter.parameter.name)},
+                            value: parameters.${parameter.parameter.name},
                             query: _query,
                             parameters: parameters
                         });
                     }`);
                 }
-                else {
-                    if (!parameter.isPartOfPath() && parameter.property.type !== 'class' && (!injectorOptions || !injectorOptions.token)) {
-                        throw new Error(`Route parameter '${parameter.property.name}' of ${getRouterControllerActionName(routeConfig.action)} is not a ClassType nor is a @inject(T) set. It can not be requested from the DI container like that.` +
-                            `If its a query parameter use '@http.query() ${parameter.property.name}' or if its a body '@http.body() ${parameter.property.name}'.`);
-                    }
-                }
                 if (!parameter.isPartOfPath()) {
-                    let injectorGet = `parameters.${parameter.property.name} = ${injector}.get(${injectorTokenVar});`;
-                    if (injectorOptions && injectorOptions.optional) {
-                        injectorGet = `try {parameters.${parameter.property.name} = ${injector}.get(${injectorTokenVar}); } catch (e) {}`;
+                    let injectorGet = `parameters.${parameter.parameter.name} = ${injector}.get(${injectorTokenVar});`;
+                    if (parameter.parameter.isOptional()) {
+                        injectorGet = `try {parameters.${parameter.parameter.name} = ${injector}.get(${injectorTokenVar}); } catch (e) {}`;
                     }
                     setParameters.push(`if (!${parameterResolverFoundVar}) ${injectorGet}`);
                 }
@@ -444,7 +433,7 @@ let Router = class Router {
             for (const middlewareConfig of middlewareConfigs) {
                 const moduleVar = middlewareConfig.module ? ', ' + compiler.reserveVariable('module', middlewareConfig.module) : '';
                 for (const middleware of middlewareConfig.config.middlewares) {
-                    if (core_1.isClass(middleware)) {
+                    if ((0, core_1.isClass)(middleware)) {
                         const classVar = compiler.reserveVariable('middlewareClassType', middleware);
                         middlewareItems.push(`{fn: function() {return _injector.get(${classVar}${moduleVar}).execute(...arguments) }, timeout: ${middlewareConfig.config.timeout}}`);
                     }
@@ -470,15 +459,15 @@ let Router = class Router {
                 ${setParameters.join('\n')}
                 ${parameterValidator.join('\n')}
                 ${bodyValidationErrorHandling}
-                if (validationErrors.length) throw ValidationFailed.from(validationErrors);
+                if (validationErrors.length) throw new ValidationError(validationErrors);
                 return [${parameterNames.join(',')}];
             }`;
         }
         let methodCheck = '';
         if (routeConfig.httpMethods.length) {
-            methodCheck = '(' + routeConfig.httpMethods.map(v => {
+            methodCheck = '(' + routeConfig.httpMethods.map(Object.assign(v => {
                 return `_method === '${v.toUpperCase()}'`;
-            }).join(' || ') + ') && ';
+            }, { __type: ['v', '', 'P"2!"/"'] })).join(' || ') + ') && ';
         }
         return `
             //=> ${routeConfig.httpMethods.join(',')} ${path}
@@ -490,15 +479,15 @@ let Router = class Router {
     getRouteUrlResolveCode(compiler, routeConfig) {
         const parsedRoute = parseRouteControllerAction(routeConfig);
         let url = routeConfig.getFullPath();
-        url = url.replace(/:(\w+)/g, (a, name) => {
+        url = url.replace(/:(\w+)/g, Object.assign((a, name) => {
             return `\${parameters.${name}}`;
-        });
+        }, { __type: ['a', 'name', '', 'P"2!"2""/#'] }));
         const modify = [];
         for (const parameter of parsedRoute.getParameters()) {
             if (parameter.query || parameter.queries) {
-                const queryPath = parameter.typePath === undefined ? parameter.property.name : parameter.typePath;
-                if (parameter.property.type === 'class') {
-                    for (const property of parameter.property.getResolvedClassSchema().getProperties()) {
+                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 */) {
+                    for (const property of type_1.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}))`);
@@ -525,8 +514,8 @@ let Router = class Router {
     addRouteForController(controller, module) {
         const data = decorator_1.httpClass._fetch(controller);
         if (!data)
-            throw new Error(`Http controller class ${core_1.getClassName(controller)} has no @http.controller decorator.`);
-        const schema = type_1.getClassSchema(controller);
+            throw new Error(`Http controller class ${(0, core_1.getClassName)(controller)} has no @http.controller decorator.`);
+        const schema = type_1.ReflectionClass.from(controller);
         for (const action of data.getActions()) {
             const routeConfig = new RouteConfig(action.name, action.httpMethods, action.path, {
                 controller,
@@ -534,19 +523,18 @@ let Router = class Router {
                 methodName: action.methodName
             });
             routeConfig.module = module;
-            routeConfig.parameterRegularExpressions = action.parameterRegularExpressions;
             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(v => {
+            routeConfig.middlewares = data.middlewares.map(Object.assign(v => {
                 return { config: v(), module };
-            });
-            routeConfig.middlewares.push(...action.middlewares.map(v => {
+            }, { __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);
@@ -555,18 +543,17 @@ let Router = class Router {
             routeConfig.resolverForParameterName = new Map(data.resolverForParameterName);
             for (const item of action.resolverForParameterName)
                 routeConfig.resolverForParameterName.set(...item);
-            routeConfig.parameters = { ...action.parameters };
             routeConfig.serializationOptions = action.serializationOptions;
             routeConfig.serializer = action.serializer;
             routeConfig.serializer = action.serializer;
             if (schema.hasMethod(action.methodName))
-                routeConfig.returnSchema = schema.getMethod(action.methodName);
+                routeConfig.returnType = schema.getMethod(action.methodName).getReturnType();
             this.addRoute(routeConfig);
         }
     }
     build() {
         const compiler = new core_1.CompilerContext;
-        compiler.context.set('ValidationFailed', type_1.ValidationFailed);
+        compiler.context.set('ValidationError', type_1.ValidationError);
         compiler.context.set('qs', require('qs'));
         const code = [];
         for (const route of this.routes) {
@@ -612,13 +599,7 @@ let Router = class Router {
         method = method.toUpperCase();
         return this.resolveRequest({ url, method });
     }
-};
-Router = __decorate([
-    injector_1.injectable,
-    __metadata("design:paramtypes", [controllers_1.HttpControllers,
-        logger_1.Logger,
-        injector_1.TagRegistry,
-        app_1.MiddlewareRegistry])
-], Router);
+}
 exports.Router = Router;
+Router.__type = [() => model_1.HttpRequest, 'request', () => __ΩResolvedController, '', 'fn', 'name', 'parameters', 'resolveFn', () => RouteConfig, 'routes', function () { return []; }, () => model_1.HttpRequest, 'req', () => UploadedFile, 'files', 'parseBody', () => controllers_1.HttpControllers, 'controllers', () => __ΩLoggerInterface, 'logger', () => injector_1.TagRegistry, 'tagRegistry', () => app_1.MiddlewareRegistry, 'middlewareRegistry', () => new app_1.MiddlewareRegistry, 'constructor', () => RouteConfig, 'getRoutes', () => __ΩClassType, () => injector_1.InjectorModule, 'module', () => __ΩClassType, 'controller', () => injector_1.TagRegistry, () => new injector_1.TagRegistry(), () => app_1.MiddlewareRegistry, () => new app_1.MiddlewareRegistry(), () => injector_1.InjectorModule, () => new injector_1.InjectorModule(), () => Router, 'forControllers', () => core_1.CompilerContext, 'compiler', () => RouteConfig, 'routeConfig', 'getRouteCode', () => core_1.CompilerContext, () => RouteConfig, 'getRouteUrlResolveCode', () => RouteConfig, 'addRoute', () => __ΩClassType, () => injector_1.InjectorModule, 'addRouteForController', () => model_1.HttpRequest, () => __ΩResolvedController, 'build', 'buildUrlResolver', 'routeName', () => ({}), 'resolveUrl', () => model_1.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'];
 //# sourceMappingURL=router.js.map