tspace-spear 1.0.0-rc

package/build/lib/core/server/index.js

@@ -0,0 +1,868 @@
+"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 });
+exports.Application = exports.Spear = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const find_my_way_1 = __importDefault(require("find-my-way"));
+const formidable_1 = __importDefault(require("formidable"));
+const url_1 = require("url");
+const on_finished_1 = __importDefault(require("on-finished"));
+const string_decoder_1 = require("string_decoder");
+const http_1 = __importStar(require("http"));
+/**
+ *
+ * The 'Spear' class is used to create a server and handle HTTP requests.
+ *
+ * @returns {Spear} application
+ * @example
+ * new Application()
+ *  .get('/' , () => 'Hello world!')
+ *  .get('/json' , () => {
+ *     return {
+ *       message : 'Hello world!'
+ *     }
+ *   })
+ *  .listen(3000 , () => console.log('server listening on port : 3000'))
+ *
+ */
+class Spear {
+    constructor({ controllers, middlewares, globalPrefix, logger } = {}) {
+        this._router = (0, find_my_way_1.default)();
+        this._errorHandler = null;
+        this._globalMiddlewares = [];
+        this._formatResponse = null;
+        this._onListeners = [];
+        this._fileUploadOptions = {
+            limits: Infinity,
+            useTempFiles: false,
+            tempFileDir: 'tmp',
+            removeTempFile: {
+                remove: true,
+                ms: 1000 * 60 * 10
+            }
+        };
+        this._filesParser = (req) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const temp = this._fileUploadOptions.tempFileDir;
+                if (!fs_1.default.existsSync(temp)) {
+                    try {
+                        fs_1.default.mkdirSync(temp, { recursive: true });
+                    }
+                    catch (err) { }
+                }
+                const form = (0, formidable_1.default)({ uploadDir: temp });
+                const [dataBody, dataFiles] = yield form.parse(req);
+                const files = {};
+                const body = {};
+                const removeTemp = (fileTemp) => {
+                    if (!this._fileUploadOptions.removeTempFile.remove)
+                        return;
+                    const remove = () => fs_1.default.unlinkSync(fileTemp);
+                    setTimeout(remove, this._fileUploadOptions.removeTempFile.ms);
+                };
+                for (const key in dataFiles) {
+                    const v = dataFiles[key];
+                    if (v == null)
+                        continue;
+                    const file = v[0];
+                    if (file.size > this._fileUploadOptions.limits) {
+                        fs_1.default.unlinkSync(file.filepath);
+                        continue;
+                    }
+                    files[key] = {
+                        size: file.size,
+                        tempFilePath: file.filepath,
+                        tempFileName: file.newFilename,
+                        mimetype: file.mimetype,
+                        name: file.originalFilename
+                    };
+                    removeTemp(file.filepath);
+                }
+                for (const key in dataBody) {
+                    const v = dataBody[key];
+                    if (v == null)
+                        continue;
+                    body[key] = v[0];
+                }
+                return {
+                    body,
+                    files
+                };
+            }
+            catch (e) {
+                return {
+                    body: {},
+                    files: {}
+                };
+            }
+        });
+        this._bodyParser = (req) => {
+            if ((req === null || req === void 0 ? void 0 : req._writeParserEnd) === true)
+                return req._bodyParser;
+            return new Promise((resolve, reject) => {
+                const decoder = new string_decoder_1.StringDecoder('utf-8');
+                let payload = '';
+                req.on('data', (data) => {
+                    payload += decoder.write(data);
+                });
+                req.on('end', () => {
+                    try {
+                        payload += decoder.end();
+                        req._writeParserEnd = true;
+                        req._bodyParser = JSON.parse(payload);
+                        return resolve(JSON.parse(payload));
+                    }
+                    catch (e) {
+                        req._writeParserEnd = true;
+                        req._bodyParser = {};
+                        return resolve({});
+                    }
+                });
+                req.on('error', (err) => {
+                    req._writeParserEnd = true;
+                    req._bodyParser = {};
+                    return reject(err);
+                });
+            });
+        };
+        this._wrapHandlers = (...handlers) => {
+            return (req, res, params) => __awaiter(this, void 0, void 0, function* () {
+                const runHandler = (index = 0) => __awaiter(this, void 0, void 0, function* () {
+                    const response = this._customizeResponse(req, res);
+                    const request = req;
+                    const body = request._bodyParser;
+                    const files = request._filesParser;
+                    const cookies = request._cookiesParser;
+                    const query = Object.assign({}, (0, url_1.parse)(String(req.url), true).query);
+                    const objectOrNull = (data) => {
+                        if (data == null)
+                            return null;
+                        return Object.keys(data).length ? data : null;
+                    };
+                    const ctx = {
+                        req: request,
+                        res: response,
+                        params: objectOrNull(params),
+                        query: objectOrNull(query),
+                        body: objectOrNull(body),
+                        files: objectOrNull(files),
+                        cookies: objectOrNull(cookies),
+                    };
+                    if (index === handlers.length - 1) {
+                        return this._wrapResponse(handlers[index].bind(handlers[index]))(ctx, this._nextFunction(ctx));
+                    }
+                    return handlers[index](ctx, () => {
+                        return runHandler(index + 1);
+                    });
+                });
+                yield runHandler()
+                    .catch(err => {
+                    const ctx = {
+                        req,
+                        res: this._customizeResponse(req, res),
+                        params: Object.keys(params).length ? params : null,
+                        query: null,
+                        body: null,
+                        files: null,
+                        cookies: null
+                    };
+                    return this._nextFunction(ctx)(err);
+                });
+            });
+        };
+        if (logger)
+            this._onListeners.push(() => this.use(this._logger));
+        this._controllers = controllers;
+        this._middlewares = middlewares;
+        this._globalPrefix = globalPrefix == null ? '' : globalPrefix;
+    }
+    /**
+     * The 'enableCors' is used to enable the cors origins on the server.
+     *
+     * @params {Object}
+     * @property {(string | RegExp)[]} origins
+     * @property {boolean} credentials
+     * @returns
+     */
+    enableCors({ origins, credentials } = {}) {
+        this._globalMiddlewares.push(({ req, res }, next) => {
+            var _a;
+            const origin = (_a = req.headers) === null || _a === void 0 ? void 0 : _a.origin;
+            if (origin == null)
+                return next();
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            if (origins == null) {
+                res.setHeader('Access-Control-Allow-Origin', '*');
+            }
+            if (Array.isArray(origins) && origins.length) {
+                if (origins.includes(origin)) {
+                    res.setHeader('Access-Control-Allow-Origin', origin);
+                }
+            }
+            if (credentials) {
+                res.setHeader('Access-Control-Allow-Credentials', 'true');
+            }
+            return next();
+        });
+        return this;
+    }
+    /**
+     * The 'use' method is used to add the middleware into the request pipeline.
+     *
+     * @callback {Function} middleware
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    use(middleware) {
+        this._globalMiddlewares.push(middleware);
+        return this;
+    }
+    /**
+     * The 'useRouter' method is used to add the router in the request context.
+     *
+     * @parms {Function} router
+     * @property  {Function} router - get() , post() , put() , patch() , delete()
+     * @returns {this}
+     */
+    useRouter(router) {
+        const routes = router.routes;
+        for (const { path, method, handlers } of routes) {
+            this[method](this._normalizePath(this._globalPrefix, path), ...handlers);
+        }
+        return this;
+    }
+    /**
+     * The 'useBodyParser' method is a middleware used to parse the request body of incoming HTTP requests.
+     *
+     * @returns {this}
+     */
+    useBodyParser() {
+        this._globalMiddlewares.push(({ req, res }, next) => __awaiter(this, void 0, void 0, function* () {
+            const contentType = req === null || req === void 0 ? void 0 : req.headers['content-type'];
+            const isFileUpload = contentType && contentType.startsWith('multipart/form-data');
+            const isListMethods = ['POST', 'PATCH', 'PUT'].includes(String(req.method));
+            if (!isListMethods)
+                return next();
+            if (isFileUpload)
+                return next();
+            if ((req === null || req === void 0 ? void 0 : req._bodyParser) != null)
+                return next();
+            req._bodyParser = yield this._bodyParser(req);
+            return next();
+        }));
+        return this;
+    }
+    /**
+     * The 'useCookiesParser' method is a middleware used to parses cookies attached to the client request object.
+     *
+     * @returns {this}
+     */
+    useCookiesParser() {
+        this._globalMiddlewares.push(({ req }, next) => {
+            if ((req === null || req === void 0 ? void 0 : req._cookiesParser) != null)
+                return next();
+            req._cookiesParser = this._cookiesParser(req);
+            return next();
+        });
+        return this;
+    }
+    /**
+     * The 'useFileUpload' method is a middleware used to handler file uploads. It adds a file upload of incoming HTTP requests.
+     *
+     * @param {?Object}
+     * @property {?number} limits
+     * @property {?boolean} useTempFiles
+     * @property {?string} tempFileDir
+     * @property {?Object} removeTempFile
+     * @property {boolean} removeTempFile.remove
+     * @property {number} removeTempFile.ms
+     * @returns
+     */
+    useFileUpload({ limits, useTempFiles, tempFileDir, removeTempFile } = {}) {
+        if (limits != null) {
+            this._fileUploadOptions.limits = limits;
+        }
+        if (tempFileDir != null) {
+            this._fileUploadOptions.tempFileDir = tempFileDir;
+        }
+        if (useTempFiles != null) {
+            this._fileUploadOptions.useTempFiles = useTempFiles;
+        }
+        if (removeTempFile != null) {
+            this._fileUploadOptions.removeTempFile = removeTempFile;
+        }
+        this._globalMiddlewares.push(({ req }, next) => __awaiter(this, void 0, void 0, function* () {
+            const contentType = req === null || req === void 0 ? void 0 : req.headers['content-type'];
+            const isFileUpload = contentType && contentType.startsWith('multipart/form-data');
+            const isListMethods = ['POST', 'PATCH', 'PUT'].includes(String(req.method));
+            if (!isListMethods)
+                return next();
+            if (!isFileUpload)
+                return next();
+            if ((req === null || req === void 0 ? void 0 : req._filesParser) != null)
+                return next();
+            const { body, files } = yield this._filesParser(req);
+            req._filesParser = files;
+            req._bodyParser = body;
+            return next();
+        }));
+        return this;
+    }
+    /**
+     * The 'formatResponse' method is used to format the response
+     *
+     * @param {function} format
+     * @returns
+     */
+    formatResponse(format) {
+        this._formatResponse = format;
+        return this;
+    }
+    /**
+     * The 'errorHandler' method is middleware that is specifically designed to handle errors that occur during the processing of requests
+     *
+     * @param {function} error
+     * @returns
+     */
+    errorHandler(error) {
+        this._errorHandler = error;
+        return this;
+    }
+    /**
+     * The 'notFoundHandler' method is middleware that is specifically designed to handle errors notfound that occur during the processing of requests
+     *
+     * @param {function} notfound
+     * @returns
+     */
+    notFoundHandler(notfound) {
+        const handler = ({ req, res }) => {
+            return notfound({
+                req,
+                res: this._customizeResponse(req, res),
+                query: null,
+                files: null,
+                body: null,
+                params: null,
+                cookies: null
+            });
+        };
+        this._onListeners.push(() => {
+            return this._router.all('*', this._wrapHandlers(...this._globalMiddlewares, handler));
+        });
+        return this;
+    }
+    /**
+     * The 'get' method is used to add the request handler to the router for the 'GET' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    get(path, ...handlers) {
+        this._onListeners.push(() => {
+            return this._router.get(this._normalizePath(this._globalPrefix, path), this._wrapHandlers(...this._globalMiddlewares, ...handlers));
+        });
+        return this;
+    }
+    /**
+     * The 'post' method is used to add the request handler to the router for the 'POST' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    post(path, ...handlers) {
+        this._onListeners.push(() => {
+            return this._router.post(this._normalizePath(this._globalPrefix, path), this._wrapHandlers(...this._globalMiddlewares, ...handlers));
+        });
+        return this;
+    }
+    /**
+     * The 'put' method is used to add the request handler to the router for the 'PUT' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    put(path, ...handlers) {
+        this._onListeners.push(() => {
+            return this._router.put(this._normalizePath(this._globalPrefix, path), this._wrapHandlers(...this._globalMiddlewares, ...handlers));
+        });
+        return this;
+    }
+    /**
+     * The 'patch' method is used to add the request handler to the router for the 'PATCH' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    patch(path, ...handlers) {
+        this._onListeners.push(() => {
+            return this._router.patch(this._normalizePath(this._globalPrefix, path), this._wrapHandlers(...this._globalMiddlewares, ...handlers));
+        });
+        return this;
+    }
+    /**
+     * The 'delete' method is used to add the request handler to the router for the 'DELETE' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {Object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {Function} next  - go to next function
+     * @returns {this}
+     */
+    delete(path, ...handlers) {
+        this._onListeners.push(() => {
+            return this._router.delete(this._normalizePath(this._globalPrefix, path), this._wrapHandlers(...this._globalMiddlewares, ...handlers));
+        });
+        return this;
+    }
+    /**
+     * The 'all' method is used to add the request handler to the router for the 'all' method.
+     *
+     * @param {string} path
+     * @callback {...Function[]} handlers of the middlewares
+     * @property  {object} ctx - context { req , res , query , params , cookies , files , body}
+     * @property  {function} next  - go to next function
+     * @returns {this}
+     */
+    all(path, ...handlers) {
+        this._onListeners.push(() => {
+            return this._router.all(this._normalizePath(this._globalPrefix, path), this._wrapHandlers(...this._globalMiddlewares, ...handlers));
+        });
+        return this;
+    }
+    /**
+     * The 'listen' method is used to bind and start a server to a particular port and optionally a hostname.
+     *
+     * @param {number} port
+     * @param {function} cb
+     * @returns
+     */
+    listen(port = 3000, cb) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length === 1 && typeof port === 'function') {
+                cb = port;
+                port = 3000;
+            }
+            const server = yield this._createServer();
+            server.listen(port == null ? 3000 : port, () => {
+                if (cb)
+                    cb({ server, port });
+            });
+            server.on('listening', () => {
+                this._onListeners.forEach(listener => listener());
+            });
+            server.on('error', (_) => {
+                port = Math.floor(Math.random() * 8999) + 1000;
+                server.listen(port);
+            });
+            return;
+        });
+    }
+    _logger({ req, res }, next) {
+        const diffTime = (hrtime) => {
+            const MS = 1000;
+            if (hrtime == null)
+                return 0;
+            const [start, end] = process.hrtime(hrtime);
+            const time = +(((start * MS) + (end / 1e6)).toFixed(2));
+            return `${time > MS ? `${time / MS} s` : `${time} ms`}`;
+        };
+        const statusCode = (res) => {
+            const statusCode = res.statusCode == null ? 500 : Number(res.statusCode);
+            return statusCode < 400
+                ? `\x1b[32m${statusCode}\x1b[0m`
+                : `\x1b[31m${statusCode}\x1b[0m`;
+        };
+        const startTime = process.hrtime();
+        (0, on_finished_1.default)(res, () => {
+            console.log([
+                `[\x1b[1m\x1b[34mINFO\x1b[0m]`,
+                `\x1b[34m${new Date().toJSON()}\x1b[0m`,
+                `\x1b[33m${req.method}\x1b[0m`,
+                `${decodeURIComponent(String(req.url))}`,
+                `${statusCode(res)}`,
+                `${diffTime(startTime)}`,
+            ].join(" "));
+        });
+        return next();
+    }
+    _import(dir, pattern) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const directories = fs_1.default.readdirSync(dir, { withFileTypes: true });
+            const files = (yield Promise.all(directories.map((directory) => {
+                const newDir = path_1.default.resolve(String(dir), directory.name);
+                if (pattern == null) {
+                    return directory.isDirectory() ? this._import(newDir) : newDir;
+                }
+                return directory.isDirectory()
+                    ? this._import(newDir)
+                    : pattern.test(directory.name)
+                        ? newDir
+                        : null;
+            }))).filter(d => d != null);
+            return [].concat(...files);
+        });
+    }
+    _registerControllers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._controllers == null)
+                return;
+            if (!Array.isArray(this._controllers)) {
+                const controllers = yield this._import(this._controllers.folder, this._controllers.name);
+                for (const file of controllers) {
+                    const response = yield Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+                    const controller = response === null || response === void 0 ? void 0 : response.default;
+                    const controllerInstance = new controller();
+                    const prefixPath = Reflect.getMetadata("controllers", controller);
+                    const routers = Reflect.getMetadata("routers", controller);
+                    if (prefixPath == null)
+                        continue;
+                    for (const { method, path, handler } of routers) {
+                        this[method](this._normalizePath(this._globalPrefix, prefixPath, path), this._wrapResponse(controllerInstance[String(handler)].bind(controllerInstance)));
+                    }
+                }
+                return;
+            }
+            for (const controller of this._controllers) {
+                const controllerInstance = new controller();
+                const prefixPath = Reflect.getMetadata("controllers", controller);
+                const routers = Reflect.getMetadata("routers", controller);
+                if (prefixPath == null)
+                    continue;
+                for (const { method, path, handler } of routers) {
+                    this[method](this._normalizePath(this._globalPrefix, prefixPath, path), this._wrapResponse(controllerInstance[String(handler)].bind(controllerInstance)));
+                }
+            }
+        });
+    }
+    _registerMiddlewares() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._middlewares == null)
+                return;
+            if (!Array.isArray(this._middlewares)) {
+                const middlewares = yield this._import(this._middlewares.folder, this._middlewares.name);
+                for (const file of middlewares) {
+                    const response = yield Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+                    const middleware = response === null || response === void 0 ? void 0 : response.default;
+                    this.use(middleware);
+                }
+                return;
+            }
+            const middlewares = this._middlewares;
+            for (const middleware of middlewares) {
+                this.use(middleware);
+            }
+            return;
+        });
+    }
+    _cookiesParser(req) {
+        var _a;
+        const cookies = {};
+        const cookieString = (_a = req.headers) === null || _a === void 0 ? void 0 : _a.cookie;
+        if (cookieString == null)
+            return null;
+        for (const cookie of cookieString.split(';')) {
+            const [name, value] = cookie.split('=').map(v => v.trim());
+            cookies[name] = decodeURIComponent(value);
+        }
+        for (const name of Object.keys(cookies)) {
+            const cookie = cookies[name];
+            if (!cookie.startsWith('Expires='))
+                continue;
+            const expiresString = cookie.replace('Expires=', '');
+            const expiresDate = new Date(expiresString);
+            if (isNaN(expiresDate.getTime()) || expiresDate < new Date()) {
+                delete cookies[name];
+            }
+        }
+        return cookies;
+    }
+    _customizeResponse(req, res) {
+        const response = res;
+        response.json = (results) => {
+            if (typeof results === 'string') {
+                if (!res.headersSent) {
+                    res.writeHead(200, { 'Content-Type': 'text/plain' });
+                }
+                return res.end(results);
+            }
+            if (!res.headersSent) {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+            }
+            if (results == null) {
+                if (this._formatResponse != null) {
+                    return res.end(JSON.stringify(this._formatResponse(null, res.statusCode), null, 2));
+                }
+                return res.end();
+            }
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse(Object.assign({}, results), res.statusCode), null, 2));
+            }
+            return res.end(JSON.stringify(Object.assign({}, results), null, 2));
+        };
+        response.send = (results) => {
+            res.writeHead(res.statusCode, { 'Content-Type': 'text/plain' });
+            return res.end(results);
+        };
+        response.error = (err) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            let code = +((_b = (_a = err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.code) ||
+                +err.code ||
+                +err.status ||
+                +err.statusCode ||
+                +((_d = (_c = err.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.statusCode) ||
+                500;
+            code = (code == null || typeof code !== 'number') ? 500 : Number.isNaN(code) ? 500 : code < 400 ? 500 : code;
+            const message = ((_f = (_e = err.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.errorMessage) ||
+                ((_h = (_g = err.response) === null || _g === void 0 ? void 0 : _g.data) === null || _h === void 0 ? void 0 : _h.message) ||
+                err.message ||
+                `The url '${req.url}' resulted in a server error. Please investigate.`;
+            response.status(code);
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse({ message }, code), null, 2));
+            }
+            return res.end(JSON.stringify({
+                message: message
+            }, null, 2));
+        };
+        response.ok = (results) => {
+            return response.json(results == null ? {} : results);
+        };
+        response.created = (results) => {
+            response.status(201);
+            return response.json(results == null ? {} : results);
+        };
+        response.accepted = (results) => {
+            response.status(202);
+            return response.json(results == null ? {} : results);
+        };
+        response.noContent = () => {
+            response.status(202);
+            return res.end();
+        };
+        response.badRequest = (message) => {
+            response.status(400);
+            message = message !== null && message !== void 0 ? message : `The url '${req.url}' resulted in a bad request. Please review the data and try again.`;
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse({ message }, 400), null, 2));
+            }
+            return res.end(JSON.stringify({
+                message: message
+            }, null, 2));
+        };
+        response.unauthorized = (message) => {
+            response.status(401);
+            message = message !== null && message !== void 0 ? message : `The url '${req.url}' is unauthorized. Please verify.`;
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse({ message }, 401), null, 2));
+            }
+            return res.end(JSON.stringify({
+                message
+            }, null, 2));
+        };
+        response.paymentRequired = (message) => {
+            response.status(402);
+            message = message !== null && message !== void 0 ? message : `The url '${req.url}' requires payment. Please proceed with payment.`;
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse({ message }, 402), null, 2));
+            }
+            return res.end(JSON.stringify({
+                message
+            }, null, 2));
+        };
+        response.forbidden = (message) => {
+            response.status(403);
+            message = message !== null && message !== void 0 ? message : `The url '${req.url}' is forbidden. Please check the permissions or access rights.`;
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse({ message }, 403), null, 2));
+            }
+            return res.end(JSON.stringify({
+                message
+            }, null, 2));
+        };
+        response.notFound = (message) => {
+            response.status(404);
+            message = message !== null && message !== void 0 ? message : `The url '${req.url}' was not found. Please re-check the your url again`;
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse({ message }, 404), null, 2));
+            }
+            return res.end(JSON.stringify({
+                message
+            }, null, 2));
+        };
+        response.serverError = (message) => {
+            response.status(500);
+            message = message !== null && message !== void 0 ? message : `The url '${req.url}' resulted in a server error. Please investigate.`;
+            if (this._formatResponse != null) {
+                return res.end(JSON.stringify(this._formatResponse({ message }, 500), null, 2));
+            }
+            return res.end(JSON.stringify({
+                message
+            }, null, 2));
+        };
+        response.status = (code) => {
+            res.writeHead(code, { 'Content-Type': 'application/json' });
+            return res;
+        };
+        response.setCookies = (cookies) => {
+            for (const [key, v] of Object.entries(cookies)) {
+                if (typeof v === 'string') {
+                    res.setHeader('Set-Cookie', `${key}=${v}`);
+                    continue;
+                }
+                if (v.value === '' || v.value == null)
+                    continue;
+                let str = `${key}=${v.value}`;
+                if (v.sameSite != null) {
+                    str += ` ;SameSite=${v.sameSite}`;
+                }
+                if (v.domain != null) {
+                    str += ` ;Domain=${v.domain}`;
+                }
+                if (v.httpOnly != null) {
+                    str += ` ;HttpOnly`;
+                }
+                if (v.secure != null) {
+                    str += ` ;Secure`;
+                }
+                if (v.expires != null) {
+                    str += ` ;Expires=${v.expires.toUTCString()}`;
+                }
+                res.setHeader('Set-Cookie', str);
+            }
+        };
+        return response;
+    }
+    _nextFunction(ctx) {
+        return (err) => __awaiter(this, void 0, void 0, function* () {
+            if (err != null) {
+                if (this._errorHandler != null) {
+                    return this._errorHandler(err, ctx);
+                }
+                ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
+                if (this._formatResponse != null) {
+                    return ctx.res.end(JSON.stringify(this._formatResponse({
+                        message: err === null || err === void 0 ? void 0 : err.message,
+                    }, ctx.res.statusCode), null, 2));
+                }
+                return ctx.res.end(JSON.stringify({
+                    message: err === null || err === void 0 ? void 0 : err.message,
+                }, null, 2));
+            }
+            if (this._errorHandler != null) {
+                return this._errorHandler(new Error(`The 'next' function does not have any subsequent function.`), ctx);
+            }
+            ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
+            if (this._formatResponse != null) {
+                return ctx.res.end(JSON.stringify(this._formatResponse({
+                    message: `The 'next' function does not have any subsequent function.`
+                }, ctx.res.statusCode), null, 2));
+            }
+            return ctx.res.end(JSON.stringify({
+                message: `The 'next' function does not have any subsequent function.`
+            }, null, 2));
+        });
+    }
+    _wrapResponse(handler) {
+        return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
+            const result = yield handler(ctx, next);
+            if (result == null)
+                return;
+            if (result instanceof http_1.ServerResponse)
+                return;
+            if (typeof result === 'string') {
+                if (!ctx.res.headersSent) {
+                    ctx.res.writeHead(200, { 'Content-Type': 'text/plain' });
+                }
+                return ctx.res.end(result);
+            }
+            if (this._formatResponse != null) {
+                const formatResponse = this._formatResponse(Object.assign({}, result), ctx.res.statusCode);
+                if (typeof formatResponse === 'string') {
+                    if (!ctx.res.headersSent) {
+                        ctx.res.writeHead(200, { 'Content-Type': 'text/plain' });
+                    }
+                    return ctx.res.end(formatResponse);
+                }
+                if (!ctx.res.headersSent) {
+                    ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+                }
+                return ctx.res.end(JSON.stringify(this._formatResponse(Object.assign({}, result), ctx.res.statusCode), null, 2));
+            }
+            if (!ctx.res.headersSent) {
+                ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+            }
+            return ctx.res.end(JSON.stringify(Object.assign({}, result), null, 2));
+        });
+    }
+    _createServer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._registerMiddlewares();
+            yield this._registerControllers();
+            const server = http_1.default.createServer((req, res) => {
+                return this._router.lookup(req, res);
+            });
+            return server;
+        });
+    }
+    _normalizePath(...paths) {
+        let path = paths
+            .join('/')
+            .replace(/\/+/g, '/')
+            .replace(/\/+$/, '');
+        return path.startsWith('/') ? path : `/${path}`;
+    }
+}
+exports.Spear = Spear;
+class Application extends Spear {
+}
+exports.Application = Application;
+exports.default = Spear;