@morojs/moro 1.0.0 → 1.0.2

package/src/core/modules/auto-discovery.ts

@@ -1,8 +1,8 @@
 // Auto-discovery system for Moro modules
-import { readdirSync, statSync } from "fs";
-import { join, extname } from "path";
-import { ModuleConfig } from "../../types/module";
-import { DiscoveryOptions } from "../../types/discovery";
+import { readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+import { ModuleConfig } from '../../types/module';
+import { DiscoveryOptions } from '../../types/discovery';
 
 export class ModuleDiscovery {
   private baseDir: string;
@@ -13,7 +13,7 @@ export class ModuleDiscovery {
     this.options = {
       pattern: /\.(module|config)\.(ts|js)$/,
       recursive: true,
-      extensions: [".ts", ".js"],
+      extensions: ['.ts', '.js'],
       ...options,
     };
   }
@@ -29,7 +29,7 @@ export class ModuleDiscovery {
         if (module) {
           modules.push(module);
           console.log(
-            `Auto-discovered module: ${module.name}@${module.version} from ${modulePath}`,
+            `Auto-discovered module: ${module.name}@${module.version} from ${modulePath}`
           );
         }
       } catch (error) {
@@ -41,9 +41,7 @@ export class ModuleDiscovery {
   }
 
   // Find modules by directory structure
-  async discoverModuleDirectories(
-    modulesDir: string = "src/modules",
-  ): Promise<ModuleConfig[]> {
+  async discoverModuleDirectories(modulesDir: string = 'src/modules'): Promise<ModuleConfig[]> {
     const modules: ModuleConfig[] = [];
     const fullPath = join(this.baseDir, modulesDir);
 
@@ -58,21 +56,19 @@ export class ModuleDiscovery {
         const itemPath = join(fullPath, item);
 
         if (statSync(itemPath).isDirectory()) {
-          const indexPath = join(itemPath, "index.ts");
+          const indexPath = join(itemPath, 'index.ts');
 
           try {
             if (statSync(indexPath).isFile()) {
               const module = await this.loadModule(indexPath);
               if (module) {
                 modules.push(module);
-                console.log(
-                  `Auto-discovered module directory: ${module.name} from ${item}/`,
-                );
+                console.log(`Auto-discovered module directory: ${module.name} from ${item}/`);
               }
             }
           } catch {
             // Try alternate patterns
-            const alternates = ["module.ts", `${item}.module.ts`, "config.ts"];
+            const alternates = ['module.ts', `${item}.module.ts`, 'config.ts'];
 
             for (const alt of alternates) {
               const altPath = join(itemPath, alt);
@@ -81,9 +77,7 @@ export class ModuleDiscovery {
                   const module = await this.loadModule(altPath);
                   if (module) {
                     modules.push(module);
-                    console.log(
-                      `Auto-discovered module: ${module.name} from ${item}/${alt}`,
-                    );
+                    console.log(`Auto-discovered module: ${module.name} from ${item}/${alt}`);
                     break;
                   }
                 }
@@ -105,7 +99,7 @@ export class ModuleDiscovery {
   private findModuleFiles(): string[] {
     const files: string[] = [];
     this.scanDirectory(this.baseDir, files);
-    return files.filter((file) => this.options.pattern?.test(file));
+    return files.filter(file => this.options.pattern?.test(file));
   }
 
   // Recursively scan directories for module files
@@ -119,10 +113,7 @@ export class ModuleDiscovery {
 
         if (stat.isDirectory()) {
           // Skip node_modules and other common directories
-          if (
-            !["node_modules", ".git", "dist", "build"].includes(item) &&
-            this.options.recursive
-          ) {
+          if (!['node_modules', '.git', 'dist', 'build'].includes(item) && this.options.recursive) {
             this.scanDirectory(fullPath, files);
           }
         } else if (stat.isFile()) {
@@ -149,8 +140,7 @@ export class ModuleDiscovery {
         module.config,
         module,
         ...Object.values(module).filter(
-          (exp) =>
-            exp && typeof exp === "object" && "name" in exp && "version" in exp,
+          exp => exp && typeof exp === 'object' && 'name' in exp && 'version' in exp
         ),
       ];
 
@@ -170,9 +160,9 @@ export class ModuleDiscovery {
   private isValidModule(obj: any): boolean {
     return (
       obj &&
-      typeof obj === "object" &&
-      typeof obj.name === "string" &&
-      typeof obj.version === "string" &&
+      typeof obj === 'object' &&
+      typeof obj.name === 'string' &&
+      typeof obj.version === 'string' &&
       (obj.routes === undefined || Array.isArray(obj.routes)) &&
       (obj.websockets === undefined || Array.isArray(obj.websockets)) &&
       (obj.services === undefined || Array.isArray(obj.services))
@@ -181,10 +171,10 @@ export class ModuleDiscovery {
 
   // Watch for module changes (for development)
   watchModules(callback: (modules: ModuleConfig[]) => void): void {
-    const fs = require("fs");
+    const fs = require('fs');
     const modulePaths = this.findModuleFiles();
 
-    modulePaths.forEach((path) => {
+    modulePaths.forEach(path => {
       try {
         fs.watchFile(path, async () => {
           console.log(`Module file changed: ${path}`);
@@ -201,7 +191,7 @@ export class ModuleDiscovery {
 // Convenience functions
 export async function autoDiscoverModules(
   baseDir?: string,
-  options?: DiscoveryOptions,
+  options?: DiscoveryOptions
 ): Promise<ModuleConfig[]> {
   const discovery = new ModuleDiscovery(baseDir, options);
   return discovery.discoverModules();
@@ -209,7 +199,7 @@ export async function autoDiscoverModules(
 
 export async function autoDiscoverModuleDirectories(
   baseDir?: string,
-  modulesDir?: string,
+  modulesDir?: string
 ): Promise<ModuleConfig[]> {
   const discovery = new ModuleDiscovery(baseDir);
   return discovery.discoverModuleDirectories(modulesDir);

package/src/core/modules/index.ts

@@ -1,6 +1,3 @@
 // Module System - Centralized Exports
-export { defineModule, ModuleLoader } from "./modules";
-export {
-  ModuleDiscovery,
-  autoDiscoverModuleDirectories,
-} from "./auto-discovery";
+export { defineModule, ModuleLoader } from './modules';
+export { ModuleDiscovery, autoDiscoverModuleDirectories } from './auto-discovery';

package/src/core/modules/modules.ts

@@ -1,13 +1,9 @@
 // Module System - Definition and Loading
-import { promises as fs } from "fs";
-import path from "path";
-import { Container } from "../utilities";
-import { ModuleConfig } from "../../types/module";
-import {
-  ModuleDefinition,
-  ModuleRoute,
-  ModuleSocket,
-} from "../../types/module";
+import { promises as fs } from 'fs';
+import path from 'path';
+import { Container } from '../utilities';
+import { ModuleConfig } from '../../types/module';
+import { ModuleDefinition, ModuleRoute, ModuleSocket } from '../../types/module';
 
 // Module Definition Function
 export function defineModule(definition: ModuleDefinition): ModuleConfig {
@@ -35,7 +31,7 @@ export function defineModule(definition: ModuleDefinition): ModuleConfig {
         acc[`route_handler_${index}`] = route.handler;
         return acc;
       },
-      {} as Record<string, Function>,
+      {} as Record<string, Function>
     );
   }
 
@@ -56,7 +52,7 @@ export function defineModule(definition: ModuleDefinition): ModuleConfig {
         acc[`socket_handler_${index}`] = socket.handler;
         return acc;
       },
-      {} as Record<string, Function>,
+      {} as Record<string, Function>
     );
   }
 
@@ -81,7 +77,7 @@ export class ModuleLoader {
 
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const modulePath = path.join(moduleDir, entry.name, "index.ts");
+          const modulePath = path.join(moduleDir, entry.name, 'index.ts');
 
           try {
             await fs.access(modulePath);
@@ -90,25 +86,20 @@ export class ModuleLoader {
             // Look for exported module config
             for (const exportName of Object.keys(moduleExports)) {
               const exported = moduleExports[exportName];
-              if (
-                exported &&
-                typeof exported === "object" &&
-                exported.name &&
-                exported.version
-              ) {
+              if (exported && typeof exported === 'object' && exported.name && exported.version) {
                 modules.push(exported as ModuleConfig);
               }
             }
           } catch (error) {
             console.warn(
               `⚠️  Could not load module from ${modulePath}:`,
-              error instanceof Error ? error.message : String(error),
+              error instanceof Error ? error.message : String(error)
             );
           }
         }
       }
     } catch (error) {
-      console.error("Failed to discover modules:", error);
+      console.error('Failed to discover modules:', error);
     }
 
     return modules;

package/src/core/networking/index.ts

@@ -1,7 +1,3 @@
 // Networking System - Centralized Exports
-export { WebSocketManager } from "./websocket-manager";
-export {
-  ServiceRegistry,
-  ServiceInfo,
-  ServiceDiscoveryOptions,
-} from "./service-discovery";
+export { WebSocketManager } from './websocket-manager';
+export { ServiceRegistry, ServiceInfo, ServiceDiscoveryOptions } from './service-discovery';

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

@@ -12,7 +12,7 @@ export interface ServiceInfo {
 }
 
 export interface ServiceDiscoveryOptions {
-  type: "consul" | "kubernetes" | "memory";
+  type: 'consul' | 'kubernetes' | 'memory';
   consulUrl?: string;
   kubernetesNamespace?: string;
   healthCheckInterval?: number;
@@ -33,13 +33,13 @@ export class ServiceRegistry {
     const { name } = service;
 
     switch (this.options.type) {
-      case "consul":
+      case 'consul':
         await this.registerWithConsul(service);
         break;
-      case "kubernetes":
+      case 'kubernetes':
         await this.registerWithKubernetes(service);
         break;
-      case "memory":
+      case 'memory':
         this.registerInMemory(service);
         break;
     }
@@ -49,11 +49,11 @@ export class ServiceRegistry {
 
   async discover(serviceName: string): Promise<ServiceInfo[]> {
     switch (this.options.type) {
-      case "consul":
+      case 'consul':
         return this.discoverFromConsul(serviceName);
-      case "kubernetes":
+      case 'kubernetes':
         return this.discoverFromKubernetes(serviceName);
-      case "memory":
+      case 'memory':
         return this.discoverFromMemory(serviceName);
       default:
         return [];
@@ -62,13 +62,13 @@ export class ServiceRegistry {
 
   async deregister(serviceName: string): Promise<void> {
     switch (this.options.type) {
-      case "consul":
+      case 'consul':
         await this.deregisterFromConsul(serviceName);
         break;
-      case "kubernetes":
+      case 'kubernetes':
         // K8s handles this automatically
         break;
-      case "memory":
+      case 'memory':
         this.services.delete(serviceName);
         break;
     }
@@ -79,9 +79,7 @@ export class ServiceRegistry {
   // 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,
-    );
+    const updated = existing.filter(s => s.host !== service.host || s.port !== service.port);
     updated.push(service);
     this.services.set(service.name, updated);
   }
@@ -93,7 +91,7 @@ export class ServiceRegistry {
   // Consul integration
   private async registerWithConsul(service: ServiceInfo): Promise<void> {
     if (!this.options.consulUrl) {
-      throw new Error("Consul URL required for consul service discovery");
+      throw new Error('Consul URL required for consul service discovery');
     }
 
     const consulService = {
@@ -105,43 +103,38 @@ export class ServiceRegistry {
       Check: service.health
         ? {
             HTTP: `http://${service.host}:${service.port}${service.health}`,
-            Interval: "30s",
-            Timeout: "10s",
+            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),
-        },
-      );
+      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);
+      console.error('Failed to register with Consul:', error);
       // Fallback to in-memory
       this.registerInMemory(service);
     }
   }
 
-  private async discoverFromConsul(
-    serviceName: string,
-  ): Promise<ServiceInfo[]> {
+  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`,
+        `${this.options.consulUrl}/v1/health/service/${serviceName}?passing=true`
       );
 
       if (!response.ok) {
@@ -157,7 +150,7 @@ export class ServiceRegistry {
         metadata: entry.Service.Meta,
       }));
     } catch (error) {
-      console.error("Failed to discover from Consul:", error);
+      console.error('Failed to discover from Consul:', error);
       return this.discoverFromMemory(serviceName);
     }
   }
@@ -166,14 +159,11 @@ export class ServiceRegistry {
     if (!this.options.consulUrl) return;
 
     try {
-      await fetch(
-        `${this.options.consulUrl}/v1/agent/service/deregister/${serviceName}`,
-        {
-          method: "PUT",
-        },
-      );
+      await fetch(`${this.options.consulUrl}/v1/agent/service/deregister/${serviceName}`, {
+        method: 'PUT',
+      });
     } catch (error) {
-      console.error("Failed to deregister from Consul:", error);
+      console.error('Failed to deregister from Consul:', error);
     }
   }
 
@@ -181,19 +171,15 @@ export class ServiceRegistry {
   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)`,
-    );
+    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[]> {
+  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";
+    const namespace = this.options.kubernetesNamespace || 'default';
 
     try {
       // Try K8s service DNS resolution
@@ -206,11 +192,11 @@ export class ServiceRegistry {
           name: serviceName,
           host,
           port: 80, // Default port, should be discovered from service definition
-          metadata: { discovered: "kubernetes" },
+          metadata: { discovered: 'kubernetes' },
         },
       ];
     } catch (error) {
-      console.error("Failed to discover from Kubernetes:", error);
+      console.error('Failed to discover from Kubernetes:', error);
       return this.discoverFromMemory(serviceName);
     }
   }
@@ -220,7 +206,7 @@ export class ServiceRegistry {
     if (this.options.healthCheckInterval) {
       this.healthCheckInterval = setInterval(
         () => this.performHealthChecks(),
-        this.options.healthCheckInterval,
+        this.options.healthCheckInterval
       );
     }
   }
@@ -234,13 +220,11 @@ export class ServiceRegistry {
               `http://${service.host}:${service.port}${service.health}`,
               {
                 timeout: 5000,
-              } as any,
+              } as any
             );
 
             if (!response.ok) {
-              console.warn(
-                `Health check failed for ${serviceName}: ${response.statusText}`,
-              );
+              console.warn(`Health check failed for ${serviceName}: ${response.statusText}`);
               // Remove unhealthy service
               this.removeUnhealthyService(serviceName, service);
             }
@@ -253,14 +237,10 @@ export class ServiceRegistry {
     }
   }
 
-  private removeUnhealthyService(
-    serviceName: string,
-    unhealthyService: ServiceInfo,
-  ): void {
+  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,
+      s => s.host !== unhealthyService.host || s.port !== unhealthyService.port
     );
 
     if (filtered.length === 0) {
@@ -273,7 +253,7 @@ export class ServiceRegistry {
   // Load balancing
   selectService(
     serviceName: string,
-    strategy: "round-robin" | "random" | "least-connections" = "round-robin",
+    strategy: 'round-robin' | 'random' | 'least-connections' = 'round-robin'
   ): ServiceInfo | null {
     const services = this.services.get(serviceName) || [];
 
@@ -282,12 +262,12 @@ export class ServiceRegistry {
     }
 
     switch (strategy) {
-      case "random":
+      case 'random':
         return services[Math.floor(Math.random() * services.length)];
-      case "round-robin":
+      case 'round-robin':
         // Simple round-robin (in production, maintain state)
         return services[Date.now() % services.length];
-      case "least-connections":
+      case 'least-connections':
         // For demo, just return the first (in production, track connections)
         return services[0];
       default:

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

@@ -1,21 +1,18 @@
 // 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";
+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 rateLimiters = new Map<string, Map<string, { count: number; resetTime: number }>>();
   private compressionEnabled = true;
   private customIdGenerator?: () => string;
 
   constructor(
     private io: SocketIOServer,
-    private container: Container,
+    private container: Container
   ) {
     this.setupAdvancedFeatures();
   }
@@ -60,7 +57,7 @@ export class WebSocketManager {
 
       // Add heartbeat mechanism
       (socket as any).heartbeat = () => {
-        socket.emit("heartbeat", { timestamp: Date.now() });
+        socket.emit('heartbeat', { timestamp: Date.now() });
       };
 
       next();
@@ -102,9 +99,9 @@ export class WebSocketManager {
   async registerHandler(
     namespace: Namespace,
     wsConfig: WebSocketDefinition,
-    moduleConfig: ModuleConfig,
+    moduleConfig: ModuleConfig
   ): Promise<void> {
-    namespace.on("connection", (socket: Socket) => {
+    namespace.on('connection', (socket: Socket) => {
       console.log(`WebSocket connected to /${moduleConfig.name}: ${socket.id}`);
       this.setupSocketHandlers(socket, wsConfig, moduleConfig);
       this.setupSocketMiddleware(socket, moduleConfig.name);
@@ -114,24 +111,21 @@ export class WebSocketManager {
   private setupSocketHandlers(
     socket: Socket,
     wsConfig: WebSocketDefinition,
-    moduleConfig: ModuleConfig,
+    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)
-        ) {
+        if (wsConfig.rateLimit && !this.checkRateLimit(socket.id, handlerKey, wsConfig.rateLimit)) {
           const error = {
             success: false,
-            error: "Rate limit exceeded",
-            code: "RATE_LIMIT",
+            error: 'Rate limit exceeded',
+            code: 'RATE_LIMIT',
           };
           if (callback) callback(error);
-          else socket.emit("error", error);
+          else socket.emit('error', error);
           return;
         }
 
@@ -143,15 +137,15 @@ export class WebSocketManager {
             if (validationError.issues) {
               const error = {
                 success: false,
-                error: "Validation failed",
+                error: 'Validation failed',
                 details: validationError.issues.map((issue: any) => ({
-                  field: issue.path.length > 0 ? issue.path.join(".") : "data",
+                  field: issue.path.length > 0 ? issue.path.join('.') : 'data',
                   message: issue.message,
                   code: issue.code,
                 })),
               };
               if (callback) callback(error);
-              else socket.emit("error", error);
+              else socket.emit('error', error);
               return;
             }
             throw validationError;
@@ -175,9 +169,8 @@ export class WebSocketManager {
           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";
+        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 = {
@@ -189,29 +182,27 @@ export class WebSocketManager {
         if (callback) {
           callback(errorResponse);
         } else {
-          socket.emit("error", errorResponse);
+          socket.emit('error', errorResponse);
         }
       }
     });
   }
 
   private setupSocketMiddleware(socket: Socket, moduleName: string): void {
-    socket.on("disconnect", (reason) => {
-      console.log(
-        `WebSocket disconnected from /${moduleName}: ${socket.id} (${reason})`,
-      );
+    socket.on('disconnect', reason => {
+      console.log(`WebSocket disconnected from /${moduleName}: ${socket.id} (${reason})`);
       this.cleanup(socket.id);
     });
 
-    socket.on("ping", () => {
-      socket.emit("pong");
+    socket.on('ping', () => {
+      socket.emit('pong');
     });
   }
 
   private checkRateLimit(
     socketId: string,
     handlerKey: string,
-    rateLimit: { requests: number; window: number },
+    rateLimit: { requests: number; window: number }
   ): boolean {
     if (!this.rateLimiters.has(handlerKey)) {
       this.rateLimiters.set(handlerKey, new Map());
@@ -245,14 +236,14 @@ export class WebSocketManager {
           failureThreshold: 5,
           resetTimeout: 30000,
           monitoringPeriod: 10000,
-        }),
+        })
       );
     }
     return this.circuitBreakers.get(key)!;
   }
 
   private cleanup(socketId: string): void {
-    this.rateLimiters.forEach((limiter) => {
+    this.rateLimiters.forEach(limiter => {
       limiter.delete(socketId);
     });
   }