@morojs/moro 1.6.1 → 1.6.3

package/src/core/networking/websocket-manager.ts

@@ -1,308 +0,0 @@
-// WebSocket Manager for Moro Framework
-// Manages WebSocket connections using pluggable adapters
-import { Container } from '../utilities';
-import { CircuitBreaker } from '../utilities';
-import { ModuleConfig, WebSocketDefinition } from '../../types/module';
-import { WebSocketAdapter, WebSocketNamespace, WebSocketConnection } from './websocket-adapter';
-import { createFrameworkLogger } from '../logger';
-
-export class WebSocketManager {
-  private circuitBreakers = new Map<string, CircuitBreaker>();
-  private rateLimiters = new Map<string, Map<string, { count: number; resetTime: number }>>();
-  private logger = createFrameworkLogger('WebSocketManager');
-
-  constructor(
-    private adapter: WebSocketAdapter,
-    private container: Container
-  ) {
-    this.logger.info(`Initialized with ${adapter.getAdapterName()} adapter`, 'AdapterInit');
-  }
-
-  /**
-   * Set custom ID generator for the adapter
-   */
-  setCustomIdGenerator(generator: () => string): void {
-    this.adapter.setCustomIdGenerator(generator);
-  }
-
-  /**
-   * Enable compression for the adapter
-   */
-  enableCompression(options?: any): void {
-    this.adapter.setCompression(true, options);
-  }
-
-  /**
-   * Get the underlying adapter
-   */
-  getAdapter(): WebSocketAdapter {
-    return this.adapter;
-  }
-
-  /**
-   * Get connection count across all namespaces
-   */
-  getConnectionCount(): number {
-    return this.adapter.getConnectionCount();
-  }
-
-  /**
-   * Create or get a namespace
-   */
-  getNamespace(namespace: string): WebSocketNamespace {
-    return this.adapter.createNamespace(namespace);
-  }
-
-  /**
-   * Register WebSocket handlers for a module
-   */
-  async registerHandler(
-    namespace: WebSocketNamespace,
-    wsConfig: WebSocketDefinition,
-    moduleConfig: ModuleConfig
-  ): Promise<void> {
-    namespace.on('connection', (socket: WebSocketConnection) => {
-      this.logger.debug(`New connection: ${socket.id}`, 'Connection', {
-        namespace: namespace.constructor.name,
-        module: moduleConfig.name,
-      });
-
-      this.setupSocketMiddleware(socket, moduleConfig.name);
-      this.setupSocketHandlers(socket, wsConfig, moduleConfig);
-    });
-  }
-
-  /**
-   * Setup socket-specific middleware
-   */
-  private setupSocketMiddleware(socket: WebSocketConnection, moduleName: string): void {
-    // Add module context to socket data
-    socket.data.module = moduleName;
-    socket.data.connectedAt = Date.now();
-
-    // Setup heartbeat if supported
-    if (socket.compressedEmit) {
-      const heartbeatInterval = setInterval(() => {
-        if (socket.connected) {
-          socket.emit('heartbeat', { timestamp: Date.now() });
-        } else {
-          clearInterval(heartbeatInterval);
-        }
-      }, 30000); // 30 seconds
-
-      socket.on('disconnect', () => {
-        clearInterval(heartbeatInterval);
-      });
-    }
-
-    // Log disconnection
-    socket.on('disconnect', () => {
-      this.logger.debug(`Socket disconnected: ${socket.id}`, 'Disconnect', {
-        module: moduleName,
-        duration: Date.now() - socket.data.connectedAt,
-      });
-    });
-  }
-
-  /**
-   * Setup handlers for a specific WebSocket configuration
-   */
-  private setupSocketHandlers(
-    socket: WebSocketConnection,
-    wsConfig: WebSocketDefinition,
-    moduleConfig: ModuleConfig
-  ): void {
-    socket.on(wsConfig.event, async (data: any, callback?: Function) => {
-      const handlerKey = `${moduleConfig.name}.${wsConfig.handler}`;
-
-      try {
-        // Rate limiting
-        if (wsConfig.rateLimit && !this.checkRateLimit(socket.id, handlerKey, wsConfig.rateLimit)) {
-          const error = {
-            success: false,
-            error: 'Rate limit exceeded',
-            code: 'RATE_LIMIT',
-          };
-          if (callback) callback(error);
-          else socket.emit('error', error);
-          return;
-        }
-
-        // Universal validation (works with any ValidationSchema)
-        if (wsConfig.validation) {
-          try {
-            data = await wsConfig.validation.parseAsync(data);
-          } catch (validationError: any) {
-            // Handle universal validation errors
-            const { normalizeValidationError } = require('../validation/schema-interface');
-            const normalizedError = normalizeValidationError(validationError);
-            const error = {
-              success: false,
-              error: 'Validation failed',
-              details: normalizedError.issues.map((issue: any) => ({
-                field: issue.path.length > 0 ? issue.path.join('.') : 'data',
-                message: issue.message,
-                code: issue.code,
-              })),
-            };
-            if (callback) callback(error);
-            else socket.emit('error', error);
-            return;
-          }
-        }
-
-        // Circuit breaker protection
-        const circuitBreaker = this.getCircuitBreaker(handlerKey);
-
-        const result = await circuitBreaker.execute(async () => {
-          const controller = this.container.resolve(moduleConfig.name);
-          return await (controller as any)[wsConfig.handler](socket, data);
-        });
-
-        // Handle response
-        if (callback) {
-          callback({ success: true, data: result });
-        } else if (result !== undefined) {
-          socket.emit(`${wsConfig.event}:response`, { success: true, data: result });
-        }
-
-        // Handle room operations
-        if (wsConfig.rooms) {
-          wsConfig.rooms.forEach(room => socket.join(room));
-        }
-
-        // Handle broadcasting
-        if (wsConfig.broadcast && result !== undefined) {
-          socket.broadcast.emit(wsConfig.event, { success: true, data: result });
-        }
-      } catch (error) {
-        this.logger.error('WebSocket handler error', 'HandlerError', {
-          handler: handlerKey,
-          error: error instanceof Error ? error.message : String(error),
-          socketId: socket.id,
-        });
-
-        const errorResponse = {
-          success: false,
-          error: 'Internal server error',
-          code: 'HANDLER_ERROR',
-        };
-
-        if (callback) callback(errorResponse);
-        else socket.emit('error', errorResponse);
-      }
-    });
-  }
-
-  /**
-   * Get or create circuit breaker for handler
-   */
-  private getCircuitBreaker(handlerKey: string): CircuitBreaker {
-    if (!this.circuitBreakers.has(handlerKey)) {
-      const circuitBreaker = new CircuitBreaker({
-        failureThreshold: 5,
-        resetTimeout: 60000,
-        monitoringPeriod: 10000,
-      });
-      this.circuitBreakers.set(handlerKey, circuitBreaker);
-    }
-    return this.circuitBreakers.get(handlerKey)!;
-  }
-
-  /**
-   * Check rate limit for socket and handler
-   */
-  private checkRateLimit(
-    socketId: string,
-    handlerKey: string,
-    rateLimit: { requests: number; window: number }
-  ): boolean {
-    if (!this.rateLimiters.has(handlerKey)) {
-      this.rateLimiters.set(handlerKey, new Map());
-    }
-
-    const handlerLimiter = this.rateLimiters.get(handlerKey)!;
-    const now = Date.now();
-    const windowStart = now - rateLimit.window;
-
-    // Clean old entries
-    for (const [id, data] of handlerLimiter.entries()) {
-      if (data.resetTime < windowStart) {
-        handlerLimiter.delete(id);
-      }
-    }
-
-    // Check current socket
-    const socketData = handlerLimiter.get(socketId);
-    if (!socketData) {
-      handlerLimiter.set(socketId, { count: 1, resetTime: now });
-      return true;
-    }
-
-    if (socketData.resetTime < windowStart) {
-      socketData.count = 1;
-      socketData.resetTime = now;
-      return true;
-    }
-
-    if (socketData.count >= rateLimit.requests) {
-      return false;
-    }
-
-    socketData.count++;
-    return true;
-  }
-
-  /**
-   * Process binary data efficiently
-   */
-  private processBinaryData(buffer: Buffer): any {
-    // Example binary processing - can be extended based on needs
-    if (buffer.length === 0) return buffer;
-
-    // Simple compression check
-    if (buffer[0] === 0x1f && buffer[1] === 0x8b) {
-      // This is gzipped data
-      try {
-        const zlib = require('zlib');
-        return zlib.gunzipSync(buffer);
-      } catch {
-        return buffer;
-      }
-    }
-
-    return buffer;
-  }
-
-  /**
-   * Check if data should be compressed
-   */
-  private shouldCompress(data: any): boolean {
-    if (typeof data === 'string') {
-      return data.length > 1024;
-    }
-    if (Buffer.isBuffer(data)) {
-      return data.length > 1024;
-    }
-    if (typeof data === 'object') {
-      return JSON.stringify(data).length > 1024;
-    }
-    return false;
-  }
-
-  /**
-   * Close the WebSocket manager and underlying adapter
-   */
-  async close(): Promise<void> {
-    this.logger.info('Closing WebSocket manager', 'Shutdown');
-
-    // Clear rate limiters
-    this.rateLimiters.clear();
-
-    // Clear circuit breakers
-    this.circuitBreakers.clear();
-
-    // Close adapter
-    await this.adapter.close();
-  }
-}

package/src/core/routing/app-integration.ts

@@ -1,216 +0,0 @@
-// Integration layer for intelligent routing system with main Moro app
-// Provides both chainable and schema-first APIs
-
-import {
-  RouteBuilder,
-  RouteSchema,
-  CompiledRoute,
-  createRoute,
-  defineRoute,
-  HttpMethod,
-} from './index';
-import { HttpRequest, HttpResponse } from '../http';
-import { createFrameworkLogger } from '../logger';
-
-const logger = createFrameworkLogger('AppIntegration');
-
-// Extended app interface with intelligent routing
-export interface IntelligentApp {
-  // Chainable route methods
-  get(path: string): RouteBuilder;
-  post(path: string): RouteBuilder;
-  put(path: string): RouteBuilder;
-  delete(path: string): RouteBuilder;
-  patch(path: string): RouteBuilder;
-  head(path: string): RouteBuilder;
-  options(path: string): RouteBuilder;
-
-  // Schema-first route method
-  route(schema: RouteSchema): CompiledRoute;
-
-  // Route registration for compiled routes
-  register(route: CompiledRoute): void;
-
-  // Direct route method (deprecated)
-  directRoute(method: string, path: string, handler: Function, options?: any): void;
-}
-
-// Route registry for managing compiled routes
-export class RouteRegistry {
-  private routes = new Map<string, CompiledRoute>();
-  private routePatterns: {
-    pattern: RegExp;
-    route: CompiledRoute;
-    method: string;
-    paramNames: string[];
-  }[] = [];
-
-  register(route: CompiledRoute): void {
-    const key = `${route.schema.method}:${route.schema.path}`;
-    this.routes.set(key, route);
-
-    // Convert path to regex pattern for matching
-    const { pattern, paramNames } = this.pathToRegex(route.schema.path);
-    this.routePatterns.push({
-      pattern,
-      route,
-      method: route.schema.method,
-      paramNames,
-    });
-
-    logger.debug(`Registered route: ${key}`, 'RouteRegistry', {
-      path: route.schema.path,
-      hasValidation: !!route.schema.validation,
-      hasAuth: !!route.schema.auth,
-      hasRateLimit: !!route.schema.rateLimit,
-    });
-  }
-
-  async handleRequest(req: HttpRequest, res: HttpResponse): Promise<boolean> {
-    const method = req.method?.toUpperCase();
-    const path = req.path;
-
-    // Find matching route
-    for (const routePattern of this.routePatterns) {
-      if (routePattern.method === method && routePattern.pattern.test(path)) {
-        // Extract path parameters
-        const matches = path.match(routePattern.pattern);
-        if (matches) {
-          req.params = {};
-          routePattern.paramNames.forEach((name, index) => {
-            req.params[name] = matches[index + 1];
-          });
-        }
-
-        // Execute the route
-        await routePattern.route.execute(req, res);
-        return true; // Route handled
-      }
-    }
-
-    return false; // No route matched
-  }
-
-  getRoutes(): CompiledRoute[] {
-    return Array.from(this.routes.values());
-  }
-
-  private pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
-    const paramNames: string[] = [];
-
-    // Convert path parameters like :id to regex groups
-    const regexPath = path
-      .replace(/\//g, '\\/') // Escape forward slashes
-      .replace(/:([^/]+)/g, (match, paramName) => {
-        paramNames.push(paramName);
-        return '([^/]+)'; // Match parameter value
-      });
-
-    return {
-      pattern: new RegExp(`^${regexPath}$`),
-      paramNames,
-    };
-  }
-}
-
-// Intelligent routing manager class
-export class IntelligentRoutingManager implements IntelligentApp {
-  private routeRegistry = new RouteRegistry();
-
-  // Chainable route methods
-  get(path: string): RouteBuilder {
-    return this.createChainableRoute('GET', path);
-  }
-
-  post(path: string): RouteBuilder {
-    return this.createChainableRoute('POST', path);
-  }
-
-  put(path: string): RouteBuilder {
-    return this.createChainableRoute('PUT', path);
-  }
-
-  delete(path: string): RouteBuilder {
-    return this.createChainableRoute('DELETE', path);
-  }
-
-  patch(path: string): RouteBuilder {
-    return this.createChainableRoute('PATCH', path);
-  }
-
-  head(path: string): RouteBuilder {
-    return this.createChainableRoute('HEAD', path);
-  }
-
-  options(path: string): RouteBuilder {
-    return this.createChainableRoute('OPTIONS', path);
-  }
-
-  // Schema-first route method
-  route(schema: RouteSchema): CompiledRoute {
-    const compiledRoute = defineRoute(schema);
-    this.register(compiledRoute);
-    return compiledRoute;
-  }
-
-  // Register compiled route
-  register(route: CompiledRoute): void {
-    this.routeRegistry.register(route);
-  }
-
-  // Handle incoming requests with intelligent routing
-  async handleIntelligentRoute(req: HttpRequest, res: HttpResponse): Promise<boolean> {
-    return await this.routeRegistry.handleRequest(req, res);
-  }
-
-  // Get all registered routes (useful for debugging/docs)
-  getIntelligentRoutes(): CompiledRoute[] {
-    return this.routeRegistry.getRoutes();
-  }
-
-  // Direct route method (deprecated)
-  directRoute(method: string, path: string, handler: Function, options?: any): void {
-    logger.warn('Using deprecated direct route method', 'DirectRoute', {
-      method,
-      path,
-      suggestion: 'Use chainable or schema-first API instead',
-    });
-
-    // Convert direct options to new schema format
-    const schema: RouteSchema = {
-      method: method.toUpperCase() as HttpMethod,
-      path,
-      handler: handler as any,
-    };
-
-    if (options?.validation) {
-      schema.validation = { body: options.validation };
-    }
-
-    if (options?.rateLimit) {
-      schema.rateLimit = options.rateLimit;
-    }
-
-    this.route(schema);
-  }
-
-  private createChainableRoute(method: HttpMethod, path: string): RouteBuilder {
-    const builder = createRoute(method, path);
-
-    // Override the handler method to auto-register the route
-    const originalHandler = builder.handler.bind(builder);
-    builder.handler = <T>(handler: any) => {
-      const compiledRoute = originalHandler(handler);
-      this.register(compiledRoute);
-      return compiledRoute;
-    };
-
-    return builder;
-  }
-}
-
-// Convenience type for apps with intelligent routing
-export type AppWithIntelligentRouting = IntelligentApp & {
-  handleIntelligentRoute(req: HttpRequest, res: HttpResponse): Promise<boolean>;
-  getIntelligentRoutes(): CompiledRoute[];
-};