@morojs/moro 1.6.0 → 1.6.1

package/src/core/http/http-server.ts

@@ -1,17 +1,9 @@
 // src/core/http-server.ts
 import { IncomingMessage, ServerResponse, createServer, Server } from 'http';
 import * as zlib from 'zlib';
-import { createReadStream } from 'fs';
-import * as crypto from 'crypto';
 import { promisify } from 'util';
-import { createFrameworkLogger } from '../logger/index.js';
-import {
-  HttpRequest,
-  HttpResponse,
-  HttpHandler,
-  Middleware,
-  RouteEntry,
-} from '../../types/http.js';
+import { createFrameworkLogger } from '../logger';
+import { HttpRequest, HttpResponse, HttpHandler, Middleware, RouteEntry } from '../../types/http';
 
 const gzip = promisify(zlib.gzip);
 const deflate = promisify(zlib.deflate);
@@ -34,11 +26,6 @@ export class MoroHttpServer {
   // Request handler pooling to avoid function creation overhead
   private middlewareExecutionCache = new Map<string, Function>();
 
-  // Response caching for ultra-fast common responses
-  private responseCache = new Map<string, Buffer>();
-  private responseCacheHits = 0;
-  private responseCacheMisses = 0;
-
   // String interning for common values (massive memory savings)
   private static readonly INTERNED_METHODS = new Map([
     ['GET', 'GET'],
@@ -294,13 +281,18 @@ export class MoroHttpServer {
       await route.handler(httpReq, httpRes);
     } catch (error) {
       // Debug: Log the actual error and where it came from
-      this.logger.debug('Request error details', 'RequestHandler', {
-        errorType: typeof error,
-        errorMessage: error instanceof Error ? error.message : String(error),
-        errorStack: error instanceof Error ? error.stack : 'No stack trace',
-        requestPath: req.url,
-        requestMethod: req.method,
-      });
+      this.logger.debug('🚨 MoroJS Request Error Details:', 'RequestHandler');
+      this.logger.debug(`📍 Error type: ${typeof error}`, 'RequestHandler');
+      this.logger.debug(
+        `📍 Error message: ${error instanceof Error ? error.message : String(error)}`,
+        'RequestHandler'
+      );
+      this.logger.debug(
+        `📍 Error stack: ${error instanceof Error ? error.stack : 'No stack trace'}`,
+        'RequestHandler'
+      );
+      this.logger.debug(`📍 Request path: ${req.url}`, 'RequestHandler');
+      this.logger.debug(`📍 Request method: ${req.method}`, 'RequestHandler');
 
       this.logger.error('Request error', 'RequestHandler', {
         error: error instanceof Error ? error.message : String(error),
@@ -324,10 +316,14 @@ export class MoroHttpServer {
             httpRes.setHeader('Content-Type', 'application/json');
           } else {
             // Even setHeader doesn't exist - object is completely wrong
-            this.logger.error('Response object is not a proper ServerResponse', 'RequestHandler', {
-              responseType: typeof httpRes,
-              responseKeys: Object.keys(httpRes),
-            });
+            this.logger.error(
+              '❌ Response object is not a proper ServerResponse:',
+              'RequestHandler',
+              {
+                responseType: typeof httpRes,
+                responseKeys: Object.keys(httpRes),
+              }
+            );
           }
 
           if (typeof httpRes.end === 'function') {
@@ -340,7 +336,7 @@ export class MoroHttpServer {
             );
           } else {
             this.logger.error(
-              'Cannot send error response - end() method missing',
+              '❌ Cannot send error response - end() method missing',
               'RequestHandler'
             );
           }
@@ -505,20 +501,6 @@ export class MoroHttpServer {
     httpRes.json = async (data: any) => {
       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
       let jsonString: string;
 
@@ -605,12 +587,6 @@ export class MoroHttpServer {
       });
 
       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));
     };
@@ -639,26 +615,6 @@ export class MoroHttpServer {
     };
 
     httpRes.cookie = (name: string, value: string, options: any = {}) => {
-      if (httpRes.headersSent) {
-        const isCritical =
-          options.critical ||
-          name.includes('session') ||
-          name.includes('auth') ||
-          name.includes('csrf');
-        const message = `Cookie '${name}' could not be set - headers already sent`;
-
-        if (isCritical || options.throwOnLateSet) {
-          throw new Error(`${message}. This may cause authentication or security issues.`);
-        } else {
-          this.logger.warn(message, 'CookieWarning', {
-            cookieName: name,
-            critical: isCritical,
-            stackTrace: new Error().stack,
-          });
-        }
-        return httpRes;
-      }
-
       const cookieValue = encodeURIComponent(value);
       let cookieString = `${name}=${cookieValue}`;
 
@@ -722,62 +678,6 @@ export class MoroHttpServer {
       }
     };
 
-    // Header management utilities
-    httpRes.hasHeader = (name: string): boolean => {
-      return httpRes.getHeader(name) !== undefined;
-    };
-
-    // Note: removeHeader is inherited from ServerResponse, we don't override it
-
-    httpRes.setBulkHeaders = (headers: Record<string, string | number>) => {
-      if (httpRes.headersSent) {
-        this.logger.warn('Cannot set headers - headers already sent', 'HeaderWarning', {
-          attemptedHeaders: Object.keys(headers),
-        });
-        return httpRes;
-      }
-
-      Object.entries(headers).forEach(([key, value]) => {
-        httpRes.setHeader(key, value);
-      });
-      return httpRes;
-    };
-
-    httpRes.appendHeader = (name: string, value: string | string[]) => {
-      if (httpRes.headersSent) {
-        this.logger.warn(
-          `Cannot append to header '${name}' - headers already sent`,
-          'HeaderWarning'
-        );
-        return httpRes;
-      }
-
-      const existing = httpRes.getHeader(name);
-      if (existing) {
-        const values = Array.isArray(existing) ? existing : [existing.toString()];
-        const newValues = Array.isArray(value) ? value : [value];
-        httpRes.setHeader(name, [...values, ...newValues]);
-      } else {
-        httpRes.setHeader(name, value);
-      }
-      return httpRes;
-    };
-
-    // Response state utilities
-    httpRes.canSetHeaders = (): boolean => {
-      return !httpRes.headersSent;
-    };
-
-    httpRes.getResponseState = () => {
-      return {
-        headersSent: httpRes.headersSent,
-        statusCode: httpRes.statusCode,
-        headers: httpRes.getHeaders ? httpRes.getHeaders() : {},
-        finished: httpRes.finished || false,
-        writable: httpRes.writable,
-      };
-    };
-
     return httpRes;
   }
 
@@ -1023,9 +923,7 @@ export class MoroHttpServer {
               .then(() => {
                 if (!nextCalled) next();
               })
-              .catch(error => {
-                reject(error);
-              });
+              .catch(reject);
           }
         } catch (error) {
           reject(error);
@@ -1064,47 +962,6 @@ export class MoroHttpServer {
   getServer(): Server {
     return this.server;
   }
-
-  // PERFORMANCE OPTIMIZATION: Generate cache key for common response patterns
-  private getResponseCacheKey(data: any): string | null {
-    // 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() {
-    return {
-      responseCacheHits: this.responseCacheHits,
-      responseCacheMisses: this.responseCacheMisses,
-      responseCacheSize: this.responseCache.size,
-      paramObjectPoolSize: this.paramObjectPool.length,
-      bufferPoolSize: this.bufferPool.length,
-      middlewareExecutionCacheSize: this.middlewareExecutionCache.size,
-    };
-  }
 }
 
 // Built-in middleware
@@ -1141,6 +998,7 @@ export const middleware = {
   },
 
   compression: (options: { threshold?: number; level?: number } = {}): Middleware => {
+    const zlib = require('zlib');
     const threshold = options.threshold || 1024;
     const level = options.level || 6;
 
@@ -1160,25 +1018,23 @@ export const middleware = {
         }
 
         if (acceptEncoding.includes('gzip')) {
+          res.setHeader('Content-Encoding', 'gzip');
           zlib.gzip(buffer, { level }, (err: any, compressed: Buffer) => {
             if (err) {
               return isJson ? originalJson.call(res, data) : originalSend.call(res, data);
             }
-            if (!res.headersSent) {
-              res.setHeader('Content-Encoding', 'gzip');
-              res.setHeader('Content-Length', compressed.length);
-            }
+            res.setHeader('Content-Length', compressed.length);
+            res.writeHead(res.statusCode || 200, res.getHeaders());
             res.end(compressed);
           });
         } else if (acceptEncoding.includes('deflate')) {
+          res.setHeader('Content-Encoding', 'deflate');
           zlib.deflate(buffer, { level }, (err: any, compressed: Buffer) => {
             if (err) {
               return isJson ? originalJson.call(res, data) : originalSend.call(res, data);
             }
-            if (!res.headersSent) {
-              res.setHeader('Content-Encoding', 'deflate');
-              res.setHeader('Content-Length', compressed.length);
-            }
+            res.setHeader('Content-Length', compressed.length);
+            res.writeHead(res.statusCode || 200, res.getHeaders());
             res.end(compressed);
           });
         } else {
@@ -1606,15 +1462,13 @@ export const middleware = {
       // Only handle SSE requests
       if (req.headers.accept?.includes('text/event-stream')) {
         // Set SSE headers
-        if (!res.headersSent) {
-          res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            Connection: 'keep-alive',
-            'Access-Control-Allow-Origin': options.cors ? '*' : undefined,
-            'Access-Control-Allow-Headers': options.cors ? 'Cache-Control' : undefined,
-          });
-        }
+        res.writeHead(200, {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+          'Access-Control-Allow-Origin': options.cors ? '*' : undefined,
+          'Access-Control-Allow-Headers': options.cors ? 'Cache-Control' : undefined,
+        });
 
         // Add SSE methods to response
         (res as any).sendEvent = (data: any, event?: string, id?: string) => {
@@ -1715,8 +1569,7 @@ export const middleware = {
             const chunkSize = end - start + 1;
 
             if (start >= fileSize || end >= fileSize) {
-              res.status(416);
-              res.setHeader('Content-Range', `bytes */${fileSize}`);
+              res.status(416).setHeader('Content-Range', `bytes */${fileSize}`);
               res.json({ success: false, error: 'Range not satisfiable' });
               return;
             }
@@ -1726,7 +1579,7 @@ export const middleware = {
             res.setHeader('Content-Length', chunkSize);
 
             // Stream the range
-            const stream = createReadStream(filePath, {
+            const stream = require('fs').createReadStream(filePath, {
               start,
               end,
             });
@@ -1744,12 +1597,12 @@ export const middleware = {
               res.write(`\r\n--${boundary}\r\n`);
               res.write(`Content-Range: bytes ${start}-${end}/${fileSize}\r\n\r\n`);
 
-              const stream = createReadStream(filePath, {
+              const stream = require('fs').createReadStream(filePath, {
                 start,
                 end,
               });
-              await new Promise<void>(resolve => {
-                stream.on('end', () => resolve());
+              await new Promise(resolve => {
+                stream.on('end', resolve);
                 stream.pipe(res, { end: false });
               });
             }
@@ -1783,6 +1636,7 @@ export const middleware = {
     const ignoreMethods = options.ignoreMethods || ['GET', 'HEAD', 'OPTIONS'];
 
     const generateToken = () => {
+      const crypto = require('crypto');
       return crypto.randomBytes(tokenLength).toString('hex');
     };
 
@@ -1871,6 +1725,7 @@ export const middleware = {
       // Generate nonce if requested
       let nonce: string | undefined;
       if (options.nonce) {
+        const crypto = require('crypto');
         nonce = crypto.randomBytes(16).toString('base64');
         (req as any).cspNonce = nonce;
       }

package/src/core/http/index.ts

@@ -1,7 +1,6 @@
 // HTTP System - Centralized Exports
-export { MoroHttpServer, middleware } from './http-server.js';
-export { UWebSocketsHttpServer } from './uws-http-server.js';
-export { Router } from './router.js';
+export { MoroHttpServer, middleware } from './http-server';
+export { Router } from './router';
 
 // Type exports
-export type { HttpRequest, HttpResponse, HttpHandler, Middleware } from '../../types/http.js';
+export type { HttpRequest, HttpResponse, HttpHandler, Middleware } from '../../types/http';

package/src/core/http/router.ts

@@ -5,21 +5,13 @@ import {
   HttpHandler,
   Middleware,
   RouteDefinition,
-} from '../../types/http.js';
-import { createFrameworkLogger } from '../logger/index.js';
+} from '../../types/http';
+import { createFrameworkLogger } from '../logger';
 
 export class Router {
   private routes: RouteDefinition[] = [];
   private logger = createFrameworkLogger('Router');
 
-  // Performance optimizations - O(1) static route lookup
-  private staticRoutes = new Map<string, RouteDefinition>(); // "GET:/api/users" -> route
-  private dynamicRoutes: RouteDefinition[] = []; // Routes with parameters
-
-  // Object pooling for parameters to reduce GC pressure
-  private paramObjectPool: Record<string, string>[] = [];
-  private readonly maxPoolSize = 50;
-
   get(path: string, ...handlers: (Middleware | HttpHandler)[]): void {
     this.addRoute('GET', path, handlers);
   }
@@ -45,37 +37,14 @@ export class Router {
     const handler = handlers.pop() as HttpHandler;
     const middleware = handlers as Middleware[];
 
-    const route: RouteDefinition = {
+    this.routes.push({
       method,
       path,
       pattern,
       paramNames,
       handler,
       middleware,
-    };
-
-    // Add to routes array (maintain compatibility)
-    this.routes.push(route);
-
-    // Performance optimization: separate static and dynamic routes
-    const isStatic = !path.includes(':') && !path.includes('*');
-    if (isStatic && middleware.length === 0) {
-      // Static route with no middleware - use O(1) lookup
-      const routeKey = `${method}:${path}`;
-      this.staticRoutes.set(routeKey, route);
-      this.logger.debug(`Added static route: ${routeKey}`, 'FastRoute');
-    } else {
-      // Dynamic route or has middleware - needs regex matching
-      this.dynamicRoutes.push(route);
-      this.logger.debug(`Added dynamic route: ${method} ${path}`, 'DynamicRoute');
-    }
-
-    // Initialize object pool on first route
-    if (this.paramObjectPool.length === 0) {
-      for (let i = 0; i < this.maxPoolSize; i++) {
-        this.paramObjectPool.push({});
-      }
-    }
+    });
   }
 
   private pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
@@ -108,30 +77,10 @@ export class Router {
       'Processing'
     );
 
-    // PERFORMANCE OPTIMIZATION: Fast path - O(1) static route lookup first
-    const routeKey = `${req.method}:${path}`;
-    const staticRoute = this.staticRoutes.get(routeKey);
-
-    if (staticRoute) {
-      this.logger.debug(`Fast route match: ${routeKey}`, 'FastRoute');
-
-      // Static route with no middleware - execute handler directly
-      req.params = {}; // No params for static routes
-      const result = await staticRoute.handler(req, res);
-
-      // If handler returns data and response hasn't been sent, send it
-      if (result !== undefined && result !== null && !res.headersSent) {
-        res.json(result);
-      }
-
-      return true;
-    }
-
-    // Fallback: Dynamic route matching (with middleware support)
-    const route = this.dynamicRoutes.find(r => r.method === req.method && r.pattern.test(path));
+    const route = this.routes.find(r => r.method === req.method && r.pattern.test(path));
 
     this.logger.debug(
-      `Found dynamic route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
+      `Found route: ${!!route}${route ? ` ${route.method} ${route.path}` : ' none'}`,
       'RouteMatch'
     );
 
@@ -139,92 +88,54 @@ export class Router {
       return false; // Route not found
     }
 
-    // Extract path parameters using object pooling
+    // Extract path parameters
     const matches = path.match(route.pattern);
     if (matches) {
-      req.params = this.acquireParamObject();
+      req.params = {};
       route.paramNames.forEach((name, index) => {
         req.params[name] = matches[index + 1];
       });
     }
 
-    try {
-      // Execute middleware
-      for (const mw of route.middleware) {
-        await new Promise<void>((resolve, reject) => {
-          let nextCalled = false;
-
-          const next = () => {
-            if (nextCalled) return;
-            nextCalled = true;
-            resolve();
-          };
-
-          try {
-            const result = mw(req, res, next);
-
-            if (result instanceof Promise) {
-              result
-                .then(() => {
-                  if (!nextCalled) next();
-                })
-                .catch(reject);
-            }
-          } catch (error) {
-            reject(error);
+    // Execute middleware
+    for (const mw of route.middleware) {
+      await new Promise<void>((resolve, reject) => {
+        let nextCalled = false;
+
+        const next = () => {
+          if (nextCalled) return;
+          nextCalled = true;
+          resolve();
+        };
+
+        try {
+          const result = mw(req, res, next);
+
+          if (result instanceof Promise) {
+            result
+              .then(() => {
+                if (!nextCalled) next();
+              })
+              .catch(reject);
           }
-        });
-
-        if (res.headersSent) break; // Early exit if response sent
-      }
-
-      // Execute handler
-      const result = await route.handler(req, res);
-
-      // If handler returns data and response hasn't been sent, send it
-      if (result !== undefined && result !== null && !res.headersSent) {
-        res.json(result);
-      }
-
-      return true;
-    } finally {
-      // Release parameter object back to pool
-      if (req.params && matches) {
-        this.releaseParamObject(req.params);
-      }
+        } catch (error) {
+          reject(error);
+        }
+      });
     }
-  }
 
-  getRoutes(): RouteDefinition[] {
-    return [...this.routes];
-  }
+    // Execute handler
+    const result = await route.handler(req, res);
 
-  // Object pooling methods for performance optimization
-  private acquireParamObject(): Record<string, string> {
-    const obj = this.paramObjectPool.pop();
-    if (obj) {
-      // Clear the object
-      for (const key in obj) {
-        delete obj[key];
-      }
-      return obj;
+    // If handler returns data and response hasn't been sent, send it
+    if (result !== undefined && result !== null && !res.headersSent) {
+      res.json(result);
     }
-    return {};
-  }
 
-  private releaseParamObject(obj: Record<string, string>): void {
-    if (this.paramObjectPool.length < this.maxPoolSize) {
-      this.paramObjectPool.push(obj);
-    }
+    return true;
   }
 
-  // Performance statistics for monitoring
-  getPerformanceStats() {
-    return {
-      totalRoutes: this.routes.length,
-      staticRoutes: this.staticRoutes.size,
-      dynamicRoutes: this.dynamicRoutes.length,
-      paramObjectPoolSize: this.paramObjectPool.length,
-    };
+  getRoutes(): RouteDefinition[] {
+    return [...this.routes];
   }
 }

package/src/core/logger/filters.ts

@@ -1,5 +1,5 @@
 // Advanced Logger Filters
-import { LogEntry, LogFilter } from '../../types/logger.js';
+import { LogEntry, LogFilter } from '../../types/logger';
 
 // Level-based filter
 export const levelFilter = (minLevel: string): LogFilter => ({
@@ -22,24 +22,16 @@ export const contextFilter = (allowedContexts: string[]): LogFilter => ({
 // Rate limiting filter
 export const rateLimitFilter = (maxPerSecond: number): LogFilter => {
   const timestamps: number[] = [];
-  let lastCleanup = 0;
 
   return {
     name: 'rate-limit',
     filter: (entry: LogEntry) => {
       const now = Date.now();
+      const oneSecondAgo = now - 1000;
 
-      // Batch cleanup for better performance and thread safety
-      if (now - lastCleanup > 1000) {
-        const cutoff = now - 1000;
-        let keepIndex = 0;
-        for (let i = 0; i < timestamps.length; i++) {
-          if (timestamps[i] >= cutoff) {
-            timestamps[keepIndex++] = timestamps[i];
-          }
-        }
-        timestamps.length = keepIndex;
-        lastCleanup = now;
+      // Remove old timestamps
+      while (timestamps.length > 0 && timestamps[0] < oneSecondAgo) {
+        timestamps.shift();
       }
 
       // Check rate limit

package/src/core/logger/index.ts

@@ -5,9 +5,8 @@ export {
   createFrameworkLogger,
   configureGlobalLogger,
   applyLoggingConfiguration,
-  destroyGlobalLogger,
-} from './logger.js';
-export * from './filters.js';
+} from './logger';
+export * from './filters';
 
 export type {
   LogLevel,
@@ -18,4 +17,4 @@ export type {
   LogFilter,
   LogMetrics,
   ColorScheme,
-} from '../../types/logger.js';
+} from '../../types/logger';