@morojs/moro 1.6.1 → 1.6.3

package/src/moro.ts

@@ -1,1197 +0,0 @@
-// Moro Framework - Modern TypeScript API Framework
-// Built for developers who demand performance, elegance, and zero compromises
-// Event-driven • Modular • Enterprise-ready • Developer-first
-import { Moro as MoroCore } from './core/framework';
-import { HttpRequest, HttpResponse, middleware } from './core/http';
-import { ModuleConfig, InternalRouteDefinition } from './types/module';
-import { MoroOptions } from './types/core';
-import { MoroEventBus } from './core/events';
-import {
-  createFrameworkLogger,
-  logger as globalLogger,
-  applyLoggingConfiguration,
-} from './core/logger';
-import { MiddlewareManager } from './core/middleware';
-import { IntelligentRoutingManager } from './core/routing/app-integration';
-import { RouteBuilder, RouteSchema, CompiledRoute } from './core/routing';
-import { AppDocumentationManager, DocsConfig } from './core/docs';
-import { readdirSync, statSync } from 'fs';
-import { join } from 'path';
-import { EventEmitter } from 'events';
-// Configuration System Integration
-import { initializeConfig, getGlobalConfig, type AppConfig } from './core/config';
-// Runtime System Integration
-import {
-  RuntimeAdapter,
-  RuntimeType,
-  createRuntimeAdapter,
-  NodeRuntimeAdapter,
-} from './core/runtime';
-
-export class Moro extends EventEmitter {
-  private coreFramework: MoroCore;
-  private routes: InternalRouteDefinition[] = [];
-  private moduleCounter = 0;
-  private loadedModules = new Set<string>();
-  private routeHandlers: Record<string, Function> = {};
-  // Enterprise event system integration
-  private eventBus: MoroEventBus;
-  // Application logger
-  private logger = createFrameworkLogger('App');
-  // Intelligent routing system
-  private intelligentRouting = new IntelligentRoutingManager();
-  // Documentation system
-  private documentation = new AppDocumentationManager();
-  // Configuration system
-  private config: AppConfig;
-  // Runtime system
-  private runtimeAdapter: RuntimeAdapter;
-  private runtimeType: RuntimeType;
-  // Middleware system
-  private middlewareManager: MiddlewareManager;
-
-  constructor(options: MoroOptions = {}) {
-    super(); // Call EventEmitter constructor
-
-    // Configure logger from environment variables BEFORE config system initialization
-    // This ensures the config loading process respects the log level
-    const envLogLevel = process.env.LOG_LEVEL || process.env.MORO_LOG_LEVEL;
-    if (envLogLevel) {
-      applyLoggingConfiguration({ level: envLogLevel }, undefined);
-    }
-
-    // Initialize configuration system - create a deep copy for this instance
-    this.config = JSON.parse(JSON.stringify(initializeConfig()));
-
-    // Apply logging configuration from the loaded config (this happens after config file processing)
-    if (this.config.logging) {
-      applyLoggingConfiguration(this.config.logging, undefined);
-    }
-
-    // Apply additional logging configuration from createApp options (takes precedence)
-    if (options.logger !== undefined) {
-      applyLoggingConfiguration(undefined, options.logger);
-    }
-
-    // Apply performance configuration from createApp options (takes precedence)
-    if (options.performance) {
-      if (options.performance.clustering) {
-        this.config.performance.clustering = {
-          ...this.config.performance.clustering,
-          ...options.performance.clustering,
-        };
-      }
-      if (options.performance.compression) {
-        this.config.performance.compression = {
-          ...this.config.performance.compression,
-          ...options.performance.compression,
-        };
-      }
-      if (options.performance.circuitBreaker) {
-        this.config.performance.circuitBreaker = {
-          ...this.config.performance.circuitBreaker,
-          ...options.performance.circuitBreaker,
-        };
-      }
-    }
-
-    // Apply modules configuration from createApp options (takes precedence)
-    if (options.modules) {
-      if (options.modules.cache) {
-        this.config.modules.cache = {
-          ...this.config.modules.cache,
-          ...options.modules.cache,
-        };
-      }
-      if (options.modules.rateLimit) {
-        this.config.modules.rateLimit = {
-          ...this.config.modules.rateLimit,
-          ...options.modules.rateLimit,
-        };
-      }
-      if (options.modules.validation) {
-        this.config.modules.validation = {
-          ...this.config.modules.validation,
-          ...options.modules.validation,
-        };
-      }
-    }
-
-    this.logger.info(
-      `Configuration system initialized: ${this.config.server.environment}:${this.config.server.port}`
-    );
-
-    // Initialize runtime system
-    this.runtimeType = options.runtime?.type || 'node';
-    this.runtimeAdapter = options.runtime?.adapter || createRuntimeAdapter(this.runtimeType);
-
-    this.logger.info(`Runtime system initialized: ${this.runtimeType}`, 'Runtime');
-
-    // Pass logging configuration from config to framework
-    const frameworkOptions: any = {
-      ...options,
-      logger: this.config.logging,
-    };
-
-    this.coreFramework = new MoroCore(frameworkOptions);
-
-    // Initialize middleware system
-    this.middlewareManager = new MiddlewareManager();
-
-    // Integrate hooks system with HTTP server
-    const httpServer = (this.coreFramework as any).httpServer;
-    if (httpServer && httpServer.setHookManager) {
-      httpServer.setHookManager((this.middlewareManager as any).hooks);
-    }
-
-    // Configure HTTP server performance based on config
-    if (httpServer && httpServer.configurePerformance) {
-      const performanceConfig = this.config.performance;
-      httpServer.configurePerformance({
-        compression: performanceConfig?.compression || { enabled: true },
-        minimal: performanceConfig?.compression?.enabled === false, // Enable minimal mode if compression disabled
-      });
-    }
-
-    // Access enterprise event bus from core framework
-    this.eventBus = (this.coreFramework as any).eventBus;
-
-    // Setup default middleware if enabled - use config defaults with options override
-    this.setupDefaultMiddleware({
-      ...this.getDefaultOptionsFromConfig(),
-      ...options,
-    });
-
-    // Auto-discover modules if enabled
-    if (options.autoDiscover !== false) {
-      this.autoDiscoverModules(options.modulesPath || './modules');
-    }
-
-    // Emit initialization event through enterprise event bus
-    this.eventBus.emit('framework:initialized', {
-      options,
-      config: this.config,
-      runtime: this.runtimeType,
-    });
-  }
-
-  /**
-   * Get configuration object
-   */
-  getConfig(): AppConfig {
-    return this.config;
-  }
-
-  /**
-   * Get runtime adapter
-   */
-  getRuntime(): RuntimeAdapter {
-    return this.runtimeAdapter;
-  }
-
-  /**
-   * Get runtime type
-   */
-  getRuntimeType(): RuntimeType {
-    return this.runtimeType;
-  }
-
-  /**
-   * Extract default options from configuration
-   */
-  private getDefaultOptionsFromConfig(): Partial<MoroOptions> {
-    return {
-      cors: this.config.security.cors.enabled,
-      compression: this.config.performance.compression.enabled,
-      helmet: this.config.security.helmet.enabled,
-    };
-  }
-
-  // Intelligent route methods - chainable with automatic middleware ordering
-  // Overloads for better TypeScript inference
-  get(path: string): RouteBuilder;
-  get(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-  get(
-    path: string,
-    handler?: (req: HttpRequest, res: HttpResponse) => any,
-    options?: any
-  ): RouteBuilder | this {
-    if (handler) {
-      // Direct route registration
-      return this.addRoute('GET', path, handler, options);
-    }
-    // Chainable route builder
-    return this.intelligentRouting.get(path);
-  }
-
-  post(path: string): RouteBuilder;
-  post(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-  post(
-    path: string,
-    handler?: (req: HttpRequest, res: HttpResponse) => any,
-    options?: any
-  ): RouteBuilder | this {
-    if (handler) {
-      // Direct route registration
-      return this.addRoute('POST', path, handler, options);
-    }
-    // Chainable route builder
-    return this.intelligentRouting.post(path);
-  }
-
-  put(path: string): RouteBuilder;
-  put(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-  put(
-    path: string,
-    handler?: (req: HttpRequest, res: HttpResponse) => any,
-    options?: any
-  ): RouteBuilder | this {
-    if (handler) {
-      // Direct route registration
-      return this.addRoute('PUT', path, handler, options);
-    }
-    // Chainable route builder
-    return this.intelligentRouting.put(path);
-  }
-
-  delete(path: string): RouteBuilder;
-  delete(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-  delete(
-    path: string,
-    handler?: (req: HttpRequest, res: HttpResponse) => any,
-    options?: any
-  ): RouteBuilder | this {
-    if (handler) {
-      // Direct route registration
-      return this.addRoute('DELETE', path, handler, options);
-    }
-    // Chainable route builder
-    return this.intelligentRouting.delete(path);
-  }
-
-  patch(path: string): RouteBuilder;
-  patch(path: string, handler: (req: HttpRequest, res: HttpResponse) => any, options?: any): this;
-  patch(
-    path: string,
-    handler?: (req: HttpRequest, res: HttpResponse) => any,
-    options?: any
-  ): RouteBuilder | this {
-    if (handler) {
-      // Direct route registration
-      return this.addRoute('PATCH', path, handler, options);
-    }
-    // Chainable route builder
-    return this.intelligentRouting.patch(path);
-  }
-
-  // Schema-first route method
-  route(schema: RouteSchema): CompiledRoute {
-    return this.intelligentRouting.route(schema);
-  }
-
-  // Enable automatic API documentation
-  enableDocs(config: DocsConfig): void {
-    this.documentation.enableDocs(config, this.intelligentRouting);
-
-    this.logger.info(`API Documentation enabled at ${config.basePath || '/docs'}`, 'Documentation');
-    this.eventBus.emit('docs:enabled', { config });
-  }
-
-  // Get OpenAPI specification
-  getOpenAPISpec() {
-    return this.documentation.getOpenAPISpec();
-  }
-
-  // Get documentation as JSON
-  getDocsJSON(): string {
-    return this.documentation.getDocsJSON();
-  }
-
-  // Get documentation as YAML
-  getDocsYAML(): string {
-    return this.documentation.getDocsYAML();
-  }
-
-  // Refresh documentation (useful after adding routes dynamically)
-  refreshDocs(): void {
-    this.documentation.refreshDocs();
-  }
-
-  // Universal middleware system - seamlessly handles standard and advanced middleware
-  async use(middlewareOrFunction: any, config?: any) {
-    // Standard middleware integration (req, res, next pattern)
-    if (typeof middlewareOrFunction === 'function' && middlewareOrFunction.length >= 3) {
-      this.coreFramework.addMiddleware(middlewareOrFunction);
-      this.eventBus.emit('middleware:registered', {
-        type: 'standard',
-        middleware: middlewareOrFunction,
-      });
-      return this;
-    }
-
-    // Function-style middleware execution
-    if (typeof middlewareOrFunction === 'function' && middlewareOrFunction.length <= 1) {
-      await middlewareOrFunction(this);
-      this.eventBus.emit('middleware:executed', {
-        type: 'function',
-        middleware: middlewareOrFunction,
-      });
-      return this;
-    }
-
-    // Advanced middleware pipeline integration - check if it's a MiddlewareInterface
-    if (
-      middlewareOrFunction &&
-      typeof middlewareOrFunction === 'object' &&
-      middlewareOrFunction.install &&
-      middlewareOrFunction.metadata
-    ) {
-      // This is a MiddlewareInterface object - install it with the MiddlewareManager
-      this.logger.debug(
-        `Installing MiddlewareInterface: ${middlewareOrFunction.metadata.name}`,
-        'Middleware'
-      );
-      this.middlewareManager.install(middlewareOrFunction, config);
-      return this;
-    }
-
-    // Fallback: emit event for unknown middleware types
-    this.eventBus.emit('middleware:advanced', {
-      middleware: middlewareOrFunction,
-      config,
-    });
-    this.logger.debug(
-      'Advanced middleware integration - enhanced capabilities loading...',
-      'Middleware'
-    );
-    return this;
-  }
-
-  // Plugin compatibility layer - unified middleware interface
-  async plugin(middleware: any, options?: any): Promise<this> {
-    return this.use(middleware, options);
-  }
-
-  // Module loading with events
-  async loadModule(moduleOrPath: ModuleConfig | string) {
-    this.eventBus.emit('module:loading', {
-      moduleId: typeof moduleOrPath === 'string' ? moduleOrPath : moduleOrPath.name,
-    });
-
-    if (typeof moduleOrPath === 'string') {
-      const module = await this.importModule(moduleOrPath);
-      await this.coreFramework.loadModule(module);
-      this.loadedModules.add(moduleOrPath);
-      this.eventBus.emit('module:loaded', {
-        moduleId: module.name,
-        version: module.version || '1.0.0',
-      });
-    } else {
-      await this.coreFramework.loadModule(moduleOrPath);
-      this.loadedModules.add(moduleOrPath.name);
-      this.eventBus.emit('module:loaded', {
-        moduleId: moduleOrPath.name,
-        version: moduleOrPath.version || '1.0.0',
-      });
-    }
-    return this;
-  }
-
-  // Database helper with events
-  database(adapter: any) {
-    this.eventBus.emit('database:connected', {
-      adapter: adapter.constructor.name,
-      config: 'hidden',
-    });
-    this.coreFramework.registerDatabase(adapter);
-    return this;
-  }
-
-  // WebSocket helper with events
-  websocket(namespace: string, handlers: Record<string, Function>) {
-    const adapter = this.coreFramework.getWebSocketAdapter();
-    if (!adapter) {
-      throw new Error(
-        'WebSocket features require a WebSocket adapter. Install socket.io or configure an adapter:\n' +
-          'npm install socket.io\n' +
-          'or\n' +
-          'new Moro({ websocket: { adapter: new SocketIOAdapter() } })'
-      );
-    }
-
-    this.emit('websocket:registering', { namespace, handlers });
-
-    const ns = adapter.createNamespace(namespace);
-
-    Object.entries(handlers).forEach(([event, handler]) => {
-      ns.on('connection', socket => {
-        this.emit('websocket:connection', { namespace, event, socket });
-
-        socket.on(event, (data, callback) => {
-          this.emit('websocket:event', { namespace, event, data });
-
-          Promise.resolve(handler(socket, data))
-            .then(result => {
-              this.emit('websocket:response', { namespace, event, result });
-              if (callback) callback(result);
-              else if (result) socket.emit(`${event}:response`, result);
-            })
-            .catch(error => {
-              this.emit('websocket:error', { namespace, event, error });
-              const errorResponse = { success: false, error: error.message };
-              if (callback) callback(errorResponse);
-              else socket.emit('error', errorResponse);
-            });
-        });
-      });
-    });
-
-    this.emit('websocket:registered', { namespace, handlers });
-    return this;
-  }
-
-  // Start server with events (Node.js only)
-  listen(callback?: () => void): void;
-  listen(port: number, callback?: () => void): void;
-  listen(port: number, host: string, callback?: () => void): void;
-  listen(
-    portOrCallback?: number | (() => void),
-    hostOrCallback?: string | (() => void),
-    callback?: () => void
-  ) {
-    // Only available for Node.js runtime
-    if (this.runtimeType !== 'node') {
-      throw new Error(
-        `listen() is only available for Node.js runtime. Current runtime: ${this.runtimeType}. Use getHandler() for other runtimes.`
-      );
-    }
-
-    // Handle overloaded parameters - supports:
-    // listen(callback)
-    // listen(port, callback)
-    // listen(port, host, callback)
-    let port: number;
-    let host: string | undefined;
-
-    if (typeof portOrCallback === 'function') {
-      // listen(callback) - use port from config
-      callback = portOrCallback;
-      port = this.config.server.port;
-      host = this.config.server.host;
-    } else if (typeof portOrCallback === 'number') {
-      // listen(port, ...) variants
-      port = portOrCallback;
-      if (typeof hostOrCallback === 'function') {
-        // listen(port, callback)
-        callback = hostOrCallback;
-        host = undefined;
-      } else {
-        // listen(port, host, callback)
-        host = hostOrCallback;
-      }
-    } else {
-      // listen() - use config defaults
-      port = this.config.server.port;
-      host = this.config.server.host;
-    }
-
-    // Validate that we have a valid port
-    if (!port || typeof port !== 'number') {
-      throw new Error(
-        'Port not specified and not found in configuration. Please provide a port number or configure it in moro.config.js/ts'
-      );
-    }
-
-    // Check if clustering is enabled for massive performance gains
-    if (this.config.performance?.clustering?.enabled) {
-      this.startWithClustering(port, host as string, callback);
-      return;
-    }
-    this.eventBus.emit('server:starting', { port, runtime: this.runtimeType });
-
-    // Add documentation middleware first (if enabled)
-    try {
-      const docsMiddleware = this.documentation.getDocsMiddleware();
-      this.coreFramework.addMiddleware(docsMiddleware);
-      this.logger.debug('Documentation middleware added', 'Documentation');
-    } catch (error) {
-      // Documentation not enabled, that's fine
-      this.logger.debug('Documentation not enabled', 'Documentation');
-    }
-
-    // Add intelligent routing middleware to handle chainable routes
-    this.coreFramework.addMiddleware(
-      async (req: HttpRequest, res: HttpResponse, next: () => void) => {
-        // Try intelligent routing first
-        const handled = await this.intelligentRouting.handleIntelligentRoute(req, res);
-        if (!handled) {
-          next(); // Fall back to direct routes
-        }
-      }
-    );
-
-    // Register direct routes with the HTTP server
-    if (this.routes.length > 0) {
-      this.registerDirectRoutes();
-    }
-
-    const actualCallback = () => {
-      const displayHost = host || 'localhost';
-      this.logger.info('Moro Server Started', 'Server');
-      this.logger.info(`Runtime: ${this.runtimeType}`, 'Server');
-      this.logger.info(`HTTP API: http://${displayHost}:${port}`, 'Server');
-      this.logger.info(`WebSocket: ws://${displayHost}:${port}`, 'Server');
-      this.logger.info('Native Node.js HTTP • Zero Dependencies • Maximum Performance', 'Server');
-      this.logger.info('Learn more at https://morojs.com', 'Server');
-
-      // Log intelligent routes info
-      const intelligentRoutes = this.intelligentRouting.getIntelligentRoutes();
-      if (intelligentRoutes.length > 0) {
-        this.logger.info(`Intelligent Routes: ${intelligentRoutes.length} registered`, 'Server');
-      }
-
-      this.eventBus.emit('server:started', { port, runtime: this.runtimeType });
-      if (callback) callback();
-    };
-
-    if (host && typeof host === 'string') {
-      this.coreFramework.listen(port, host, actualCallback);
-    } else {
-      this.coreFramework.listen(port, actualCallback);
-    }
-  }
-
-  // Get handler for non-Node.js runtimes
-  getHandler() {
-    // Create a unified request handler that works with the runtime adapter
-    const handler = async (req: HttpRequest, res: HttpResponse) => {
-      // Add documentation middleware first (if enabled)
-      try {
-        const docsMiddleware = this.documentation.getDocsMiddleware();
-        await docsMiddleware(req, res, () => {});
-        if (res.headersSent) return;
-      } catch (error) {
-        // Documentation not enabled, that's fine
-      }
-
-      // Try intelligent routing first
-      const handled = await this.intelligentRouting.handleIntelligentRoute(req, res);
-      if (handled) return;
-
-      // Handle direct routes
-      if (this.routes.length > 0) {
-        await this.handleDirectRoutes(req, res);
-      }
-    };
-
-    // Use the runtime adapter to create the appropriate handler
-    return this.runtimeAdapter.createServer(handler);
-  }
-
-  // Handle direct routes for runtime adapters
-  private async handleDirectRoutes(req: HttpRequest, res: HttpResponse) {
-    // Find matching route
-    const route = this.findMatchingRoute(req.method!, req.path);
-    if (!route) {
-      (res as any).status(404).json({ success: false, error: 'Not found' });
-      return;
-    }
-
-    try {
-      // Extract path parameters
-      const matches = req.path.match(route.pattern);
-      if (matches) {
-        req.params = {};
-        route.paramNames.forEach((name: string, index: number) => {
-          req.params[name] = matches[index + 1];
-        });
-      }
-
-      // Get handler function
-      const handler = this.routeHandlers[route.handler];
-      if (!handler) {
-        (res as any).status(500).json({ success: false, error: 'Handler not found' });
-        return;
-      }
-
-      // Execute validation if present
-      if (route.validation) {
-        try {
-          const validated = route.validation.parse(req.body);
-          req.body = validated;
-        } catch (error: any) {
-          if (error.issues) {
-            (res as any).status(400).json({
-              success: false,
-              error: 'Validation failed',
-              details: error.issues.map((issue: any) => ({
-                field: issue.path.length > 0 ? issue.path.join('.') : 'body',
-                message: issue.message,
-                code: issue.code,
-              })),
-            });
-            return;
-          }
-          throw error;
-        }
-      }
-
-      // Execute rate limiting if present
-      if (route.rateLimit) {
-        const clientId = req.ip || 'unknown';
-        const key = `${route.method}:${route.path}:${clientId}`;
-
-        if (!this.checkRateLimit(key, route.rateLimit)) {
-          (res as any).status(429).json({
-            success: false,
-            error: 'Rate limit exceeded',
-            retryAfter: Math.ceil(route.rateLimit.window / 1000),
-          });
-          return;
-        }
-      }
-
-      // Execute the handler
-      const result = await handler(req, res);
-      if (result && !(res as any).headersSent) {
-        (res as any).json(result);
-      }
-    } catch (error) {
-      if (!(res as any).headersSent) {
-        (res as any).status(500).json({
-          success: false,
-          error: error instanceof Error ? error.message : 'Internal server error',
-        });
-      }
-    }
-  }
-
-  // Advanced route matching with caching and optimization
-  private routeCache = new Map<string, { pattern: RegExp; paramNames: string[] }>();
-  private staticRouteMap = new Map<string, any>();
-  private dynamicRoutesBySegments = new Map<number, any[]>();
-
-  private findMatchingRoute(method: string, path: string) {
-    // Phase 1: O(1) static route lookup
-    const staticKey = `${method}:${path}`;
-    const staticRoute = this.staticRouteMap.get(staticKey);
-    if (staticRoute) {
-      return {
-        ...staticRoute,
-        pattern: /^.*$/, // Dummy pattern for static routes
-        paramNames: [],
-      };
-    }
-
-    // Phase 2: Optimized dynamic route matching by segment count
-    const segments = path.split('/').filter(s => s.length > 0);
-    const segmentCount = segments.length;
-    const candidateRoutes = this.dynamicRoutesBySegments.get(segmentCount) || [];
-
-    for (const route of candidateRoutes) {
-      if (route.method === method) {
-        const cacheKey = `${method}:${route.path}`;
-        let pattern = this.routeCache.get(cacheKey);
-
-        if (!pattern) {
-          pattern = this.pathToRegex(route.path);
-          this.routeCache.set(cacheKey, pattern);
-        }
-
-        if (pattern.pattern.test(path)) {
-          return {
-            ...route,
-            pattern: pattern.pattern,
-            paramNames: pattern.paramNames,
-          };
-        }
-      }
-    }
-
-    return null;
-  }
-
-  // Convert path to regex (simplified version)
-  private pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
-    const paramNames: string[] = [];
-    const regexPath = path.replace(/\//g, '\\/').replace(/:([^/]+)/g, (match, paramName) => {
-      paramNames.push(paramName);
-      return '([^/]+)';
-    });
-
-    return {
-      pattern: new RegExp(`^${regexPath}$`),
-      paramNames,
-    };
-  }
-
-  // Access enterprise event system for advanced integrations
-  get events() {
-    return this.eventBus;
-  }
-
-  // Access to core framework for advanced usage
-  get core() {
-    return this.coreFramework;
-  }
-
-  // Force cleanup of pooled objects
-  forceCleanup(): void {
-    const httpServer = (this.coreFramework as any).httpServer;
-    if (httpServer && httpServer.forceCleanup) {
-      httpServer.forceCleanup();
-    }
-  }
-
-  // Private methods
-  private addRoute(method: string, path: string, handler: Function, options: any = {}) {
-    const handlerName = `handler_${this.routes.length}`;
-
-    const route = {
-      method: method as any,
-      path,
-      handler: handlerName,
-      validation: options.validation,
-      rateLimit: options.rateLimit,
-      cache: options.cache,
-      middleware: options.middleware,
-    };
-
-    this.routes.push(route);
-
-    // Organize routes for optimal lookup
-    this.organizeRouteForLookup(route);
-
-    // Store handler for later module creation
-    this.routeHandlers[handlerName] = handler;
-
-    return this;
-  }
-
-  private organizeRouteForLookup(route: any): void {
-    if (!route.path.includes(':')) {
-      // Static route - add to static map for O(1) lookup
-      const staticKey = `${route.method}:${route.path}`;
-      this.staticRouteMap.set(staticKey, route);
-    } else {
-      // Dynamic route - organize by segment count
-      const segments = route.path.split('/').filter((s: string) => s.length > 0);
-      const segmentCount = segments.length;
-
-      if (!this.dynamicRoutesBySegments.has(segmentCount)) {
-        this.dynamicRoutesBySegments.set(segmentCount, []);
-      }
-      this.dynamicRoutesBySegments.get(segmentCount)!.push(route);
-    }
-  }
-
-  private registerDirectRoutes() {
-    // Register routes directly with the HTTP server for optimal performance
-    // This provides the intuitive developer experience users expect
-    for (const route of this.routes) {
-      const handler = this.routeHandlers[route.handler];
-
-      // Get direct access to the HTTP server through the core framework
-      const httpServer = (this.coreFramework as any).httpServer;
-
-      // Create a wrapper handler that handles validation, rate limiting, and return values
-      const wrappedHandler = async (req: any, res: any) => {
-        try {
-          // Enhance request with events property for direct routes
-          req.events = this.eventBus;
-
-          // Universal validation middleware (works with any ValidationSchema)
-          if (route.validation) {
-            try {
-              const validated = await route.validation.parseAsync(req.body);
-              req.body = validated;
-            } catch (error: any) {
-              // Handle universal validation errors
-              const { normalizeValidationError } = require('./core/validation/schema-interface');
-              const normalizedError = normalizeValidationError(error);
-              res.status(400).json({
-                success: false,
-                error: 'Validation failed',
-                details: normalizedError.issues.map((issue: any) => ({
-                  field: issue.path.length > 0 ? issue.path.join('.') : 'body',
-                  message: issue.message,
-                  code: issue.code,
-                })),
-                requestId: req.requestId,
-              });
-              return;
-            }
-          }
-
-          // Rate limiting middleware
-          if (route.rateLimit) {
-            const clientId = req.ip || req.connection.remoteAddress || 'unknown';
-            const key = `${route.method}:${route.path}:${clientId}`;
-
-            if (!this.checkRateLimit(key, route.rateLimit)) {
-              res.status(429).json({
-                success: false,
-                error: 'Rate limit exceeded',
-                retryAfter: Math.ceil(route.rateLimit.window / 1000),
-              });
-              return;
-            }
-          }
-
-          // Execute the actual handler
-          const result = await handler(req, res);
-          if (result && !res.headersSent) {
-            res.json(result);
-          }
-        } catch (error) {
-          if (!res.headersSent) {
-            res.status(500).json({
-              success: false,
-              error: error instanceof Error ? error.message : 'Internal server error',
-            });
-          }
-        }
-      };
-
-      // Register with the appropriate HTTP method
-      const method = route.method.toLowerCase();
-      if (httpServer && httpServer[method]) {
-        httpServer[method](route.path, wrappedHandler);
-      }
-    }
-  }
-
-  // Simple rate limiting for direct routes
-  private rateLimitStore = new Map<string, { count: number; resetTime: number }>();
-
-  private checkRateLimit(key: string, config: { requests: number; window: number }): boolean {
-    const now = Date.now();
-    const bucket = this.rateLimitStore.get(key);
-
-    if (!bucket || now > bucket.resetTime) {
-      // Create new bucket or reset expired bucket
-      this.rateLimitStore.set(key, {
-        count: 1,
-        resetTime: now + config.window,
-      });
-      return true;
-    }
-
-    if (bucket.count >= config.requests) {
-      return false; // Rate limit exceeded
-    }
-
-    bucket.count++;
-    return true;
-  }
-
-  private setupDefaultMiddleware(options: MoroOptions) {
-    // CORS
-    if (options.cors !== false) {
-      const corsOptions = typeof options.cors === 'object' ? options.cors : {};
-      this.use(middleware.cors(corsOptions));
-    }
-
-    // Helmet
-    if (options.helmet !== false) {
-      this.use(middleware.helmet());
-    }
-
-    // Compression
-    if (options.compression !== false) {
-      const compressionOptions = typeof options.compression === 'object' ? options.compression : {};
-      this.use(middleware.compression(compressionOptions));
-    }
-
-    // Body size limiting
-    this.use(middleware.bodySize({ limit: '10mb' }));
-  }
-
-  private autoDiscoverModules(modulesPath: string) {
-    try {
-      if (!statSync(modulesPath).isDirectory()) return;
-
-      const items = readdirSync(modulesPath);
-      items.forEach(item => {
-        const fullPath = join(modulesPath, item);
-        if (statSync(fullPath).isDirectory()) {
-          const indexPath = join(fullPath, 'index.ts');
-          try {
-            statSync(indexPath);
-            // Module directory found, will be loaded later
-            this.logger.debug(`Discovered module: ${item}`, 'ModuleDiscovery');
-          } catch {
-            // No index.ts, skip
-          }
-        }
-      });
-    } catch {
-      // Modules directory doesn't exist, that's fine
-    }
-  }
-
-  private async importModule(modulePath: string): Promise<ModuleConfig> {
-    const module = await import(modulePath);
-    return module.default || module;
-  }
-
-  // Clustering support for massive performance gains with proper cleanup
-  private clusterWorkers = new Map<number, any>();
-  private startWithClustering(port: number, host?: string, callback?: () => void): void {
-    const cluster = require('cluster');
-    const os = require('os');
-
-    // Smart worker count calculation based on actual bottlenecks
-    let workerCount = this.config.performance?.clustering?.workers || os.cpus().length;
-
-    // Auto-optimize worker count based on system characteristics
-    if (workerCount === 'auto' || workerCount > 8) {
-      // For high-core machines, limit workers to prevent IPC/memory bottlenecks
-      const cpuCount = os.cpus().length;
-      const totalMemoryGB = os.totalmem() / (1024 * 1024 * 1024);
-
-      // Optimal worker count formula based on research
-      if (cpuCount >= 16) {
-        // High-core machines: focus on memory/IPC efficiency
-        workerCount = Math.min(Math.ceil(totalMemoryGB / 2), 4); // 2GB per worker max, cap at 4
-      } else if (cpuCount >= 8) {
-        // Mid-range machines: balanced approach
-        workerCount = Math.min(cpuCount / 2, 4);
-      } else {
-        // Low-core machines: use all cores
-        workerCount = cpuCount;
-      }
-
-      this.logger.info(
-        `Auto-optimized workers: ${workerCount} (CPU: ${cpuCount}, RAM: ${totalMemoryGB.toFixed(1)}GB)`,
-        'Cluster'
-      );
-    }
-
-    if (cluster.isPrimary) {
-      this.logger.info(`🚀 Starting ${workerCount} workers for maximum performance`, 'Cluster');
-
-      // Optimize cluster scheduling for high concurrency
-      cluster.schedulingPolicy = cluster.SCHED_RR; // Round-robin scheduling
-
-      // Set cluster settings for better performance
-      cluster.setupMaster({
-        exec: process.argv[1],
-        args: process.argv.slice(2),
-        silent: false,
-      });
-
-      // Optimize IPC to reduce communication overhead
-      process.env.NODE_CLUSTER_SCHED_POLICY = 'rr'; // Ensure round-robin
-      process.env.NODE_DISABLE_COLORS = '1'; // Reduce IPC message size
-
-      // Graceful shutdown handler
-      const gracefulShutdown = () => {
-        this.logger.info('Gracefully shutting down cluster...', 'Cluster');
-
-        // Clean up all workers
-        for (const [pid, worker] of this.clusterWorkers) {
-          worker.removeAllListeners();
-          worker.kill('SIGTERM');
-        }
-
-        // Clean up cluster listeners
-        cluster.removeAllListeners();
-        process.exit(0);
-      };
-
-      // Handle process signals for graceful shutdown
-      process.on('SIGINT', gracefulShutdown);
-      process.on('SIGTERM', gracefulShutdown);
-
-      // Fork workers with proper tracking and CPU affinity
-      for (let i = 0; i < workerCount; i++) {
-        const worker = cluster.fork({
-          WORKER_ID: i,
-          WORKER_CPU_AFFINITY: i % os.cpus().length, // Distribute workers across CPUs
-        });
-        this.clusterWorkers.set(worker.process.pid!, worker);
-        this.logger.info(
-          `Worker ${worker.process.pid} started (CPU ${i % os.cpus().length})`,
-          'Cluster'
-        );
-
-        // Handle individual worker messages (reuse handler)
-        worker.on('message', this.handleWorkerMessage.bind(this));
-      }
-
-      // Handle worker exits with cleanup
-      cluster.on('exit', (worker: any, code: number, signal: string) => {
-        // Clean up worker tracking
-        this.clusterWorkers.delete(worker.process.pid);
-
-        this.logger.warn(
-          `Worker ${worker.process.pid} died (${signal || code}). Restarting...`,
-          'Cluster'
-        );
-
-        // Restart worker with proper tracking
-        const newWorker = cluster.fork();
-        this.clusterWorkers.set(newWorker.process.pid!, newWorker);
-        newWorker.on('message', this.handleWorkerMessage.bind(this));
-        this.logger.info(`Worker ${newWorker.process.pid} started`, 'Cluster');
-      });
-
-      // Master process callback
-      if (callback) callback();
-    } else {
-      // Worker process - start the actual server with proper cleanup
-      this.logger.info(`Worker ${process.pid} initializing`, 'Worker');
-
-      // Worker-specific optimizations for high concurrency
-      process.env.UV_THREADPOOL_SIZE = '64';
-
-      // Reduce logging contention in workers (major bottleneck)
-      if (this.config.logging) {
-        // Workers log less frequently to reduce I/O contention
-        this.config.logging.level = 'warn'; // Only warnings and errors
-      }
-
-      // Memory optimization for workers
-      process.env.NODE_OPTIONS = '--max-old-space-size=1024'; // Limit memory per worker
-
-      // Optimize V8 flags for better performance (Rust-level optimizations)
-      if (process.env.NODE_ENV === 'production') {
-        // Ultra-aggressive V8 optimizations for maximum performance
-        const v8Flags = [
-          '--optimize-for-size', // Trade memory for speed
-          '--always-opt', // Always optimize functions
-          '--turbo-fast-api-calls', // Optimize API calls
-          '--turbo-escape-analysis', // Escape analysis optimization
-          '--turbo-inline-api-calls', // Inline API calls
-          '--max-old-space-size=1024', // Limit memory to prevent GC pressure
-        ];
-        process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS || '') + ' ' + v8Flags.join(' ');
-      }
-
-      // Optimize garbage collection for workers
-      // eslint-disable-next-line no-undef
-      if ((global as any).gc) {
-        setInterval(() => {
-          // eslint-disable-next-line no-undef
-          if ((global as any).gc) (global as any).gc();
-        }, 60000); // GC every 60 seconds (less frequent)
-      }
-
-      // Graceful shutdown for worker
-      const workerShutdown = () => {
-        this.logger.info(`Worker ${process.pid} shutting down gracefully...`, 'Worker');
-
-        // Clean up event listeners
-        this.eventBus.removeAllListeners();
-        this.removeAllListeners();
-
-        // Close server gracefully
-        if (this.coreFramework) {
-          const server = (this.coreFramework as any).server;
-          if (server) {
-            server.close(() => {
-              process.exit(0);
-            });
-          }
-        }
-      };
-
-      // Handle worker shutdown signals
-      process.on('SIGTERM', workerShutdown);
-      process.on('SIGINT', workerShutdown);
-
-      // Continue with normal server startup for this worker
-      this.eventBus.emit('server:starting', {
-        port,
-        runtime: this.runtimeType,
-        worker: process.pid,
-      });
-
-      // Add documentation middleware first (if enabled)
-      try {
-        const docsMiddleware = this.documentation.getDocsMiddleware();
-        this.coreFramework.addMiddleware(docsMiddleware);
-      } catch (error) {
-        // Documentation not enabled, that's fine
-      }
-
-      // Add intelligent routing middleware
-      this.coreFramework.addMiddleware(
-        async (req: HttpRequest, res: HttpResponse, next: () => void) => {
-          const handled = await this.intelligentRouting.handleIntelligentRoute(req, res);
-          if (!handled) {
-            next();
-          }
-        }
-      );
-
-      // Register direct routes
-      if (this.routes.length > 0) {
-        this.registerDirectRoutes();
-      }
-
-      const workerCallback = () => {
-        const displayHost = host || 'localhost';
-        this.logger.info(`Worker ${process.pid} ready on ${displayHost}:${port}`, 'Worker');
-        this.eventBus.emit('server:started', {
-          port,
-          runtime: this.runtimeType,
-          worker: process.pid,
-        });
-      };
-
-      if (host) {
-        this.coreFramework.listen(port, host, workerCallback);
-      } else {
-        this.coreFramework.listen(port, workerCallback);
-      }
-    }
-  }
-
-  // Reusable worker message handler (avoids creating new functions)
-  private handleWorkerMessage(message: any): void {
-    // Handle inter-worker communication if needed
-    if (message.type === 'health-check') {
-      // Worker health check response
-      return;
-    }
-
-    // Log other worker messages
-    this.logger.debug(`Worker message: ${JSON.stringify(message)}`, 'Cluster');
-  }
-}
-
-// Export convenience function
-export function createApp(options?: MoroOptions): Moro {
-  return new Moro(options);
-}
-
-// Runtime-specific convenience functions
-export function createAppNode(options?: Omit<MoroOptions, 'runtime'>): Moro {
-  return new Moro({
-    ...options,
-    runtime: { type: 'node' },
-  });
-}
-
-export function createAppEdge(options?: Omit<MoroOptions, 'runtime'>): Moro {
-  return new Moro({
-    ...options,
-    runtime: { type: 'vercel-edge' },
-  });
-}
-
-export function createAppLambda(options?: Omit<MoroOptions, 'runtime'>): Moro {
-  return new Moro({
-    ...options,
-    runtime: { type: 'aws-lambda' },
-  });
-}
-
-export function createAppWorker(options?: Omit<MoroOptions, 'runtime'>): Moro {
-  return new Moro({
-    ...options,
-    runtime: { type: 'cloudflare-workers' },
-  });
-}