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

package/dist/cjs/src/module.d.ts

@@ -1,32 +1,14 @@
-import { AppModule } from '@deepkit/app';
-export declare const HttpModule: AppModule<{
-    name: string;
-    config: import("@deepkit/app").AppModuleConfig<{
-        debug: import("@deepkit/type").FieldDecoratorResult<boolean>;
-    }>;
-    workflows: (import("@deepkit/workflow").WorkflowDefinition<{
-        start: typeof import("@deepkit/workflow").WorkflowEvent;
-        request: typeof import("./http").HttpWorkflowEvent;
-        route: typeof import("./http").HttpRouteEvent;
-        routeNotFound: typeof import("./http").HttpWorkflowEvent;
-        auth: typeof import("./http").HttpAuthEvent;
-        resolveParameters: typeof import("./http").HttpResolveParametersEvent;
-        accessDenied: typeof import("./http").HttpAccessDeniedEvent;
-        controller: typeof import("./http").HttpControllerEvent;
-        controllerError: typeof import("./http").HttpControllerErrorEvent;
-        parametersFailed: typeof import("./http").HttpControllerErrorEvent;
-        response: typeof import("./http").HttpResponseEvent;
-    }> & import("@deepkit/workflow").WorkflowDefinitionEvents<{
-        start: typeof import("@deepkit/workflow").WorkflowEvent;
-        request: typeof import("./http").HttpWorkflowEvent;
-        route: typeof import("./http").HttpRouteEvent;
-        routeNotFound: typeof import("./http").HttpWorkflowEvent;
-        auth: typeof import("./http").HttpAuthEvent;
-        resolveParameters: typeof import("./http").HttpResolveParametersEvent;
-        accessDenied: typeof import("./http").HttpAccessDeniedEvent;
-        controller: typeof import("./http").HttpControllerEvent;
-        controllerError: typeof import("./http").HttpControllerErrorEvent;
-        parametersFailed: typeof import("./http").HttpControllerErrorEvent;
-        response: typeof import("./http").HttpResponseEvent;
-    }>)[];
-}, "">;
+import { HttpConfig } from './module.config.js';
+import { AddedListener, AppModule, ControllerConfig } from '@deepkit/app';
+import { HttpControllers } from './controllers.js';
+import '@deepkit/type';
+import { EventToken } from '@deepkit/event';
+declare const HttpModule_base: import("@deepkit/app").AppModuleClass<HttpConfig>;
+export declare class HttpModule extends HttpModule_base {
+    protected httpControllers: HttpControllers;
+    process(): void;
+    protected patchEventsForHttpRequestAccess: EventToken<any>[];
+    processListener(module: AppModule<any>, listener: AddedListener): void;
+    processController(module: AppModule<any>, config: ControllerConfig): void;
+}
+export {};

package/dist/cjs/src/module.js

@@ -1,14 +1,129 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpModule = void 0;
-const http_1 = require("./http");
-const module_config_1 = require("./module.config");
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
+const http_js_1 = require("./http.js");
+const module_config_js_1 = require("./module.config.js");
 const app_1 = require("@deepkit/app");
-exports.HttpModule = new app_1.AppModule({
-    name: 'http',
-    config: module_config_1.config,
+const router_js_1 = require("./router.js");
+const kernel_js_1 = require("./kernel.js");
+const filter_js_1 = require("./filter.js");
+const controllers_js_1 = require("./controllers.js");
+const logger_1 = require("@deepkit/logger");
+const model_js_1 = require("./model.js");
+require("@deepkit/type");
+const decorator_js_1 = require("./decorator.js");
+const event_1 = require("@deepkit/event");
+const type_1 = require("@deepkit/type");
+const request_parser_js_1 = require("./request-parser.js");
+const injector_1 = require("@deepkit/injector");
+function parameterRequiresRequest(parameter) {
+    return Boolean(type_1.typeAnnotation.getType(parameter.type, 'httpQueries')
+        || type_1.typeAnnotation.getType(parameter.type, 'httpQuery')
+        || type_1.typeAnnotation.getType(parameter.type, 'httpBody')
+        || type_1.typeAnnotation.getType(parameter.type, 'httpRequestParser')
+        || type_1.typeAnnotation.getType(parameter.type, 'httpPath')
+        || type_1.typeAnnotation.getType(parameter.type, 'httpHeader'));
+}
+parameterRequiresRequest.__type = [() => type_1.ReflectionParameter, 'parameter', 'parameterRequiresRequest', 'PP7!2")/#'];
+class HttpModule extends (0, app_1.createModuleClass)({
+    config: module_config_js_1.HttpConfig,
+    providers: [
+        router_js_1.HttpRouter,
+        kernel_js_1.HttpKernel,
+        http_js_1.HttpResultFormatter,
+        router_js_1.HttpRouterRegistry,
+        filter_js_1.HttpRouterFilterResolver,
+        { provide: model_js_1.HttpResponse, scope: 'http' },
+        { provide: model_js_1.HttpRequest, scope: 'http' },
+        { provide: router_js_1.RouteConfig, useValue: undefined, scope: 'http' },
+        { provide: logger_1.Logger, useValue: new logger_1.Logger([new logger_1.ConsoleTransport()]) },
+    ],
+    listeners: [
+        http_js_1.HttpListener,
+    ],
     workflows: [
-        http_1.httpWorkflow
+        http_js_1.httpWorkflow
     ],
-}).forRoot();
+    exports: [
+        router_js_1.HttpRouter,
+        router_js_1.HttpRouterRegistry,
+        kernel_js_1.HttpKernel,
+        http_js_1.HttpResultFormatter,
+        filter_js_1.HttpRouterFilterResolver,
+        model_js_1.HttpResponse,
+        model_js_1.HttpRequest,
+        controllers_js_1.HttpControllers,
+        router_js_1.RouteConfig,
+        logger_1.Logger,
+    ]
+}) {
+    constructor() {
+        super(...arguments);
+        this.httpControllers = new controllers_js_1.HttpControllers;
+        this.patchEventsForHttpRequestAccess = [http_js_1.httpWorkflow.onRequest, http_js_1.httpWorkflow.onAuth, http_js_1.httpWorkflow.onController];
+    }
+    process() {
+        this.addProvider({ provide: controllers_js_1.HttpControllers, useValue: this.httpControllers });
+    }
+    processListener(module, listener) {
+        if (!this.patchEventsForHttpRequestAccess.includes(listener.eventToken))
+            return;
+        let requiresHttpRequest = false;
+        let needsAsync = false;
+        const params = listener.reflection.getParameters().slice(1);
+        for (const parameter of params) {
+            if (type_1.typeAnnotation.getType(parameter.type, 'httpBody'))
+                needsAsync = true;
+            if (parameterRequiresRequest(parameter))
+                requiresHttpRequest = true;
+        }
+        if (needsAsync) {
+            //not yet supported since we have to patch the listener to be async and redirect the call (as the DI container is sync).
+            throw new Error(`Listener ${(0, app_1.stringifyListener)(listener)} requires async HttpBody. This is not yet supported. You have to parse the request manually by injecting HttpRequest.`);
+        }
+        const parserCache = (Map.Ω = [[() => router_js_1.RouteConfig, 'P7!'], [() => Function, 'Pu!']], new Map());
+        for (let index = 0; index < params.length; index++) {
+            const parameter = params[index];
+            if (!parameterRequiresRequest(parameter))
+                continue;
+            //change the reflection type so that we create a unique injection token for that type.
+            const unique = Symbol('event.parameter:' + parameter.name);
+            const uniqueType = { kind: type_1.ReflectionKind.literal, literal: unique };
+            type_1.typeAnnotation.registerType(parameter.type, { name: 'inject', options: uniqueType });
+            let i = index;
+            this.addProvider({
+                provide: uniqueType, useFactory: __assignType((httpConfig, request, injector, config) => {
+                    let build = config && parserCache.get(config);
+                    if (!build) {
+                        const params = listener.reflection.getParameters().slice(1);
+                        build = (0, request_parser_js_1.buildRequestParser)(httpConfig.parser, params, config);
+                        if (config)
+                            parserCache.set(config, build);
+                    }
+                    const parser = build(request);
+                    const result = parser(injector);
+                    return result.arguments[i];
+                }, [() => module_config_js_1.HttpConfig, 'httpConfig', () => model_js_1.HttpRequest, 'request', () => injector_1.InjectorContext, 'injector', () => router_js_1.RouteConfig, 'config', '', 'PP7!2"P7#2$P7%2&P7\'2(8"/)']), scope: 'http'
+            });
+            this.addExport(uniqueType);
+        }
+    }
+    processController(module, config) {
+        const controller = config.controller;
+        if (!controller)
+            return;
+        const httpConfig = decorator_js_1.httpClass._fetch(controller);
+        if (!httpConfig)
+            return;
+        if (!module.isProvided(controller))
+            module.addProvider({ provide: controller, scope: 'http' });
+        this.httpControllers.add(controller, module);
+    }
+}
+exports.HttpModule = HttpModule;
+HttpModule.__type = [() => (0, app_1.createModuleClass)({ config: module_config_js_1.HttpConfig, providers: [router_js_1.HttpRouter, kernel_js_1.HttpKernel, http_js_1.HttpResultFormatter, router_js_1.HttpRouterRegistry, filter_js_1.HttpRouterFilterResolver, { provide: model_js_1.HttpResponse, scope: "http" }, { provide: model_js_1.HttpRequest, scope: "http" }, { provide: router_js_1.RouteConfig, useValue: undefined, scope: "http" }, { provide: logger_1.Logger, useValue: new logger_1.Logger([new logger_1.ConsoleTransport()]) }], listeners: [http_js_1.HttpListener], workflows: [http_js_1.httpWorkflow], exports: [router_js_1.HttpRouter, router_js_1.HttpRouterRegistry, kernel_js_1.HttpKernel, http_js_1.HttpResultFormatter, filter_js_1.HttpRouterFilterResolver, model_js_1.HttpResponse, model_js_1.HttpRequest, controllers_js_1.HttpControllers, router_js_1.RouteConfig, logger_1.Logger] }), 'httpControllers', function () { return new controllers_js_1.HttpControllers; }, 'process', () => event_1.EventToken, 'patchEventsForHttpRequestAccess', function () { return [http_js_1.httpWorkflow.onRequest, http_js_1.httpWorkflow.onAuth, http_js_1.httpWorkflow.onController]; }, () => app_1.AppModule, 'module', 'AddedListener', 'listener', 'processListener', () => app_1.AppModule, 'ControllerConfig', 'config', 'processController', 'HttpModule', 'P7!!3"<>#P"0$P"7%F3&<>\'PP"7(2)"w*2+"0,PP"7-2)"w.2/"005w1'];
 //# sourceMappingURL=module.js.map

package/dist/cjs/src/module.js.map

@@ -1 +1 @@
-{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../src/module.ts"],"names":[],"mappings":";;;AAAA,iCAAsC;AACtC,mDAAyC;AACzC,sCAAyC;AAE5B,QAAA,UAAU,GAAG,IAAI,eAAS,CAAC;IACpC,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,sBAAM;IACd,SAAS,EAAE;QACP,mBAAY;KACf;CACJ,CAAC,CAAC,OAAO,EAAE,CAAC"}
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../src/module.ts"],"names":[],"mappings":";;;;;;;AAAA,uCAA4E;AAC5E,yDAAgD;AAChD,sCAAgH;AAChH,2CAA0E;AAC1E,2CAAyC;AACzC,2CAAuD;AACvD,qDAAmD;AACnD,4CAA2D;AAC3D,yCAAuD;AACvD,yBAAuB;AACvB,iDAA2C;AAC3C,0CAA4C;AAC5C,wCAA0F;AAC1F,2DAAyD;AACzD,gDAAoD;AAEpD,SAAS,wBAAwB,CAAC,SAA8B;IAC5D,OAAO,OAAO,CAAC,qBAAc,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,aAAa,CAAC;WAC7D,qBAAc,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC;WACnD,qBAAc,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC;WAClD,qBAAc,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,mBAAmB,CAAC;WAC3D,qBAAc,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC;WAClD,qBAAc,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC;AACjE,CAAC;;AAGD,MAAa,UAAW,SAAQ,IAAA,uBAAiB,EAAC;IAC9C,MAAM,EAAE,6BAAU;IAClB,SAAS,EAAE;QACP,sBAAU;QACV,sBAAU;QACV,6BAAmB;QACnB,8BAAkB;QAClB,oCAAwB;QACxB,EAAE,OAAO,EAAE,uBAAY,EAAE,KAAK,EAAE,MAAM,EAAE;QACxC,EAAE,OAAO,EAAE,sBAAW,EAAE,KAAK,EAAE,MAAM,EAAE;QACvC,EAAE,OAAO,EAAE,uBAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE;QAC5D,EAAE,OAAO,EAAE,eAAM,EAAE,QAAQ,EAAE,IAAI,eAAM,CAAC,CAAC,IAAI,yBAAgB,EAAE,CAAC,CAAC,EAAE;KACtE;IACD,SAAS,EAAE;QACP,sBAAY;KACf;IACD,SAAS,EAAE;QACP,sBAAY;KACf;IACD,OAAO,EAAE;QACL,sBAAU;QACV,8BAAkB;QAClB,sBAAU;QACV,6BAAmB;QACnB,oCAAwB;QACxB,uBAAY;QACZ,sBAAW;QACX,gCAAe;QACf,uBAAW;QACX,eAAM;KACT;CACJ,CAAC;IA/BF;;QAgCc,oBAAe,GAAG,IAAI,gCAAe,CAAC;QAMtC,oCAA+B,GAAsB,CAAC,sBAAY,CAAC,SAAS,EAAE,sBAAY,CAAC,MAAM,EAAE,sBAAY,CAAC,YAAY,CAAC,CAAC;KA2D3I;IA/DG,OAAO;QACH,IAAI,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,gCAAe,EAAE,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;IACnF,CAAC;IAID,eAAe,CAAC,MAAsB,EAAE,QAAuB;QAC3D,IAAI,CAAC,IAAI,CAAC,+BAA+B,CAAC,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC;YAAE,OAAO;QAEhF,IAAI,mBAAmB,GAAG,KAAK,CAAC;QAChC,IAAI,UAAU,GAAG,KAAK,CAAC;QACvB,MAAM,MAAM,GAAG,QAAQ,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAE5D,KAAK,MAAM,SAAS,IAAI,MAAM,EAAE,CAAC;YAC7B,IAAI,qBAAc,CAAC,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC;gBAAE,UAAU,GAAG,IAAI,CAAC;YAC1E,IAAI,wBAAwB,CAAC,SAAS,CAAC;gBAAE,mBAAmB,GAAG,IAAI,CAAC;QACxE,CAAC;QAED,IAAI,UAAU,EAAE,CAAC;YACb,wHAAwH;YACxH,MAAM,IAAI,KAAK,CAAC,YAAY,IAAA,uBAAiB,EAAC,QAAQ,CAAC,uHAAuH,CAAC,CAAC;QACpL,CAAC;QAED,MAAM,WAAW,IAAO,GAAG,wEAAP,IAAI,GAAG,EAAyB,CAAA,CAAC;QAErD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACjD,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC;gBAAE,SAAS;YAEnD,sFAAsF;YACtF,MAAM,MAAM,GAAG,MAAM,CAAC,kBAAkB,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC;YAC3D,MAAM,UAAU,GAAS,EAAE,IAAI,EAAE,qBAAc,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAC3E,qBAAc,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC;YACrF,IAAI,CAAC,GAAG,KAAK,CAAC;YAEd,IAAI,CAAC,WAAW,CAAC;gBACb,OAAO,EAAE,UAAU,EAAE,UAAU,eAAE,CAAC,UAAsB,EAAE,OAAoB,EAAE,QAAyB,EAAE,MAAoB,EAAE,EAAE;oBAC/H,IAAI,KAAK,GAAG,MAAM,IAAI,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBAC9C,IAAI,CAAC,KAAK,EAAE,CAAC;wBACT,MAAM,MAAM,GAAG,QAAQ,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;wBAC5D,KAAK,GAAG,IAAA,sCAAkB,EAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;wBAC9D,IAAI,MAAM;4BAAE,WAAW,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;oBAC/C,CAAC;oBAED,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;oBAC9B,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;oBAChC,OAAO,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;gBAC/B,CAAC,wNAAA,EAAE,KAAK,EAAE,MAAM;aACnB,CAAC,CAAC;YACH,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC/B,CAAC;IACL,CAAC;IAED,iBAAiB,CAAC,MAAsB,EAAE,MAAwB;QAC9D,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACrC,IAAI,CAAC,UAAU;YAAE,OAAO;QAExB,MAAM,UAAU,GAAG,wBAAS,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC,UAAU;YAAE,OAAO;QAExB,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC;YAAE,MAAM,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAC/F,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IACjD,CAAC;;AAhGL,gCAiGC;w6BAjE+B,IAAI,gCAAe,kGAMgB,CAAC,sBAAY,CAAC,SAAS,EAAE,sBAAY,CAAC,MAAM,EAAE,sBAAY,CAAC,YAAY,CAAC"}

package/dist/cjs/src/request-parser.d.ts

@@ -0,0 +1,37 @@
+import { ClassType, CompilerContext } from '@deepkit/core';
+import { InjectorModule } from '@deepkit/injector';
+import { ReflectionParameter, Type } from '@deepkit/type';
+import { HttpRequest } from './model.js';
+import { RouteConfig } from './router.js';
+import { HttpParserOptions } from './module.config.js';
+export declare class ParameterForRequestParser {
+    parameter: ReflectionParameter;
+    regexPosition?: number;
+    constructor(parameter: ReflectionParameter);
+    get body(): boolean;
+    get requestParser(): boolean;
+    get bodyValidation(): boolean;
+    getType(): Type;
+    get header(): boolean;
+    get query(): boolean;
+    get queries(): boolean;
+    get typePath(): string | undefined;
+    getName(): string;
+    isPartOfPath(): boolean;
+}
+export declare function parseRoutePathToRegex(path: string, params: ReflectionParameter[]): {
+    regex: string;
+    parameterNames: {
+        [name: string]: number;
+    };
+};
+export declare function buildRequestParser(parseOptions: HttpParserOptions, parameters: ReflectionParameter[], routeConfig?: RouteConfig): (request: HttpRequest) => any[];
+export declare function getRequestParserCodeForParameters(compiler: CompilerContext, parseOptions: HttpParserOptions, parameters: ParameterForRequestParser[], config: {
+    module?: InjectorModule<any>;
+    resolverForParameterName?: Map<string, ClassType>;
+    resolverForToken?: Map<any, ClassType>;
+    pathParameterNames?: {
+        [name: string]: number;
+    };
+    routeConfig?: RouteConfig;
+}): string;

package/dist/cjs/src/request-parser.js

@@ -0,0 +1,382 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterForRequestParser = void 0;
+exports.parseRoutePathToRegex = parseRoutePathToRegex;
+exports.buildRequestParser = buildRequestParser;
+exports.getRequestParserCodeForParameters = getRequestParserCodeForParameters;
+/*@ts-ignore*/
+const { __ΩHttpParserOptions } = require('./module.config.js');
+/*@ts-ignore*/
+const { __ΩClassType } = require('@deepkit/core');
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
+const core_1 = require("@deepkit/core");
+const injector_1 = require("@deepkit/injector");
+const type_1 = require("@deepkit/type");
+const model_js_1 = require("./model.js");
+const router_js_1 = require("./router.js");
+const qs_1 = __importDefault(require("qs"));
+const formidable_1 = __importDefault(require("formidable"));
+function parseBody(options, req, foundFiles) {
+    const form = (0, formidable_1.default)(Object.assign(options, {
+        multiples: true,
+    }));
+    return (0, core_1.asyncOperation)(__assignType(async (resolve, reject) => {
+        function parseData(fields, files) {
+            const fileEntries = Object.entries(files);
+            // formidable turns JSON arrays into numerically keyed objects, so we convert them back
+            if ('0' in fields && fileEntries.length === 0 && Object.keys(fields).every(__assignType((key, idx) => parseInt(key) === idx, ['key', 'idx', '', 'P"2!"2""/#']))) {
+                return resolve(Object.values(fields));
+            }
+            for (const [name, files] of fileEntries) {
+                if (!files)
+                    continue;
+                const file = files[0];
+                if (!file)
+                    continue;
+                if (!file.filepath || 'string' !== typeof file.filepath)
+                    continue;
+                if (!file.size || 'number' !== typeof file.size)
+                    continue;
+                foundFiles[name] = {
+                    validator: router_js_1.UploadedFileSymbol,
+                    size: file.size,
+                    path: file.filepath,
+                    name: file.originalFilename || null,
+                    type: file.mimetype || null,
+                    lastModifiedDate: null,
+                };
+            }
+            const body = { ...fields, ...foundFiles };
+            resolve(body);
+        }
+        parseData.__type = ['fields', 'files', 'parseData', 'P!2!!2""/#'];
+        if (req.body) {
+            const [fields, files] = await form.parse((0, model_js_1.createRequestWithCachedBody)(req, req.body));
+            parseData(fields, files);
+        }
+        const chunks = [];
+        function read(chunk) {
+            chunks.push(chunk);
+        }
+        read.__type = ['chunk', 'read', 'P!2!"/"'];
+        req.on('data', read);
+        req.once('end', () => {
+            req.body = Buffer.concat(chunks);
+            req.off('data', read);
+        });
+        req.once('error', () => req.off('data', read));
+        const [fields, files] = await form.parse(req);
+        parseData(fields, files);
+    }, ['resolve', 'reject', '', 'P"2!"2""/#']));
+}
+parseBody.__type = [() => __ΩHttpParserOptions, 'options', () => model_js_1.HttpRequest, 'req', () => router_js_1.UploadedFile, 'foundFiles', 'parseBody', 'Pn!2"P7#2$P&P7%LM2&"/\''];
+class ParameterForRequestParser {
+    constructor(parameter) {
+        this.parameter = parameter;
+    }
+    get body() {
+        return type_1.typeAnnotation.getType(this.parameter.type, 'httpBody') !== undefined;
+    }
+    get requestParser() {
+        return type_1.typeAnnotation.getType(this.parameter.type, 'httpRequestParser') !== undefined;
+    }
+    get bodyValidation() {
+        return type_1.typeAnnotation.getType(this.parameter.type, 'httpBodyValidation') !== undefined;
+    }
+    getType() {
+        const parser = type_1.typeAnnotation.getType(this.parameter.type, 'httpRequestParser');
+        if (parser) {
+            return parser;
+        }
+        if (this.bodyValidation) {
+            (0, type_1.assertType)(this.parameter.type, type_1.ReflectionKind.class);
+            const valueType = (0, type_1.findMember)('value', this.parameter.type.types);
+            if (!valueType || valueType.kind !== type_1.ReflectionKind.property)
+                throw new Error(`No property value found at ${(0, type_1.stringifyType)(this.parameter.type)}`);
+            return valueType.type;
+        }
+        return this.parameter.type;
+    }
+    get header() {
+        return type_1.typeAnnotation.getType(this.parameter.type, 'httpHeader') !== undefined;
+    }
+    get query() {
+        return type_1.typeAnnotation.getType(this.parameter.type, 'httpQuery') !== undefined;
+    }
+    get queries() {
+        return type_1.typeAnnotation.getType(this.parameter.type, 'httpQueries') !== undefined;
+    }
+    get typePath() {
+        const typeOptions = type_1.typeAnnotation.getType(this.parameter.type, 'httpQueries') || type_1.typeAnnotation.getType(this.parameter.type, 'httpQuery')
+            || type_1.typeAnnotation.getType(this.parameter.type, 'httpPath') || type_1.typeAnnotation.getType(this.parameter.type, 'httpHeader');
+        if (!typeOptions)
+            return;
+        const options = (0, type_1.typeToObject)(typeOptions);
+        if ((0, core_1.isObject)(options))
+            return options.name;
+        return;
+    }
+    getName() {
+        return this.parameter.name;
+    }
+    isPartOfPath() {
+        return type_1.typeAnnotation.getType(this.parameter.type, 'httpPath') !== undefined || this.regexPosition !== undefined;
+    }
+}
+exports.ParameterForRequestParser = ParameterForRequestParser;
+ParameterForRequestParser.__type = ['regexPosition', () => type_1.ReflectionParameter, 'parameter', 'constructor', 'Type', 'getType', 'getName', 'isPartOfPath', 'ParameterForRequestParser', '\'3!8PP7"2#:"0$!!!P"w%0&!!!!P"0\'P)0(5w)'];
+function parseRoutePathToRegex(path, params) {
+    const parameterNames = {};
+    let argumentIndex = 0;
+    path = path.replace(/:(\w+)/g, __assignType((a, name) => {
+        parameterNames[name] = argumentIndex;
+        argumentIndex++;
+        const parameter = params.find(__assignType(v => v.name === name, ['v', '', 'P"2!"/"']));
+        if (parameter) {
+            const regExp = (0, model_js_1.getRegExp)(parameter.type);
+            if (regExp instanceof RegExp) {
+                return '(' + regExp.source + ')';
+            }
+            else if (regExp) {
+                return '(' + regExp + ')';
+            }
+        }
+        return String.raw `([^/]+)`;
+    }, ['a', 'name', '', 'P"2!"2""/#']));
+    return { regex: path, parameterNames };
+}
+parseRoutePathToRegex.__type = ['path', () => type_1.ReflectionParameter, 'params', 'regex', 'parameterNames', 'parseRoutePathToRegex', 'P&2!P7"F2#P&4$P&\'LM4%M/&'];
+function isTypeUnknown(type) {
+    if (type.id)
+        return false; //if is has an id we treat it as nominal type
+    return type.kind === type_1.ReflectionKind.unknown || type.kind === type_1.ReflectionKind.any
+        || type.kind === type_1.ReflectionKind.never;
+}
+isTypeUnknown.__type = ['Type', 'type', 'isTypeUnknown', 'P"w!2")/#'];
+function buildRequestParser(parseOptions, parameters, routeConfig) {
+    const compiler = new core_1.CompilerContext();
+    const params = parameters.map(__assignType(v => new ParameterForRequestParser(v), ['v', '', 'P"2!"/"']));
+    //todo: parse path
+    let pathRegex = '';
+    let pathParameterNames = {};
+    if (routeConfig) {
+        const parsedPath = parseRoutePathToRegex(routeConfig.getFullPath(), parameters);
+        pathRegex = parsedPath.regex;
+        pathParameterNames = parsedPath.parameterNames;
+        for (const param of params) {
+            param.regexPosition = parsedPath.parameterNames[param.parameter.name];
+        }
+    }
+    const code = getRequestParserCodeForParameters(compiler, parseOptions, params, {
+        pathParameterNames,
+        routeConfig
+    });
+    compiler.context.set('ValidationError', type_1.ValidationError);
+    compiler.context.set('qs', qs_1.default);
+    let needsQueryString = !!params.find(__assignType(v => v.query || v.queries || v.requestParser, ['v', '', 'P"2!"/"']));
+    const query = needsQueryString ? '_qPosition === -1 ? {} : qs.parse(_url.substr(_qPosition + 1))' : '{}';
+    const regexVar = compiler.reserveVariable('regex', new RegExp('^' + pathRegex + '$'));
+    return compiler.build(`
+        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 _match = _path.match(${regexVar}) || [];
+        const _query = ${query};
+        return ${code}
+    `, 'request');
+}
+buildRequestParser.__type = [() => __ΩHttpParserOptions, 'parseOptions', () => type_1.ReflectionParameter, 'parameters', () => router_js_1.RouteConfig, 'routeConfig', () => model_js_1.HttpRequest, 'request', '', 'buildRequestParser', 'Pn!2"P7#F2$P7%2&8PP7\'2("F/)/*'];
+function getRequestParserCodeForParameters(compiler, parseOptions, parameters, config) {
+    compiler.set({ DependenciesUnmetError: injector_1.DependenciesUnmetError });
+    let enableParseBody = false;
+    let requiresAsyncParameters = false;
+    const setParameters = [];
+    const parameterNames = [];
+    const parameterValidator = [];
+    let setParametersFromPath = '';
+    let bodyValidationErrorHandling = `if (bodyErrors.length) throw ValidationError.from(bodyErrors);`;
+    for (const parameter of parameters) {
+        if (parameter.requestParser || 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));
+            if (parameter.bodyValidation) {
+                compiler.context.set('BodyValidation', model_js_1.ValidatedBody);
+                compiler.context.set('BodyValidationError', model_js_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}`);
+            }
+            if (parameter.requestParser) {
+                const parseOptionsVar = compiler.reserveVariable('parseOptions', parseOptions);
+                const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
+                let assignPathNames = [];
+                for (const [name, index] of Object.entries(config.pathParameterNames || {})) {
+                    assignPathNames.push(`res.${name} = _match[${1 + index}];`);
+                }
+                setParameters.push(`parameters.${parameter.parameter.name} = async (options = {}) => {
+                    let res = {};
+                    if (options.withPath !== false) {
+                        ${assignPathNames.join('\n')}
+                    }
+                    if (options.withHeader !== false) {
+                        Object.assign(res, _headers);
+                    }
+                    if (options.withBody !== false) {
+                        bodyFields = bodyFields || (await ${parseBodyVar}(${parseOptionsVar}, request, uploadedFiles));
+                        Object.assign(res, bodyFields);
+                    }
+                    if (options.withQuery !== false) {
+                        Object.assign(res, _query);
+                    }
+                    res = ${converterVar}(res, {loosely: true});
+                    ${validatorVar}(res, {errors: bodyErrors});
+                    if (bodyErrors.length) throw ValidationError.from(bodyErrors);
+                    return res;
+                }`);
+            }
+            else {
+                enableParseBody = true;
+                setParameters.push(`parameters.${parameter.parameter.name} = ${converterVar}(bodyFields, {loosely: true});`);
+                parameterValidator.push(`${validatorVar}(parameters.${parameter.parameter.name}, {errors: bodyErrors});`);
+            }
+        }
+        else if (parameter.query || parameter.queries || parameter.header) {
+            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.queries ? parameter.parameter.name : parameter.typePath;
+            const accessor = queryPath ? `['` + (queryPath.replace(/\./g, `']['`)) + `']` : '';
+            const queryAccessor = parameter.header ? `_headers${accessor}` : queryPath ? `_query${accessor}` : '_query';
+            if ((0, type_1.isOptional)(parameter.parameter.parameter) || (0, type_1.hasDefaultValue)(parameter.parameter.parameter)) {
+                setParameters.push(`parameters.${parameter.parameter.name} = ${queryAccessor} === undefined ? undefined : ${converterVar}(${queryAccessor}, {loosely: true});`);
+            }
+            else {
+                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.parameter.name}`);
+            if (parameter.isPartOfPath()) {
+                if (parameter.parameter.type.kind !== type_1.ReflectionKind.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.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.parameter.name}, {errors: validationErrors}, ${JSON.stringify(parameter.getName())});`);
+                }
+                else {
+                    setParameters.push(`parameters.${parameter.parameter.name} = _match[${1 + (parameter.regexPosition || 0)}];`);
+                }
+            }
+            const injectorTokenVar = compiler.reserveVariable('type', parameter.parameter.type);
+            const parameterResolverFoundVar = compiler.reserveVariable('parameterResolverFound', false);
+            setParameters.push(`${parameterResolverFoundVar} = false;`);
+            const resolverType = config.resolverForParameterName?.get(parameter.getName())
+                || config.resolverForToken?.get(parameter.parameter.type.kind === type_1.ReflectionKind.class ? parameter.parameter.type.classType : undefined);
+            //make sure all parameter values from the path are available, important for parameter resolver
+            if (resolverType && !setParametersFromPath && config.pathParameterNames) {
+                for (const i in config.pathParameterNames) {
+                    setParametersFromPath += `parameters.${i} = _match[${1 + config.pathParameterNames[i]}];`;
+                }
+            }
+            if (!resolverType && !parameter.isPartOfPath() && isTypeUnknown(parameter.parameter.type)) {
+                const label = config.routeConfig ? (0, router_js_1.getRouteActionLabel)(config.routeConfig?.action) + ' ' : '';
+                throw new Error(`Parameter ${label}${JSON.stringify(parameter.parameter.name)} has no runtime type. Runtime types disabled or circular dependencies?`);
+            }
+            let injector = '_injector';
+            const moduleRawVar = config.module ? compiler.reserveConst(config.module, 'module') : 'undefined';
+            const moduleVar = config.module ? `, ${moduleRawVar}` : '';
+            if (resolverType) {
+                requiresAsyncParameters = true;
+                let instanceFetcher = '';
+                if (config.module && config.module.injector) {
+                    const resolverResolverVar = compiler.reserveVariable('resolverProvideToken', config.module.injector.createResolver((0, type_1.resolveReceiveType)(resolverType)));
+                    instanceFetcher = `${resolverResolverVar}(${injector}.scope)`;
+                }
+                else {
+                    const resolverProvideTokenVar = compiler.reserveVariable('resolverProvideToken', resolverType);
+                    instanceFetcher = `${injector}.get(${resolverProvideTokenVar}${moduleVar})`;
+                }
+                const instance = compiler.reserveVariable('resolverInstance');
+                const routeConfigVar = compiler.reserveVariable('routeConfigVar', config.routeConfig);
+                const classTypeToken = parameter.parameter.type.kind === type_1.ReflectionKind.class ? parameter.parameter.type.classType : undefined;
+                const classTypeTokenVar = compiler.reserveVariable('classType', classTypeToken);
+                setParameters.push(`
+                    //resolver ${(0, core_1.getClassName)(resolverType)} for ${parameter.getName()}
+                    ${instance} = ${instanceFetcher};
+                    if (!${parameterResolverFoundVar}) {
+                        ${parameterResolverFoundVar} = true;
+                        parameters.${parameter.parameter.name} = await ${instance}.resolve({
+                            token: ${classTypeTokenVar},
+                            route: ${routeConfigVar},
+                            request: request,
+                            name: ${JSON.stringify(parameter.parameter.name)},
+                            value: parameters.${parameter.parameter.name},
+                            query: _query,
+                            parameters: parameters,
+                            type: ${compiler.reserveVariable('parameterType', parameter.parameter)}
+                        });
+                    }`);
+            }
+            if (!parameter.isPartOfPath()) {
+                const resolverVar = compiler.reserveVariable('resolver');
+                let injectorGet = `
+                if (!${resolverVar}) ${resolverVar} = ${injector}.resolve(${moduleRawVar}, ${injectorTokenVar});
+                parameters.${parameter.parameter.name} = ${resolverVar}(${injector}.scope);
+                `;
+                if (!parameter.parameter.isOptional()) {
+                    injectorGet += `
+                    if (!parameters.${parameter.parameter.name}) {
+                        throw new DependenciesUnmetError(
+                            \`Parameter \${${JSON.stringify(parameter.parameter.name)}} is required but provider returned undefined.\`,
+                        );
+                    }`;
+                }
+                setParameters.push(`if (!${parameterResolverFoundVar}) { ${injectorGet} }`);
+            }
+        }
+    }
+    let parseBodyLoading = '';
+    if (enableParseBody) {
+        const parseOptionsVar = compiler.reserveVariable('parseOptions', parseOptions);
+        const parseBodyVar = compiler.reserveVariable('parseBody', parseBody);
+        parseBodyLoading = `
+            bodyFields = bodyFields || (await ${parseBodyVar}(${parseOptionsVar}, request, uploadedFiles));`;
+        requiresAsyncParameters = true;
+    }
+    let parametersLoader = '() => {}';
+    if (setParameters.length) {
+        parametersLoader = `${requiresAsyncParameters ? 'async' : ''} function parse(_injector){
+                const validationErrors = [];
+                const bodyErrors = [];
+                const parameters = {};
+                let bodyFields;
+                ${setParametersFromPath}
+                ${parseBodyLoading}
+                ${setParameters.join('\n')}
+                ${parameterValidator.join('\n')}
+                ${bodyValidationErrorHandling}
+                if (validationErrors.length) throw new ValidationError(validationErrors);
+                return {arguments: [${parameterNames.join(',')}], parameters: parameters};
+            }`;
+    }
+    return parametersLoader;
+}
+getRequestParserCodeForParameters.__type = [() => core_1.CompilerContext, 'compiler', () => __ΩHttpParserOptions, 'parseOptions', () => ParameterForRequestParser, 'parameters', () => injector_1.InjectorModule, 'module', () => __ΩClassType, 'resolverForParameterName', () => __ΩClassType, 'resolverForToken', 'pathParameterNames', () => router_js_1.RouteConfig, 'routeConfig', 'config', 'getRequestParserCodeForParameters', 'PP7!2"n#2$P7%F2&PP"7\'4(8&n)E4*8"n+E4,8P&\'LM4-8P7.4/8M20"/1'];
+//# sourceMappingURL=request-parser.js.map