tspace-spear 1.2.2 → 1.2.4

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

@@ -38,15 +38,20 @@ var __importDefault = (this && this.__importDefault) || function (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 const_1 = require("../const");
+const stream_1 = require("stream");
 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 net_1 = __importDefault(require("net"));
 const parser_factory_1 = require("./parser-factory");
+const fast_router_1 = require("./fast-router");
+const response_1 = require("./response");
+const uWS_1 = require("./uWS");
+const net_2 = require("./net");
 /**
  *
  * The 'Spear' class is used to create a server and handle HTTP requests.
@@ -66,9 +71,10 @@ const parser_factory_1 = require("./parser-factory");
 class Spear {
     _controllers;
     _middlewares;
-    _globalPrefix;
-    _router = (0, find_my_way_1.default)();
+    _router = new fast_router_1.FastRouter();
     _parser = new parser_factory_1.ParserFactory();
+    _globalPrefix = '';
+    _adapter = { kind: 'http', server: http_1.default };
     _cluster;
     _cors;
     _swagger = {
@@ -76,7 +82,7 @@ class Spear {
         path: '/api/docs',
         servers: [
             {
-                url: 'http://localhost:3000'
+                url: '/'
             }
         ],
         tags: [],
@@ -87,9 +93,11 @@ class Spear {
         }
     };
     _swaggerSpecs = [];
-    _wss;
-    _ws;
-    _wsOptions;
+    _ws = {
+        handler: null,
+        server: null,
+        options: null
+    };
     _errorHandler = null;
     _globalMiddlewares = [];
     _formatResponse = null;
@@ -102,14 +110,17 @@ class Spear {
             ms: 1000 * 60 * 10
         }
     };
-    constructor({ controllers, middlewares, globalPrefix, logger, cluster } = {}) {
+    constructor({ controllers, middlewares, globalPrefix, logger, cluster, adapter } = {}) {
+        this._controllers = controllers;
+        this._middlewares = middlewares;
         if (logger)
             this.useLogger();
         if (cluster)
             this.useCluster(cluster);
-        this._controllers = controllers;
-        this._middlewares = middlewares;
-        this._globalPrefix = globalPrefix == null ? '' : globalPrefix;
+        if (adapter)
+            this.useAdater(adapter);
+        if (globalPrefix)
+            this.useGlobalPrefix(globalPrefix);
     }
     /**
      * The get 'instance' method is used to get the instance of Spear.
@@ -122,7 +133,7 @@ class Spear {
     /**
      * The get 'routers' method is used get the all routers.
      *
-     * @returns {Instance<findMyWayRouter.HTTPVersion.V1>}
+     * @returns {FastRouter}
      */
     get routers() {
         return this._router;
@@ -135,8 +146,8 @@ class Spear {
      * @returns {this}
      */
     ws(handlers, options) {
-        this._ws = handlers();
-        this._wsOptions = options ?? {};
+        this._ws.handler = handlers();
+        this._ws.options = options ?? {};
         return this;
     }
     /**
@@ -151,6 +162,40 @@ class Spear {
         this._globalMiddlewares.push(middleware);
         return this;
     }
+    /**
+     * The 'useGlobalPrefix' method is used to sets a global prefix for all routes in the router.
+     *
+     * If `globalPrefix` is `null` or `undefined`, it will default to an empty string,
+     * meaning no prefix will be applied.
+     *
+     * @param {string | null} globalPrefix - The base path prefix to apply to all routes.
+     * @returns {this} Returns the current instance for method chaining.
+     */
+    useGlobalPrefix(globalPrefix) {
+        this._globalPrefix = globalPrefix == null ? '' : globalPrefix;
+        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.AdapterServer} adapter - The adapter instance (e.g., HTTP or uWS).
+     * @returns {this} Returns the current instance for chaining
+     */
+    useAdater(adapter) {
+        if (adapter === http_1.default) {
+            this._adapter = { kind: 'http', server: adapter };
+        }
+        else if (adapter === net_1.default) {
+            this._adapter = { kind: 'net', server: adapter };
+        }
+        else {
+            //@ts-ignore
+            this._adapter = { kind: 'uWS', server: adapter };
+        }
+        this._parser.useAdater(this._adapter);
+        return this;
+    }
     /**
      * The 'useCluster' method is used cluster run the server
      *
@@ -187,13 +232,13 @@ class Spear {
                     ? `\x1b[32m${statusCode}\x1b[0m`
                     : `\x1b[31m${statusCode}\x1b[0m`;
             };
-            if (exceptPath instanceof RegExp && exceptPath.test(String(req.url)))
+            if (exceptPath instanceof RegExp && exceptPath.test(req.url))
                 return next();
-            if (Array.isArray(exceptPath) && exceptPath.some(v => String(req.url) === v))
+            if (Array.isArray(exceptPath) && exceptPath.some(v => req.url === v))
                 return next();
             if (methods != null &&
                 methods.length &&
-                !methods.some(v => v.toLocaleLowerCase() === String(req.method).toLocaleLowerCase())) {
+                !methods.some(v => v.toLowerCase() === req.method.toLowerCase())) {
                 return next();
             }
             const startTime = process.hrtime();
@@ -202,7 +247,7 @@ class Spear {
                     `[\x1b[1m\x1b[34mINFO\x1b[0m]`,
                     `\x1b[34m${new Date().toJSON()}\x1b[0m`,
                     `\x1b[33m${req.method}\x1b[0m`,
-                    `${decodeURIComponent(String(req.url))}`,
+                    `${decodeURIComponent(req.url)}`,
                     `${statusCode(res)}`,
                     `${diffTime(startTime)}`,
                 ].join(" "));
@@ -219,29 +264,26 @@ class Spear {
      */
     useBodyParser({ except } = {}) {
         this._globalMiddlewares.push((ctx, next) => {
-            const { req } = ctx;
-            const contentType = req?.headers['content-type'] ?? '';
-            const isFileUpload = contentType && contentType.startsWith('multipart/form-data');
-            const isCanParserBody = contentType.includes('application/json') ||
-                contentType.includes('application/x-www-form-urlencoded');
-            if (except != null &&
-                Array.isArray(except) &&
-                except.some(v => v.toLocaleLowerCase() === (req.method)?.toLocaleLowerCase())) {
+            const { req, res } = ctx;
+            if (Array.isArray(except) &&
+                except.some(v => v.toLowerCase() === (req.method).toLowerCase())) {
                 return next();
             }
-            if (isFileUpload)
+            const contentType = req?.headers['content-type'] ?? null;
+            if (contentType == null)
                 return next();
-            if (!isCanParserBody)
+            const isFileUpload = contentType && contentType.startsWith('multipart/form-data');
+            if (isFileUpload)
                 return next();
             if (req?.body != null)
                 return next();
-            Promise.resolve(this._parser.body(req))
-                .then(r => {
-                req.body = r;
+            Promise.resolve(this._parser.body(req, res))
+                .then(body => {
+                req.body = body;
                 return next();
             })
                 .catch(err => {
-                return this._nextFunction(ctx)(err);
+                return this._nextError(ctx)(err);
             });
         });
         return this;
@@ -250,11 +292,11 @@ class Spear {
      * 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 {?number} limits // bytes. default Infinity
      * @property {?string} tempFileDir
      * @property {?Object} removeTempFile
      * @property {boolean} removeTempFile.remove
-     * @property {number} removeTempFile.ms
+     * @property {number}  removeTempFile.ms
      * @returns
      */
     useFileUpload({ limit, tempFileDir, removeTempFile } = {}) {
@@ -268,7 +310,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();
             }
@@ -279,14 +321,14 @@ 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;
                 return next();
             })
                 .catch(err => {
-                return this._nextFunction(ctx)(err);
+                return this._nextError(ctx)(err);
             });
         });
         return this;
@@ -359,6 +401,22 @@ class Spear {
             });
             return server;
         }
+        if (this._adapter.kind === 'uWS') {
+            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 })];
@@ -369,10 +427,6 @@ class Spear {
                 this._swaggerHandler();
             }
         });
-        server.on('error', (_) => {
-            port = Math.floor(Math.random() * 8999) + 1000;
-            server.listen(port);
-        });
         return server;
     }
     /**
@@ -443,20 +497,10 @@ class Spear {
      */
     notfound(fn) {
         const handler = ({ req, res }) => {
-            return fn({
-                req,
-                res: this._customizeResponse(req, res),
-                headers: {},
-                query: {},
-                files: {},
-                body: {},
-                params: {},
-                cookies: {}
-            });
+            const ctx = this._createContext({ req, res, ps: {} });
+            return fn(ctx);
         };
-        this._onListeners.push(() => {
-            return this.all('*', ...this._globalMiddlewares, handler);
-        });
+        this.all('*', handler);
         return this;
     }
     /**
@@ -565,7 +609,7 @@ class Spear {
         return this;
     }
     /**
-     * The 'any' method is used to add the request handler to the router for 'GET' 'POST' 'PUT' 'PATCH' 'DELETE' 'HEAD' 'OPTIONS' methods.
+     * The 'all' method is used to add the request handler to the router for 'GET' 'POST' 'PUT' 'PATCH' 'DELETE' 'HEAD' 'OPTIONS' methods.
      *
      * @param {string} path
      * @callback {...Function[]} handlers of the middlewares
@@ -573,58 +617,12 @@ class Spear {
      * @property  {function} next  - go to next function
      * @returns {this}
      */
-    any(path, ...handlers) {
-        this._onListeners.push(() => {
-            return this._router.all(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 'GET' 'POST' 'PUT' 'PATCH' 'DELETE' 'HEAD' 'OPTIONS' methods.
-    *
-    * @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;
     }
-    _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) => {
@@ -738,382 +736,258 @@ class Spear {
         }
         return;
     }
-    _customizeResponse(req, res) {
-        const response = res;
-        response.json = (results) => {
-            if (res.writableEnded)
-                return;
-            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({
-                    ...results
-                }, res.statusCode), null, 2));
-            }
-            return res.end(JSON.stringify({
-                ...results,
-            }, null, 2));
-        };
-        response.send = (results) => {
-            if (res.writableEnded)
-                return;
-            res.writeHead(res.statusCode, { 'Content-Type': 'text/plain' });
-            return res.end(results);
-        };
-        response.html = (results) => {
-            if (res.writableEnded)
-                return;
-            res.writeHead(res.statusCode, { 'Content-Type': 'text/html' });
-            return res.end(results);
-        };
-        response.error = (err) => {
-            const statusCandidates = [
-                err?.response?.data?.code,
-                err?.code,
-                err?.status,
-                err?.statusCode,
-                err?.response?.data?.statusCode
-            ];
-            let code = statusCandidates
-                .map(v => Number(v))
-                .find(v => Number.isFinite(v) && v >= 400) ?? 500;
-            const message = err?.response?.data?.errorMessage ??
-                err?.response?.data?.message ??
-                err?.message ??
-                `The request '${req.url}' resulted in a server error.`;
-            response.status(code);
-            const payload = { message };
-            if (this._formatResponse) {
-                return res.end(JSON.stringify(this._formatResponse(payload, code)));
-            }
-            return res.end(JSON.stringify(payload));
-        };
-        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(204);
-            return res.end();
-        };
-        response.badRequest = (message) => {
-            if (res.writableEnded)
-                return;
-            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({
-                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({
-                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({
-                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({
-                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({
-                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({
-                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({
-                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({
-                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;
-    }
     _wrapHandlers(...handlers) {
-        return (req, res, params) => {
-            const nextHandler = (index = 0) => {
+        return (req, res, ps) => {
+            const dispatch = (index = 0) => {
+                const handler = handlers[index];
+                if (!handler)
+                    return;
+                const ctx = this._createContext({ req, res, ps });
                 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)
-                    };
-                    if (index === handlers.length - 1) {
-                        return this._wrapResponse(handlers[index]
-                            .bind(handlers[index]))(ctx, this._nextFunction(ctx));
+                    const next = () => dispatch(index + 1);
+                    const isLast = index === handlers.length - 1;
+                    if (isLast) {
+                        return this._wrapResponse(handler)(ctx, this._nextError(ctx));
                     }
-                    return handlers[index](ctx, () => {
-                        return nextHandler(index + 1);
-                    });
+                    return handler(ctx, next);
                 }
                 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);
+                    return this._nextError(ctx)(err);
                 }
             };
-            if (res.writableEnded)
-                return;
-            return nextHandler();
+            return dispatch();
         };
     }
     _wrapResponse(handler) {
         return (ctx, next) => {
             Promise.resolve(handler(ctx, next))
                 .then(result => {
-                if (ctx.res.writableEnded)
+                if (ctx.res.writableEnded) {
                     return;
+                }
                 if (result instanceof http_1.ServerResponse) {
-                    if (result?.end) {
-                        result.end();
-                    }
                     return;
                 }
-                if (result == null) {
-                    if (!ctx.res.headersSent) {
-                        ctx.res.writeHead(204, { 'Content-Type': 'text/plain' });
-                    }
-                    ctx.res.end();
+                if (result instanceof stream_1.Stream) {
                     return;
                 }
-                if (typeof result === 'string') {
-                    if (!ctx.res.headersSent) {
-                        ctx.res.writeHead(200, { 'Content-Type': 'text/plain' });
-                    }
-                    ctx.res.end(result ?? '');
+                if (result == null) {
+                    ctx.res.noContent();
                     return;
                 }
-                if (this._formatResponse != null) {
-                    const formattedResult = this._formatResponse(result, ctx.res.statusCode);
-                    if (typeof formattedResult === 'string') {
-                        if (!ctx.res.headersSent) {
-                            ctx.res.writeHead(200, { 'Content-Type': 'text/plain' });
-                        }
-                        ctx.res.end(formattedResult);
-                        return;
-                    }
-                    if (!ctx.res.headersSent) {
-                        ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
-                    }
-                    ctx.res.end(JSON.stringify(formattedResult));
+                if (typeof result === 'string') {
+                    ctx.res.send(result);
                     return;
                 }
-                if (!ctx.res.headersSent) {
-                    ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
-                }
-                ctx.res.end(JSON.stringify(result));
+                ctx.res.json(result);
                 return;
             })
-                .catch(err => {
-                return this._nextFunction(ctx)(err);
-            });
+                .catch(err => next(err));
         };
     }
-    _nextFunction(ctx) {
+    _nextError(ctx) {
         const NEXT_MESSAGE = "The 'next' function does not have any subsequent function.";
         return (err) => {
-            if (err != null) {
-                if (this._errorHandler != null) {
-                    const callback = this._errorHandler(err, ctx);
-                    if (callback == null || !(callback instanceof http_1.ServerResponse)) {
-                        ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
-                        return ctx.res.end(JSON.stringify({
-                            message: err?.message
-                        }, null, 2));
-                    }
-                    return callback;
-                }
-                ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
-                if (this._formatResponse != null) {
-                    return ctx.res.end(JSON.stringify(this._formatResponse({
-                        message: err?.message,
-                    }, ctx.res.statusCode), null, 2));
-                }
-                return ctx.res.end(JSON.stringify({
-                    message: err?.message
-                }, null, 2));
-            }
+            const errorMessage = err?.message || NEXT_MESSAGE;
             if (this._errorHandler != null) {
-                return this._errorHandler(new Error(NEXT_MESSAGE), ctx);
+                return this._errorHandler(new Error(errorMessage), ctx);
+            }
+            if (!ctx.res.headersSent) {
+                ctx.res.writeHead(500, const_1.HEADER_CONTENT_TYPES['json']);
             }
-            ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
             if (this._formatResponse != null) {
-                return ctx.res.end(JSON.stringify(this._formatResponse({
-                    message: NEXT_MESSAGE
-                }, ctx.res.statusCode), null, 2));
+                ctx.res.end(JSON.stringify(this._formatResponse({
+                    message: errorMessage
+                }, ctx.res.statusCode)));
+                return;
             }
-            return ctx.res.end(JSON.stringify({
-                message: NEXT_MESSAGE
-            }, null, 2));
+            ctx.res.end(JSON.stringify({
+                message: errorMessage
+            }));
+            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 (this._adapter.kind === 'uWS') {
+                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);
+        const adapter = this._adapter;
+        if (adapter.kind === 'uWS') {
+            const server = adapter.server.App();
+            server.any('/*', (uwsRes, uwsReq) => {
+                const { req, res } = (0, uWS_1.uWSAdaptRequestResponse)(uwsReq, uwsRes);
+                if (cors)
+                    cors(req, res);
                 return lookup(req, res);
+            });
+            if (this._ws?.handler) {
+                server.ws('/*', {
+                    open: (ws) => {
+                        this._ws.handler?.connection?.(ws);
+                    },
+                    message: (ws, message) => {
+                        this._ws.handler?.message?.(ws, Buffer.from(message));
+                    },
+                    close: (ws, code, message) => {
+                        this._ws.handler?.close?.(ws, code, Buffer.from(message));
+                    }
+                });
             }
-            : (req, res) => {
-                return lookup(req, res);
+            return server;
+        }
+        if (adapter.kind === 'net') {
+            const server = net_1.default.createServer((socket) => {
+                (0, net_2.netAdaptRequestResponse)(socket, (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) => {
-                if (this._ws?.connection) {
-                    this._ws.connection(ws);
+            if (this._ws?.handler) {
+                this._ws.server = new ws_1.default.Server({ server, ...this._ws.options });
+                this._ws.server.on('connection', (ws) => {
+                    if (this._ws.handler?.connection) {
+                        this._ws.handler.connection(ws);
+                    }
+                    ws.on('message', (data) => {
+                        this._ws.handler?.message?.(ws, data);
+                    });
+                    ws.on('close', (code, reason) => {
+                        if (this._ws.handler?.close) {
+                            this._ws.handler?.close(ws, code, reason);
+                        }
+                    });
+                    ws.on('error', (err) => {
+                        if (this._ws.handler?.error) {
+                            this._ws.handler.error(ws, err);
+                        }
+                    });
+                });
+            }
+            return server;
+        }
+        const server = http_1.default.createServer((req, res) => {
+            if (cors)
+                cors(req, res);
+            return lookup(req, res);
+        });
+        if (this._ws?.handler) {
+            this._ws.server = new ws_1.default.Server({ server, ...this._ws.options });
+            this._ws.server.on('connection', (ws) => {
+                if (this._ws.handler?.connection) {
+                    this._ws.handler.connection(ws);
                 }
                 ws.on('message', (data) => {
-                    if (this._ws?.message) {
-                        this._ws.message(ws, data);
-                    }
+                    this._ws.handler?.message?.(ws, data);
                 });
                 ws.on('close', (code, reason) => {
-                    if (this._ws?.close) {
-                        this._ws.close(ws, code, reason);
+                    if (this._ws.handler?.close) {
+                        this._ws.handler?.close(ws, code, reason);
                     }
                 });
                 ws.on('error', (err) => {
-                    if (this._ws?.error) {
-                        this._ws.error(ws, err);
+                    if (this._ws.handler?.error) {
+                        this._ws.handler.error(ws, err);
                     }
                 });
             });
         }
         return server;
     }
+    _createContext({ req, res, ps }) {
+        const request = req;
+        const response = (0, response_1.Response)(req, res, {
+            formatResponse: this._formatResponse,
+            isUwebSocket: this._adapter.kind === 'uWS'
+        });
+        const headers = req.headers;
+        const params = ps;
+        const body = request.body;
+        const files = request.files;
+        const cookies = request.cookies;
+        const query = this._parser.queryString(req.url) || {};
+        const xff = headers['x-forwarded-for'];
+        const xrip = headers['x-real-ip'];
+        const cfip = headers['cf-connecting-ip'];
+        let ips = [];
+        if (cfip) {
+            ips = Array.isArray(cfip) ? cfip : [cfip];
+        }
+        else if (xff) {
+            ips = Array.isArray(xff) ? xff : [xff];
+        }
+        else if (xrip) {
+            ips = Array.isArray(xrip) ? xrip : [xrip];
+        }
+        else {
+            const addr = req.socket?.remoteAddress;
+            ips = addr ? [addr] : [];
+        }
+        const ip = (ips.length ? ips[0] : null);
+        request.params = params;
+        request.query = query;
+        request.ip = ip;
+        request.ips = ips;
+        return {
+            req: request,
+            res: response,
+            headers: headers || Object.create(null),
+            params: params || Object.create(null),
+            query,
+            body: body || Object.create(null),
+            files: files || Object.create(null),
+            cookies: cookies || Object.create(null),
+            ip,
+            ips
+        };
+    }
     _normalizePath(...paths) {
         const path = paths
             .join('/')
@@ -1141,10 +1015,10 @@ class Spear {
             routes
         });
         this._router.get(staticUrl, staticSwaggerHandler);
-        this._router.get(path, (_, res) => {
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.write(html);
-            return res.end();
+        this._router.get(path, (req, res) => {
+            res.writeHead(200, const_1.HEADER_CONTENT_TYPES['html']);
+            res.end(html);
+            return;
         });
         return;
     }