@morojs/moro 1.5.17 → 1.6.1

package/src/core/database/adapters/redis.ts

@@ -11,15 +11,6 @@ interface RedisConfig {
   maxRetriesPerRequest?: number;
   retryDelayOnFailover?: number;
   lazyConnect?: boolean;
-  tls?: {
-    rejectUnauthorized?: boolean;
-    ca?: string;
-    cert?: string;
-    key?: string;
-    passphrase?: string;
-    servername?: string;
-    checkServerIdentity?: boolean;
-  };
   cluster?: {
     enableReadyCheck?: boolean;
     redisOptions?: any;
@@ -39,20 +30,13 @@ export class RedisAdapter implements DatabaseAdapter {
 
       if (config.cluster) {
         // Redis Cluster
-        const clusterOptions: any = {
+        this.client = new Redis.Cluster(config.cluster.nodes, {
           enableReadyCheck: config.cluster.enableReadyCheck || false,
           redisOptions: config.cluster.redisOptions || {},
-        };
-
-        // Add TLS options to cluster configuration
-        if (config.tls) {
-          clusterOptions.redisOptions.tls = { ...config.tls };
-        }
-
-        this.client = new Redis.Cluster(config.cluster.nodes, clusterOptions);
+        });
       } else {
         // Single Redis instance
-        const redisOptions: any = {
+        this.client = new Redis({
           host: config.host || 'localhost',
           port: config.port || 6379,
           password: config.password,
@@ -60,14 +44,7 @@ export class RedisAdapter implements DatabaseAdapter {
           maxRetriesPerRequest: config.maxRetriesPerRequest || 3,
           retryDelayOnFailover: config.retryDelayOnFailover || 100,
           lazyConnect: config.lazyConnect || true,
-        };
-
-        // Add TLS options if provided
-        if (config.tls) {
-          redisOptions.tls = { ...config.tls };
-        }
-
-        this.client = new Redis(redisOptions);
+        });
       }
 
       this.client.on('error', (err: Error) => {

package/src/core/framework.ts

@@ -15,17 +15,19 @@ import { MoroEventBus } from './events';
 import { createFrameworkLogger, logger as globalLogger } from './logger';
 import { ModuleConfig, InternalRouteDefinition } from '../types/module';
 import { LogLevel, LoggerOptions } from '../types/logger';
-import { MoroOptions as CoreMoroOptions } from '../types/core';
 import { WebSocketAdapter, WebSocketAdapterOptions } from './networking/websocket-adapter';
 
-// Extended MoroOptions that includes both core options and framework-specific options
-export interface MoroOptions extends CoreMoroOptions {
+export interface MoroOptions {
   http2?: boolean;
   https?: {
     key: string | Buffer;
     cert: string | Buffer;
     ca?: string | Buffer;
   };
+  compression?: {
+    enabled?: boolean;
+    threshold?: number;
+  };
   websocket?:
     | {
         enabled?: boolean;
@@ -35,7 +37,7 @@ export interface MoroOptions extends CoreMoroOptions {
         options?: WebSocketAdapterOptions;
       }
     | false;
-  config?: any; // Full configuration object
+  logger?: LoggerOptions | boolean;
 }
 
 export class Moro extends EventEmitter {
@@ -52,12 +54,10 @@ export class Moro extends EventEmitter {
   // Framework logger
   private logger: any;
   private options: MoroOptions;
-  private config: any;
 
   constructor(options: MoroOptions = {}) {
     super();
     this.options = options;
-    this.config = options.config || {};
 
     // Configure global logger based on options
     if (options.logger !== undefined) {
@@ -106,11 +106,8 @@ export class Moro extends EventEmitter {
     this.container = new Container();
     this.moduleLoader = new ModuleLoader(this.container);
 
-    // Setup WebSocket adapter if enabled in config OR options
-    if (
-      this.config.websocket.enabled ||
-      (options.websocket && typeof options.websocket === 'object')
-    ) {
+    // Setup WebSocket adapter if enabled
+    if (options.websocket !== false) {
       this.setupWebSockets(options.websocket || {});
     }
 
@@ -134,49 +131,19 @@ export class Moro extends EventEmitter {
   }
 
   private setupCore() {
-    // PERFORMANCE FIX: Only apply middleware if enabled in config OR options
-
-    // Security middleware - check config enabled property OR options.security.*.enabled === true
-    if (this.config.security.helmet.enabled || this.options.security?.helmet?.enabled === true) {
-      this.httpServer.use(middleware.helmet());
-    }
+    // Security middleware
+    this.httpServer.use(middleware.helmet());
+    this.httpServer.use(middleware.cors());
 
-    if (this.config.security.cors.enabled || this.options.security?.cors?.enabled === true) {
-      const corsOptions =
-        typeof this.options.cors === 'object'
-          ? this.options.cors
-          : this.config.security.cors
-            ? this.config.security.cors
-            : {};
-      this.httpServer.use(middleware.cors(corsOptions));
-    }
-
-    // Performance middleware - check config enabled property OR options.performance.*.enabled === true
-    if (
-      this.config.performance.compression.enabled ||
-      this.options.performance?.compression?.enabled === true
-    ) {
-      const compressionOptions =
-        typeof this.options.compression === 'object'
-          ? this.options.compression
-          : this.config.performance.compression
-            ? this.config.performance.compression
-            : {};
-      this.httpServer.use(middleware.compression(compressionOptions));
-    }
+    // Performance middleware
+    this.httpServer.use(middleware.compression());
+    this.httpServer.use(middleware.bodySize({ limit: '10mb' }));
 
-    // Body size middleware - always enabled with configurable limit
-    this.httpServer.use(middleware.bodySize({ limit: this.config.server.bodySizeLimit }));
+    // Request tracking middleware
+    this.httpServer.use(this.requestTrackingMiddleware());
 
-    // Request tracking middleware - configurable
-    if (this.config.server.requestTracking.enabled) {
-      this.httpServer.use(this.requestTrackingMiddleware());
-    }
-
-    // Error boundary middleware - configurable but recommended to keep enabled
-    if (this.config.server.errorBoundary.enabled) {
-      this.httpServer.use(this.errorBoundaryMiddleware());
-    }
+    // Error boundary middleware
+    this.httpServer.use(this.errorBoundaryMiddleware());
   }
 
   /**
@@ -444,76 +411,6 @@ export class Moro extends EventEmitter {
           throw new Error(`Handler ${route.handler} is not a function`);
         }
 
-        // Check authentication if auth configuration is provided
-        if ((route as any).auth) {
-          const auth = (req as any).auth;
-          const authConfig = (route as any).auth;
-
-          if (!auth) {
-            res.status(401);
-            res.json({
-              success: false,
-              error: 'Authentication required',
-              message: 'You must be logged in to access this resource',
-            });
-            return;
-          }
-
-          // Check authentication requirement (default is required unless optional: true)
-          if (!authConfig.optional && !auth.isAuthenticated) {
-            res.status(401);
-            res.json({
-              success: false,
-              error: 'Authentication required',
-              message: 'You must be logged in to access this resource',
-            });
-            return;
-          }
-
-          // Skip further checks if not authenticated but optional
-          if (!auth.isAuthenticated && authConfig.optional) {
-            // Continue to handler
-          } else if (auth.isAuthenticated) {
-            const user = auth.user;
-
-            // Check roles if specified
-            if (authConfig.roles && authConfig.roles.length > 0) {
-              const userRoles = user?.roles || [];
-              const hasRole = authConfig.roles.some((role: string) => userRoles.includes(role));
-
-              if (!hasRole) {
-                res.status(403);
-                res.json({
-                  success: false,
-                  error: 'Insufficient permissions',
-                  message: `Required roles: ${authConfig.roles.join(', ')}`,
-                  userRoles,
-                });
-                return;
-              }
-            }
-
-            // Check permissions if specified
-            if (authConfig.permissions && authConfig.permissions.length > 0) {
-              const userPermissions = user?.permissions || [];
-              const hasPermission = authConfig.permissions.every((permission: string) =>
-                userPermissions.includes(permission)
-              );
-
-              if (!hasPermission) {
-                res.status(403);
-                res.json({
-                  success: false,
-                  error: 'Insufficient permissions',
-                  message: `Required permissions: ${authConfig.permissions.join(', ')}`,
-                  userPermissions,
-                });
-                return;
-              }
-            }
-          }
-        }
-
         // Validate request if validation schema is provided
         if (route.validation) {
           try {
@@ -619,61 +516,22 @@ export class Moro extends EventEmitter {
     this.logger.debug(`Mounting router for basePath: ${basePath}`, 'Router');
 
     // Enterprise-grade middleware integration with performance optimization
-    // IMPORTANT: Module middleware runs AFTER user middleware (like auth) to ensure proper order
     this.httpServer.use(async (req: HttpRequest, res: HttpResponse, next: () => void) => {
       if (req.path.startsWith(basePath)) {
         this.logger.debug(`Module middleware handling: ${req.method} ${req.path}`, 'Middleware', {
           basePath,
         });
 
-        // Mark this request as being handled by a module
-        (req as any).__moduleBasePath = basePath;
-        (req as any).__moduleRouter = router;
-
-        // Continue to next middleware (including auth) first
-        next();
-      } else {
-        next();
-      }
-    });
-
-    this.logger.info(`Router mounted for ${basePath}`, 'Router');
-  }
-
-  private finalModuleHandlerSetup = false;
-
-  // Setup final module handler that runs after all user middleware
-  setupFinalModuleHandler(): void {
-    // Prevent duplicate setup
-    if (this.finalModuleHandlerSetup) {
-      this.logger.debug('Final module handler already set up, skipping', 'ModuleSystem');
-      return;
-    }
-    this.finalModuleHandlerSetup = true;
-
-    this.logger.info(
-      'Setting up final module handler to run after user middleware',
-      'ModuleSystem'
-    );
-
-    this.httpServer.use(async (req: HttpRequest, res: HttpResponse, next: () => void) => {
-      // Check if this request was marked for module handling
-      const moduleBasePath = (req as any).__moduleBasePath;
-      const moduleRouter = (req as any).__moduleRouter;
-
-      if (moduleBasePath && moduleRouter && !res.headersSent) {
-        this.logger.debug(`Final module handler processing: ${req.method} ${req.path}`, 'Router');
-
         try {
-          const handled = await moduleRouter.handle(req, res, moduleBasePath);
-          this.logger.debug(`Route handled by module: ${handled}`, 'Router');
+          const handled = await router.handle(req, res, basePath);
+          this.logger.debug(`Route handled: ${handled}`, 'Router');
 
           if (!handled) {
             next(); // Let other middleware handle it
           }
           // If handled, the router already sent the response, so don't call next()
         } catch (error) {
-          this.logger.error('Module router error', 'Router', {
+          this.logger.error('Router error', 'Router', {
             error: error instanceof Error ? error.message : String(error),
           });
           if (!res.headersSent) {
@@ -684,6 +542,8 @@ export class Moro extends EventEmitter {
         next();
       }
     });
+
+    this.logger.info(`Router mounted for ${basePath}`, 'Router');
   }
 
   private async setupWebSocketHandlers(config: ModuleConfig): Promise<void> {

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

@@ -26,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'],
@@ -286,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),
@@ -316,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') {
@@ -332,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'
             );
           }
@@ -497,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;
 
@@ -597,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));
     };
@@ -631,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}`;
 
@@ -714,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;
   }
 
@@ -1015,9 +923,7 @@ export class MoroHttpServer {
               .then(() => {
                 if (!nextCalled) next();
               })
-              .catch(error => {
-                reject(error);
-              });
+              .catch(reject);
           }
         } catch (error) {
           reject(error);
@@ -1056,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
@@ -1153,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 {
@@ -1599,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) => {
@@ -1708,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;
             }