@morojs/moro 1.5.17 → 1.6.0

package/dist/core/http/uws-http-server.js

@@ -0,0 +1,688 @@
+// uWebSockets.js HTTP Server Implementation for Moro Framework
+// Provides ultra-high-performance HTTP and WebSocket server using uWebSockets.js
+import cluster from 'cluster';
+import { createFrameworkLogger } from '../logger/index.js';
+/**
+ * uWebSockets HTTP Server Adapter
+ * Bridges uWebSockets.js with Moro's HTTP abstractions
+ */
+export class UWebSocketsHttpServer {
+    app; // uWebSockets app instance
+    uws; // uWebSockets module reference (stored to avoid re-importing)
+    listenSocket; // uWebSockets listen socket
+    routes = [];
+    globalMiddleware = [];
+    logger = createFrameworkLogger('UWSHttpServer');
+    hookManager;
+    requestCounter = 0;
+    isListening = false;
+    port;
+    host;
+    initPromise;
+    // Route caching for performance
+    staticRoutes = new Map();
+    dynamicRoutes = [];
+    // Performance optimizations - object pooling
+    paramObjectPool = [];
+    queryObjectPool = [];
+    maxPoolSize = 100;
+    // String interning for common values
+    static INTERNED_METHODS = new Map([
+        ['get', 'GET'],
+        ['post', 'POST'],
+        ['put', 'PUT'],
+        ['delete', 'DELETE'],
+        ['patch', 'PATCH'],
+        ['head', 'HEAD'],
+        ['options', 'OPTIONS'],
+    ]);
+    // Pre-compiled response buffers
+    static RESPONSE_BUFFERS = {
+        notFound: Buffer.from('{"success":false,"error":"Not found"}'),
+        serverError: Buffer.from('{"success":false,"error":"Internal server error"}'),
+    };
+    constructor(options = {}) {
+        this.initPromise = this.initialize(options);
+    }
+    async initialize(options) {
+        try {
+            // Lazy load uWebSockets.js - only when explicitly configured
+            // This ensures it's an optional dependency with graceful fallback
+            const uwsModule = await import('uWebSockets.js');
+            this.uws = uwsModule.default || uwsModule;
+            if (options.ssl && options.ssl.key_file_name && options.ssl.cert_file_name) {
+                this.app = this.uws.SSLApp({
+                    key_file_name: options.ssl.key_file_name,
+                    cert_file_name: options.ssl.cert_file_name,
+                    passphrase: options.ssl.passphrase,
+                });
+                this.logger.info('uWebSockets SSL/TLS HTTP server created', 'Init');
+            }
+            else {
+                this.app = this.uws.App();
+                this.logger.info('uWebSockets HTTP server created', 'Init');
+            }
+            // Setup generic route handler for all HTTP methods and paths
+            this.setupRouteHandlers();
+        }
+        catch (error) {
+            // Log helpful error message with installation instructions
+            this.logger.error('Failed to load uWebSockets.js (optional dependency)\n' +
+                'To use uWebSockets, install it with:\n' +
+                '  npm install --save-dev github:uNetworking/uWebSockets.js#v20.52.0\n' +
+                'Or set useUWebSockets: false in your config to use the standard HTTP server.\n' +
+                'Error: ' +
+                (error instanceof Error ? error.message : String(error)), 'Init');
+            throw error; // Re-throw so framework.ts can catch and fallback
+        }
+    }
+    setupRouteHandlers() {
+        // Handle all HTTP methods through catchall for proper routing
+        this.app.any('/*', (res, req) => {
+            // Try fast synchronous path first
+            const method = req.getMethod().toUpperCase();
+            const path = req.getUrl();
+            // Fast path: No body, no global middleware
+            if (this.globalMiddleware.length === 0 && method === 'GET') {
+                const route = this.findRoute(method, path);
+                if (route && (!route.middleware || route.middleware.length === 0)) {
+                    this.handleRequestSync(req, res, route, method, path);
+                    return;
+                }
+            }
+            // Slow path: Has middleware or body or other complexity
+            this.handleRequest(req, res);
+        });
+    }
+    // Fast synchronous handler for simple GET requests
+    handleRequestSync(req, res, route, method, path) {
+        this.requestCounter++;
+        let httpReq;
+        try {
+            httpReq = this.createMoroRequest(req, res);
+            const httpRes = this.createMoroResponse(req, res);
+            // Extract params if needed
+            if (route.paramNames.length > 0) {
+                const matches = path.match(route.pattern);
+                if (matches) {
+                    httpReq.params = this.acquireParamObject();
+                    route.paramNames.forEach((name, index) => {
+                        httpReq.params[name] = matches[index + 1];
+                    });
+                    httpReq._pooledParams = httpReq.params;
+                }
+            }
+            // Execute handler synchronously
+            const result = route.handler(httpReq, httpRes);
+            // Handle return value
+            if (result && typeof result.then === 'function') {
+                // Oops, handler is async - handle it
+                result
+                    .then((data) => {
+                    if (data !== undefined && data !== null && !httpRes.headersSent) {
+                        httpRes.json(data);
+                    }
+                })
+                    .catch(() => {
+                    if (!res.aborted) {
+                        res.cork(() => {
+                            res.writeStatus('500 Internal Server Error');
+                            res.end('{"success":false,"error":"Internal server error"}');
+                        });
+                    }
+                });
+            }
+            else if (result !== undefined && result !== null && !httpRes.headersSent) {
+                httpRes.json(result);
+            }
+        }
+        finally {
+            const pooledParams = httpReq?._pooledParams;
+            if (pooledParams)
+                this.releaseParamObject(pooledParams);
+            const pooledQuery = httpReq?._pooledQuery;
+            if (pooledQuery)
+                this.releaseQueryObject(pooledQuery);
+        }
+    }
+    // Object pooling methods for performance
+    acquireParamObject() {
+        return this.paramObjectPool.pop() || {};
+    }
+    releaseParamObject(obj) {
+        if (this.paramObjectPool.length < this.maxPoolSize) {
+            for (const key in obj)
+                delete obj[key];
+            this.paramObjectPool.push(obj);
+        }
+    }
+    acquireQueryObject() {
+        return this.queryObjectPool.pop() || {};
+    }
+    releaseQueryObject(obj) {
+        if (this.queryObjectPool.length < this.maxPoolSize) {
+            for (const key in obj)
+                delete obj[key];
+            this.queryObjectPool.push(obj);
+        }
+    }
+    async handleRequest(req, res) {
+        this.requestCounter++;
+        // Declare outside try block for cleanup in finally
+        let httpReq;
+        try {
+            // Create Moro-compatible request object
+            httpReq = this.createMoroRequest(req, res);
+            const httpRes = this.createMoroResponse(req, res);
+            // Parse body only if there's actually a body (check content-length)
+            const method = req.getMethod().toUpperCase();
+            const contentLength = req.getHeader('content-length');
+            if ((method === 'POST' || method === 'PUT' || method === 'PATCH') &&
+                contentLength &&
+                parseInt(contentLength) > 0) {
+                await this.readBody(res, httpReq);
+            }
+            // Execute hooks before request processing
+            if (this.hookManager) {
+                await this.hookManager.execute('request', {
+                    request: httpReq,
+                    response: httpRes,
+                });
+            }
+            // Find route first (before middleware)
+            const route = this.findRoute(httpReq.method, httpReq.path);
+            if (!route) {
+                // 404 Not Found - fast path
+                if (!httpRes.headersSent) {
+                    httpRes.statusCode = 404;
+                    httpRes.setHeader('Content-Type', 'application/json');
+                    httpRes.end('{"success":false,"error":"Not found"}');
+                }
+                return;
+            }
+            // Extract path parameters early - use pooled object
+            const matches = httpReq.path.match(route.pattern);
+            if (matches) {
+                httpReq.params = this.acquireParamObject();
+                route.paramNames.forEach((name, index) => {
+                    httpReq.params[name] = matches[index + 1];
+                });
+                // Store for cleanup
+                httpReq._pooledParams = httpReq.params;
+            }
+            // Execute ALL middleware in one pass (global + route)
+            if (this.globalMiddleware.length > 0 || (route.middleware && route.middleware.length > 0)) {
+                const allMiddleware = route.middleware && route.middleware.length > 0
+                    ? [...this.globalMiddleware, ...route.middleware]
+                    : this.globalMiddleware;
+                await this.executeMiddleware(allMiddleware, httpReq, httpRes);
+                if (httpRes.headersSent)
+                    return;
+            }
+            // Execute route handler
+            const result = await route.handler(httpReq, httpRes);
+            // If handler returns data and response hasn't been sent, send it
+            if (result !== undefined && result !== null && !httpRes.headersSent) {
+                httpRes.json(result);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Request handling error: ${error instanceof Error ? error.message : String(error)}`, 'RequestError');
+            // Send error response if not already sent
+            if (!res.aborted) {
+                try {
+                    res.cork(() => {
+                        res.writeStatus('500 Internal Server Error');
+                        res.writeHeader('Content-Type', 'application/json');
+                        res.end('{"success":false,"error":"Internal server error"}');
+                    });
+                }
+                catch (writeError) {
+                    this.logger.error('Failed to send error response', 'ResponseError');
+                }
+            }
+        }
+        finally {
+            // Cleanup: Release pooled objects back to pool for reuse
+            const pooledParams = httpReq._pooledParams;
+            if (pooledParams) {
+                this.releaseParamObject(pooledParams);
+            }
+            const pooledQuery = httpReq._pooledQuery;
+            if (pooledQuery) {
+                this.releaseQueryObject(pooledQuery);
+            }
+        }
+    }
+    createMoroRequest(req, res) {
+        const url = req.getUrl();
+        const queryString = req.getQuery();
+        const methodRaw = req.getMethod();
+        // Use interned method string if available
+        const method = UWebSocketsHttpServer.INTERNED_METHODS.get(methodRaw) || methodRaw.toUpperCase();
+        // Lazy query parsing - use pooled object
+        let queryParams;
+        if (queryString) {
+            queryParams = this.acquireQueryObject();
+            // Fast query parsing without URLSearchParams overhead
+            const pairs = queryString.split('&');
+            for (let i = 0; i < pairs.length; i++) {
+                const pair = pairs[i];
+                const eqIdx = pair.indexOf('=');
+                if (eqIdx > 0) {
+                    const key = pair.substring(0, eqIdx);
+                    const value = pair.substring(eqIdx + 1);
+                    queryParams[decodeURIComponent(key)] = decodeURIComponent(value);
+                }
+            }
+        }
+        // Lazy header parsing - only parse headers that exist
+        const headers = {};
+        req.forEach((key, value) => {
+            const lowerKey = key.toLowerCase();
+            headers[lowerKey] = value;
+        });
+        const httpReq = {
+            method,
+            path: url,
+            url: url,
+            query: queryParams || {},
+            params: {}, // Will be filled by route matching
+            headers,
+            body: null,
+            ip: '', // Lazy - only compute if accessed
+            requestId: '', // Lazy - only generate if accessed
+        };
+        // Store original query object for cleanup
+        httpReq._pooledQuery = queryParams;
+        return httpReq;
+    }
+    createMoroResponse(req, res) {
+        let headersSent = false;
+        let statusCode = 200;
+        const responseHeaders = {};
+        //eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const httpRes = {
+            statusCode,
+            get headersSent() {
+                return headersSent;
+            },
+            status(code) {
+                statusCode = code;
+                httpRes.statusCode = code;
+                return httpRes;
+            },
+            setHeader(name, value) {
+                responseHeaders[name.toLowerCase()] = value;
+                return httpRes;
+            },
+            getHeader(name) {
+                return responseHeaders[name.toLowerCase()];
+            },
+            removeHeader(name) {
+                delete responseHeaders[name.toLowerCase()];
+                return httpRes;
+            },
+            json(data) {
+                if (headersSent || res.aborted)
+                    return;
+                const body = JSON.stringify(data);
+                responseHeaders['content-type'] = 'application/json';
+                try {
+                    res.cork(() => {
+                        res.writeStatus(`${statusCode} OK`);
+                        Object.entries(responseHeaders).forEach(([key, value]) => {
+                            res.writeHeader(key, Array.isArray(value) ? value.join(', ') : String(value));
+                        });
+                        res.end(body);
+                    });
+                    headersSent = true;
+                }
+                catch (error) {
+                    self.logger.error('Failed to send JSON response', 'ResponseError');
+                }
+            },
+            send(data) {
+                if (headersSent || res.aborted)
+                    return;
+                const body = typeof data === 'string' ? data : data.toString();
+                try {
+                    res.cork(() => {
+                        res.writeStatus(`${statusCode} OK`);
+                        Object.entries(responseHeaders).forEach(([key, value]) => {
+                            res.writeHeader(key, Array.isArray(value) ? value.join(', ') : String(value));
+                        });
+                        res.end(body);
+                    });
+                    headersSent = true;
+                }
+                catch (error) {
+                    self.logger.error('Failed to send response', 'ResponseError');
+                }
+            },
+            end(data, encoding, callback) {
+                if (headersSent || res.aborted) {
+                    if (typeof callback === 'function')
+                        callback();
+                    return httpRes;
+                }
+                try {
+                    res.cork(() => {
+                        res.writeStatus(`${statusCode} OK`);
+                        Object.entries(responseHeaders).forEach(([key, value]) => {
+                            res.writeHeader(key, Array.isArray(value) ? value.join(', ') : String(value));
+                        });
+                        res.end(data || '');
+                    });
+                    headersSent = true;
+                    if (typeof callback === 'function')
+                        callback();
+                }
+                catch (error) {
+                    self.logger.error('Failed to end response', 'ResponseError');
+                    if (typeof callback === 'function')
+                        callback();
+                }
+                return httpRes;
+            },
+            redirect(url, code) {
+                if (headersSent || res.aborted)
+                    return;
+                const redirectCode = code || 302;
+                statusCode = redirectCode;
+                try {
+                    res.cork(() => {
+                        res.writeStatus(`${redirectCode} Found`);
+                        res.writeHeader('Location', url);
+                        res.end();
+                    });
+                    headersSent = true;
+                }
+                catch (error) {
+                    self.logger.error('Failed to send redirect', 'ResponseError');
+                }
+            },
+            // EventEmitter compatibility - stub implementations for middleware
+            on(event, callback) {
+                // uWebSockets doesn't use events like Node.js, but middleware might try to listen
+                // Only implement 'finish' and 'close' events as stubs
+                return httpRes;
+            },
+            once(event, callback) {
+                return httpRes;
+            },
+            emit(event, ...args) {
+                return true;
+            },
+            removeListener(event, callback) {
+                return httpRes;
+            },
+            cookie(name, value, options) {
+                let cookie = `${name}=${value}`;
+                if (options) {
+                    if (options.maxAge)
+                        cookie += `; Max-Age=${options.maxAge}`;
+                    if (options.domain)
+                        cookie += `; Domain=${options.domain}`;
+                    if (options.path)
+                        cookie += `; Path=${options.path}`;
+                    if (options.secure)
+                        cookie += '; Secure';
+                    if (options.httpOnly)
+                        cookie += '; HttpOnly';
+                    if (options.sameSite)
+                        cookie += `; SameSite=${options.sameSite}`;
+                }
+                const existing = responseHeaders['set-cookie'];
+                if (existing) {
+                    if (Array.isArray(existing)) {
+                        responseHeaders['set-cookie'] = [...existing, cookie];
+                    }
+                    else {
+                        responseHeaders['set-cookie'] = [existing, cookie];
+                    }
+                }
+                else {
+                    responseHeaders['set-cookie'] = cookie;
+                }
+                return httpRes;
+            },
+        };
+        return httpRes;
+    }
+    async readBody(res, httpReq) {
+        return new Promise((resolve, reject) => {
+            let buffer;
+            res.onData((chunk, isLast) => {
+                const chunkBuffer = Buffer.from(chunk);
+                if (isLast) {
+                    if (buffer) {
+                        buffer = Buffer.concat([buffer, chunkBuffer]);
+                    }
+                    else {
+                        buffer = chunkBuffer;
+                    }
+                    try {
+                        const contentType = httpReq.headers['content-type'] || '';
+                        if (contentType.includes('application/json')) {
+                            httpReq.body = JSON.parse(buffer.toString('utf-8'));
+                        }
+                        else if (contentType.includes('application/x-www-form-urlencoded')) {
+                            const params = new URLSearchParams(buffer.toString('utf-8'));
+                            const body = {};
+                            params.forEach((value, key) => {
+                                body[key] = value;
+                            });
+                            httpReq.body = body;
+                        }
+                        else {
+                            httpReq.body = buffer.toString('utf-8');
+                        }
+                        resolve();
+                    }
+                    catch (error) {
+                        this.logger.error('Failed to parse request body', 'BodyParseError');
+                        httpReq.body = null;
+                        resolve();
+                    }
+                }
+                else {
+                    if (buffer) {
+                        buffer = Buffer.concat([buffer, chunkBuffer]);
+                    }
+                    else {
+                        buffer = chunkBuffer;
+                    }
+                }
+            });
+            res.onAborted(() => {
+                this.logger.debug('Request aborted', 'RequestAborted');
+                resolve();
+            });
+        });
+    }
+    async executeMiddleware(middleware, req, res) {
+        for (const mw of middleware) {
+            if (res.headersSent)
+                break;
+            await new Promise((resolve, reject) => {
+                try {
+                    const result = mw(req, res, (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                    // Handle async middleware
+                    if (result && typeof result.then === 'function') {
+                        result.then(() => resolve()).catch(reject);
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        }
+    }
+    findRoute(method, path) {
+        // Fast path: static route lookup
+        const staticKey = `${method}:${path}`;
+        const staticRoute = this.staticRoutes.get(staticKey);
+        if (staticRoute)
+            return staticRoute;
+        // Dynamic route matching
+        for (const route of this.dynamicRoutes) {
+            if (route.method === method && route.pattern.test(path)) {
+                return route;
+            }
+        }
+        return null;
+    }
+    // Public API - matches MoroHttpServer interface
+    use(middleware) {
+        this.globalMiddleware.push(middleware);
+    }
+    get(path, handler, middleware) {
+        this.addRoute('GET', path, handler, middleware);
+    }
+    post(path, handler, middleware) {
+        this.addRoute('POST', path, handler, middleware);
+    }
+    put(path, handler, middleware) {
+        this.addRoute('PUT', path, handler, middleware);
+    }
+    delete(path, handler, middleware) {
+        this.addRoute('DELETE', path, handler, middleware);
+    }
+    patch(path, handler, middleware) {
+        this.addRoute('PATCH', path, handler, middleware);
+    }
+    options(path, handler, middleware) {
+        this.addRoute('OPTIONS', path, handler, middleware);
+    }
+    head(path, handler, middleware) {
+        this.addRoute('HEAD', path, handler, middleware);
+    }
+    addRoute(method, path, handler, middleware) {
+        const { pattern, paramNames } = this.pathToRegex(path);
+        const route = {
+            method,
+            path,
+            pattern,
+            paramNames,
+            handler,
+            middleware: middleware || [],
+        };
+        this.routes.push(route);
+        // Optimize route lookup
+        if (paramNames.length === 0) {
+            // Static route
+            this.staticRoutes.set(`${method}:${path}`, route);
+        }
+        else {
+            // Dynamic route
+            this.dynamicRoutes.push(route);
+        }
+        this.logger.debug(`Route registered: ${method} ${path}`, 'RouteRegistration');
+    }
+    pathToRegex(path) {
+        const paramNames = [];
+        const regexPath = path.replace(/\//g, '\\/').replace(/:([^/]+)/g, (match, paramName) => {
+            paramNames.push(paramName);
+            return '([^/]+)';
+        });
+        return {
+            pattern: new RegExp(`^${regexPath}$`),
+            paramNames,
+        };
+    }
+    setHookManager(hookManager) {
+        this.hookManager = hookManager;
+    }
+    configurePerformance(config) {
+        // uWebSockets is already highly optimized
+        // This method exists for API compatibility
+        this.logger.debug('Performance configuration noted (uWebSockets is pre-optimized)', 'Config');
+    }
+    listen(port, hostOrCallback, callback) {
+        // Wrap in async to await init
+        this.initPromise
+            .then(() => {
+            if (this.isListening) {
+                this.logger.warn('Server is already listening', 'Listen');
+                return;
+            }
+            const host = typeof hostOrCallback === 'string' ? hostOrCallback : '0.0.0.0';
+            const cb = typeof hostOrCallback === 'function' ? hostOrCallback : callback;
+            this.port = port;
+            this.host = host;
+            // Check if we're in a cluster environment
+            const isClusterWorker = cluster.isWorker;
+            const isClusterPrimary = cluster.isPrimary;
+            // ALWAYS use LIBUS_LISTEN_EXCLUSIVE_PORT when clustering
+            // This enables SO_REUSEPORT at the OS level, allowing multiple processes to bind to the same port
+            // NOTE: uWebSockets.js API doesn't have listen(host, port, options, cb)
+            // We must use listen(port, options, cb) which binds to 0.0.0.0
+            const listenOptions = 1; // ALWAYS use LIBUS_LISTEN_EXCLUSIVE_PORT for clustering support
+            this.app.listen(port, listenOptions, (token) => {
+                if (token) {
+                    this.listenSocket = token;
+                    this.isListening = true;
+                    const clusterInfo = isClusterWorker ? ` (worker ${process.pid})` : '';
+                    this.logger.info(`uWebSockets HTTP server listening on 0.0.0.0:${port}${clusterInfo}`, 'Listen');
+                    if (cb)
+                        cb();
+                }
+                else {
+                    const clusterInfo = isClusterWorker ? ` (worker ${process.pid})` : '';
+                    this.logger.error(`Failed to listen on port ${port}${clusterInfo}`, 'Listen');
+                    // Don't throw in cluster workers - let them fail gracefully
+                    if (!isClusterWorker) {
+                        throw new Error(`Failed to bind to port ${port}`);
+                    }
+                }
+            });
+        })
+            .catch(error => {
+            this.logger.error('Failed to initialize server before listen', 'Listen', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
+    async close(callback) {
+        if (!this.isListening) {
+            if (callback)
+                callback();
+            return;
+        }
+        try {
+            // Use stored module reference instead of re-importing
+            if (this.listenSocket && this.uws) {
+                this.uws.us_listen_socket_close(this.listenSocket);
+                this.listenSocket = null;
+                this.isListening = false;
+                this.logger.info('uWebSockets HTTP server closed', 'Close');
+            }
+            if (callback)
+                callback();
+        }
+        catch (error) {
+            this.logger.error('Error closing server', 'Close');
+            if (callback)
+                callback();
+        }
+    }
+    getServer() {
+        // Return the uWebSockets app for direct access if needed
+        return this.app;
+    }
+    getApp() {
+        return this.app;
+    }
+    forceCleanup() {
+        // Cleanup method for compatibility
+        this.logger.debug('Force cleanup called', 'Cleanup');
+    }
+}
+//# sourceMappingURL=uws-http-server.js.map