@morojs/moro 1.6.0 → 1.6.2

package/dist/core/http/http-server.d.ts

@@ -6,18 +6,11 @@ export declare class MoroHttpServer {
     private globalMiddleware;
     private compressionEnabled;
     private compressionThreshold;
+    private requestTrackingEnabled;
     private logger;
     private hookManager;
     private requestCounter;
-    private paramObjectPool;
-    private bufferPool;
-    private readonly maxPoolSize;
-    private middlewareExecutionCache;
-    private responseCache;
-    private responseCacheHits;
-    private responseCacheMisses;
-    private static readonly INTERNED_METHODS;
-    private static readonly INTERNED_HEADERS;
+    private poolManager;
     private static readonly RESPONSE_TEMPLATES;
     private static readonly BUFFER_SIZES;
     private static readonly BUFFER_POOLS;
@@ -31,6 +24,7 @@ export declare class MoroHttpServer {
         };
         minimal?: boolean;
     }): void;
+    setRequestTracking(enabled: boolean): void;
     use(middleware: Middleware): void;
     setHookManager(hookManager: any): void;
     get(path: string, ...handlers: (Middleware | HttpHandler)[]): void;
@@ -57,6 +51,7 @@ export declare class MoroHttpServer {
     private parseMultipart;
     private parseUrlEncoded;
     private parseQueryString;
+    private parseQueryStringPooled;
     private routeCache;
     private staticRoutes;
     private dynamicRoutes;
@@ -71,14 +66,59 @@ export declare class MoroHttpServer {
     close(): Promise<void>;
     forceCleanup(): void;
     getServer(): Server;
-    private getResponseCacheKey;
     getPerformanceStats(): {
-        responseCacheHits: number;
-        responseCacheMisses: number;
-        responseCacheSize: number;
         paramObjectPoolSize: number;
-        bufferPoolSize: number;
-        middlewareExecutionCacheSize: number;
+        queryObjectPoolSize: number;
+        headerObjectPoolSize: number;
+        poolManager: {
+            paramPool: {
+                poolSize: number;
+                maxSize: number;
+                acquireCount: number;
+                releaseCount: number;
+                createCount: number;
+                utilization: number;
+            };
+            headerPool: {
+                poolSize: number;
+                maxSize: number;
+                acquireCount: number;
+                releaseCount: number;
+                createCount: number;
+                utilization: number;
+            };
+            queryPool: {
+                poolSize: number;
+                maxSize: number;
+                acquireCount: number;
+                releaseCount: number;
+                createCount: number;
+                utilization: number;
+            };
+            bufferPools: Record<string, any>;
+            routeCache: {
+                size: number;
+                maxSize: number;
+                hits: number;
+                misses: number;
+                hitRate: number;
+            };
+            responseCache: {
+                size: number;
+                maxSize: number;
+                hits: number;
+                misses: number;
+                hitRate: number;
+            };
+            totalMemory: {
+                params: number;
+                headers: number;
+                queries: number;
+                buffers: number;
+                routes: number;
+                responses: number;
+            };
+        };
     };
 }
 export declare const middleware: {

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

@@ -5,6 +5,8 @@ import { createReadStream } from 'fs';
 import * as crypto from 'crypto';
 import { promisify } from 'util';
 import { createFrameworkLogger } from '../logger/index.js';
+import { PathMatcher } from '../routing/path-matcher.js';
+import { ObjectPoolManager } from '../pooling/object-pool-manager.js';
 const gzip = promisify(zlib.gzip);
 const deflate = promisify(zlib.deflate);
 export class MoroHttpServer {
@@ -13,40 +15,13 @@ export class MoroHttpServer {
     globalMiddleware = [];
     compressionEnabled = true;
     compressionThreshold = 1024;
+    requestTrackingEnabled = true; // Generate request IDs
     logger = createFrameworkLogger('HttpServer');
     hookManager;
     requestCounter = 0;
-    // Efficient object pooling with minimal overhead
-    paramObjectPool = [];
-    bufferPool = [];
-    maxPoolSize = 50;
-    // Request handler pooling to avoid function creation overhead
-    middlewareExecutionCache = new Map();
-    // Response caching for ultra-fast common responses
-    responseCache = new Map();
-    responseCacheHits = 0;
-    responseCacheMisses = 0;
-    // String interning for common values (massive memory savings)
-    static INTERNED_METHODS = new Map([
-        ['GET', 'GET'],
-        ['POST', 'POST'],
-        ['PUT', 'PUT'],
-        ['DELETE', 'DELETE'],
-        ['PATCH', 'PATCH'],
-        ['HEAD', 'HEAD'],
-        ['OPTIONS', 'OPTIONS'],
-    ]);
-    static INTERNED_HEADERS = new Map([
-        ['content-type', 'content-type'],
-        ['content-length', 'content-length'],
-        ['authorization', 'authorization'],
-        ['accept', 'accept'],
-        ['user-agent', 'user-agent'],
-        ['host', 'host'],
-        ['connection', 'connection'],
-        ['cache-control', 'cache-control'],
-    ]);
-    // Pre-compiled response templates for ultra-common responses
+    // Use shared object pool manager
+    poolManager = ObjectPoolManager.getInstance();
+    // Pre-compiled response templates for common responses
     static RESPONSE_TEMPLATES = {
         notFound: Buffer.from('{"success":false,"error":"Not found"}'),
         unauthorized: Buffer.from('{"success":false,"error":"Unauthorized"}'),
@@ -55,7 +30,7 @@ export class MoroHttpServer {
         methodNotAllowed: Buffer.from('{"success":false,"error":"Method not allowed"}'),
         rateLimited: Buffer.from('{"success":false,"error":"Rate limit exceeded"}'),
     };
-    // Ultra-fast buffer pool for zero-copy operations (Rust-level performance)
+    // Buffer pool for zero-copy operations
     static BUFFER_SIZES = [64, 256, 1024, 4096, 16384];
     static BUFFER_POOLS = new Map();
     static {
@@ -110,6 +85,10 @@ export class MoroHttpServer {
             this.compressionThreshold = Infinity; // Never compress
         }
     }
+    // Configure request tracking (ID generation)
+    setRequestTracking(enabled) {
+        this.requestTrackingEnabled = enabled;
+    }
     // Middleware management
     use(middleware) {
         this.globalMiddleware.push(middleware);
@@ -165,39 +144,33 @@ export class MoroHttpServer {
         }
     }
     pathToRegex(path) {
-        const paramNames = [];
-        // Convert parameterized routes to regex
-        const regexPattern = path
-            .replace(/\/:([^/]+)/g, (match, paramName) => {
-            paramNames.push(paramName);
-            return '/([^/]+)';
-        })
-            .replace(/\//g, '\\/');
+        // Use shared PathMatcher for consistent path compilation
+        const compiled = PathMatcher.compile(path);
         return {
-            pattern: new RegExp(`^${regexPattern}$`),
-            paramNames,
+            pattern: compiled.pattern || new RegExp(`^${path.replace(/\//g, '\\/')}$`),
+            paramNames: compiled.paramNames,
         };
     }
     async handleRequest(req, res) {
         const httpReq = this.enhanceRequest(req);
-        const httpRes = this.enhanceResponse(res);
+        const httpRes = this.enhanceResponse(res, httpReq);
         // Store original params for efficient cleanup
         const originalParams = httpReq.params;
         try {
-            // Optimized URL and query parsing
+            // Optimized URL and query parsing with object pooling
             const urlString = req.url;
             const queryIndex = urlString.indexOf('?');
             if (queryIndex === -1) {
-                // No query string - fast path
+                // No query string
                 httpReq.path = urlString;
                 httpReq.query = {};
             }
             else {
-                // Has query string - parse efficiently
+                // Has query string - parse efficiently with pooled object
                 httpReq.path = urlString.substring(0, queryIndex);
-                httpReq.query = this.parseQueryString(urlString.substring(queryIndex + 1));
+                httpReq.query = this.parseQueryStringPooled(urlString.substring(queryIndex + 1));
             }
-            // Ultra-fast method checking - avoid array includes
+            // Method checking - avoid array includes
             const method = req.method;
             if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
                 httpReq.body = await this.parseBody(req);
@@ -218,7 +191,7 @@ export class MoroHttpServer {
             // Find matching route
             const route = this.findRoute(req.method, httpReq.path);
             if (!route) {
-                // Ultra-fast 404 response with pre-compiled buffer
+                // 404 response with pre-compiled buffer
                 httpRes.statusCode = 404;
                 httpRes.setHeader('Content-Type', 'application/json; charset=utf-8');
                 httpRes.setHeader('Content-Length', MoroHttpServer.RESPONSE_TEMPLATES.notFound.length);
@@ -264,7 +237,7 @@ export class MoroHttpServer {
                     });
                 }
                 else {
-                    // Ultra-defensive fallback - check each method individually
+                    // Defensive fallback - check each method individually
                     if (typeof httpRes.setHeader === 'function') {
                         httpRes.statusCode = 500;
                         httpRes.setHeader('Content-Type', 'application/json');
@@ -313,50 +286,27 @@ export class MoroHttpServer {
             }
         });
     }
-    // Efficient object pooling for parameter objects with ES2022 optimizations
+    // Use shared object pool for parameter objects
     acquireParamObject() {
-        const obj = this.paramObjectPool.pop();
-        if (obj) {
-            // ES2022: Use Object.hasOwn for safer property checks and faster clearing
-            // Clear existing properties more efficiently
-            for (const key in obj) {
-                if (Object.hasOwn(obj, key)) {
-                    delete obj[key];
-                }
-            }
-            return obj;
-        }
-        return {};
+        return this.poolManager.acquireParams();
     }
     releaseParamObject(params) {
-        if (this.paramObjectPool.length < this.maxPoolSize) {
-            this.paramObjectPool.push(params);
-        }
+        this.poolManager.releaseParams(params);
     }
     // Force cleanup of all pooled objects
     forceCleanupPools() {
-        // ES2022: More efficient array clearing
-        this.paramObjectPool.splice(0);
-        this.bufferPool.splice(0);
+        // Use shared pool manager cleanup
+        this.poolManager.clearAll();
         // Force garbage collection if available
-        // Use modern globalThis check with optional chaining
         if (globalThis?.gc) {
             globalThis.gc();
         }
     }
     acquireBuffer(size) {
-        // ES2022: Use findIndex for better performance than find + indexOf
-        const index = this.bufferPool.findIndex(b => b.length >= size);
-        if (index !== -1) {
-            const buffer = this.bufferPool.splice(index, 1)[0];
-            return buffer.subarray(0, size);
-        }
-        return Buffer.allocUnsafe(size);
+        return this.poolManager.acquireBuffer(size);
     }
     releaseBuffer(buffer) {
-        if (this.bufferPool.length < this.maxPoolSize && buffer.length <= 8192) {
-            this.bufferPool.push(buffer);
-        }
+        this.poolManager.releaseBuffer(buffer);
     }
     streamLargeResponse(res, data) {
         res.setHeader('Content-Type', 'application/json; charset=utf-8');
@@ -375,7 +325,7 @@ export class MoroHttpServer {
         if (this.pathNormalizationCache.has(path)) {
             return this.pathNormalizationCache.get(path);
         }
-        // Fast normalization: remove trailing slash (except root), decode once
+        // Normalization: remove trailing slash (except root), decode once
         let normalized = path;
         if (normalized.length > 1 && normalized.endsWith('/')) {
             normalized = normalized.slice(0, -1);
@@ -393,8 +343,8 @@ export class MoroHttpServer {
         httpReq.body = null;
         httpReq.path = '';
         httpReq.ip = req.socket.remoteAddress || '';
-        // Faster request ID generation
-        httpReq.requestId = Date.now().toString(36) + (++this.requestCounter).toString(36);
+        // Request ID generation using pool manager (if enabled)
+        httpReq.requestId = this.requestTrackingEnabled ? this.poolManager.generateRequestId() : '';
         httpReq.headers = req.headers;
         // Parse cookies
         httpReq.cookies = this.parseCookies(req.headers.cookie || '');
@@ -412,8 +362,10 @@ export class MoroHttpServer {
         });
         return cookies;
     }
-    enhanceResponse(res) {
+    enhanceResponse(res, req) {
         const httpRes = res;
+        // Store request reference for access to headers (needed for compression, logging, etc.)
+        httpRes.req = req;
         // BULLETPROOF status method - always works
         httpRes.status = (code) => {
             httpRes.statusCode = code;
@@ -422,20 +374,7 @@ export class MoroHttpServer {
         httpRes.json = async (data) => {
             if (httpRes.headersSent)
                 return;
-            // PERFORMANCE OPTIMIZATION: Check response cache for common patterns
-            const cacheKey = this.getResponseCacheKey(data);
-            if (cacheKey) {
-                const cachedBuffer = this.responseCache.get(cacheKey);
-                if (cachedBuffer) {
-                    this.responseCacheHits++;
-                    httpRes.setHeader('Content-Type', 'application/json; charset=utf-8');
-                    httpRes.setHeader('Content-Length', cachedBuffer.length);
-                    httpRes.end(cachedBuffer);
-                    return;
-                }
-                this.responseCacheMisses++;
-            }
-            // Ultra-fast JSON serialization with zero-copy buffers
+            // JSON serialization with zero-copy buffers
             let jsonString;
             // Enhanced JSON optimization for common API patterns
             if (data && typeof data === 'object' && 'success' in data) {
@@ -512,10 +451,6 @@ export class MoroHttpServer {
                 httpRes.setHeader(key, value);
             });
             httpRes.end(finalBuffer);
-            // PERFORMANCE OPTIMIZATION: Cache small, common responses
-            if (cacheKey && finalBuffer.length < 1024 && this.responseCache.size < 100) {
-                this.responseCache.set(cacheKey, Buffer.from(finalBuffer));
-            }
             // Return buffer to pool after response (zero-copy achievement!)
             process.nextTick(() => MoroHttpServer.returnBuffer(buffer));
         };
@@ -785,12 +720,18 @@ export class MoroHttpServer {
         }
         return result;
     }
+    // Legacy method for backward compatibility
     parseQueryString(queryString) {
-        const result = {};
+        return this.parseQueryStringPooled(queryString);
+    }
+    // Optimized query string parser with object pooling
+    parseQueryStringPooled(queryString) {
         if (!queryString)
-            return result;
+            return {};
+        const result = this.poolManager.acquireQuery();
         const pairs = queryString.split('&');
-        for (const pair of pairs) {
+        for (let i = 0; i < pairs.length; i++) {
+            const pair = pairs[i];
             const equalIndex = pair.indexOf('=');
             if (equalIndex === -1) {
                 result[decodeURIComponent(pair)] = '';
@@ -809,7 +750,7 @@ export class MoroHttpServer {
     dynamicRoutes = [];
     routesBySegmentCount = new Map();
     pathNormalizationCache = new Map();
-    // Ultra-fast CPU cache-friendly optimizations (Rust-level performance)
+    // CPU cache-friendly optimizations
     routeHitCount = new Map(); // Track route popularity for cache optimization
     static HOT_ROUTE_THRESHOLD = 100; // Routes accessed 100+ times get hot path treatment
     findRoute(method, path) {
@@ -854,35 +795,43 @@ export class MoroHttpServer {
         }
         return route;
     }
+    // Optimized middleware execution with reduced Promise allocation
     async executeMiddleware(middleware, req, res) {
-        for (const mw of middleware) {
+        for (let i = 0; i < middleware.length; i++) {
             // Short-circuit if response already sent
             if (res.headersSent)
                 return;
+            const mw = middleware[i];
             await new Promise((resolve, reject) => {
-                let nextCalled = false;
+                let resolved = false;
+                // Reuse next function to reduce allocations
                 const next = () => {
-                    if (nextCalled)
+                    if (resolved)
                         return;
-                    nextCalled = true;
+                    resolved = true;
                     resolve();
                 };
                 try {
                     const result = mw(req, res, next);
                     // Handle async middleware
-                    if (result instanceof Promise) {
+                    if (result && typeof result.then === 'function') {
                         result
                             .then(() => {
-                            if (!nextCalled)
+                            if (!resolved)
                                 next();
                         })
-                            .catch(error => {
-                            reject(error);
-                        });
+                            .catch(reject);
+                    }
+                    else if (!resolved) {
+                        // Sync middleware that didn't call next
+                        next();
                     }
                 }
                 catch (error) {
-                    reject(error);
+                    if (!resolved) {
+                        resolved = true;
+                        reject(error);
+                    }
                 }
             });
         }
@@ -912,39 +861,14 @@ export class MoroHttpServer {
     getServer() {
         return this.server;
     }
-    // PERFORMANCE OPTIMIZATION: Generate cache key for common response patterns
-    getResponseCacheKey(data) {
-        // Only cache simple, common responses
-        if (!data || typeof data !== 'object') {
-            // Simple primitives or strings - generate key
-            const key = JSON.stringify(data);
-            return key.length < 100 ? key : null;
-        }
-        // Common API response patterns
-        if ('hello' in data && Object.keys(data).length <= 2) {
-            // Hello world type responses
-            return `hello:${JSON.stringify(data)}`;
-        }
-        if ('status' in data && Object.keys(data).length <= 3) {
-            // Status responses like {status: "ok", version: "1.0.0"}
-            return `status:${JSON.stringify(data)}`;
-        }
-        if ('success' in data && 'message' in data && Object.keys(data).length <= 3) {
-            // Simple success/error responses
-            return `msg:${data.success}:${data.message}`;
-        }
-        // Don't cache complex objects
-        return null;
-    }
     // Performance statistics
     getPerformanceStats() {
+        const poolStats = this.poolManager.getStats();
         return {
-            responseCacheHits: this.responseCacheHits,
-            responseCacheMisses: this.responseCacheMisses,
-            responseCacheSize: this.responseCache.size,
-            paramObjectPoolSize: this.paramObjectPool.length,
-            bufferPoolSize: this.bufferPool.length,
-            middlewareExecutionCacheSize: this.middlewareExecutionCache.size,
+            paramObjectPoolSize: poolStats.paramPool.poolSize,
+            queryObjectPoolSize: poolStats.queryPool.poolSize,
+            headerObjectPoolSize: poolStats.headerPool.poolSize,
+            poolManager: poolStats,
         };
     }
 }