tspace-spear 1.2.1 → 1.2.3

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

@@ -15,27 +15,36 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Spear = exports.Application = void 0;
+const http_1 = __importStar(require("http"));
+const find_my_way_1 = __importDefault(require("find-my-way"));
 const cluster_1 = __importDefault(require("cluster"));
 const os_1 = __importDefault(require("os"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const url_1 = require("url");
 const on_finished_1 = __importDefault(require("on-finished"));
 const ws_1 = __importDefault(require("ws"));
-const http_1 = __importStar(require("http"));
-const find_my_way_1 = __importDefault(require("find-my-way"));
 const parser_factory_1 = require("./parser-factory");
 /**
  *
@@ -59,6 +68,7 @@ class Spear {
     _globalPrefix;
     _router = (0, find_my_way_1.default)();
     _parser = new parser_factory_1.ParserFactory();
+    _adapter = http_1.default;
     _cluster;
     _cors;
     _swagger = {
@@ -76,10 +86,10 @@ class Spear {
             version: "1.0.0"
         }
     };
+    _swaggerSpecs = [];
     _wss;
     _ws;
     _wsOptions;
-    _swaggerSpecs = [];
     _errorHandler = null;
     _globalMiddlewares = [];
     _formatResponse = null;
@@ -92,11 +102,13 @@ class Spear {
             ms: 1000 * 60 * 10
         }
     };
-    constructor({ controllers, middlewares, globalPrefix, logger, cluster } = {}) {
+    constructor({ controllers, middlewares, globalPrefix, logger, cluster, adapter } = {}) {
         if (logger)
             this.useLogger();
         if (cluster)
             this.useCluster(cluster);
+        if (adapter)
+            this.useAdater(adapter);
         this._controllers = controllers;
         this._middlewares = middlewares;
         this._globalPrefix = globalPrefix == null ? '' : globalPrefix;
@@ -141,6 +153,18 @@ class Spear {
         this._globalMiddlewares.push(middleware);
         return this;
     }
+    /**
+     * The 'useAdater' method is used to switch between different server implementations,
+     * such as the native Node.js HTTP server or uWebSockets.js (uWS).
+     *
+     * @param {T.Adapter} adapter - The adapter instance (e.g., HTTP or uWS).
+     * @returns {this} Returns the current instance for chaining
+     */
+    useAdater(adapter) {
+        this._adapter = adapter;
+        this._parser.useAdater(adapter);
+        return this;
+    }
     /**
      * The 'useCluster' method is used cluster run the server
      *
@@ -209,7 +233,7 @@ class Spear {
      */
     useBodyParser({ except } = {}) {
         this._globalMiddlewares.push((ctx, next) => {
-            const { req } = ctx;
+            const { req, res } = ctx;
             const contentType = req?.headers['content-type'] ?? '';
             const isFileUpload = contentType && contentType.startsWith('multipart/form-data');
             const isCanParserBody = contentType.includes('application/json') ||
@@ -225,7 +249,7 @@ class Spear {
                 return next();
             if (req?.body != null)
                 return next();
-            Promise.resolve(this._parser.body(req))
+            Promise.resolve(this._parser.body(req, res))
                 .then(r => {
                 req.body = r;
                 return next();
@@ -258,7 +282,7 @@ class Spear {
             this._fileUploadOptions.removeTempFile = removeTempFile;
         }
         this._globalMiddlewares.push((ctx, next) => {
-            const { req } = ctx;
+            const { req, res } = ctx;
             if (req.method === 'GET') {
                 return next();
             }
@@ -269,7 +293,7 @@ class Spear {
             if (req?.files != null)
                 return next();
             Promise
-                .resolve(this._parser.files(req, this._fileUploadOptions))
+                .resolve(this._parser.files({ req, res, options: this._fileUploadOptions }))
                 .then(r => {
                 req.files = r.files;
                 req.body = r.body;
@@ -349,6 +373,22 @@ class Spear {
             });
             return server;
         }
+        if ('App' in this._adapter) {
+            const handler = () => {
+                this._onListeners.forEach(listener => listener());
+                if (this._swagger.use) {
+                    this._swaggerHandler();
+                }
+                callback?.({ server, port });
+            };
+            if (hostname) {
+                server.listen(port, String(hostname), handler);
+            }
+            else {
+                server.listen(port, handler);
+            }
+            return server;
+        }
         const args = hostname
             ? [port, hostname, () => callback?.({ server, port: port })]
             : [port, () => callback?.({ server, port: port })];
@@ -359,10 +399,6 @@ class Spear {
                 this._swaggerHandler();
             }
         });
-        server.on('error', (_) => {
-            port = Math.floor(Math.random() * 8999) + 1000;
-            server.listen(port);
-        });
         return server;
     }
     /**
@@ -441,7 +477,8 @@ class Spear {
                 files: {},
                 body: {},
                 params: {},
-                cookies: {}
+                cookies: {},
+                ip: null
             });
         };
         this._onListeners.push(() => {
@@ -584,37 +621,6 @@ class Spear {
         });
         return this;
     }
-    _clusterMode({ server, port, hostname, callback }) {
-        if (cluster_1.default.isPrimary) {
-            const numCPUs = os_1.default.cpus().length;
-            const maxWorkers = typeof this._cluster === 'boolean' || this._cluster == null
-                ? numCPUs
-                : this._cluster;
-            for (let i = 0; i < maxWorkers; i++) {
-                cluster_1.default.fork();
-            }
-            cluster_1.default.on('exit', () => {
-                cluster_1.default.fork();
-            });
-        }
-        if (cluster_1.default.isWorker) {
-            const args = hostname
-                ? [port, hostname, () => callback?.({ server, port: port })]
-                : [port, () => callback?.({ server, port: port })];
-            server.listen(...args);
-            server.on('listening', () => {
-                this._onListeners.forEach(listener => listener());
-                if (this._swagger.use) {
-                    this._swaggerHandler();
-                }
-            });
-            server.on('error', (_) => {
-                port = Math.floor(Math.random() * 8999) + 1000;
-                server.listen(port);
-            });
-        }
-        return;
-    }
     async _import(dir, pattern) {
         const directories = fs_1.default.readdirSync(dir, { withFileTypes: true });
         const files = (await Promise.all(directories.map((directory) => {
@@ -744,18 +750,18 @@ class Spear {
             }
             if (results == null) {
                 if (this._formatResponse != null) {
-                    return res.end(JSON.stringify(this._formatResponse(null, res.statusCode), null, 2));
+                    return res.end(JSON.stringify(this._formatResponse(null, res.statusCode)));
                 }
                 return res.end();
             }
             if (this._formatResponse != null) {
                 return res.end(JSON.stringify(this._formatResponse({
                     ...results
-                }, res.statusCode), null, 2));
+                }, res.statusCode)));
             }
             return res.end(JSON.stringify({
                 ...results,
-            }, null, 2));
+            }));
         };
         response.send = (results) => {
             if (res.writableEnded)
@@ -812,81 +818,81 @@ class Spear {
             response.status(400);
             message = message ?? `The request '${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(this._formatResponse({ message }, 400)));
             }
             return res.end(JSON.stringify({
                 message: message
-            }, null, 2));
+            }));
         };
         response.unauthorized = (message) => {
             response.status(401);
             message = message ?? `The request '${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(this._formatResponse({ message }, 401)));
             }
             return res.end(JSON.stringify({
                 message
-            }, null, 2));
+            }));
         };
         response.paymentRequired = (message) => {
             response.status(402);
             message = message ?? `The request '${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(this._formatResponse({ message }, 402)));
             }
             return res.end(JSON.stringify({
                 message
-            }, null, 2));
+            }));
         };
         response.forbidden = (message) => {
             response.status(403);
             message = message ?? `The request '${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(this._formatResponse({ message }, 403)));
             }
             return res.end(JSON.stringify({
                 message
-            }, null, 2));
+            }));
         };
         response.notFound = (message) => {
             response.status(404);
             message = message ?? `The request '${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(this._formatResponse({ message }, 404)));
             }
             return res.end(JSON.stringify({
                 message
-            }, null, 2));
+            }));
         };
         response.unprocessable = (message) => {
             response.status(422);
             message = message ?? `The request to '${req.url}' failed validation.`;
             if (this._formatResponse != null) {
-                return res.end(JSON.stringify(this._formatResponse({ message }, 422), null, 2));
+                return res.end(JSON.stringify(this._formatResponse({ message }, 422)));
             }
             return res.end(JSON.stringify({
                 message
-            }, null, 2));
+            }));
         };
         response.tooManyRequests = (message) => {
             response.status(429);
             message = message ?? `The request '${req.url}' is too many request. Please wait and try agian.`;
             if (this._formatResponse != null) {
-                return res.end(JSON.stringify(this._formatResponse({ message }, 429), null, 2));
+                return res.end(JSON.stringify(this._formatResponse({ message }, 429)));
             }
             return res.end(JSON.stringify({
                 message
-            }, null, 2));
+            }));
         };
         response.serverError = (message) => {
             response.status(500);
             message = message ?? `The request '${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(this._formatResponse({ message }, 500)));
             }
             return res.end(JSON.stringify({
                 message
-            }, null, 2));
+            }));
         };
         response.status = (code) => {
             res.writeHead(code, { 'Content-Type': 'application/json' });
@@ -922,58 +928,48 @@ class Spear {
         return response;
     }
     _wrapHandlers(...handlers) {
-        return (req, res, params) => {
-            const nextHandler = (index = 0) => {
+        return (req, res, ps) => {
+            if (res.writableEnded)
+                return;
+            const request = req;
+            const response = this._customizeResponse(req, res);
+            const params = ps;
+            const headers = req.headers;
+            const query = this._parser.queryString(req.url);
+            const xff = headers['x-forwarded-for'];
+            const ip = (Array.isArray(xff) ? xff[0] : xff)?.split(',')[0]?.trim()
+                || (Array.isArray(headers['x-real-ip']) ? headers['x-real-ip'][0] : headers['x-real-ip'])
+                || (Array.isArray(headers['cf-connecting-ip']) ? headers['cf-connecting-ip'][0] : headers['cf-connecting-ip'])
+                || null;
+            const dispatch = (index = 0) => {
+                const body = request.body;
+                const files = request.files;
+                const cookies = request.cookies;
+                const ctx = {
+                    req: request,
+                    res: response,
+                    headers: headers ?? {},
+                    params: params ?? {},
+                    query: query ?? {},
+                    body: body ?? {},
+                    files: files ?? {},
+                    cookies: cookies ?? {},
+                    ip: ip ?? null
+                };
                 try {
-                    const response = this._customizeResponse(req, res);
-                    const request = req;
-                    request.params = params;
-                    const body = request.body;
-                    const files = request.files;
-                    const cookies = request.cookies;
-                    const headers = request.headers;
-                    const url = new url_1.URL(req.url, "http://localhost");
-                    const query = Object.fromEntries(url.searchParams);
-                    const RecordOrEmptyRecord = (data) => {
-                        if (data == null)
-                            return {};
-                        return Object.keys(data).length ? data : {};
-                    };
-                    const ctx = {
-                        req: request,
-                        res: response,
-                        headers: RecordOrEmptyRecord(headers),
-                        params: RecordOrEmptyRecord(params),
-                        query: RecordOrEmptyRecord(query),
-                        body: RecordOrEmptyRecord(body),
-                        files: RecordOrEmptyRecord(files),
-                        cookies: RecordOrEmptyRecord(cookies)
-                    };
+                    const handler = handlers[index];
+                    if (!handler)
+                        return;
                     if (index === handlers.length - 1) {
-                        return this._wrapResponse(handlers[index]
-                            .bind(handlers[index]))(ctx, this._nextFunction(ctx));
+                        return Promise.resolve(this._wrapResponse(handler)(ctx, this._nextFunction(ctx))).catch(err => this._nextFunction(ctx)(err));
                     }
-                    return handlers[index](ctx, () => {
-                        return nextHandler(index + 1);
-                    });
+                    return Promise.resolve(handler(ctx, () => dispatch(index + 1))).catch(err => this._nextFunction(ctx)(err));
                 }
                 catch (err) {
-                    const ctx = {
-                        req,
-                        res: this._customizeResponse(req, res),
-                        params: Object.keys(params).length ? params : {},
-                        headers: {},
-                        query: {},
-                        body: {},
-                        files: {},
-                        cookies: {}
-                    };
                     return this._nextFunction(ctx)(err);
                 }
             };
-            if (res.writableEnded)
-                return;
-            return nextHandler();
+            return dispatch();
         };
     }
     _wrapResponse(handler) {
@@ -996,9 +992,6 @@ class Spear {
                     return;
                 }
                 if (typeof result === 'string') {
-                    if (!ctx.res.headersSent) {
-                        ctx.res.writeHead(200, { 'Content-Type': 'text/plain' });
-                    }
                     ctx.res.end(result ?? '');
                     return;
                 }
@@ -1038,7 +1031,7 @@ class Spear {
                         ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
                         return ctx.res.end(JSON.stringify({
                             message: err?.message
-                        }, null, 2));
+                        }));
                     }
                     return callback;
                 }
@@ -1046,39 +1039,109 @@ class Spear {
                 if (this._formatResponse != null) {
                     return ctx.res.end(JSON.stringify(this._formatResponse({
                         message: err?.message,
-                    }, ctx.res.statusCode), null, 2));
+                    }, ctx.res.statusCode)));
                 }
-                return ctx.res.end(JSON.stringify({
+                ctx.res.end(JSON.stringify({
                     message: err?.message
-                }, null, 2));
+                }));
+                return;
             }
             if (this._errorHandler != null) {
                 return this._errorHandler(new Error(NEXT_MESSAGE), ctx);
             }
             ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
             if (this._formatResponse != null) {
-                return ctx.res.end(JSON.stringify(this._formatResponse({
+                ctx.res.end(JSON.stringify(this._formatResponse({
                     message: NEXT_MESSAGE
-                }, ctx.res.statusCode), null, 2));
+                }, ctx.res.statusCode)));
+                return;
             }
-            return ctx.res.end(JSON.stringify({
+            ctx.res.end(JSON.stringify({
                 message: NEXT_MESSAGE
-            }, null, 2));
+            }));
+            return;
         };
     }
+    _clusterMode({ server, port, hostname, callback }) {
+        if (cluster_1.default.isPrimary) {
+            const numCPUs = os_1.default.cpus().length;
+            const maxWorkers = typeof this._cluster === 'boolean' || this._cluster == null
+                ? numCPUs
+                : this._cluster;
+            for (let i = 0; i < maxWorkers; i++) {
+                cluster_1.default.fork();
+            }
+            cluster_1.default.on('exit', () => {
+                cluster_1.default.fork();
+            });
+        }
+        if (cluster_1.default.isWorker) {
+            if ('App' in this._adapter) {
+                const handler = () => {
+                    this._onListeners.forEach(listener => listener());
+                    if (this._swagger.use) {
+                        this._swaggerHandler();
+                    }
+                    callback?.({ server, port });
+                };
+                if (hostname) {
+                    server.listen(port, hostname, handler);
+                    return server;
+                }
+                server.listen(port, handler);
+                return server;
+            }
+            const args = hostname
+                ? [port, hostname, () => callback?.({ server, port: port })]
+                : [port, () => callback?.({ server, port: port })];
+            server.listen(...args);
+            server.on('listening', () => {
+                this._onListeners.forEach(listener => listener());
+                if (this._swagger.use) {
+                    this._swaggerHandler();
+                }
+            });
+            server.on('error', (_) => {
+                port = Math.floor(Math.random() * 8999) + 1000;
+                server.listen(port);
+            });
+        }
+        return;
+    }
     async _createServer() {
         await this._registerMiddlewares();
         await this._registerControllers();
         const lookup = this._router.lookup.bind(this._router);
         const cors = this._cors;
-        const server = http_1.default.createServer({ maxHeaderSize: 1024 * 1024 }, cors
-            ? (req, res) => {
-                cors(req, res);
-                return lookup(req, res);
-            }
-            : (req, res) => {
+        const adapter = this._adapter;
+        if ('App' in adapter) {
+            const server = adapter.App();
+            server.any('/*', (uwsRes, uwsReq) => {
+                const { req, res } = this._uWSRequestResponse(uwsReq, uwsRes);
+                if (cors)
+                    cors(req, res);
                 return lookup(req, res);
             });
+            if (this._ws) {
+                server.ws('/*', {
+                    open: (ws) => {
+                        this._ws?.connection?.(ws);
+                    },
+                    message: (ws, message) => {
+                        this._ws?.message?.(ws, Buffer.from(message));
+                    },
+                    close: (ws, code, message) => {
+                        this._ws?.close?.(ws, code, Buffer.from(message));
+                    }
+                });
+            }
+            return server;
+        }
+        const server = http_1.default.createServer((req, res) => {
+            if (cors)
+                cors(req, res);
+            return lookup(req, res);
+        });
         if (this._ws) {
             this._wss = new ws_1.default.Server({ server, ...this._wsOptions });
             this._wss.on('connection', (ws) => {
@@ -1086,9 +1149,7 @@ class Spear {
                     this._ws.connection(ws);
                 }
                 ws.on('message', (data) => {
-                    if (this._ws?.message) {
-                        this._ws.message(ws, data);
-                    }
+                    this._ws?.message?.(ws, data);
                 });
                 ws.on('close', (code, reason) => {
                     if (this._ws?.close) {
@@ -1104,27 +1165,169 @@ class Spear {
         }
         return server;
     }
+    _uWSRequestResponse(uwsReq, uwsRes) {
+        const req = {
+            method: String(uwsReq.getMethod()).toLocaleUpperCase(),
+            url: uwsReq.getUrl() + (uwsReq.getQuery() ? `?${uwsReq.getQuery()}` : ''),
+            headers: {}
+        };
+        uwsReq.forEach((key, value) => req.headers[key] = value);
+        const res = {
+            writeHeader: (key, value) => {
+                if (!res.aborted) {
+                    uwsRes.writeHeader(key, value);
+                }
+                return res;
+            },
+            setHeader: (key, value) => {
+                if (!res.aborted) {
+                    uwsRes.writeHeader(key, value);
+                }
+                return res;
+            },
+            writeHead(status, context) {
+                res.writeHeaders = {
+                    ...res.writeHeaders,
+                    [status]: context
+                };
+                res.headersSent = true;
+                res.statusCode = status;
+                return res;
+            },
+            _writeHead(status, context) {
+                const statusMessages = {
+                    100: 'Continue',
+                    101: 'Switching Protocols',
+                    102: 'Processing',
+                    200: 'OK',
+                    201: 'Created',
+                    202: 'Accepted',
+                    203: 'Non-Authoritative Information',
+                    204: 'No Content',
+                    205: 'Reset Content',
+                    206: 'Partial Content',
+                    207: 'Multi-Status',
+                    208: 'Already Reported',
+                    226: 'IM Used',
+                    300: 'Multiple Choices',
+                    301: 'Moved Permanently',
+                    302: 'Found',
+                    303: 'See Other',
+                    304: 'Not Modified',
+                    305: 'Use Proxy',
+                    306: '(Unused)',
+                    307: 'Temporary Redirect',
+                    308: 'Permanent Redirect',
+                    400: 'Bad Request',
+                    401: 'Unauthorized',
+                    402: 'Payment Required',
+                    403: 'Forbidden',
+                    404: 'Not Found',
+                    405: 'Method Not Allowed',
+                    406: 'Not Acceptable',
+                    407: 'Proxy Authentication Required',
+                    408: 'Request Timeout',
+                    409: 'Conflict',
+                    410: 'Gone',
+                    411: 'Length Required',
+                    412: 'Precondition Failed',
+                    413: 'Payload Too Large',
+                    414: 'URI Too Long',
+                    415: 'Unsupported Media Type',
+                    416: 'Range Not Satisfiable',
+                    417: 'Expectation Failed',
+                    418: 'I\'m a teapot',
+                    421: 'Misdirected Request',
+                    422: 'Unprocessable Entity',
+                    423: 'Locked',
+                    424: 'Failed Dependency',
+                    425: 'Too Early',
+                    426: 'Upgrade Required',
+                    428: 'Precondition Required',
+                    429: 'Too Many Requests',
+                    431: 'Request Header Fields Too Large',
+                    451: 'Unavailable For Legal Reasons',
+                    500: 'Internal Server Error',
+                    501: 'Not Implemented',
+                    502: 'Bad Gateway',
+                    503: 'Service Unavailable',
+                    504: 'Gateway Timeout',
+                    505: 'HTTP Version Not Supported',
+                    506: 'Variant Also Negotiates',
+                    507: 'Insufficient Storage',
+                    508: 'Loop Detected',
+                    510: 'Not Extended',
+                    511: 'Network Authentication Required'
+                };
+                const statusMessage = statusMessages[status] || statusMessages[500];
+                res.uwsRes.writeStatus(`${status} ${statusMessage}`);
+                res.uwsRes.writeHeader(Object.keys(context)[0], Object.values(context)[0]);
+                return res;
+            },
+            writeStatus: (status) => {
+                if (!res.aborted) {
+                    res.uwsRes.writeStatus(status);
+                }
+                return res;
+            },
+            end: (str) => {
+                if (res.aborted) {
+                    return;
+                }
+                uwsRes.cork(() => {
+                    if (!res.aborted) {
+                        res.aborted = true;
+                        for (const h in res.writeHeaders) {
+                            //@ts-ignore
+                            res._writeHead(h, res.writeHeaders[h]);
+                        }
+                        uwsRes.end(str);
+                        return;
+                    }
+                });
+            },
+            aborted: false,
+            writeHeaders: {},
+            headersSent: false,
+            statusCode: 200,
+            uwsRes,
+        };
+        uwsRes.onAborted(() => {
+            res.aborted = true;
+        });
+        return { req, res };
+    }
     _normalizePath(...paths) {
         const path = paths
             .join('/')
             .replace(/\/+/g, '/')
             .replace(/\/+$/, '');
         const normalizedPath = path.startsWith('/') ? path : `/${path}`;
-        return /\/api\/api/.test(normalizedPath) ? normalizedPath.replace(/\/api\/api\//, "/api/") : normalizedPath;
+        return /\/api\/api/.test(normalizedPath)
+            ? normalizedPath.replace(/\/api\/api\//, "/api/")
+            : normalizedPath;
     }
     _swaggerHandler() {
         const routes = this.routers
-            .routes.filter(r => ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(r.method));
+            .routes
+            .filter(r => {
+            return [
+                "GET", "POST",
+                "PUT", "PATCH",
+                "DELETE",
+                "HEAD", "OPTIONS"
+            ].includes(r.method);
+        });
         const { path, html, staticSwaggerHandler, staticUrl } = this._parser.swagger({
             ...this._swagger,
             specs: this._swaggerSpecs,
             routes
         });
         this._router.get(staticUrl, staticSwaggerHandler);
-        this._router.get(String(path), (req, res) => {
+        this._router.get(path, (_, res) => {
             res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.write(html);
-            return res.end();
+            res.end(html);
+            return;
         });
         return;
     }