@morojs/moro 1.0.0

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

@@ -0,0 +1,309 @@
+// Service Discovery Client for Microservices
+// Supports Consul, Kubernetes, and in-memory registry
+
+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;
+
+  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;
+    }
+
+    console.log(`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;
+    }
+
+    console.log(`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) {
+      console.error("Failed to register with Consul:", 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) {
+      console.error("Failed to discover from Consul:", 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) {
+      console.error("Failed to deregister from Consul:", 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
+    console.log(
+      `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) {
+      console.error("Failed to discover from Kubernetes:", 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) {
+              console.warn(
+                `Health check failed for ${serviceName}: ${response.statusText}`,
+              );
+              // Remove unhealthy service
+              this.removeUnhealthyService(serviceName, service);
+            }
+          } catch (error) {
+            console.warn(`Health check failed for ${serviceName}:`, 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-manager.ts

@@ -0,0 +1,259 @@
+// src/core/websocket-manager.ts
+import { Server as SocketIOServer, Socket, Namespace } from "socket.io";
+import { Container } from "../utilities";
+import { CircuitBreaker } from "../utilities";
+import { ModuleConfig, WebSocketDefinition } from "../../types/module";
+
+export class WebSocketManager {
+  private circuitBreakers = new Map<string, CircuitBreaker>();
+  private rateLimiters = new Map<
+    string,
+    Map<string, { count: number; resetTime: number }>
+  >();
+  private compressionEnabled = true;
+  private customIdGenerator?: () => string;
+
+  constructor(
+    private io: SocketIOServer,
+    private container: Container,
+  ) {
+    this.setupAdvancedFeatures();
+  }
+
+  private setupAdvancedFeatures() {
+    // Enable compression for WebSocket messages
+    if (this.compressionEnabled) {
+      (this.io.engine as any).compression = true;
+      (this.io.engine as any).perMessageDeflate = {
+        threshold: 1024,
+        concurrencyLimit: 10,
+        memLevel: 8,
+      };
+    }
+
+    // Custom session ID generation if provided
+    if (this.customIdGenerator) {
+      (this.io.engine as any).generateId = this.customIdGenerator;
+    }
+
+    // Global WebSocket middleware for advanced features
+    this.io.use((socket, next) => {
+      // Add binary message handling
+      socket.onAny((event, ...args) => {
+        // Handle binary frames efficiently
+        args.forEach((arg, index) => {
+          if (Buffer.isBuffer(arg)) {
+            // Process binary data with optimizations
+            args[index] = this.processBinaryData(arg);
+          }
+        });
+      });
+
+      // Add compression per message
+      (socket as any).compressedEmit = (event: string, data: any) => {
+        if (this.compressionEnabled && this.shouldCompress(data)) {
+          socket.compress(true).emit(event, data);
+        } else {
+          socket.emit(event, data);
+        }
+      };
+
+      // Add heartbeat mechanism
+      (socket as any).heartbeat = () => {
+        socket.emit("heartbeat", { timestamp: Date.now() });
+      };
+
+      next();
+    });
+  }
+
+  setCustomIdGenerator(generator: () => string) {
+    this.customIdGenerator = generator;
+    (this.io.engine as any).generateId = generator;
+  }
+
+  enableCompression(options?: {
+    threshold?: number;
+    concurrencyLimit?: number;
+    memLevel?: number;
+  }) {
+    this.compressionEnabled = true;
+    if (options) {
+      (this.io.engine as any).perMessageDeflate = {
+        threshold: options.threshold || 1024,
+        concurrencyLimit: options.concurrencyLimit || 10,
+        memLevel: options.memLevel || 8,
+      };
+    }
+  }
+
+  private processBinaryData(buffer: Buffer): Buffer {
+    // Optimize binary data processing
+    // Could add compression, validation, etc.
+    return buffer;
+  }
+
+  private shouldCompress(data: any): boolean {
+    // Determine if data should be compressed
+    const serialized = JSON.stringify(data);
+    return serialized.length > 1024; // Compress if larger than 1KB
+  }
+
+  async registerHandler(
+    namespace: Namespace,
+    wsConfig: WebSocketDefinition,
+    moduleConfig: ModuleConfig,
+  ): Promise<void> {
+    namespace.on("connection", (socket: Socket) => {
+      console.log(`WebSocket connected to /${moduleConfig.name}: ${socket.id}`);
+      this.setupSocketHandlers(socket, wsConfig, moduleConfig);
+      this.setupSocketMiddleware(socket, moduleConfig.name);
+    });
+  }
+
+  private setupSocketHandlers(
+    socket: Socket,
+    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;
+        }
+
+        // Validation (Zod-only)
+        if (wsConfig.validation) {
+          try {
+            data = wsConfig.validation.parse(data);
+          } catch (validationError: any) {
+            if (validationError.issues) {
+              const error = {
+                success: false,
+                error: "Validation failed",
+                details: validationError.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;
+            }
+            throw validationError;
+          }
+        }
+
+        // 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 (wsConfig.broadcast && result?.event) {
+          socket.broadcast.emit(result.event, result.data);
+        } else if (result) {
+          socket.emit(`${wsConfig.event}:response`, result);
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        const errorCode = (error as any)?.code || "INTERNAL_ERROR";
+        console.error(`WebSocket error in ${handlerKey}:`, errorMessage);
+
+        const errorResponse = {
+          success: false,
+          error: errorMessage,
+          code: errorCode,
+        };
+
+        if (callback) {
+          callback(errorResponse);
+        } else {
+          socket.emit("error", errorResponse);
+        }
+      }
+    });
+  }
+
+  private setupSocketMiddleware(socket: Socket, moduleName: string): void {
+    socket.on("disconnect", (reason) => {
+      console.log(
+        `WebSocket disconnected from /${moduleName}: ${socket.id} (${reason})`,
+      );
+      this.cleanup(socket.id);
+    });
+
+    socket.on("ping", () => {
+      socket.emit("pong");
+    });
+  }
+
+  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 socketLimit = handlerLimiter.get(socketId);
+
+    if (!socketLimit || now > socketLimit.resetTime) {
+      handlerLimiter.set(socketId, {
+        count: 1,
+        resetTime: now + rateLimit.window,
+      });
+      return true;
+    }
+
+    if (socketLimit.count >= rateLimit.requests) {
+      return false;
+    }
+
+    socketLimit.count++;
+    return true;
+  }
+
+  private getCircuitBreaker(key: string): CircuitBreaker {
+    if (!this.circuitBreakers.has(key)) {
+      this.circuitBreakers.set(
+        key,
+        new CircuitBreaker({
+          failureThreshold: 5,
+          resetTimeout: 30000,
+          monitoringPeriod: 10000,
+        }),
+      );
+    }
+    return this.circuitBreakers.get(key)!;
+  }
+
+  private cleanup(socketId: string): void {
+    this.rateLimiters.forEach((limiter) => {
+      limiter.delete(socketId);
+    });
+  }
+}