@morojs/moro 1.6.1 → 1.6.3

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

@@ -1,263 +0,0 @@
-// 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 { logger, createFrameworkLogger } from '../logger';
-
-export class ModuleDiscovery {
-  private baseDir: string;
-  private options: DiscoveryOptions;
-  private discoveryLogger = createFrameworkLogger('MODULE_DISCOVERY');
-
-  constructor(baseDir: string = process.cwd(), options: DiscoveryOptions = {}) {
-    this.baseDir = baseDir;
-    this.options = {
-      pattern: /\.(module|config)\.(ts|js)$/,
-      recursive: true,
-      extensions: ['.ts', '.js'],
-      ...options,
-    };
-  }
-
-  // Auto-discover modules in the filesystem
-  async discoverModules(): Promise<ModuleConfig[]> {
-    const modules: ModuleConfig[] = [];
-    const modulePaths = this.findModuleFiles();
-
-    for (const modulePath of modulePaths) {
-      try {
-        const module = await this.loadModule(modulePath);
-        if (module) {
-          modules.push(module);
-          this.discoveryLogger.info(
-            `Auto-discovered module: ${module.name}@${module.version} from ${modulePath}`
-          );
-        }
-      } catch (error) {
-        this.discoveryLogger.warn(`Failed to load module from ${modulePath}:`, 'ModuleDiscovery', {
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    }
-
-    return modules;
-  }
-
-  // Find modules by directory structure
-  async discoverModuleDirectories(modulesDir: string = 'src/modules'): Promise<ModuleConfig[]> {
-    const modules: ModuleConfig[] = [];
-    const fullPath = join(this.baseDir, modulesDir);
-
-    try {
-      if (!statSync(fullPath).isDirectory()) {
-        return modules;
-      }
-
-      const items = readdirSync(fullPath);
-
-      for (const item of items) {
-        const itemPath = join(fullPath, item);
-
-        if (statSync(itemPath).isDirectory()) {
-          const indexPath = join(itemPath, 'index.ts');
-
-          try {
-            if (statSync(indexPath).isFile()) {
-              const module = await this.loadModule(indexPath);
-              if (module) {
-                modules.push(module);
-                this.discoveryLogger.info(
-                  `Auto-discovered module directory: ${module.name} from ${item}/`
-                );
-              }
-            }
-          } catch {
-            // Try alternate patterns
-            const alternates = ['module.ts', `${item}.module.ts`, 'config.ts'];
-
-            for (const alt of alternates) {
-              const altPath = join(itemPath, alt);
-              try {
-                if (statSync(altPath).isFile()) {
-                  const module = await this.loadModule(altPath);
-                  if (module) {
-                    modules.push(module);
-                    this.discoveryLogger.info(
-                      `Auto-discovered module: ${module.name} from ${item}/${alt}`
-                    );
-                    break;
-                  }
-                }
-              } catch {
-                // Continue trying
-              }
-            }
-          }
-        }
-      }
-    } catch {
-      // Directory doesn't exist, that's fine
-    }
-
-    return modules;
-  }
-
-  // Find all module files matching the pattern
-  private findModuleFiles(): string[] {
-    const files: string[] = [];
-    this.scanDirectory(this.baseDir, files);
-    return files.filter(file => this.options.pattern?.test(file));
-  }
-
-  // Recursively scan directories for module files
-  private scanDirectory(dir: string, files: string[]): void {
-    try {
-      const items = readdirSync(dir);
-
-      for (const item of items) {
-        const fullPath = join(dir, item);
-        const stat = statSync(fullPath);
-
-        if (stat.isDirectory()) {
-          // Skip node_modules and other common directories
-          if (!['node_modules', '.git', 'dist', 'build'].includes(item) && this.options.recursive) {
-            this.scanDirectory(fullPath, files);
-          }
-        } else if (stat.isFile()) {
-          const ext = extname(item);
-          if (this.options.extensions?.includes(ext)) {
-            files.push(fullPath);
-          }
-        }
-      }
-    } catch {
-      // Directory not accessible, skip
-    }
-  }
-
-  // Load a module from a file path
-  private async loadModule(modulePath: string): Promise<ModuleConfig | null> {
-    try {
-      const module = await import(modulePath);
-
-      // Try different export patterns
-      const candidates = [
-        module.default,
-        module.module,
-        module.config,
-        module,
-        ...Object.values(module).filter(
-          exp => exp && typeof exp === 'object' && 'name' in exp && 'version' in exp
-        ),
-      ];
-
-      for (const candidate of candidates) {
-        if (this.isValidModule(candidate)) {
-          return candidate as ModuleConfig;
-        }
-      }
-
-      return null;
-    } catch (error) {
-      throw new Error(`Failed to import module: ${(error as Error).message}`);
-    }
-  }
-
-  // Validate that an object is a valid ModuleConfig
-  private isValidModule(obj: any): boolean {
-    return (
-      obj &&
-      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))
-    );
-  }
-
-  // Watch for module changes (for development)
-  watchModules(callback: (modules: ModuleConfig[]) => void): void {
-    const fs = require('fs');
-    const modulePaths = this.findModuleFiles();
-
-    modulePaths.forEach(path => {
-      try {
-        fs.watchFile(path, async () => {
-          this.discoveryLogger.info(`Module file changed: ${path}`);
-          const modules = await this.discoverModules();
-          callback(modules);
-        });
-      } catch {
-        // File watching not supported or failed
-      }
-    });
-  }
-}
-
-// Convenience functions
-export async function autoDiscoverModules(
-  baseDir?: string,
-  options?: DiscoveryOptions
-): Promise<ModuleConfig[]> {
-  const discovery = new ModuleDiscovery(baseDir, options);
-  return discovery.discoverModules();
-}
-
-export async function autoDiscoverModuleDirectories(
-  baseDir?: string,
-  modulesDir?: string
-): Promise<ModuleConfig[]> {
-  const discovery = new ModuleDiscovery(baseDir);
-  return discovery.discoverModuleDirectories(modulesDir);
-}
-
-// Module registry for tracking loaded modules
-export class ModuleRegistry {
-  private modules = new Map<string, ModuleConfig>();
-  private loadedModules = new Set<string>();
-
-  register(module: ModuleConfig): void {
-    const key = `${module.name}@${module.version}`;
-    this.modules.set(key, module);
-  }
-
-  markLoaded(moduleName: string, version: string): void {
-    const key = `${moduleName}@${version}`;
-    this.loadedModules.add(key);
-  }
-
-  isLoaded(moduleName: string, version: string): boolean {
-    const key = `${moduleName}@${version}`;
-    return this.loadedModules.has(key);
-  }
-
-  getModule(moduleName: string, version?: string): ModuleConfig | undefined {
-    if (version) {
-      return this.modules.get(`${moduleName}@${version}`);
-    }
-
-    // Find latest version if no version specified
-    const modules = Array.from(this.modules.entries())
-      .filter(([key]) => key.startsWith(`${moduleName}@`))
-      .sort(([a], [b]) => b.localeCompare(a)); // Sort by version desc
-
-    return modules[0]?.[1];
-  }
-
-  getAllModules(): ModuleConfig[] {
-    return Array.from(this.modules.values());
-  }
-
-  getLoadedModules(): ModuleConfig[] {
-    return Array.from(this.modules.entries())
-      .filter(([key]) => this.loadedModules.has(key))
-      .map(([, module]) => module);
-  }
-
-  clear(): void {
-    this.modules.clear();
-    this.loadedModules.clear();
-  }
-}

package/src/core/modules/index.ts

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

package/src/core/modules/modules.ts

@@ -1,124 +0,0 @@
-// 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 { logger, createFrameworkLogger } from '../logger';
-
-// Module Definition Function
-export function defineModule(definition: ModuleDefinition): ModuleConfig {
-  const moduleConfig: ModuleConfig = {
-    name: definition.name,
-    version: definition.version,
-    dependencies: definition.dependencies,
-  };
-
-  // Store route definitions and handlers
-  if (definition.routes) {
-    moduleConfig.routes = definition.routes.map((route, index) => ({
-      method: route.method,
-      path: route.path,
-      handler: `route_handler_${index}`, // Standardized naming
-      validation: route.validation,
-      cache: route.cache,
-      rateLimit: route.rateLimit,
-      middleware: route.middleware,
-    }));
-
-    // Store the actual route handler functions
-    moduleConfig.routeHandlers = definition.routes.reduce(
-      (acc, route, index) => {
-        acc[`route_handler_${index}`] = route.handler;
-        return acc;
-      },
-      {} as Record<string, Function>
-    );
-  }
-
-  // Store socket definitions and handlers
-  if (definition.sockets) {
-    moduleConfig.sockets = definition.sockets.map((socket, index) => ({
-      event: socket.event,
-      handler: `socket_handler_${index}`, // Standardized naming
-      validation: socket.validation,
-      rateLimit: socket.rateLimit,
-      rooms: socket.rooms,
-      broadcast: socket.broadcast,
-    }));
-
-    // Store the actual socket handler functions
-    moduleConfig.socketHandlers = definition.sockets.reduce(
-      (acc, socket, index) => {
-        acc[`socket_handler_${index}`] = socket.handler;
-        return acc;
-      },
-      {} as Record<string, Function>
-    );
-  }
-
-  // Copy config
-  if (definition.config) {
-    moduleConfig.config = definition.config;
-  }
-
-  return moduleConfig;
-}
-
-// Module Loader Class
-export class ModuleLoader {
-  private moduleLogger = createFrameworkLogger('MODULE_LOADER');
-
-  constructor(private container: Container) {}
-
-  async discoverModules(directory: string): Promise<ModuleConfig[]> {
-    const modules: ModuleConfig[] = [];
-
-    try {
-      const moduleDir = path.resolve(directory);
-      const entries = await fs.readdir(moduleDir, { withFileTypes: true });
-
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          const modulePath = path.join(moduleDir, entry.name, 'index.ts');
-
-          try {
-            await fs.access(modulePath);
-            const moduleExports = await import(modulePath);
-
-            // 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) {
-                modules.push(exported as ModuleConfig);
-              }
-            }
-          } catch (error) {
-            this.moduleLogger.warn(
-              `⚠️  Could not load module from ${modulePath}:`,
-              'ModuleLoader',
-              {
-                error: error instanceof Error ? error.message : String(error),
-              }
-            );
-          }
-        }
-      }
-    } catch (error) {
-      this.moduleLogger.error('Failed to discover modules:', 'ModuleLoader', {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-
-    return modules;
-  }
-
-  validateModule(config: ModuleConfig): boolean {
-    if (!config.name || !config.version) {
-      return false;
-    }
-
-    // [TODO] Add more validation logic here
-    return true;
-  }
-}

package/src/core/networking/adapters/index.ts

@@ -1,16 +0,0 @@
-// WebSocket Adapters for Moro Framework
-// Export all available adapters from this centralized location
-
-export { SocketIOAdapter } from './socketio-adapter';
-export { WSAdapter } from './ws-adapter';
-
-// Re-export the adapter interface for convenience
-export type {
-  WebSocketAdapter,
-  WebSocketAdapterOptions,
-  WebSocketNamespace,
-  WebSocketConnection,
-  WebSocketEmitter,
-  WebSocketMiddleware,
-  WebSocketEventHandler,
-} from '../websocket-adapter';

package/src/core/networking/adapters/socketio-adapter.ts

@@ -1,252 +0,0 @@
-// Socket.IO WebSocket Adapter for Moro Framework
-// Implements the WebSocket adapter interface using Socket.IO
-
-import {
-  WebSocketAdapter,
-  WebSocketAdapterOptions,
-  WebSocketNamespace,
-  WebSocketConnection,
-  WebSocketEmitter,
-  WebSocketMiddleware,
-} from '../websocket-adapter';
-
-/**
- * Socket.IO adapter implementation
- */
-export class SocketIOAdapter implements WebSocketAdapter {
-  private io: any; // Socket.IO server instance
-  private customIdGenerator?: () => string;
-
-  async initialize(httpServer: any, options: WebSocketAdapterOptions = {}): Promise<void> {
-    try {
-      // Dynamic import to avoid requiring socket.io as a hard dependency
-      const { Server } = await import('socket.io');
-
-      this.io = new Server(httpServer, {
-        cors: options.cors || { origin: '*' },
-        path: options.path || '/socket.io/',
-        compression: options.compression !== false,
-        maxHttpBufferSize: options.maxPayloadLength,
-        ...options,
-      });
-
-      // Apply custom ID generator if set
-      if (this.customIdGenerator) {
-        (this.io.engine as any).generateId = this.customIdGenerator;
-      }
-
-      // Setup compression if enabled
-      if (options.compression) {
-        this.setCompression(true);
-      }
-    } catch (error) {
-      throw new Error(
-        'Socket.IO not found. Install it with: npm install socket.io\n' +
-          'Or use a different WebSocket adapter.'
-      );
-    }
-  }
-
-  createNamespace(namespace: string): WebSocketNamespace {
-    if (!this.io) {
-      throw new Error('Socket.IO adapter not initialized');
-    }
-
-    const ns = this.io.of(namespace);
-    return new SocketIONamespaceWrapper(ns);
-  }
-
-  getDefaultNamespace(): WebSocketNamespace {
-    return this.createNamespace('/');
-  }
-
-  async close(): Promise<void> {
-    if (this.io) {
-      return new Promise(resolve => {
-        this.io.close(() => resolve());
-      });
-    }
-  }
-
-  setCompression(enabled: boolean, options: any = {}): void {
-    if (this.io && enabled) {
-      (this.io.engine as any).compression = true;
-      (this.io.engine as any).perMessageDeflate = {
-        threshold: 1024,
-        concurrencyLimit: 10,
-        memLevel: 8,
-        ...options,
-      };
-    }
-  }
-
-  setCustomIdGenerator(generator: () => string): void {
-    this.customIdGenerator = generator;
-    if (this.io) {
-      (this.io.engine as any).generateId = generator;
-    }
-  }
-
-  getAdapterName(): string {
-    return 'socket.io';
-  }
-
-  getConnectionCount(): number {
-    if (!this.io) return 0;
-    return this.io.engine.clientsCount || 0;
-  }
-}
-
-/**
- * Socket.IO namespace wrapper
- */
-class SocketIONamespaceWrapper implements WebSocketNamespace {
-  constructor(private namespace: any) {}
-
-  on(event: 'connection', handler: (socket: WebSocketConnection) => void): void {
-    this.namespace.on(event, (socket: any) => {
-      handler(new SocketIOConnectionWrapper(socket));
-    });
-  }
-
-  emit(event: string, data: any): void {
-    this.namespace.emit(event, data);
-  }
-
-  to(room: string | string[]): WebSocketEmitter {
-    const target = Array.isArray(room)
-      ? room.reduce((acc, r) => acc.to(r), this.namespace)
-      : this.namespace.to(room);
-    return new SocketIOEmitterWrapper(target);
-  }
-
-  except(room: string | string[]): WebSocketEmitter {
-    const target = Array.isArray(room)
-      ? room.reduce((acc, r) => acc.except(r), this.namespace)
-      : this.namespace.except(room);
-    return new SocketIOEmitterWrapper(target);
-  }
-
-  getSockets(): WebSocketConnection[] {
-    const sockets = this.namespace.sockets;
-    return Array.from(sockets.values()).map((socket: any) => new SocketIOConnectionWrapper(socket));
-  }
-
-  getConnectionCount(): number {
-    return this.namespace.sockets.size;
-  }
-
-  use(middleware: WebSocketMiddleware): void {
-    this.namespace.use((socket: any, next: any) => {
-      middleware(new SocketIOConnectionWrapper(socket), next);
-    });
-  }
-}
-
-/**
- * Socket.IO connection wrapper
- */
-class SocketIOConnectionWrapper implements WebSocketConnection {
-  public data: Record<string, any> = {};
-
-  constructor(private socket: any) {
-    // Map socket.data to our data property
-    this.data = socket.data || {};
-  }
-
-  get id(): string {
-    return this.socket.id;
-  }
-
-  get ip(): string | undefined {
-    return this.socket.handshake?.address;
-  }
-
-  get headers(): Record<string, string> | undefined {
-    return this.socket.handshake?.headers;
-  }
-
-  get connected(): boolean {
-    return this.socket.connected;
-  }
-
-  get broadcast(): WebSocketEmitter {
-    return new SocketIOEmitterWrapper(this.socket.broadcast);
-  }
-
-  on(event: string, handler: (data: any, callback?: (response?: any) => void) => void): void {
-    this.socket.on(event, handler);
-  }
-
-  onAny(handler: (event: string, ...args: any[]) => void): void {
-    this.socket.onAny(handler);
-  }
-
-  emit(event: string, data: any): void {
-    this.socket.emit(event, data);
-  }
-
-  compressedEmit(event: string, data: any): void {
-    this.socket.compress(true).emit(event, data);
-  }
-
-  join(room: string | string[]): void {
-    if (Array.isArray(room)) {
-      room.forEach(r => this.socket.join(r));
-    } else {
-      this.socket.join(room);
-    }
-  }
-
-  leave(room: string | string[]): void {
-    if (Array.isArray(room)) {
-      room.forEach(r => this.socket.leave(r));
-    } else {
-      this.socket.leave(room);
-    }
-  }
-
-  to(room: string | string[]): WebSocketEmitter {
-    const target = Array.isArray(room)
-      ? room.reduce((acc, r) => acc.to(r), this.socket)
-      : this.socket.to(room);
-    return new SocketIOEmitterWrapper(target);
-  }
-
-  getRooms(): Set<string> {
-    return new Set(this.socket.rooms);
-  }
-
-  disconnect(close?: boolean): void {
-    this.socket.disconnect(close);
-  }
-}
-
-/**
- * Socket.IO emitter wrapper
- */
-class SocketIOEmitterWrapper implements WebSocketEmitter {
-  constructor(private emitter: any) {}
-
-  emit(event: string, data: any): void {
-    this.emitter.emit(event, data);
-  }
-
-  to(room: string | string[]): WebSocketEmitter {
-    const target = Array.isArray(room)
-      ? room.reduce((acc, r) => acc.to(r), this.emitter)
-      : this.emitter.to(room);
-    return new SocketIOEmitterWrapper(target);
-  }
-
-  except(room: string | string[]): WebSocketEmitter {
-    const target = Array.isArray(room)
-      ? room.reduce((acc, r) => acc.except(r), this.emitter)
-      : this.emitter.except(room);
-    return new SocketIOEmitterWrapper(target);
-  }
-
-  compress(compress: boolean): WebSocketEmitter {
-    return new SocketIOEmitterWrapper(this.emitter.compress(compress));
-  }
-}