@morojs/moro 1.6.2 → 1.6.3

package/src/core/modules/index.ts

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

package/src/core/modules/modules.ts

@@ -1,135 +0,0 @@
-// Module System - Definition and Loading
-import { promises as fs } from 'fs';
-import path from 'path';
-import { Container } from '../utilities/index.js';
-import { ModuleConfig } from '../../types/module.js';
-import { ModuleDefinition, ModuleRoute, ModuleSocket } from '../../types/module.js';
-import { createFrameworkLogger } from '../logger/index.js';
-
-// 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,
-      // Copy all additional properties for extensibility
-      ...Object.fromEntries(
-        Object.entries(route).filter(
-          ([key]) =>
-            ![
-              'method',
-              'path',
-              'handler',
-              'validation',
-              'cache',
-              'rateLimit',
-              'middleware',
-            ].includes(key)
-        )
-      ),
-    }));
-
-    // 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}`, 'MODULE_LOADER', {
-              error: error instanceof Error ? error.message : String(error),
-            });
-          }
-        }
-      }
-    } catch (error) {
-      this.moduleLogger.error('Failed to discover modules', 'MODULE_LOADER', {
-        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,17 +0,0 @@
-// WebSocket Adapters for Moro Framework
-// Export all available adapters from this centralized location
-
-export { SocketIOAdapter } from './socketio-adapter.js';
-export { WSAdapter } from './ws-adapter.js';
-export { UWebSocketsAdapter } from './uws-adapter.js';
-
-// Re-export the adapter interface for convenience
-export type {
-  WebSocketAdapter,
-  WebSocketAdapterOptions,
-  WebSocketNamespace,
-  WebSocketConnection,
-  WebSocketEmitter,
-  WebSocketMiddleware,
-  WebSocketEventHandler,
-} from '../websocket-adapter.js';

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

@@ -1,254 +0,0 @@
-// Socket.IO WebSocket Adapter for Moro Framework
-// Implements the WebSocket adapter interface using Socket.IO
-
-import { resolveUserPackage } from '../../utilities/package-utils.js';
-import {
-  WebSocketAdapter,
-  WebSocketAdapterOptions,
-  WebSocketNamespace,
-  WebSocketConnection,
-  WebSocketEmitter,
-  WebSocketMiddleware,
-} from '../websocket-adapter.js';
-
-/**
- * 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 from user's context to find their installed socket.io
-      const socketIOPath = resolveUserPackage('socket.io');
-      const { Server } = await import(socketIOPath);
-
-      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));
-  }
-}