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

package/dist/cjs/src/http.js

@@ -1,13 +1,4 @@
 "use strict";
-/*
- * 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.
- */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -17,18 +8,58 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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.HttpListener = exports.JSONResponse = exports.HtmlResponse = exports.httpWorkflow = exports.HttpControllerErrorEvent = exports.HttpResponseEvent = exports.HttpControllerEvent = exports.HttpResolveParametersEvent = exports.HttpAccessDeniedEvent = exports.HttpAuthEvent = exports.HttpRouteEvent = exports.HttpWorkflowEventWithRoute = exports.HttpRouteNotFoundEvent = exports.HttpRequestEvent = exports.HttpWorkflowEvent = exports.HttpAccessDeniedError = exports.HttpBadRequestError = exports.HttpNotFoundError = exports.HttpError = exports.Redirect = void 0;
+exports.HttpListener = exports.HttpResultFormatter = exports.__ΩHttpResultFormatterContext = exports.__ΩSupportedHttpResult = exports.JSONResponse = exports.HtmlResponse = exports.Response = exports.BaseResponse = exports.httpWorkflow = exports.HttpControllerErrorEvent = exports.HttpResponseEvent = exports.HttpControllerEvent = exports.HttpResolveParametersEvent = exports.HttpAccessDeniedEvent = exports.HttpAuthEvent = exports.HttpRouteEvent = exports.HttpWorkflowEventWithRoute = exports.HttpRouteNotFoundEvent = exports.HttpRequestEvent = exports.HttpWorkflowEvent = exports.HttpNotImplementedError = exports.HttpInternalServerError = exports.HttpTooManyRequestsError = exports.HttpGoneError = exports.HttpConflictError = exports.HttpTimeoutError = exports.HttpNotAcceptableError = exports.HttpMethodNotAllowedError = exports.HttpNotFoundError = exports.HttpAccessDeniedError = exports.HttpUnauthorizedError = exports.HttpBadRequestError = exports.HttpError = exports.Redirect = void 0;
+exports.isElementStruct = isElementStruct;
+exports.createHttpError = createHttpError;
+const __ΩError = ['name', 'message', 'stack', 'Error', 'P&4!&4"&4#8Mw$y'];
+/*@ts-ignore*/
+const { __ΩClassType } = require('@deepkit/core');
+/*@ts-ignore*/
+const { __ΩRouteParameterResolverForInjector } = require('./router.js');
+/*@ts-ignore*/
+const { __ΩHttpRequestPositionedParameters } = require('./model.js');
+/*@ts-ignore*/
+const { __ΩLoggerInterface } = require('@deepkit/logger');
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
+/*
+ * 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.
+ */
 const core_1 = require("@deepkit/core");
-const type_1 = require("@deepkit/type");
 const http_1 = require("http");
 const event_1 = require("@deepkit/event");
-const model_1 = require("./model");
+const model_js_1 = require("./model.js");
 const injector_1 = require("@deepkit/injector");
-const logger_1 = require("@deepkit/logger");
-const router_1 = require("./router");
+const router_js_1 = require("./router.js");
 const workflow_1 = require("@deepkit/workflow");
-const template_1 = require("@deepkit/template");
+const stopwatch_1 = require("@deepkit/stopwatch");
+const type_1 = require("@deepkit/type");
+const stream_1 = __importDefault(require("stream"));
+function isElementStruct(v) {
+    return (0, core_1.isObject)(v) && 'hasOwnProperty' in v && v.hasOwnProperty('render') && v.hasOwnProperty('attributes');
+}
+isElementStruct.__type = ['v', 'isElementStruct', 'P"2!!/"'];
+let templateRender;
+function getTemplateRender() {
+    if (!templateRender) {
+        const template = require('@deepkit/template');
+        templateRender = template.render;
+    }
+    return templateRender;
+}
+getTemplateRender.__type = [() => render, 'getTemplateRender', 'Pi!/"'];
 class Redirect {
     constructor(statusCode = 302) {
         this.statusCode = statusCode;
@@ -46,38 +77,82 @@ class Redirect {
     }
 }
 exports.Redirect = Redirect;
-function HttpError(code, defaultMessage = '') {
-    return class extends core_1.CustomError {
-        constructor(message = defaultMessage) {
-            super(message);
-        }
-        static getHttpCode() {
-            return code;
-        }
-    };
+Redirect.__type = ['routeName', 'routeParameters', 'url', 'statusCode', () => 302, 'constructor', 'parameters', () => ({}), () => 302, () => Redirect, 'toRoute', () => 302, () => Redirect, 'toUrl', 'Redirect', '&3!8P&"LM3"8&3#8P\'2$:>%"0&P&2!P&"LM2\'>(\'2$>)P7*0+sP&2#\'2$>,P7-0.s5w/'];
+class HttpError extends core_1.CustomError {
+    constructor(message, httpCode) {
+        super(message);
+        this.message = message;
+        this.httpCode = httpCode;
+    }
 }
 exports.HttpError = HttpError;
-class HttpNotFoundError extends HttpError(404, 'Not found') {
+HttpError.__type = ['T', () => core_1.CustomError, 'message', 'httpCode', 'constructor', 'HttpError', 'b!P7"P&2#:e"!2$:"0%5w&'];
+function createHttpError(code, defaultMessage = '') {
+    var _a;
+    return _a = class extends HttpError {
+            constructor(message = defaultMessage) {
+                super(message, code);
+                this.message = message;
+            }
+        },
+        _a.__type = [() => code, () => HttpError, 'message', () => defaultMessage, 'constructor', () => code, 'PPdi!h!!qe!!!j7"P&2#:>$"0%5Pdi&h!!qe!!!j6"'],
+        _a;
 }
-exports.HttpNotFoundError = HttpNotFoundError;
-class HttpBadRequestError extends HttpError(400, 'Bad request') {
+createHttpError.__type = ['code', 'defaultMessage', () => "", () => __ΩClassType, () => HttpError, 'createHttpError', 'P"2!&2">#P"7%o$"/&'];
+class HttpBadRequestError extends createHttpError(400, 'Bad request') {
 }
 exports.HttpBadRequestError = HttpBadRequestError;
-class HttpAccessDeniedError extends HttpError(403, 'Access denied') {
+HttpBadRequestError.__type = [() => createHttpError(400, "Bad request"), 'HttpBadRequestError', 'P7!5w"'];
+class HttpUnauthorizedError extends createHttpError(401, 'Unauthorized') {
+}
+exports.HttpUnauthorizedError = HttpUnauthorizedError;
+HttpUnauthorizedError.__type = [() => createHttpError(401, "Unauthorized"), 'HttpUnauthorizedError', 'P7!5w"'];
+class HttpAccessDeniedError extends createHttpError(403, 'Access denied') {
 }
 exports.HttpAccessDeniedError = HttpAccessDeniedError;
+HttpAccessDeniedError.__type = [() => createHttpError(403, "Access denied"), 'HttpAccessDeniedError', 'P7!5w"'];
+class HttpNotFoundError extends createHttpError(404, 'Not found') {
+}
+exports.HttpNotFoundError = HttpNotFoundError;
+HttpNotFoundError.__type = [() => createHttpError(404, "Not found"), 'HttpNotFoundError', 'P7!5w"'];
+class HttpMethodNotAllowedError extends createHttpError(405, 'Method not allowed') {
+}
+exports.HttpMethodNotAllowedError = HttpMethodNotAllowedError;
+HttpMethodNotAllowedError.__type = [() => createHttpError(405, "Method not allowed"), 'HttpMethodNotAllowedError', 'P7!5w"'];
+class HttpNotAcceptableError extends createHttpError(406, 'Not acceptable') {
+}
+exports.HttpNotAcceptableError = HttpNotAcceptableError;
+HttpNotAcceptableError.__type = [() => createHttpError(406, "Not acceptable"), 'HttpNotAcceptableError', 'P7!5w"'];
+class HttpTimeoutError extends createHttpError(408, 'Request timeout') {
+}
+exports.HttpTimeoutError = HttpTimeoutError;
+HttpTimeoutError.__type = [() => createHttpError(408, "Request timeout"), 'HttpTimeoutError', 'P7!5w"'];
+class HttpConflictError extends createHttpError(409, 'Conflict') {
+}
+exports.HttpConflictError = HttpConflictError;
+HttpConflictError.__type = [() => createHttpError(409, "Conflict"), 'HttpConflictError', 'P7!5w"'];
+class HttpGoneError extends createHttpError(410, 'Gone') {
+}
+exports.HttpGoneError = HttpGoneError;
+HttpGoneError.__type = [() => createHttpError(410, "Gone"), 'HttpGoneError', 'P7!5w"'];
+class HttpTooManyRequestsError extends createHttpError(429, 'Too many requests') {
+}
+exports.HttpTooManyRequestsError = HttpTooManyRequestsError;
+HttpTooManyRequestsError.__type = [() => createHttpError(429, "Too many requests"), 'HttpTooManyRequestsError', 'P7!5w"'];
+class HttpInternalServerError extends createHttpError(500, 'Internal server error') {
+}
+exports.HttpInternalServerError = HttpInternalServerError;
+HttpInternalServerError.__type = [() => createHttpError(500, "Internal server error"), 'HttpInternalServerError', 'P7!5w"'];
+class HttpNotImplementedError extends createHttpError(501, 'Not implemented') {
+}
+exports.HttpNotImplementedError = HttpNotImplementedError;
+HttpNotImplementedError.__type = [() => createHttpError(501, "Not implemented"), 'HttpNotImplementedError', 'P7!5w"'];
 class HttpWorkflowEvent {
-    constructor(injectorContext, request, response) {
-        this.injectorContext = injectorContext;
-        this.request = request;
-        this.response = response;
-        this.stopped = false;
-    }
     stopPropagation() {
-        this.stopped = true;
+        this.propagationStopped = true;
     }
-    isStopped() {
-        return this.stopped;
+    isPropagationStopped() {
+        return this.propagationStopped;
     }
     clearNext() {
         this.nextState = undefined;
@@ -90,9 +165,18 @@ class HttpWorkflowEvent {
         this.nextState = nextState;
         this.nextStateEvent = event;
     }
+    /**
+     * Whether already a next workflow state has been scheduled.
+     */
     hasNext() {
         return this.nextState !== undefined;
     }
+    constructor(injectorContext, request, response) {
+        this.injectorContext = injectorContext;
+        this.request = request;
+        this.response = response;
+        this.propagationStopped = false;
+    }
     get url() {
         return this.request.url || '/';
     }
@@ -107,6 +191,7 @@ class HttpWorkflowEvent {
     }
 }
 exports.HttpWorkflowEvent = HttpWorkflowEvent;
+HttpWorkflowEvent.__type = ['propagationStopped', function () { return false; }, 'stopPropagation', 'isPropagationStopped', 'nextState', 'nextStateEvent', 'clearNext', 'event', 'next', 'hasNext', () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', 'constructor', 'send', 'HttpWorkflowEvent', ')3!>"P"0#P"0$"3%8"3&8P"0\'P&2%"2(8"0)P)0*PP7+2,:P7-2.:P7/20:"01!!P"20"025w3'];
 exports.HttpRequestEvent = HttpWorkflowEvent;
 exports.HttpRouteNotFoundEvent = HttpWorkflowEvent;
 class HttpWorkflowEventWithRoute extends HttpWorkflowEvent {
@@ -120,8 +205,12 @@ class HttpWorkflowEventWithRoute extends HttpWorkflowEvent {
     send(response) {
         this.next('response', new HttpResponseEvent(this.injectorContext, this.request, this.response, response, this.route));
     }
+    accessDenied(error) {
+        this.next('accessDenied', new HttpAccessDeniedEvent(this.injectorContext, this.request, this.response, this.route, error));
+    }
 }
 exports.HttpWorkflowEventWithRoute = HttpWorkflowEventWithRoute;
+HttpWorkflowEventWithRoute.__type = [() => HttpWorkflowEvent, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => router_js_1.RouteConfig, 'route', 'constructor', 'send', () => __ΩError, 'error', 'accessDenied', 'HttpWorkflowEventWithRoute', 'P7!PP7"2#:P7$2%:P7&2\':P7(2):"0*P"2\'"0+Pn,2-8"0.5w/'];
 class HttpRouteEvent extends HttpWorkflowEvent {
     constructor(injectorContext, request, response, parameterResolver, route) {
         super(injectorContext, request, response);
@@ -140,6 +229,7 @@ class HttpRouteEvent extends HttpWorkflowEvent {
     }
 }
 exports.HttpRouteEvent = HttpRouteEvent;
+HttpRouteEvent.__type = [() => HttpWorkflowEvent, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => __ΩRouteParameterResolverForInjector, 'parameterResolver', () => router_js_1.RouteConfig, 'route', 'constructor', () => router_js_1.RouteConfig, () => __ΩRouteParameterResolverForInjector, 'routeFound', 'notFound', 'HttpRouteEvent', 'P7!PP7"2#:P7$2%:P7&2\':n(2)8:P7*2+8:"0,PP7-2+n.2)"0/P"005w1'];
 class HttpAuthEvent extends HttpWorkflowEventWithRoute {
     constructor(injectorContext, request, response, route, parameterResolver) {
         super(injectorContext, request, response, route);
@@ -152,36 +242,40 @@ class HttpAuthEvent extends HttpWorkflowEventWithRoute {
     success() {
         this.next('resolveParameters', new HttpResolveParametersEvent(this.injectorContext, this.request, this.response, this.parameterResolver, this.route));
     }
-    accessDenied() {
-        this.next('accessDenied', new HttpAccessDeniedEvent(this.injectorContext, this.request, this.response, this.route));
-    }
 }
 exports.HttpAuthEvent = HttpAuthEvent;
+HttpAuthEvent.__type = [() => HttpWorkflowEventWithRoute, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => router_js_1.RouteConfig, 'route', () => __ΩRouteParameterResolverForInjector, 'parameterResolver', 'constructor', 'success', 'HttpAuthEvent', 'P7!PP7"2#:P7$2%:P7&2\':P7(2):n*2+:"0,P"0-5w.'];
 class HttpAccessDeniedEvent extends HttpWorkflowEvent {
-    constructor(injectorContext, request, response, route) {
+    constructor(injectorContext, request, response, route, error) {
         super(injectorContext, request, response);
         this.injectorContext = injectorContext;
         this.request = request;
         this.response = response;
         this.route = route;
+        this.error = error;
     }
 }
 exports.HttpAccessDeniedEvent = HttpAccessDeniedEvent;
-class HttpResolveParametersEvent extends HttpWorkflowEvent {
+HttpAccessDeniedEvent.__type = [() => HttpWorkflowEvent, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => router_js_1.RouteConfig, 'route', () => __ΩError, 'error', 'constructor', 'HttpAccessDeniedEvent', 'P7!PP7"2#:P7$2%:P7&2\':P7(2):n*2+8:"0,5w-'];
+class HttpResolveParametersEvent extends HttpWorkflowEventWithRoute {
     constructor(injectorContext, request, response, parameterResolver, route) {
-        super(injectorContext, request, response);
+        super(injectorContext, request, response, route);
         this.injectorContext = injectorContext;
         this.request = request;
         this.response = response;
         this.parameterResolver = parameterResolver;
         this.route = route;
-        this.parameters = [];
+        this.parameters = { arguments: [], parameters: {} };
+    }
+    accessDenied() {
+        this.next('accessDenied', new HttpAccessDeniedEvent(this.injectorContext, this.request, this.response, this.route));
     }
 }
 exports.HttpResolveParametersEvent = HttpResolveParametersEvent;
-class HttpControllerEvent extends HttpWorkflowEvent {
-    constructor(injectorContext, request, response, parameters = [], route) {
-        super(injectorContext, request, response);
+HttpResolveParametersEvent.__type = [() => HttpWorkflowEventWithRoute, () => __ΩHttpRequestPositionedParameters, 'parameters', function () { return { arguments: [], parameters: {} }; }, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => __ΩRouteParameterResolverForInjector, 'parameterResolver', () => router_js_1.RouteConfig, 'route', 'constructor', 'accessDenied', 'HttpResolveParametersEvent', 'P7!n"3#>$PP7%2&:P7\'2(:P7)2*:n+2,:P7-2.:"0/P"005w1'];
+class HttpControllerEvent extends HttpWorkflowEventWithRoute {
+    constructor(injectorContext, request, response, parameters = { arguments: [], parameters: {} }, route) {
+        super(injectorContext, request, response, route);
         this.injectorContext = injectorContext;
         this.request = request;
         this.response = response;
@@ -190,6 +284,7 @@ class HttpControllerEvent extends HttpWorkflowEvent {
     }
 }
 exports.HttpControllerEvent = HttpControllerEvent;
+HttpControllerEvent.__type = [() => HttpWorkflowEventWithRoute, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => __ΩHttpRequestPositionedParameters, 'parameters', () => ({ arguments: [], parameters: {} }), () => router_js_1.RouteConfig, 'route', 'constructor', 'HttpControllerEvent', 'P7!PP7"2#:P7$2%:P7&2\':n(2):>*P7+2,:"0-5w.'];
 class HttpResponseEvent extends workflow_1.WorkflowEvent {
     constructor(injectorContext, request, response, result, route) {
         super();
@@ -198,21 +293,31 @@ class HttpResponseEvent extends workflow_1.WorkflowEvent {
         this.response = response;
         this.result = result;
         this.route = route;
+        /**
+         * The time it took to call the controller action in milliseconds.
+         */
+        this.controllerActionTime = 0;
     }
 }
 exports.HttpResponseEvent = HttpResponseEvent;
-class HttpControllerErrorEvent extends HttpWorkflowEvent {
+HttpResponseEvent.__type = [() => workflow_1.WorkflowEvent, 'controllerActionTime', function () { return 0; }, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', 'result', () => router_js_1.RouteConfig, 'route', 'constructor', 'HttpResponseEvent', 'P7!\'3">#PP7$2%:P7&2\':P7(2):"2*:P7+2,8:"0-5w.'];
+class HttpControllerErrorEvent extends HttpWorkflowEventWithRoute {
     constructor(injectorContext, request, response, route, error) {
-        super(injectorContext, request, response);
+        super(injectorContext, request, response, route);
         this.injectorContext = injectorContext;
         this.request = request;
         this.response = response;
         this.route = route;
         this.error = error;
+        /**
+         * The time it took to call the controller action in milliseconds.
+         */
+        this.controllerActionTime = 0;
     }
 }
 exports.HttpControllerErrorEvent = HttpControllerErrorEvent;
-exports.httpWorkflow = workflow_1.createWorkflow('http', {
+HttpControllerErrorEvent.__type = [() => HttpWorkflowEventWithRoute, 'controllerActionTime', function () { return 0; }, () => injector_1.InjectorContext, 'injectorContext', () => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => router_js_1.RouteConfig, 'route', () => __ΩError, 'error', 'constructor', 'HttpControllerErrorEvent', 'P7!\'3">#PP7$2%:P7&2\':P7(2):P7*2+:n,2-:"0.5w/'];
+exports.httpWorkflow = (0, workflow_1.createWorkflow)('http', {
     start: workflow_1.WorkflowEvent,
     request: exports.HttpRequestEvent,
     route: HttpRouteEvent,
@@ -236,24 +341,200 @@ exports.httpWorkflow = workflow_1.createWorkflow('http', {
     parametersFailed: 'response',
     routeNotFound: 'response',
 });
-class HtmlResponse {
+class BaseResponse {
+    constructor(_statusCode, _headers = {}) {
+        this._statusCode = _statusCode;
+        this._headers = _headers;
+        this.autoSerializing = true;
+    }
+    status(code) {
+        this._statusCode = code;
+        return this;
+    }
+    /**
+     * Per default a JSONResponse is serialized using the return type specified at the route.
+     * This disables that behaviour so that JSON.stringify is run on the result directly.
+     */
+    disableAutoSerializing() {
+        this.autoSerializing = false;
+        return this;
+    }
+    header(name, value) {
+        this._headers[name] = value;
+        return this;
+    }
+    headers(headers) {
+        this._headers = headers;
+        return this;
+    }
+    contentType(type) {
+        this._headers['content-type'] = type;
+        return this;
+    }
+}
+exports.BaseResponse = BaseResponse;
+BaseResponse.__type = ['autoSerializing', function () { return true; }, '_statusCode', '_headers', () => ({}), 'constructor', 'code', 'status', 'disableAutoSerializing', 'name', 'value', 'header', 'headers', 'type', 'contentType', 'BaseResponse', ')3!>"P\'2#8:!2$:>%"0&P\'2\'!0(P"0)P&2*P&\'J2+!0,P!2-!0-P&2.!0/5w0'];
+class Response extends BaseResponse {
+    constructor(content, contentType, statusCode) {
+        super(statusCode);
+        this.content = content;
+        this.contentType(contentType);
+    }
+}
+exports.Response = Response;
+Response.__type = [() => BaseResponse, 'content', 'contentType', 'statusCode', 'constructor', 'Response', 'P7!PP&WJ2":&2#\'2$8"0%5w&'];
+class HtmlResponse extends BaseResponse {
     constructor(html, statusCode) {
+        super(statusCode);
         this.html = html;
-        this.statusCode = statusCode;
     }
 }
 exports.HtmlResponse = HtmlResponse;
-class JSONResponse {
+HtmlResponse.__type = [() => BaseResponse, 'html', 'statusCode', 'constructor', 'HtmlResponse', 'P7!P&2":\'2#8"0$5w%'];
+class JSONResponse extends BaseResponse {
     constructor(json, statusCode) {
+        super(statusCode);
         this.json = json;
-        this.statusCode = statusCode;
     }
 }
 exports.JSONResponse = JSONResponse;
-let HttpListener = class HttpListener {
-    constructor(router, logger) {
+JSONResponse.__type = [() => BaseResponse, 'json', 'statusCode', 'constructor', 'JSONResponse', 'P7!P"2":\'2#8"0$5w%'];
+const __ΩSupportedHttpResult = [() => Response, () => JSONResponse, () => HtmlResponse, () => model_js_1.HttpResponse, () => Redirect, () => __ΩError, 'SupportedHttpResult', 'P-,\'&P7!P7"P7#P7$!!P7%Wn&Jw\'y'];
+exports.__ΩSupportedHttpResult = __ΩSupportedHttpResult;
+const __ΩHttpResultFormatterContext = [() => model_js_1.HttpRequest, 'request', () => model_js_1.HttpResponse, 'response', () => router_js_1.RouteConfig, 'route', 'HttpResultFormatterContext', 'PP7!4"P7#4$P7%4&8Mw\'y'];
+exports.__ΩHttpResultFormatterContext = __ΩHttpResultFormatterContext;
+class HttpResultFormatter {
+    constructor(router) {
+        this.router = router;
+        this.jsonContentType = 'application/json; charset=utf-8';
+        this.htmlContentType = 'text/html; charset=utf-8';
+    }
+    setContentTypeIfNotSetAlready(response, contentType) {
+        if (response.hasHeader('Content-Type'))
+            return;
+        response.setHeader('Content-Type', contentType);
+    }
+    handleError(error, context) {
+    }
+    handleUndefined(result, context) {
+        context.response.end(result);
+    }
+    handleRedirect(result, context) {
+        if (result.routeName) {
+            context.response.writeHead(result.statusCode, {
+                Location: this.router.resolveUrl(result.routeName, result.routeParameters)
+            });
+        }
+        else {
+            context.response.writeHead(result.statusCode, {
+                Location: result.url
+            });
+        }
+        context.response.end();
+    }
+    handleUnknown(result, context) {
+        const oldCheck = type_1.typeSettings.unpopulatedCheck;
+        try {
+            type_1.typeSettings.unpopulatedCheck = type_1.UnpopulatedCheck.None;
+            this.setContentTypeIfNotSetAlready(context.response, this.jsonContentType);
+            context.response.end(JSON.stringify(result));
+        }
+        finally {
+            type_1.typeSettings.unpopulatedCheck = oldCheck;
+        }
+    }
+    handleHtmlResponse(result, context) {
+        this.setContentTypeIfNotSetAlready(context.response, this.htmlContentType);
+        context.response.writeHead(result._statusCode || 200, result._headers);
+        context.response.end(result.html);
+    }
+    handleGenericResponse(result, context) {
+        context.response.writeHead(result._statusCode || 200, result._headers);
+        context.response.end(result.content);
+    }
+    handleJSONResponse(result, context) {
+        this.setContentTypeIfNotSetAlready(context.response, this.jsonContentType);
+        context.response.writeHead(result._statusCode || 200, result._headers);
+        context.response.end(JSON.stringify(result.json));
+    }
+    handleTypeEntity(classType, instance, context, route) {
+        this.handleType((0, type_1.resolveReceiveType)(classType), instance, context, route);
+    }
+    handleType(type, instance, context, route) {
+        this.setContentTypeIfNotSetAlready(context.response, this.jsonContentType);
+        const serializerToUse = route && route?.serializer ? route.serializer : type_1.serializer;
+        context.response.end(JSON.stringify((0, type_1.serialize)(instance, route ? route.serializationOptions : undefined, serializerToUse, undefined, type)));
+    }
+    handleStream(stream, context) {
+        stream.pipe(context.response);
+    }
+    handleBinary(result, context) {
+        context.response.end(result);
+    }
+    handleResponse(context) {
+    }
+    handle(result, context) {
+        if (result === null || result === undefined) {
+            this.handleUndefined(result, context);
+        }
+        else if (result instanceof Error) {
+            this.handleError(result, context);
+        }
+        else if (result instanceof Redirect) {
+            this.handleRedirect(result, context);
+        }
+        else if (result instanceof http_1.ServerResponse) {
+            this.handleResponse(context);
+        }
+        else if (result instanceof HtmlResponse) {
+            this.handleHtmlResponse(result, context);
+        }
+        else if (result instanceof stream_1.default.Readable) {
+            this.handleStream(result, context);
+        }
+        else if (result instanceof Uint8Array) {
+            this.handleBinary(result, context);
+        }
+        else if (result instanceof JSONResponse) {
+            this.handleJSONResponse(result, context);
+        }
+        else if (result instanceof Response) {
+            this.handleGenericResponse(result, context);
+        }
+        else {
+            if ((0, core_1.isClassInstance)(result)) {
+                const classType = (0, core_1.getClassTypeFromInstance)(result);
+                if ((0, type_1.hasTypeInformation)(classType)) {
+                    this.handleTypeEntity(classType, result, context);
+                    return;
+                }
+            }
+            else if ((0, core_1.isArray)(result) && result.length > 0 && (0, core_1.isClassInstance)(result[0])) {
+                const firstClassType = (0, core_1.getClassTypeFromInstance)(result[0]);
+                let allSameType = true;
+                for (const item of result) {
+                    if (!(0, core_1.isClassInstance)(item) || (0, core_1.getClassTypeFromInstance)(item) !== firstClassType) {
+                        allSameType = false;
+                        break;
+                    }
+                }
+                if (allSameType && (0, type_1.hasTypeInformation)(firstClassType)) {
+                    this.handleType({ kind: type_1.ReflectionKind.array, type: (0, type_1.resolveReceiveType)(firstClassType) }, result, context);
+                    return;
+                }
+            }
+            this.handleUnknown(result, context);
+        }
+    }
+}
+exports.HttpResultFormatter = HttpResultFormatter;
+HttpResultFormatter.__type = ['jsonContentType', function () { return 'application/json; charset=utf-8'; }, 'htmlContentType', function () { return 'text/html; charset=utf-8'; }, () => router_js_1.HttpRouter, 'router', 'constructor', () => model_js_1.HttpResponse, 'response', 'contentType', 'setContentTypeIfNotSetAlready', () => __ΩError, 'error', () => __ΩHttpResultFormatterContext, 'context', 'handleError', 'result', () => __ΩHttpResultFormatterContext, 'handleUndefined', () => Redirect, () => __ΩHttpResultFormatterContext, 'handleRedirect', () => __ΩHttpResultFormatterContext, 'handleUnknown', () => HtmlResponse, () => __ΩHttpResultFormatterContext, 'handleHtmlResponse', () => Response, () => __ΩHttpResultFormatterContext, 'handleGenericResponse', () => JSONResponse, () => __ΩHttpResultFormatterContext, 'handleJSONResponse', () => __ΩClassType, 'classType', 'instance', () => __ΩHttpResultFormatterContext, () => router_js_1.RouteConfig, 'route', 'handleTypeEntity', 'Type', 'type', () => __ΩHttpResultFormatterContext, () => router_js_1.RouteConfig, 'handleType', 'stream', () => __ΩHttpResultFormatterContext, 'handleStream', () => __ΩHttpResultFormatterContext, 'handleBinary', () => __ΩHttpResultFormatterContext, 'handleResponse', () => __ΩSupportedHttpResult, () => __ΩHttpResultFormatterContext, 'handle', 'HttpResultFormatter', '&3!<>"&3#<>$PP7%2&<"0\'PP7(2)&2*$0+<Pn,2-n.2/$00PP-,J21n22/$03PP7421n52/$06P"21n72/$08PP7921n:2/$0;PP7<21n=2/$0>PP7?21n@2/$0AP"oB"2C"2DnE2/P7F2G8$0HP"wI2J"2DnK2/P7L2G8$0MP!2NnO2/$0PPW21nQ2/$0RPnS2/"0TPnU21nV2/$0W5wX'];
+class HttpListener {
+    constructor(router, logger, resultFormatter, stopwatch) {
         this.router = router;
         this.logger = logger;
+        this.resultFormatter = resultFormatter;
+        this.stopwatch = stopwatch;
     }
     onRequest(event) {
         if (event.sent)
@@ -262,14 +543,73 @@ let HttpListener = class HttpListener {
             return;
         event.next('route', new HttpRouteEvent(event.injectorContext, event.request, event.response));
     }
-    onRoute(event) {
+    async onRoute(event) {
         if (event.sent)
             return;
         if (event.hasNext())
             return;
-        const resolved = this.router.resolveRequest(event.request);
-        if (resolved) {
-            event.routeFound(resolved.routeConfig, resolved.parameters);
+        const logger = this.logger;
+        try {
+            const resolved = this.router.resolveRequest(event.request);
+            if (resolved) {
+                event.request.uploadedFiles = resolved.uploadedFiles;
+                //todo: embed that into the generated router code.
+                if (resolved.middlewares) {
+                    const middlewares = resolved.middlewares(event.injectorContext);
+                    if (middlewares.length) {
+                        await (0, core_1.asyncOperation)(__assignType(async (resolve, reject) => {
+                            let lastTimer = undefined;
+                            function finish() {
+                                clearTimeout(lastTimer);
+                                resolve(undefined);
+                                //middleware finished the request. We end the workflow transition
+                            }
+                            finish.__type = ['finish', 'P"/!'];
+                            event.response.once('finish', finish);
+                            let i = -1;
+                            async function next() {
+                                i++;
+                                if (i >= middlewares.length) {
+                                    event.response.off('finish', finish);
+                                    resolve(undefined);
+                                    return;
+                                }
+                                const timeout = middlewares[i].timeout;
+                                if (timeout !== undefined && timeout > 0) {
+                                    lastTimer = setTimeout(() => {
+                                        logger.warn(`Middleware timed out. Increase the timeout or fix the middleware. (${middlewares[i].fn})`);
+                                        next();
+                                    }, timeout);
+                                }
+                                try {
+                                    await middlewares[i].fn(event.request, event.response, __assignType((error) => {
+                                        if (lastTimer)
+                                            clearTimeout(lastTimer);
+                                        if (error) {
+                                            event.response.off('finish', finish);
+                                            reject(error);
+                                        }
+                                        else {
+                                            next();
+                                        }
+                                    }, ['error', '', 'P"2!8"/"']));
+                                }
+                                catch (error) {
+                                    reject(error);
+                                }
+                            }
+                            next.__type = ['next', 'P"/!'];
+                            await next();
+                        }, ['resolve', 'reject', '', 'P"2!"2""/#']));
+                    }
+                }
+                event.injectorContext.set(router_js_1.RouteConfig, resolved.routeConfig);
+                event.routeFound(resolved.routeConfig, resolved.parameters);
+            }
+        }
+        catch (error) {
+            this.logger.error('Could not resolve request', error);
+            event.notFound();
         }
     }
     onRouteForward(event) {
@@ -286,7 +626,12 @@ let HttpListener = class HttpListener {
             return;
         if (event.hasNext())
             return;
-        event.send(new HtmlResponse('Not found', 404));
+        if (event.request.throwErrorOnNotFound) {
+            throw new HttpNotFoundError;
+        }
+        else {
+            event.send(new HtmlResponse('Not found', 404));
+        }
     }
     onAuth(event) {
         if (event.sent)
@@ -320,33 +665,82 @@ let HttpListener = class HttpListener {
             return;
         if (event.hasNext())
             return;
-        const controllerInstance = event.injectorContext.get(event.route.action.controller);
+        const start = Date.now();
+        const stopWatchLabel = event.route.action.type === 'controller'
+            ? (0, core_1.getClassName)(event.route.action.controller) + '.' + event.route.action.methodName
+            : event.route.action.fn.name;
+        const frame = this.stopwatch ? this.stopwatch.start(stopWatchLabel, stopwatch_1.FrameCategory.httpController) : undefined;
         try {
-            const method = controllerInstance[event.route.action.methodName];
-            event.next('response', new HttpResponseEvent(event.injectorContext, event.request, event.response, await method.apply(controllerInstance, event.parameters), event.route));
+            let result;
+            if (event.route.action.type === 'controller') {
+                const controllerInstance = event.injectorContext.get(event.route.action.controller, event.route.action.module);
+                const method = controllerInstance[event.route.action.methodName];
+                result = await method.apply(controllerInstance, event.parameters.arguments);
+            }
+            else {
+                result = await event.route.action.fn(...event.parameters.arguments);
+            }
+            if (isElementStruct(result)) {
+                const html = await getTemplateRender()(event.injectorContext.getRootInjector(), result, this.stopwatch ? this.stopwatch : undefined);
+                result = new HtmlResponse(html, 200).header('Content-Type', 'text/html; charset=utf-8');
+            }
+            if (result instanceof stream_1.default.Readable) {
+                const stream = result;
+                await new Promise(__assignType((resolve, reject) => {
+                    stream.once('readable', resolve);
+                    stream.once('error', reject);
+                }, ['resolve', 'reject', '', 'P"2!"2""/#']));
+            }
+            const responseEvent = new HttpResponseEvent(event.injectorContext, event.request, event.response, result, event.route);
+            responseEvent.controllerActionTime = Date.now() - start;
+            event.next('response', responseEvent);
         }
         catch (error) {
+            if (frame)
+                frame.end();
             if (error instanceof HttpAccessDeniedError) {
-                event.next('accessDenied', new HttpAccessDeniedEvent(event.injectorContext, event.request, event.response, event.route));
+                event.next('accessDenied', new HttpAccessDeniedEvent(event.injectorContext, event.request, event.response, event.route, error));
             }
             else {
-                event.next('controllerError', new HttpControllerErrorEvent(event.injectorContext, event.request, event.response, event.route, error));
+                const errorEvent = new HttpControllerErrorEvent(event.injectorContext, event.request, event.response, event.route, error);
+                errorEvent.controllerActionTime = Date.now() - start;
+                event.next('controllerError', errorEvent);
             }
         }
+        finally {
+            if (frame)
+                frame.end();
+        }
     }
     onParametersFailed(event) {
         if (event.response.finished)
             return;
         if (event.sent)
             return;
-        this.logger.error('Controller parameter resolving error:', event.error);
-        if (event.error instanceof type_1.ValidationFailed) {
+        if (event.error instanceof type_1.SerializationError) {
+            event.send(new JSONResponse({
+                message: event.error.message,
+                errors: [{
+                        path: event.error.path,
+                        code: 'serialization',
+                        message: event.error.originalMessage,
+                    }]
+            }, 400).disableAutoSerializing());
+        }
+        else if (event.error instanceof type_1.ValidationError) {
             event.send(new JSONResponse({
                 message: event.error.message,
                 errors: event.error.errors
-            }, 500));
+            }, 400).disableAutoSerializing());
+        }
+        else if (event.error instanceof HttpError) {
+            event.send(new JSONResponse({
+                message: event.error.message
+            }, event.error.httpCode).disableAutoSerializing());
+            return;
         }
         else {
+            this.logger.error(`Controller for route ${event.route.getFullPath()} parameter resolving error:`, event.error);
             event.send(new HtmlResponse('Internal error', 500));
         }
     }
@@ -355,61 +749,68 @@ let HttpListener = class HttpListener {
             return;
         if (event.sent)
             return;
+        if (event.error instanceof type_1.ValidationError) {
+            event.send(new JSONResponse({
+                message: event.error.message,
+                errors: event.error.errors
+            }, 400).disableAutoSerializing());
+            return;
+        }
+        else if (event.error instanceof HttpError) {
+            if (event.request.throwErrorOnNotFound && event.error.httpCode === 404) {
+                throw event.error;
+            }
+            event.send(new JSONResponse({
+                message: event.error.message
+            }, event.error.httpCode).disableAutoSerializing());
+            return;
+        }
         this.logger.error('Controller error', event.error);
         event.send(new HtmlResponse('Internal error', 500));
     }
-    async onResponse(event) {
-        const response = event.result;
-        if (response === null || response === undefined) {
-            event.response.end(response);
-        }
-        else if ('string' === typeof response) {
-            event.response.end(response);
-        }
-        else if (response instanceof Redirect) {
-            if (response.routeName) {
-                event.response.writeHead(response.statusCode, {
-                    Location: this.router.resolveUrl(response.routeName, response.routeParameters)
-                });
-            }
-            else {
-                event.response.writeHead(response.statusCode, {
-                    Location: response.url
-                });
-            }
-            event.response.end();
-        }
-        else if (response instanceof http_1.ServerResponse || response instanceof model_1.HttpResponse) {
-        }
-        else if (response instanceof HtmlResponse) {
-            event.response.setHeader('Content-Type', 'text/html; charset=utf-8');
-            if (response.statusCode)
-                event.response.writeHead(response.statusCode);
-            event.response.end(response.html);
-        }
-        else if (template_1.isElementStruct(response)) {
-            event.response.setHeader('Content-Type', 'text/html; charset=utf-8');
-            event.response.end(await template_1.render(event.injectorContext, response));
-        }
-        else if (type_1.isClassInstance(response) && type_1.isRegisteredEntity(type_1.getClassTypeFromInstance(response))) {
-            event.response.setHeader('Content-Type', 'application/json; charset=utf-8');
-            event.response.end(JSON.stringify(type_1.jsonSerializer.for(type_1.getClassTypeFromInstance(response)).serialize(response)));
+    /**
+     * This happens before the result is sent.
+     */
+    async onResultSerialization(event) {
+        if (!event.route)
+            return;
+        if (event.response.headersSent)
+            return;
+        if (event.result === undefined || event.result === null)
+            return;
+        if (event.result instanceof HtmlResponse || event.result instanceof Response || event.result instanceof http_1.ServerResponse || event.result instanceof Redirect || event.result instanceof stream_1.default.Readable) {
+            // don't do anything
         }
-        else if (response instanceof Uint8Array) {
-            event.response.end(response);
+        else if (event.result instanceof JSONResponse) {
+            const schema = (event.result._statusCode && event.route.getSchemaForResponse(event.result._statusCode)) || event.route.returnType;
+            if (!schema || !event.result.autoSerializing)
+                return;
+            const serializerToUse = event.route && event.route.serializer ? event.route.serializer : type_1.serializer;
+            const serialize = (0, type_1.getSerializeFunction)(schema, serializerToUse.serializeRegistry);
+            event.result.json = serialize(event.result.json, event.route.serializationOptions);
         }
-        else if (response instanceof JSONResponse) {
-            event.response.setHeader('Content-Type', 'application/json; charset=utf-8');
-            if (response.statusCode)
-                event.response.writeHead(response.statusCode);
-            event.response.end(JSON.stringify(response.json));
+        else if (event.route.returnType && event.route.returnType.kind !== type_1.ReflectionKind.any) {
+            const serializerToUse = event.route && event.route.serializer ? event.route.serializer : type_1.serializer;
+            const serialize = (0, type_1.getSerializeFunction)(event.route.returnType, serializerToUse.serializeRegistry);
+            event.result = serialize(event.result, event.route.serializationOptions);
         }
         else {
-            event.response.setHeader('Content-Type', 'application/json; charset=utf-8');
-            event.response.end(JSON.stringify(response));
+            const schema = event.route.getSchemaForResponse(200);
+            if (!schema)
+                return;
+            const serializerToUse = event.route && event.route.serializer ? event.route.serializer : type_1.serializer;
+            const serialize = (0, type_1.getSerializeFunction)(schema, serializerToUse.serializeRegistry);
+            event.result = serialize(event.result, event.route.serializationOptions);
         }
     }
-};
+    async onResponse(event) {
+        if (event.response.headersSent)
+            return;
+        this.resultFormatter.handle(event.result, event);
+    }
+}
+exports.HttpListener = HttpListener;
+HttpListener.__type = [() => router_js_1.HttpRouter, 'router', () => __ΩLoggerInterface, 'logger', () => HttpResultFormatter, 'resultFormatter', () => stopwatch_1.Stopwatch, 'stopwatch', 'constructor', () => exports.httpWorkflow.onRequest.event, 'event', 'onRequest', () => exports.httpWorkflow.onRoute.event, 'onRoute', () => exports.httpWorkflow.onRoute.event, 'onRouteForward', () => exports.httpWorkflow.onRouteNotFound.event, 'routeNotFound', () => exports.httpWorkflow.onAuth.event, 'onAuth', () => exports.httpWorkflow.onResolveParameters.event, 'onResolveParameters', () => exports.httpWorkflow.onAccessDenied.event, 'onAccessDenied', () => exports.httpWorkflow.onController.event, 'onController', () => exports.httpWorkflow.onParametersFailed.event, 'onParametersFailed', () => exports.httpWorkflow.onControllerError.event, 'onControllerError', () => exports.httpWorkflow.onResponse.event, 'onResultSerialization', () => exports.httpWorkflow.onResponse.event, 'onResponse', 'HttpListener', 'PP7!2"<n#2$<P7%2&<P7\'2(8<"0)Pi*2+$0,Pi-2+"0.Pi/2+"00Pi12+$`02Pi32+$04Pi52+"06Pi72+$08Pi92+"0:Pi;2+$0<Pi=2+$0>Pi?2+"0@PiA2+"0B5wC'];
 __decorate([
     event_1.eventDispatcher.listen(exports.httpWorkflow.onRequest, 100),
     __metadata("design:type", Function),
@@ -420,7 +821,7 @@ __decorate([
     event_1.eventDispatcher.listen(exports.httpWorkflow.onRoute, 100),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
+    __metadata("design:returntype", Promise)
 ], HttpListener.prototype, "onRoute", null);
 __decorate([
     event_1.eventDispatcher.listen(exports.httpWorkflow.onRoute, 1000),
@@ -470,16 +871,16 @@ __decorate([
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
 ], HttpListener.prototype, "onControllerError", null);
+__decorate([
+    event_1.eventDispatcher.listen(exports.httpWorkflow.onResponse, -100),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], HttpListener.prototype, "onResultSerialization", null);
 __decorate([
     event_1.eventDispatcher.listen(exports.httpWorkflow.onResponse, 100),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
 ], HttpListener.prototype, "onResponse", null);
-HttpListener = __decorate([
-    injector_1.injectable(),
-    __metadata("design:paramtypes", [router_1.Router,
-        logger_1.Logger])
-], HttpListener);
-exports.HttpListener = HttpListener;
 //# sourceMappingURL=http.js.map