web_api_base 5.0.0 → 5.1.1

package/dist/Application.d.ts

@@ -0,0 +1,28 @@
+import { Express } from "express";
+import IApplication, { ApplicationExceptionHandler } from "./interfaces/IApplication";
+import IApplicationConfiguration from "./interfaces/IApplicationConfiguration";
+import { ControllerBase } from "./controllers/base/ControllerBase";
+import AbstractMultiPartRequestService from "./File/AbstractMultiPartRequestService";
+export default abstract class Application implements IApplication {
+    static Configurations: IApplicationConfiguration;
+    private _createdControllers;
+    private _URIs;
+    ApplicationConfiguration: IApplicationConfiguration;
+    Express: Express;
+    ApplicationThreadExeptionHandler?: ApplicationExceptionHandler;
+    constructor();
+    StartAsync(): Promise<void>;
+    protected UseCors(): void;
+    private GetIgnoredPaths;
+    private TryFindControllerFolder;
+    protected UseControllersAsync(root?: string): Promise<void>;
+    protected UseCustomMultiPartRequestHandler<T extends AbstractMultiPartRequestService>(cTor: new (...args: any[]) => T): void;
+    protected AppendController<T extends ControllerBase>(ctor: {
+        new (...args: any[]): T;
+    }): void;
+    CreateDocumentation(): void;
+    private SendResponseIfNecessary;
+    private CastToExpection;
+    private CallErrorHandler;
+    abstract ConfigureAsync(appConfig: IApplicationConfiguration): Promise<void>;
+}

package/dist/Application.js

@@ -0,0 +1,626 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const ApplicationConfiguration_1 = __importDefault(require("./ApplicationConfiguration"));
+const ControllerDecorators_1 = __importDefault(require("./decorators/controllers/ControllerDecorators"));
+const DependecyService_1 = __importDefault(require("./dependencyInjection/DependecyService"));
+const HttpVerbs_1 = require("./enums/httpVerbs/HttpVerbs");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ValidationDecorators_1 = __importDefault(require("./decorators/validations/ValidationDecorators"));
+const ControllerLoadException_1 = __importDefault(require("./exceptions/ControllerLoadException"));
+const Exception_1 = __importDefault(require("./exceptions/Exception"));
+const Documentation_1 = __importDefault(require("./documentation/Documentation"));
+const ActionResult_1 = __importDefault(require("./controllers/ActionResult"));
+const BodyParseException_1 = __importDefault(require("./exceptions/BodyParseException"));
+const AbstractMultiPartRequestService_1 = __importStar(require("./File/AbstractMultiPartRequestService"));
+const FormidableMultiPartRequestService_1 = __importDefault(require("./File/FormidableMultiPartRequestService"));
+const File_1 = __importDefault(require("./File/File"));
+const Type_1 = __importDefault(require("./metadata/Type"));
+class Application {
+    constructor() {
+        this._createdControllers = [];
+        this._URIs = [];
+        this.ApplicationConfiguration = new ApplicationConfiguration_1.default();
+        this.Express = (0, express_1.default)();
+    }
+    StartAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ApplicationConfiguration.LoadAsync();
+            Application.Configurations = this.ApplicationConfiguration;
+            this.Express.use(express_1.default.json({ limit: 50 * 1024 * 1024 }));
+            this.ApplicationConfiguration.AddScoped(AbstractMultiPartRequestService_1.default, FormidableMultiPartRequestService_1.default);
+            yield this.ConfigureAsync(this.ApplicationConfiguration);
+            if (this.ApplicationConfiguration)
+                this.Express.use((e, rq, rs, n) => {
+                    if (e && e instanceof Error && e instanceof SyntaxError) {
+                        let b = new BodyParseException_1.default(e.message);
+                        b.stack = e.stack;
+                        this.CallErrorHandler(rq, rs, b);
+                    }
+                    else
+                        n();
+                });
+            yield this.ApplicationConfiguration.SaveAsync();
+            this.Express.listen(this.ApplicationConfiguration.Port, this.ApplicationConfiguration.Host, () => {
+                console.log(`Application running on ${this.ApplicationConfiguration.Host}:${this.ApplicationConfiguration.Port}`);
+            });
+        });
+    }
+    UseCors() {
+        this.Express.use(require('cors')());
+    }
+    GetIgnoredPaths() {
+        return [
+            ".git",
+            ".vscode",
+            "coverage",
+            "node_modules"
+        ];
+    }
+    TryFindControllerFolder(path) {
+        if (this.GetIgnoredPaths().filter(s => path.endsWith(s)).length > 0)
+            return undefined;
+        if (path.indexOf("node_modules") > -1)
+            return undefined;
+        if (!fs_1.default.existsSync(path))
+            return undefined;
+        if (fs_1.default.readdirSync(path).filter(s => s.toLowerCase().endsWith("controller.js")).length > 0)
+            return path;
+        let folder = fs_1.default.readdirSync(path).filter(s => !fs_1.default.lstatSync(path_1.default.join(path, s)).isFile());
+        if (folder.length == 0)
+            return undefined;
+        for (let f of folder) {
+            let find = this.TryFindControllerFolder(path_1.default.join(path, f));
+            if (find && find.toLowerCase().endsWith("controllers"))
+                return find;
+        }
+        return undefined;
+    }
+    UseControllersAsync(root) {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            let controllersPath = this.TryFindControllerFolder(path_1.default.join(root !== null && root !== void 0 ? root : this.ApplicationConfiguration.RootPath, "controllers"));
+            if (!controllersPath)
+                controllersPath = this.TryFindControllerFolder(root !== null && root !== void 0 ? root : this.ApplicationConfiguration.RootPath);
+            if (!controllersPath || !fs_1.default.existsSync(controllersPath))
+                return;
+            console.debug(`reading controllers in ${controllersPath}`);
+            let files = fs_1.default.readdirSync(controllersPath).filter(s => s.toLowerCase().endsWith("controller.js"));
+            for (let controllerFile of files) {
+                let controllerModule = yield Promise.resolve(`${path_1.default.join(controllersPath, controllerFile)}`).then(s => __importStar(require(s)));
+                let controllerClass = undefined;
+                if (controllerModule.default == undefined) {
+                    for (let c in controllerModule) {
+                        if (c.toLowerCase().endsWith("controller")) {
+                            controllerClass = controllerModule[c];
+                        }
+                    }
+                }
+                else
+                    controllerClass = controllerModule.default;
+                if (controllerClass == undefined)
+                    throw new ControllerLoadException_1.default(`Can find any controller from file : ${controllerFile}`);
+                let controller = Reflect.construct(controllerClass.prototype.constructor, []);
+                if (controller != undefined && controller != null) {
+                    this.AppendController(controllerClass.prototype.constructor);
+                }
+                else {
+                    throw new ControllerLoadException_1.default(`Can not load ${controllerClass.name} controller from file : ${controllerFile}`);
+                }
+            }
+            resolve();
+        }));
+    }
+    UseCustomMultiPartRequestHandler(cTor) {
+        this.ApplicationConfiguration.AddScoped(AbstractMultiPartRequestService_1.default, cTor);
+    }
+    AppendController(ctor) {
+        let empty = new ctor();
+        let methods = Reflect.ownKeys(empty.constructor.prototype).filter(m => {
+            return typeof empty[m] == "function";
+        });
+        let route = ControllerDecorators_1.default.GetRoute(empty);
+        let validateBody = ControllerDecorators_1.default.IsToValidate(empty);
+        if (!route)
+            return;
+        this._createdControllers.push(ctor);
+        for (let method of methods) {
+            let action = ControllerDecorators_1.default.GetAction(empty, method.toString());
+            if (!action) {
+                continue;
+            }
+            let verb = ControllerDecorators_1.default.GetVerb(empty, method.toString());
+            let fromBody = ControllerDecorators_1.default.GetFromBodyArgs(empty.constructor, method.toString());
+            let fromQuery = ControllerDecorators_1.default.GetFromQueryArgs(empty.constructor, method.toString());
+            let fromFiles = ControllerDecorators_1.default.GetFromFilesArgs(empty.constructor, method.toString());
+            let maxFilesSize = ControllerDecorators_1.default.GetMaxFilesSize(empty.constructor);
+            let headers = ControllerDecorators_1.default.GetHeaders(empty.constructor);
+            ControllerDecorators_1.default.GetNonDecoratedArguments(empty, method, fromBody, fromQuery, fromFiles);
+            if (!verb)
+                verb = HttpVerbs_1.HTTPVerbs.GET;
+            if (verb == HttpVerbs_1.HTTPVerbs.GET && fromBody.length > 0)
+                throw new ControllerLoadException_1.default(`GET method: ${ctor.name}.${method.toString()} can not have body params`);
+            let collision = this._URIs.filter(s => s.URI == `${route}${action}`);
+            if (collision.length > 0)
+                throw new ControllerLoadException_1.default(`The URI: ${route}${action} exists in two controllers: ${collision[0].Controller} and ${ctor.name}.${method.toString()}`);
+            console.debug("appended : ", verb, `${route}${action}`);
+            this._URIs.push({ URI: `${route}${action}`, Controller: `${ctor.name}.${method.toString()}` });
+            this.Express[verb.toString().toLowerCase()](`${route}${action}`, (request, response) => __awaiter(this, void 0, void 0, function* () {
+                let midlewares = ControllerDecorators_1.default.GetMidlewares(empty).map(s => s).reverse();
+                midlewares.push(...ControllerDecorators_1.default.GetBefores(empty, method.toString()).map(s => s).reverse());
+                let afters = ControllerDecorators_1.default.GetMidlewaresAfter(empty).map(s => s).reverse();
+                afters.push(...ControllerDecorators_1.default.GetAfters(empty, method.toString()).map(s => s).reverse());
+                let handler = (context) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b;
+                    for (let h of headers) {
+                        if (!request.headers[h]) {
+                            response.status(400);
+                            response.json({
+                                Message: "Header missing",
+                                Detailts: `Header ${h} is required to this endpoint`
+                            });
+                        }
+                    }
+                    let params = [];
+                    let ts = ((_b = ((_a = Reflect.getMetadata("design:paramtypes", empty, method.toString())) !== null && _a !== void 0 ? _a : Reflect.getMetadata("design:paramtypes", empty.constructor, method.toString()))) !== null && _b !== void 0 ? _b : []);
+                    let content_type = request.headers["content-type"];
+                    let isMultiPartFormData = content_type && content_type.indexOf('multipart/form-data') > -1;
+                    let parts = [];
+                    let fromFilesParams = [];
+                    if (isMultiPartFormData) {
+                        let multiPartService = DependecyService_1.default.Resolve(AbstractMultiPartRequestService_1.default);
+                        try {
+                            parts = yield multiPartService.GetPartsFromRequestAsync(request, { MaxFileSize: maxFilesSize });
+                        }
+                        catch (err) {
+                            return this.CallErrorHandler(request, response, this.CastToExpection(err));
+                        }
+                        for (let f of fromFiles) {
+                            let fs = parts === null || parts === void 0 ? void 0 : parts.filter(s => s.Type == AbstractMultiPartRequestService_1.PartType.FILE);
+                            if (fs.length > 0) {
+                                if (f.FileName) {
+                                    let files = fs.filter(s => s.Filename == f.FileName);
+                                    if (files.length > 0) {
+                                        let fileClass = new File_1.default(files[0].Filename, files[0].Content);
+                                        fromFilesParams.push(fileClass);
+                                        params[f.Index] = fileClass;
+                                    }
+                                }
+                                else {
+                                    let fileClass = new File_1.default(fs[0].Filename, fs[0].Content);
+                                    fromFilesParams.push(fileClass);
+                                    params[f.Index] = fileClass;
+                                }
+                            }
+                        }
+                    }
+                    let fromBodyParams = [];
+                    if (fromBody.length > 0) {
+                        fromBody.sort((a, b) => a.Index - b.Index).forEach(f => {
+                            let obj = undefined;
+                            if (!f.Field || f.Type.name == "Object") {
+                                let fieldParts = parts.filter(s => s.Name == 'body');
+                                if (isMultiPartFormData && fieldParts.length > 0) {
+                                    try {
+                                        obj = JSON.parse(fieldParts[0].Content);
+                                    }
+                                    catch (_a) {
+                                        obj = fieldParts[0].Content;
+                                    }
+                                }
+                                else {
+                                    obj = request.body;
+                                }
+                            }
+                            else {
+                                let fieldParts = parts.filter(s => s.Name == f.Field);
+                                if (isMultiPartFormData && fieldParts.length > 0) {
+                                    try {
+                                        obj = JSON.parse(fieldParts[0].Content);
+                                    }
+                                    catch (_b) {
+                                        obj = fieldParts[0].Content;
+                                    }
+                                }
+                                else {
+                                    obj = request.body[f.Field];
+                                }
+                            }
+                            if (["string", "number", "boolean", "bigint"].filter(s => s == ts[f.Index].name.toLowerCase()).length == 0) {
+                                try {
+                                    obj.__proto__ = ts[f.Index];
+                                }
+                                catch (_c) { }
+                                if (f.Type.name == "Object") {
+                                    fromBodyParams.push(obj);
+                                    params[f.Index] = obj;
+                                }
+                                else {
+                                    let t = Reflect.construct(ts[f.Index], []);
+                                    Object.assign(t, obj);
+                                    fromBodyParams.push(t);
+                                    params[f.Index] = t;
+                                }
+                            }
+                            else {
+                                if (obj != undefined && typeof obj == "string" && obj.indexOf('"') == 0 && obj.lastIndexOf('"') == obj.length - 1)
+                                    obj = obj.substring(1, obj.length - 1);
+                                if (obj != undefined && ts[f.Index].name.toLowerCase() == "number") {
+                                    let number = Number.parseFloat(obj.toString());
+                                    if (number != Number.NaN) {
+                                        fromBodyParams.push(number);
+                                        params[f.Index] = number;
+                                    }
+                                    else {
+                                        fromBodyParams.push(undefined);
+                                        params[f.Index] = undefined;
+                                    }
+                                }
+                                else if (obj != undefined && ts[f.Index].name.toLowerCase() == "string") {
+                                    fromBodyParams.push(obj.toString());
+                                    params[f.Index] = obj.toString();
+                                }
+                                else if (obj != undefined && ts[f.Index].name.toLowerCase() == "date") {
+                                    try {
+                                        fromBodyParams.push(new Date(obj));
+                                        params[f.Index] = new Date(obj);
+                                    }
+                                    catch (_d) { }
+                                }
+                                else {
+                                    fromBodyParams.push(obj);
+                                    params[f.Index] = obj;
+                                }
+                            }
+                        });
+                    }
+                    let fromQueryParams = [];
+                    if (fromQuery.length > 0) {
+                        fromQuery.sort((a, b) => a.Index - b.Index).forEach((f, j) => {
+                            var _a;
+                            let obj;
+                            obj = (_a = request.query[f.Field]) === null || _a === void 0 ? void 0 : _a.toString();
+                            if (obj != undefined && typeof obj == "string" && obj.indexOf('"') == 0 && obj.lastIndexOf('"') == obj.length - 1)
+                                obj = obj.substring(1, obj.length - 1);
+                            if (obj != undefined && f.Type.name.toLowerCase() == "number") {
+                                let number = Number.parseFloat(obj.toString());
+                                if (number != Number.NaN) {
+                                    fromQueryParams.push(number);
+                                    params[f.Index] = number;
+                                }
+                                else {
+                                    fromBodyParams.push(undefined);
+                                    params[f.Index] = undefined;
+                                }
+                            }
+                            else if (obj != undefined && f.Type.name.toLowerCase() == "string") {
+                                fromQueryParams.push(obj.toString());
+                                params[f.Index] = obj.toString();
+                            }
+                            else if (obj != undefined && f.Type.name.toLowerCase() == "date") {
+                                try {
+                                    fromQueryParams.push(new Date(obj));
+                                    params[f.Index] = new Date(obj);
+                                }
+                                catch (_b) { }
+                            }
+                            else if (obj != undefined && f.Type.name.toLowerCase() == "boolean") {
+                                try {
+                                    if (typeof obj != "boolean") {
+                                        let v = obj.toString().toLowerCase() == "true";
+                                        fromQueryParams.push(v);
+                                        params[f.Index] = v;
+                                    }
+                                    else {
+                                        fromQueryParams.push(obj);
+                                        params[f.Index] = obj;
+                                    }
+                                }
+                                catch (_c) { }
+                            }
+                            else {
+                                fromQueryParams.push(obj);
+                                params[f.Index] = obj;
+                            }
+                        });
+                    }
+                    if (validateBody) {
+                        if (fromBody.length > 0) {
+                            let modelBindErros = [];
+                            for (let p of fromBody) {
+                                if (p.Required && (params.length <= p.Index || params[p.Index] == undefined)) {
+                                    modelBindErros.push(p);
+                                }
+                                else {
+                                    try {
+                                        Type_1.default.ValidateType(params[p.Index], ts[p.Index]);
+                                    }
+                                    catch (e) {
+                                        response.status(400);
+                                        response.json({
+                                            Message: "Model binding fail",
+                                            Detailts: e.message
+                                        });
+                                        return;
+                                    }
+                                }
+                            }
+                            if (modelBindErros.length > 0) {
+                                response.status(400);
+                                response.json({
+                                    Message: "Model binding fail",
+                                    Detailts: modelBindErros.map(s => `Parameter "${s.Field}" is required`)
+                                });
+                                return;
+                            }
+                        }
+                        if (fromQuery.length > 0) {
+                            let modelBindErros = [];
+                            for (let p of fromQuery) {
+                                if (p.Required && (params.length <= p.Index || params[p.Index] == undefined)) {
+                                    modelBindErros.push(p);
+                                }
+                            }
+                            if (modelBindErros.length > 0) {
+                                response.status(400);
+                                response.json({
+                                    Message: "Model binding fail",
+                                    Detailts: modelBindErros.map(s => `Parameter "${s.Field}" is required`)
+                                });
+                                return;
+                            }
+                        }
+                        if (fromFiles.length > 0) {
+                            let modelBindErros = [];
+                            for (let p of fromFiles) {
+                                if (p.Required && (params.length <= p.Index || params[p.Index] == undefined)) {
+                                    modelBindErros.push(p);
+                                }
+                            }
+                            if (modelBindErros.length > 0) {
+                                response.status(400);
+                                response.json({
+                                    Message: "Model binding fail",
+                                    Detailts: modelBindErros.map(s => `The file ${(s.FileName ? `"${s.FileName} "` : "")}is required`)
+                                });
+                                return;
+                            }
+                        }
+                        let validationsErrors = [];
+                        for (let a of fromBodyParams) {
+                            try {
+                                validationsErrors.push(...ValidationDecorators_1.default.Validate(a).map(s => s.Message));
+                            }
+                            catch (_c) { }
+                        }
+                        if (validationsErrors.length > 0) {
+                            response.status(400);
+                            response.json({
+                                Message: "Validation fail",
+                                Detailts: validationsErrors
+                            });
+                            return;
+                        }
+                    }
+                    let controller = DependecyService_1.default.ResolveCtor(empty.constructor);
+                    if (controller == undefined)
+                        controller = new ctor();
+                    try {
+                        DependecyService_1.default.CheckForDependenciesAndResolve(controller);
+                    }
+                    catch (err) {
+                        this.CallErrorHandler(request, response, this.CastToExpection(err));
+                    }
+                    controller.Request = context.Request;
+                    controller.Response = context.Response;
+                    try {
+                        let exceutionTask = controller[method](...params);
+                        if (exceutionTask instanceof Promise) {
+                            try {
+                                let c = yield exceutionTask;
+                                for (let afterHandler of afters) {
+                                    try {
+                                        yield afterHandler({
+                                            Request: request,
+                                            Response: response,
+                                            Result: c
+                                        });
+                                    }
+                                    catch (subErr) {
+                                        return this.CallErrorHandler(request, response, this.CastToExpection(subErr));
+                                    }
+                                }
+                                this.SendResponseIfNecessary(controller, response, c);
+                            }
+                            catch (err) {
+                                for (let afterHandler of afters) {
+                                    try {
+                                        yield afterHandler({
+                                            Exception: this.CastToExpection(err),
+                                            Request: request,
+                                            Response: response
+                                        });
+                                    }
+                                    catch (subErr) {
+                                        return this.CallErrorHandler(request, response, this.CastToExpection(subErr));
+                                    }
+                                }
+                                if (afters.length == 0)
+                                    this.CallErrorHandler(request, response, this.CastToExpection(err));
+                            }
+                        }
+                        else {
+                            for (let afterHandler of afters) {
+                                try {
+                                    yield afterHandler({
+                                        Request: request,
+                                        Response: response,
+                                        Result: exceutionTask
+                                    });
+                                }
+                                catch (err) {
+                                    this.CallErrorHandler(request, response, this.CastToExpection(err));
+                                }
+                            }
+                            this.SendResponseIfNecessary(controller, response, exceutionTask);
+                        }
+                    }
+                    catch (err) {
+                        for (let afterHandler of afters) {
+                            try {
+                                yield afterHandler({
+                                    Exception: this.CastToExpection(err),
+                                    Request: request,
+                                    Response: response
+                                });
+                            }
+                            catch (subErr) {
+                                this.CallErrorHandler(request, response, this.CastToExpection(subErr));
+                            }
+                        }
+                        if (afters.length == 0)
+                            this.CallErrorHandler(request, response, this.CastToExpection(err));
+                    }
+                });
+                if (midlewares && midlewares.length > 0) {
+                    let httpRequestContexts = [];
+                    let pipeline = [];
+                    for (let i = 0; i <= midlewares.length; i++) {
+                        httpRequestContexts.push({
+                            Request: request,
+                            Response: response,
+                            Next: () => __awaiter(this, void 0, void 0, function* () { })
+                        });
+                    }
+                    for (let i = 0; i < httpRequestContexts.length; i++) {
+                        let box = {
+                            v: i
+                        };
+                        pipeline.push({
+                            Execute: () => __awaiter(this, void 0, void 0, function* () {
+                                try {
+                                    pipeline.length - 1 == box.v ? yield handler(httpRequestContexts[box.v]) : yield midlewares[box.v](httpRequestContexts[box.v]);
+                                }
+                                catch (err) {
+                                    this.CallErrorHandler(request, response, this.CastToExpection(err));
+                                }
+                            })
+                        });
+                    }
+                    for (let i = 0; i < pipeline.length; i++) {
+                        httpRequestContexts[i].Next = i == pipeline.length - 1 ? () => __awaiter(this, void 0, void 0, function* () { }) : () => __awaiter(this, void 0, void 0, function* () {
+                            try {
+                                yield pipeline[i + 1].Execute();
+                            }
+                            catch (err) {
+                                this.CallErrorHandler(request, response, this.CastToExpection(err));
+                            }
+                        });
+                    }
+                    yield pipeline[0].Execute();
+                }
+                else {
+                    yield handler({
+                        Request: request,
+                        Response: response,
+                        Next: () => __awaiter(this, void 0, void 0, function* () { })
+                    });
+                }
+            }));
+        }
+    }
+    CreateDocumentation() {
+        new Documentation_1.default().CreateDocumentation(this._createdControllers, this.Express);
+    }
+    SendResponseIfNecessary(controller, response, result) {
+        if (response.headersSent)
+            return;
+        if (!result) {
+            controller.SendResponse(204);
+            return;
+        }
+        if (result instanceof ActionResult_1.default) {
+            controller.SendResponse(result.StatusCode, result.Result);
+            return;
+        }
+        controller.SendResponse(200, result);
+    }
+    CastToExpection(err) {
+        let ex;
+        if (err instanceof Exception_1.default)
+            ex = err;
+        else {
+            ex = new Exception_1.default(err.message);
+            ex.stack = err.stack;
+        }
+        return ex;
+    }
+    CallErrorHandler(request, response, exception) {
+        let defaultHandler = (request, response, exception) => {
+            try {
+                if (response.headersSent)
+                    return;
+                response.status(500);
+                response.json(exception);
+            }
+            catch (err) {
+                console.log("Error while trying handle the error");
+                console.log(err);
+            }
+            finally {
+                console.log("Inner exception");
+                console.log(exception);
+            }
+        };
+        if (this.ApplicationThreadExeptionHandler != undefined) {
+            try {
+                this.ApplicationThreadExeptionHandler(request, response, this.CastToExpection(exception));
+            }
+            catch (err) {
+                console.log("Error while trying handle the error with custom delegate");
+                console.log(err);
+                defaultHandler(request, response, this.CastToExpection(err));
+            }
+        }
+        else {
+            defaultHandler(request, response, this.CastToExpection(exception));
+        }
+    }
+}
+exports.default = Application;
+//# sourceMappingURL=Application.js.map