@morojs/moro 1.6.1 → 1.6.2

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

@@ -1,14 +1,16 @@
 // 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';
+import { join, extname, relative, isAbsolute } from 'path';
+import { ModuleConfig } from '../../types/module.js';
+import { DiscoveryOptions } from '../../types/discovery.js';
+import { ModuleDefaultsConfig } from '../../types/config.js';
+import { createFrameworkLogger } from '../logger/index.js';
 
 export class ModuleDiscovery {
   private baseDir: string;
   private options: DiscoveryOptions;
   private discoveryLogger = createFrameworkLogger('MODULE_DISCOVERY');
+  private watchers: any[] = []; // Store file watchers for cleanup
 
   constructor(baseDir: string = process.cwd(), options: DiscoveryOptions = {}) {
     this.baseDir = baseDir;
@@ -35,7 +37,7 @@ export class ModuleDiscovery {
           );
         }
       } catch (error) {
-        this.discoveryLogger.warn(`Failed to load module from ${modulePath}:`, 'ModuleDiscovery', {
+        this.discoveryLogger.warn(`Failed to load module from ${modulePath}`, 'MODULE_DISCOVERY', {
           error: error instanceof Error ? error.message : String(error),
         });
       }
@@ -177,22 +179,483 @@ export class ModuleDiscovery {
     );
   }
 
+  // Enhanced auto-discovery with advanced configuration
+  async discoverModulesAdvanced(
+    config: ModuleDefaultsConfig['autoDiscovery']
+  ): Promise<ModuleConfig[]> {
+    if (!config.enabled) {
+      return [];
+    }
+
+    const allModules: ModuleConfig[] = [];
+
+    // Discover from all configured paths
+    for (const searchPath of config.paths) {
+      const modules = await this.discoverFromPath(searchPath, config);
+      allModules.push(...modules);
+    }
+
+    // Remove duplicates based on name@version
+    const uniqueModules = this.deduplicateModules(allModules);
+
+    // Sort modules based on load order strategy
+    const sortedModules = this.sortModules(uniqueModules, config.loadOrder);
+
+    // Validate dependencies if using dependency order
+    if (config.loadOrder === 'dependency') {
+      return this.resolveDependencyOrder(sortedModules);
+    }
+
+    return sortedModules;
+  }
+
+  // Discover modules from a specific path with advanced filtering
+  private async discoverFromPath(
+    searchPath: string,
+    config: ModuleDefaultsConfig['autoDiscovery']
+  ): Promise<ModuleConfig[]> {
+    const modules: ModuleConfig[] = [];
+    const fullPath = join(this.baseDir, searchPath);
+
+    try {
+      const stat = statSync(fullPath);
+
+      if (!stat.isDirectory()) {
+        return modules;
+      }
+    } catch (error) {
+      return modules;
+    }
+
+    try {
+      const files = await this.findMatchingFilesWithGlob(
+        fullPath,
+        config.patterns,
+        config.ignorePatterns,
+        config.maxDepth
+      );
+
+      for (const filePath of files) {
+        try {
+          // Convert relative path to absolute path for import
+          const absolutePath = join(this.baseDir, filePath);
+          const module = await this.loadModule(absolutePath);
+          if (module && this.validateAdvancedModule(module, config)) {
+            modules.push(module);
+            this.discoveryLogger.info(
+              `Auto-discovered module: ${module.name}@${module.version} from ${filePath}`
+            );
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+
+          if (config.failOnError) {
+            throw new Error(`Failed to load module from ${filePath}: ${errorMsg}`);
+          } else {
+            this.discoveryLogger.warn(
+              `Failed to load module from ${filePath}`,
+              'MODULE_DISCOVERY',
+              {
+                error: errorMsg,
+              }
+            );
+          }
+        }
+      }
+    } catch (error) {
+      if (config.failOnError) {
+        throw error;
+      }
+      // Directory doesn't exist or other error, continue silently
+    }
+
+    return modules;
+  }
+
+  // Find files matching patterns with ignore support
+  private findMatchingFiles(
+    basePath: string,
+    config: ModuleDefaultsConfig['autoDiscovery'],
+    currentDepth: number = 0
+  ): string[] {
+    const files: string[] = [];
+
+    if (currentDepth >= config.maxDepth) {
+      return files;
+    }
+
+    try {
+      const items = readdirSync(basePath);
+
+      for (const item of items) {
+        const fullPath = join(basePath, item);
+        const relativePath = relative(this.baseDir, fullPath);
+
+        // Check ignore patterns
+        if (this.shouldIgnore(relativePath, config.ignorePatterns)) {
+          continue;
+        }
+
+        const stat = statSync(fullPath);
+
+        if (stat.isDirectory() && config.recursive) {
+          files.push(...this.findMatchingFiles(fullPath, config, currentDepth + 1));
+        } else if (stat.isFile()) {
+          // Check if file matches any pattern
+          if (this.matchesPatterns(relativePath, config.patterns)) {
+            files.push(fullPath);
+          }
+        }
+      }
+    } catch {
+      // Directory not accessible, skip
+    }
+
+    return files;
+  }
+
+  // Use native Node.js glob to find matching files
+  private async findMatchingFilesWithGlob(
+    searchPath: string,
+    patterns: string[],
+    ignorePatterns: string[],
+    maxDepth: number = 5
+  ): Promise<string[]> {
+    // Force fallback in CI environments or if Node.js version is uncertain
+    const isCI = process.env.CI === 'true' || process.env.GITHUB_ACTIONS === 'true';
+
+    if (isCI) {
+      return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+    }
+
+    const allFiles: string[] = [];
+
+    try {
+      // Try to use native fs.glob if available (Node.js 20+)
+      const { glob } = await import('fs/promises');
+
+      // Check if glob is actually a function and test it
+      if (typeof glob !== 'function') {
+        return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+      }
+
+      // Test glob with a simple pattern first
+      try {
+        const testIterator = glob(join(searchPath, '*'));
+        let testCount = 0;
+        for await (const _ of testIterator) {
+          testCount++;
+          if (testCount > 0) break; // Just test that it works
+        }
+      } catch (testError) {
+        return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+      }
+
+      for (const pattern of patterns) {
+        const fullPattern = join(searchPath, pattern);
+        try {
+          // fs.glob returns an AsyncIterator, need to collect results
+          const globIterator = glob(fullPattern);
+          const files: string[] = [];
+
+          for await (const file of globIterator) {
+            const filePath = typeof file === 'string' ? file : (file as any).name || String(file);
+            const relativePath = relative(this.baseDir, filePath);
+
+            // Check if file should be ignored and within max depth
+            if (
+              !this.shouldIgnore(relativePath, ignorePatterns) &&
+              this.isWithinMaxDepth(relativePath, searchPath, maxDepth)
+            ) {
+              files.push(relativePath);
+            }
+          }
+
+          allFiles.push(...files);
+        } catch (error) {
+          // If any glob call fails, fall back to manual discovery
+          this.discoveryLogger.warn(`Glob pattern failed: ${pattern}`, String(error));
+          return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+        }
+      }
+    } catch (error) {
+      // fs.glob not available, fall back to manual file discovery
+      this.discoveryLogger.debug('Native fs.glob not available, using fallback');
+      return this.findMatchingFilesFallback(searchPath, patterns, ignorePatterns, maxDepth);
+    }
+
+    return [...new Set(allFiles)]; // Remove duplicates
+  }
+
+  // Fallback for Node.js versions without fs.glob
+  private async findMatchingFilesFallback(
+    searchPath: string,
+    patterns: string[],
+    ignorePatterns: string[],
+    maxDepth: number = 5
+  ): Promise<string[]> {
+    const config = {
+      patterns,
+      ignorePatterns,
+      maxDepth,
+      recursive: true,
+    } as ModuleDefaultsConfig['autoDiscovery'];
+
+    // Handle both absolute and relative paths
+    const fullSearchPath = isAbsolute(searchPath) ? searchPath : join(this.baseDir, searchPath);
+
+    // Check if search path exists
+    try {
+      const { access } = await import('fs/promises');
+      await access(fullSearchPath);
+    } catch (e) {
+      return [];
+    }
+
+    // Get files and convert to relative paths
+    const files = this.findMatchingFiles(fullSearchPath, config);
+    const relativeFiles = files.map(file => relative(this.baseDir, file));
+
+    return relativeFiles;
+  }
+
+  // Simple pattern matching for fallback (basic glob support)
+  private matchesSimplePattern(path: string, pattern: string): boolean {
+    try {
+      // Normalize path separators
+      const normalizedPath = path.replace(/\\/g, '/');
+      const normalizedPattern = pattern.replace(/\\/g, '/');
+
+      // Convert simple glob patterns to regex
+      const regexPattern = normalizedPattern
+        .replace(/\*\*/g, '___DOUBLESTAR___') // Temporarily replace ** BEFORE escaping
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape regex chars
+        .replace(/\\\*/g, '[^/]*') // * matches anything except /
+        .replace(/___DOUBLESTAR___/g, '.*') // ** matches anything including /
+        .replace(/\\\?/g, '[^/]') // ? matches single character except /
+        .replace(/\\\{([^}]+)\\\}/g, '($1)') // {ts,js} -> (ts|js)
+        .replace(/,/g, '|'); // Convert comma to OR
+
+      const regex = new RegExp(`^${regexPattern}$`, 'i');
+      const result = regex.test(normalizedPath);
+
+      return result;
+    } catch (error) {
+      this.discoveryLogger.warn(`Pattern matching error for "${pattern}": ${String(error)}`);
+      return false;
+    }
+  }
+
+  // Check if path should be ignored
+  private shouldIgnore(path: string, ignorePatterns: string[]): boolean {
+    return ignorePatterns.some(pattern => this.matchesSimplePattern(path, pattern));
+  }
+
+  // Check if path matches any of the patterns
+  private matchesPatterns(path: string, patterns: string[]): boolean {
+    return patterns.some(pattern => this.matchesSimplePattern(path, pattern));
+  }
+
+  // Check if file is within max depth (for glob results)
+  private isWithinMaxDepth(relativePath: string, searchPath: string, maxDepth: number): boolean {
+    // Count directory separators to determine depth
+    const pathFromSearch = relative(searchPath, join(this.baseDir, relativePath));
+    const depth = pathFromSearch.split('/').length - 1; // -1 because file itself doesn't count as depth
+    return depth <= maxDepth;
+  }
+
+  // Remove duplicate modules
+  private deduplicateModules(modules: ModuleConfig[]): ModuleConfig[] {
+    const seen = new Set<string>();
+    return modules.filter(module => {
+      const key = `${module.name}@${module.version}`;
+      if (seen.has(key)) {
+        this.discoveryLogger.warn(`Duplicate module found: ${key}`, 'MODULE_DISCOVERY');
+        return false;
+      }
+      seen.add(key);
+      return true;
+    });
+  }
+
+  // Sort modules based on strategy
+  private sortModules(
+    modules: ModuleConfig[],
+    strategy: ModuleDefaultsConfig['autoDiscovery']['loadOrder']
+  ): ModuleConfig[] {
+    switch (strategy) {
+      case 'alphabetical':
+        return modules.sort((a, b) => a.name.localeCompare(b.name));
+
+      case 'dependency':
+        // Will be handled by resolveDependencyOrder
+        return modules;
+
+      case 'custom':
+        // Allow custom sorting via module priority (if defined)
+        return modules.sort((a, b) => {
+          const aPriority = (a.config as any)?.priority || 0;
+          const bPriority = (b.config as any)?.priority || 0;
+          return bPriority - aPriority; // Higher priority first
+        });
+
+      default:
+        return modules;
+    }
+  }
+
+  // Resolve dependency order using topological sort
+  private resolveDependencyOrder(modules: ModuleConfig[]): ModuleConfig[] {
+    const moduleMap = new Map<string, ModuleConfig>();
+    const dependencyGraph = new Map<string, string[]>();
+
+    // Build module map and dependency graph
+    modules.forEach(module => {
+      const key = `${module.name}@${module.version}`;
+      moduleMap.set(key, module);
+      dependencyGraph.set(key, module.dependencies || []);
+    });
+
+    // Topological sort
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+    const sorted: ModuleConfig[] = [];
+
+    const visit = (moduleKey: string): void => {
+      if (visiting.has(moduleKey)) {
+        throw new Error(`Circular dependency detected involving ${moduleKey}`);
+      }
+
+      if (visited.has(moduleKey)) {
+        return;
+      }
+
+      visiting.add(moduleKey);
+
+      const dependencies = dependencyGraph.get(moduleKey) || [];
+      dependencies.forEach(dep => {
+        // Find the dependency in our modules
+        const depModule = Array.from(moduleMap.keys()).find(key =>
+          key.startsWith(`${dep.split('@')[0]}@`)
+        );
+        if (depModule) {
+          visit(depModule);
+        }
+      });
+
+      visiting.delete(moduleKey);
+      visited.add(moduleKey);
+
+      const module = moduleMap.get(moduleKey);
+      if (module) {
+        sorted.push(module);
+      }
+    };
+
+    // Visit all modules
+    Array.from(moduleMap.keys()).forEach(key => {
+      if (!visited.has(key)) {
+        visit(key);
+      }
+    });
+
+    return sorted;
+  }
+
+  // Enhanced module validation
+  private validateAdvancedModule(
+    module: ModuleConfig,
+    _config: ModuleDefaultsConfig['autoDiscovery']
+  ): boolean {
+    // Basic validation
+    if (!this.isValidModule(module)) {
+      return false;
+    }
+
+    // Additional validation can be added here
+    // For example, checking module compatibility, version constraints, etc.
+
+    return true;
+  }
+
   // Watch for module changes (for development)
   watchModules(callback: (modules: ModuleConfig[]) => void): void {
-    const fs = require('fs');
-    const modulePaths = this.findModuleFiles();
+    // Use dynamic import for fs to avoid require()
+    import('fs')
+      .then(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);
+        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
+          }
         });
-      } catch {
-        // File watching not supported or failed
+      })
+      .catch(() => {
+        // fs module not available
+      });
+  }
+
+  // Watch modules with advanced configuration
+  watchModulesAdvanced(
+    config: ModuleDefaultsConfig['autoDiscovery'],
+    callback: (modules: ModuleConfig[]) => void
+  ): void {
+    if (!config.watchForChanges) {
+      return;
+    }
+
+    import('fs')
+      .then(fs => {
+        const watchedPaths = new Set<string>();
+
+        // Watch all configured paths
+        config.paths.forEach(searchPath => {
+          const fullPath = join(this.baseDir, searchPath);
+
+          try {
+            if (statSync(fullPath).isDirectory() && !watchedPaths.has(fullPath)) {
+              watchedPaths.add(fullPath);
+
+              const watcher = fs.watch(
+                fullPath,
+                { recursive: config.recursive },
+                async (eventType: string, filename: string | null) => {
+                  if (filename && this.matchesPatterns(filename, config.patterns)) {
+                    this.discoveryLogger.info(`Module file changed: ${filename}`);
+                    const modules = await this.discoverModulesAdvanced(config);
+                    callback(modules);
+                  }
+                }
+              );
+
+              // Store watcher for cleanup
+              this.watchers.push(watcher);
+            }
+          } catch {
+            // Path doesn't exist or not accessible
+          }
+        });
+      })
+      .catch(() => {
+        // fs module not available
+      });
+  }
+
+  // Clean up file watchers
+  cleanup(): void {
+    this.watchers.forEach(watcher => {
+      if (watcher && typeof watcher.close === 'function') {
+        watcher.close();
       }
     });
+    this.watchers = [];
   }
 }
 

package/src/core/modules/index.ts

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

package/src/core/modules/modules.ts

@@ -1,10 +1,10 @@
 // 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';
+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 {
@@ -24,6 +24,21 @@ export function defineModule(definition: ModuleDefinition): ModuleConfig {
       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
@@ -94,18 +109,14 @@ export class ModuleLoader {
               }
             }
           } catch (error) {
-            this.moduleLogger.warn(
-              `⚠️  Could not load module from ${modulePath}:`,
-              'ModuleLoader',
-              {
-                error: error instanceof Error ? error.message : String(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:', 'ModuleLoader', {
+      this.moduleLogger.error('Failed to discover modules', 'MODULE_LOADER', {
         error: error instanceof Error ? error.message : String(error),
       });
     }

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

@@ -1,8 +1,9 @@
 // WebSocket Adapters for Moro Framework
 // Export all available adapters from this centralized location
 
-export { SocketIOAdapter } from './socketio-adapter';
-export { WSAdapter } from './ws-adapter';
+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 {
@@ -13,4 +14,4 @@ export type {
   WebSocketEmitter,
   WebSocketMiddleware,
   WebSocketEventHandler,
-} from '../websocket-adapter';
+} from '../websocket-adapter.js';

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

@@ -1,6 +1,7 @@
 // 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,
@@ -8,7 +9,7 @@ import {
   WebSocketConnection,
   WebSocketEmitter,
   WebSocketMiddleware,
-} from '../websocket-adapter';
+} from '../websocket-adapter.js';
 
 /**
  * Socket.IO adapter implementation
@@ -19,8 +20,9 @@ export class SocketIOAdapter implements WebSocketAdapter {
 
   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');
+      // 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: '*' },