tspace-spear 1.2.3 → 1.2.5-beta.1

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

@@ -38,14 +38,21 @@ 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 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 compiler_1 = require("../compiler");
+const uWS_1 = require("./uWS");
+const net_2 = require("./net");
 /**
  *
  * The 'Spear' class is used to create a server and handle HTTP requests.
@@ -65,10 +72,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();
-    _adapter = http_1.default;
+    _globalPrefix = '';
+    _adapter = { kind: 'http', server: http_1.default };
     _cluster;
     _cors;
     _swagger = {
@@ -76,7 +83,7 @@ class Spear {
         path: '/api/docs',
         servers: [
             {
-                url: 'http://localhost:3000'
+                url: '/'
             }
         ],
         tags: [],
@@ -87,9 +94,11 @@ class Spear {
         }
     };
     _swaggerSpecs = [];
-    _wss;
-    _ws;
-    _wsOptions;
+    _ws = {
+        handler: null,
+        server: null,
+        options: null
+    };
     _errorHandler = null;
     _globalMiddlewares = [];
     _formatResponse = null;
@@ -102,16 +111,18 @@ class Spear {
             ms: 1000 * 60 * 10
         }
     };
+    _generateRoutes;
     constructor({ controllers, middlewares, globalPrefix, logger, cluster, adapter } = {}) {
+        this._controllers = controllers;
+        this._middlewares = middlewares;
         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;
+        if (globalPrefix)
+            this.useGlobalPrefix(globalPrefix);
     }
     /**
      * The get 'instance' method is used to get the instance of Spear.
@@ -124,11 +135,15 @@ class Spear {
     /**
      * The get 'routers' method is used get the all routers.
      *
-     * @returns {Instance<findMyWayRouter.HTTPVersion.V1>}
+     * @returns {FastRouter}
      */
     get routers() {
         return this._router;
     }
+    useGenerateRouteType(options) {
+        this._generateRoutes = options;
+        return this;
+    }
     /**
      * The 'ws' method is used to creates the WebSocket server.
      *
@@ -137,8 +152,8 @@ class Spear {
      * @returns {this}
      */
     ws(handlers, options) {
-        this._ws = handlers();
-        this._wsOptions = options ?? {};
+        this._ws.handler = handlers();
+        this._ws.options = options ?? {};
         return this;
     }
     /**
@@ -153,16 +168,38 @@ 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.Adapter} adapter - The adapter instance (e.g., HTTP or uWS).
+     * @param {T.AdapterServer} 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);
+        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;
     }
     /**
@@ -201,13 +238,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();
@@ -216,7 +253,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(" "));
@@ -234,28 +271,25 @@ class Spear {
     useBodyParser({ except } = {}) {
         this._globalMiddlewares.push((ctx, next) => {
             const { req, res } = 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())) {
+            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, res))
-                .then(r => {
-                req.body = r;
+                .then(body => {
+                req.body = body;
                 return next();
             })
                 .catch(err => {
-                return this._nextFunction(ctx)(err);
+                return this._nextError(ctx)(err);
             });
         });
         return this;
@@ -264,11 +298,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 } = {}) {
@@ -300,7 +334,7 @@ class Spear {
                 return next();
             })
                 .catch(err => {
-                return this._nextFunction(ctx)(err);
+                return this._nextError(ctx)(err);
             });
         });
         return this;
@@ -363,6 +397,9 @@ class Spear {
             callback = hostname;
         }
         const server = await this._createServer();
+        if (this._generateRoutes) {
+            await new compiler_1.Compiler().generateRoutes(this._generateRoutes);
+        }
         if (this._cluster != null &&
             this._cluster || typeof this._cluster === 'number') {
             this._clusterMode({
@@ -373,7 +410,7 @@ class Spear {
             });
             return server;
         }
-        if ('App' in this._adapter) {
+        if (this._adapter.kind === 'uWS') {
             const handler = () => {
                 this._onListeners.forEach(listener => listener());
                 if (this._swagger.use) {
@@ -469,21 +506,10 @@ class Spear {
      */
     notfound(fn) {
         const handler = ({ req, res }) => {
-            return fn({
-                req,
-                res: this._customizeResponse(req, res),
-                headers: {},
-                query: {},
-                files: {},
-                body: {},
-                params: {},
-                cookies: {},
-                ip: null
-            });
+            const ctx = this._createContext({ req, res, ps: {} });
+            return fn(ctx);
         };
-        this._onListeners.push(() => {
-            return this.all('*', ...this._globalMiddlewares, handler);
-        });
+        this.all('*', handler);
         return this;
     }
     /**
@@ -592,7 +618,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
@@ -600,21 +626,6 @@ 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));
@@ -734,239 +745,23 @@ 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)));
-                }
-                return res.end();
-            }
-            if (this._formatResponse != null) {
-                return res.end(JSON.stringify(this._formatResponse({
-                    ...results
-                }, res.statusCode)));
-            }
-            return res.end(JSON.stringify({
-                ...results,
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message: message
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message
-            }));
-        };
-        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)));
-            }
-            return res.end(JSON.stringify({
-                message
-            }));
-        };
-        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, 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
-                };
+                const handler = handlers[index];
+                if (!handler)
+                    return;
+                const ctx = this._createContext({ req, res, ps });
                 try {
-                    const handler = handlers[index];
-                    if (!handler)
-                        return;
-                    if (index === handlers.length - 1) {
-                        return Promise.resolve(this._wrapResponse(handler)(ctx, this._nextFunction(ctx))).catch(err => this._nextFunction(ctx)(err));
+                    const next = () => dispatch(index + 1);
+                    const isLast = index === handlers.length - 1;
+                    if (isLast) {
+                        return this._wrapResponse(handler)(ctx, this._nextError(ctx));
                     }
-                    return Promise.resolve(handler(ctx, () => dispatch(index + 1))).catch(err => this._nextFunction(ctx)(err));
+                    return handler(ctx, next);
                 }
                 catch (err) {
-                    return this._nextFunction(ctx)(err);
+                    return this._nextError(ctx)(err);
                 }
             };
             return dispatch();
@@ -976,88 +771,47 @@ class Spear {
         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') {
-                    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
-                        }));
-                    }
-                    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)));
-                }
-                ctx.res.end(JSON.stringify({
-                    message: err?.message
-                }));
-                return;
-            }
+            const errorMessage = err?.message || NEXT_MESSAGE;
             if (this._errorHandler != null) {
-                return this._errorHandler(new Error(NEXT_MESSAGE), ctx);
+                return this._errorHandler(err, 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) {
                 ctx.res.end(JSON.stringify(this._formatResponse({
-                    message: NEXT_MESSAGE
+                    message: errorMessage
                 }, ctx.res.statusCode)));
                 return;
             }
             ctx.res.end(JSON.stringify({
-                message: NEXT_MESSAGE
+                message: errorMessage
             }));
             return;
         };
@@ -1076,7 +830,7 @@ class Spear {
             });
         }
         if (cluster_1.default.isWorker) {
-            if ('App' in this._adapter) {
+            if (this._adapter.kind === 'uWS') {
                 const handler = () => {
                     this._onListeners.forEach(listener => listener());
                     if (this._swagger.use) {
@@ -1114,188 +868,134 @@ class Spear {
         const lookup = this._router.lookup.bind(this._router);
         const cors = this._cors;
         const adapter = this._adapter;
-        if ('App' in adapter) {
-            const server = adapter.App();
+        if (adapter.kind === 'uWS') {
+            const server = adapter.server.App();
             server.any('/*', (uwsRes, uwsReq) => {
-                const { req, res } = this._uWSRequestResponse(uwsReq, uwsRes);
+                const { req, res } = (0, uWS_1.uWSAdaptRequestResponse)(uwsReq, uwsRes);
                 if (cors)
                     cors(req, res);
                 return lookup(req, res);
             });
-            if (this._ws) {
+            if (this._ws?.handler) {
                 server.ws('/*', {
                     open: (ws) => {
-                        this._ws?.connection?.(ws);
+                        this._ws.handler?.connection?.(ws);
                     },
                     message: (ws, message) => {
-                        this._ws?.message?.(ws, Buffer.from(message));
+                        this._ws.handler?.message?.(ws, Buffer.from(message));
                     },
                     close: (ws, code, message) => {
-                        this._ws?.close?.(ws, code, Buffer.from(message));
+                        this._ws.handler?.close?.(ws, code, Buffer.from(message));
                     }
                 });
             }
             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?.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) {
-            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?.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;
     }
-    _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;
+    _createContext({ req, res, ps }) {
+        const request = req;
+        const response = (0, response_1.Response)(req, res, {
+            formatResponse: this._formatResponse,
+            isUwebSocket: this._adapter.kind === 'uWS'
         });
-        return { req, res };
+        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
@@ -1324,8 +1024,8 @@ class Spear {
             routes
         });
         this._router.get(staticUrl, staticSwaggerHandler);
-        this._router.get(path, (_, res) => {
-            res.writeHead(200, { 'Content-Type': 'text/html' });
+        this._router.get(path, (req, res) => {
+            res.writeHead(200, const_1.HEADER_CONTENT_TYPES['html']);
             res.end(html);
             return;
         });