@morojs/moro 1.6.2 → 1.6.3

package/src/core/networking/service-discovery.ts

@@ -1,303 +0,0 @@
-// Service Discovery Client for Microservices
-// Supports Consul, Kubernetes, and in-memory registry
-import { createFrameworkLogger } from '../logger/index.js';
-
-export interface ServiceInfo {
-  name: string;
-  host: string;
-  port: number;
-  health?: string;
-  version?: string;
-  tags?: string[];
-  metadata?: Record<string, any>;
-}
-
-export interface ServiceDiscoveryOptions {
-  type: 'consul' | 'kubernetes' | 'memory';
-  consulUrl?: string;
-  kubernetesNamespace?: string;
-  healthCheckInterval?: number;
-  tags?: string[];
-}
-
-export class ServiceRegistry {
-  private services = new Map<string, ServiceInfo[]>();
-  private options: ServiceDiscoveryOptions;
-  private healthCheckInterval?: NodeJS.Timeout;
-  private serviceLogger = createFrameworkLogger('SERVICE_DISCOVERY');
-
-  constructor(options: ServiceDiscoveryOptions) {
-    this.options = options;
-    this.startHealthChecks();
-  }
-
-  async register(service: ServiceInfo): Promise<void> {
-    const { name } = service;
-
-    switch (this.options.type) {
-      case 'consul':
-        await this.registerWithConsul(service);
-        break;
-      case 'kubernetes':
-        await this.registerWithKubernetes(service);
-        break;
-      case 'memory':
-        this.registerInMemory(service);
-        break;
-    }
-
-    this.serviceLogger.info(`Service registered: ${name}@${service.host}:${service.port}`);
-  }
-
-  async discover(serviceName: string): Promise<ServiceInfo[]> {
-    switch (this.options.type) {
-      case 'consul':
-        return this.discoverFromConsul(serviceName);
-      case 'kubernetes':
-        return this.discoverFromKubernetes(serviceName);
-      case 'memory':
-        return this.discoverFromMemory(serviceName);
-      default:
-        return [];
-    }
-  }
-
-  async deregister(serviceName: string): Promise<void> {
-    switch (this.options.type) {
-      case 'consul':
-        await this.deregisterFromConsul(serviceName);
-        break;
-      case 'kubernetes':
-        // K8s handles this automatically
-        break;
-      case 'memory':
-        this.services.delete(serviceName);
-        break;
-    }
-
-    this.serviceLogger.info(`Service deregistered: ${serviceName}`);
-  }
-
-  // In-memory registry methods
-  private registerInMemory(service: ServiceInfo): void {
-    const existing = this.services.get(service.name) || [];
-    const updated = existing.filter(s => s.host !== service.host || s.port !== service.port);
-    updated.push(service);
-    this.services.set(service.name, updated);
-  }
-
-  private discoverFromMemory(serviceName: string): ServiceInfo[] {
-    return this.services.get(serviceName) || [];
-  }
-
-  // Consul integration
-  private async registerWithConsul(service: ServiceInfo): Promise<void> {
-    if (!this.options.consulUrl) {
-      throw new Error('Consul URL required for consul service discovery');
-    }
-
-    const consulService = {
-      ID: `${service.name}-${service.host}-${service.port}`,
-      Name: service.name,
-      Tags: service.tags || [],
-      Address: service.host,
-      Port: service.port,
-      Check: service.health
-        ? {
-            HTTP: `http://${service.host}:${service.port}${service.health}`,
-            Interval: '30s',
-            Timeout: '10s',
-          }
-        : undefined,
-      Meta: service.metadata || {},
-    };
-
-    try {
-      const response = await fetch(`${this.options.consulUrl}/v1/agent/service/register`, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(consulService),
-      });
-
-      if (!response.ok) {
-        throw new Error(`Consul registration failed: ${response.statusText}`);
-      }
-    } catch (error) {
-      this.serviceLogger.error('Failed to register with Consul', 'SERVICE_DISCOVERY', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      // Fallback to in-memory
-      this.registerInMemory(service);
-    }
-  }
-
-  private async discoverFromConsul(serviceName: string): Promise<ServiceInfo[]> {
-    if (!this.options.consulUrl) {
-      return this.discoverFromMemory(serviceName);
-    }
-
-    try {
-      const response = await fetch(
-        `${this.options.consulUrl}/v1/health/service/${serviceName}?passing=true`
-      );
-
-      if (!response.ok) {
-        throw new Error(`Consul discovery failed: ${response.statusText}`);
-      }
-
-      const services = (await response.json()) as any[];
-      return services.map((entry: any) => ({
-        name: entry.Service.Service,
-        host: entry.Service.Address,
-        port: entry.Service.Port,
-        tags: entry.Service.Tags,
-        metadata: entry.Service.Meta,
-      }));
-    } catch (error) {
-      this.serviceLogger.error('Failed to discover from Consul', 'SERVICE_DISCOVERY', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return this.discoverFromMemory(serviceName);
-    }
-  }
-
-  private async deregisterFromConsul(serviceName: string): Promise<void> {
-    if (!this.options.consulUrl) return;
-
-    try {
-      await fetch(`${this.options.consulUrl}/v1/agent/service/deregister/${serviceName}`, {
-        method: 'PUT',
-      });
-    } catch (error) {
-      this.serviceLogger.error('Failed to deregister from Consul', 'SERVICE_DISCOVERY', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
-
-  // Kubernetes integration
-  private async registerWithKubernetes(service: ServiceInfo): Promise<void> {
-    // In Kubernetes, services are registered via Service/Endpoints resources
-    // This would typically be handled by the K8s API, not application code
-    this.serviceLogger.info(`K8s service registration: ${service.name} (handled by Kubernetes)`);
-
-    // Fallback to in-memory for local development
-    this.registerInMemory(service);
-  }
-
-  private async discoverFromKubernetes(serviceName: string): Promise<ServiceInfo[]> {
-    // In K8s, we can discover services via DNS or the K8s API
-    const namespace = this.options.kubernetesNamespace || 'default';
-
-    try {
-      // Try K8s service DNS resolution
-      const host = `${serviceName}.${namespace}.svc.cluster.local`;
-
-      // For demo purposes, return the service info
-      // In production, you'd query the K8s API or use DNS
-      return [
-        {
-          name: serviceName,
-          host,
-          port: 80, // Default port, should be discovered from service definition
-          metadata: { discovered: 'kubernetes' },
-        },
-      ];
-    } catch (error) {
-      this.serviceLogger.error('Failed to discover from Kubernetes', 'SERVICE_DISCOVERY', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-      return this.discoverFromMemory(serviceName);
-    }
-  }
-
-  // Health checking
-  private startHealthChecks(): void {
-    if (this.options.healthCheckInterval) {
-      this.healthCheckInterval = setInterval(
-        () => this.performHealthChecks(),
-        this.options.healthCheckInterval
-      );
-    }
-  }
-
-  private async performHealthChecks(): Promise<void> {
-    for (const [serviceName, services] of this.services.entries()) {
-      for (const service of services) {
-        if (service.health) {
-          try {
-            const response = await fetch(
-              `http://${service.host}:${service.port}${service.health}`,
-              {
-                timeout: 5000,
-              } as any
-            );
-
-            if (!response.ok) {
-              this.serviceLogger.warn(
-                `Health check failed for ${serviceName}: ${response.statusText}`
-              );
-              // Remove unhealthy service
-              this.removeUnhealthyService(serviceName, service);
-            }
-          } catch (error) {
-            this.serviceLogger.warn(`Health check failed for ${serviceName}`, 'SERVICE_DISCOVERY', {
-              error: error instanceof Error ? error.message : String(error),
-            });
-            this.removeUnhealthyService(serviceName, service);
-          }
-        }
-      }
-    }
-  }
-
-  private removeUnhealthyService(serviceName: string, unhealthyService: ServiceInfo): void {
-    const services = this.services.get(serviceName) || [];
-    const filtered = services.filter(
-      s => s.host !== unhealthyService.host || s.port !== unhealthyService.port
-    );
-
-    if (filtered.length === 0) {
-      this.services.delete(serviceName);
-    } else {
-      this.services.set(serviceName, filtered);
-    }
-  }
-
-  // Load balancing
-  selectService(
-    serviceName: string,
-    strategy: 'round-robin' | 'random' | 'least-connections' = 'round-robin'
-  ): ServiceInfo | null {
-    const services = this.services.get(serviceName) || [];
-
-    if (services.length === 0) {
-      return null;
-    }
-
-    switch (strategy) {
-      case 'random':
-        return services[Math.floor(Math.random() * services.length)];
-      case 'round-robin':
-        // Simple round-robin (in production, maintain state)
-        return services[Date.now() % services.length];
-      case 'least-connections':
-        // For demo, just return the first (in production, track connections)
-        return services[0];
-      default:
-        return services[0];
-    }
-  }
-
-  // Cleanup
-  destroy(): void {
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval);
-    }
-  }
-
-  // Get all registered services
-  getAllServices(): Record<string, ServiceInfo[]> {
-    return Object.fromEntries(this.services.entries());
-  }
-}

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

@@ -1,217 +0,0 @@
-// WebSocket Adapter Interface for Moro Framework
-// Provides a common interface for different WebSocket implementations
-
-export interface WebSocketAdapterOptions {
-  compression?: boolean;
-  cors?: {
-    origin?: string | string[] | boolean;
-    methods?: string[];
-    credentials?: boolean;
-  };
-  path?: string;
-  maxPayloadLength?: number;
-  idleTimeout?: number;
-  [key: string]: any; // Allow adapter-specific options
-}
-
-/**
- * Abstract WebSocket adapter interface
- * Allows the framework to work with different WebSocket implementations
- */
-export interface WebSocketAdapter {
-  /**
-   * Initialize the WebSocket server with the given HTTP server
-   */
-  initialize(httpServer: any, options?: WebSocketAdapterOptions): Promise<void>;
-
-  /**
-   * Create a namespace for organizing WebSocket connections
-   */
-  createNamespace(namespace: string): WebSocketNamespace;
-
-  /**
-   * Get the default namespace (usually '/')
-   */
-  getDefaultNamespace(): WebSocketNamespace;
-
-  /**
-   * Close the WebSocket server and all connections
-   */
-  close(): Promise<void>;
-
-  /**
-   * Set compression configuration
-   */
-  setCompression(enabled: boolean, options?: any): void;
-
-  /**
-   * Set custom ID generator for connections
-   */
-  setCustomIdGenerator(generator: () => string): void;
-
-  /**
-   * Get adapter name/type
-   */
-  getAdapterName(): string;
-
-  /**
-   * Get connection count across all namespaces
-   */
-  getConnectionCount(): number;
-}
-
-/**
- * WebSocket namespace interface
- * Represents a logical grouping of WebSocket connections
- */
-export interface WebSocketNamespace {
-  /**
-   * Listen for connection events
-   */
-  on(event: 'connection', handler: (socket: WebSocketConnection) => void): void;
-
-  /**
-   * Emit event to all connected sockets in this namespace
-   */
-  emit(event: string, data: any): void;
-
-  /**
-   * Emit to specific room(s)
-   */
-  to(room: string | string[]): WebSocketEmitter;
-
-  /**
-   * Emit to sockets except those in specified room(s)
-   */
-  except(room: string | string[]): WebSocketEmitter;
-
-  /**
-   * Get all connected sockets
-   */
-  getSockets(): WebSocketConnection[];
-
-  /**
-   * Get connection count for this namespace
-   */
-  getConnectionCount(): number;
-
-  /**
-   * Use middleware for this namespace
-   */
-  use(middleware: (socket: WebSocketConnection, next: (err?: Error) => void) => void): void;
-}
-
-/**
- * WebSocket connection interface
- * Represents an individual client connection
- */
-export interface WebSocketConnection {
-  /** Unique connection ID */
-  id: string;
-
-  /** Client IP address */
-  ip?: string;
-
-  /** Connection headers */
-  headers?: Record<string, string>;
-
-  /** Custom data storage */
-  data: Record<string, any>;
-
-  /**
-   * Listen for events from this socket
-   */
-  on(event: string, handler: (data: any, callback?: (response?: any) => void) => void): void;
-
-  /**
-   * Listen for any event from this socket
-   */
-  onAny(handler: (event: string, ...args: any[]) => void): void;
-
-  /**
-   * Emit event to this socket
-   */
-  emit(event: string, data: any): void;
-
-  /**
-   * Emit with compression
-   */
-  compressedEmit?(event: string, data: any): void;
-
-  /**
-   * Join a room
-   */
-  join(room: string | string[]): void;
-
-  /**
-   * Leave a room
-   */
-  leave(room: string | string[]): void;
-
-  /**
-   * Emit to specific room(s)
-   */
-  to(room: string | string[]): WebSocketEmitter;
-
-  /**
-   * Emit to all sockets except this one
-   */
-  broadcast: WebSocketEmitter;
-
-  /**
-   * Get rooms this socket has joined
-   */
-  getRooms(): Set<string>;
-
-  /**
-   * Disconnect this socket
-   */
-  disconnect(close?: boolean): void;
-
-  /**
-   * Check if socket is connected
-   */
-  connected: boolean;
-}
-
-/**
- * WebSocket emitter interface for chaining operations
- */
-export interface WebSocketEmitter {
-  /**
-   * Emit to target sockets
-   */
-  emit(event: string, data: any): void;
-
-  /**
-   * Target specific room(s)
-   */
-  to(room: string | string[]): WebSocketEmitter;
-
-  /**
-   * Exclude specific room(s)
-   */
-  except(room: string | string[]): WebSocketEmitter;
-
-  /**
-   * Use compression for this emit
-   */
-  compress(compress: boolean): WebSocketEmitter;
-}
-
-/**
- * WebSocket middleware function type
- */
-export type WebSocketMiddleware = (
-  socket: WebSocketConnection,
-  next: (err?: Error) => void
-) => void;
-
-/**
- * WebSocket event handler type
- */
-export type WebSocketEventHandler = (
-  socket: WebSocketConnection,
-  data: any,
-  callback?: (response?: any) => void
-) => void | Promise<void>;