@morojs/moro 1.6.0 → 1.6.1

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

@@ -1,688 +0,0 @@
-// 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