@morojs/moro 1.5.14 → 1.5.15

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

@@ -1,14 +1,17 @@
 // Auto-discovery system for Moro modules
 import { readdirSync, statSync } from 'fs';
-import { join, extname } from 'path';
+import { join, extname, relative } from 'path';
 import { ModuleConfig } from '../../types/module';
 import { DiscoveryOptions } from '../../types/discovery';
+import { ModuleDefaultsConfig } from '../../types/config';
 import { createFrameworkLogger } from '../logger';
+import { minimatch } from 'minimatch';
 
 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;
@@ -177,22 +180,330 @@ 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 {
+      if (!statSync(fullPath).isDirectory()) {
+        return modules;
+      }
+
+      const files = this.findMatchingFiles(fullPath, config);
+
+      for (const filePath of files) {
+        try {
+          const module = await this.loadModule(filePath);
+          if (module && this.validateAdvancedModule(module, config)) {
+            modules.push(module);
+            this.discoveryLogger.info(
+              `Auto-discovered module: ${module.name}@${module.version} from ${relative(this.baseDir, 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;
+  }
+
+  // Check if path should be ignored
+  private shouldIgnore(path: string, ignorePatterns: string[]): boolean {
+    return ignorePatterns.some(pattern => minimatch(path, pattern));
+  }
+
+  // Check if path matches any of the patterns
+  private matchesPatterns(path: string, patterns: string[]): boolean {
+    return patterns.some(pattern => minimatch(path, pattern));
+  }
+
+  // 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/moro.ts

@@ -5,41 +5,28 @@ import { Moro as MoroCore } from './core/framework';
 import { HttpRequest, HttpResponse, middleware } from './core/http';
 import { ModuleConfig, InternalRouteDefinition } from './types/module';
 import { MoroOptions } from './types/core';
+import { ModuleDefaultsConfig } from './types/config';
 import { MoroEventBus } from './core/events';
-import {
-  createFrameworkLogger,
-  logger as globalLogger,
-  applyLoggingConfiguration,
-} from './core/logger';
+import { createFrameworkLogger, applyLoggingConfiguration } from './core/logger';
 import { Logger } from './types/logger';
 import { MiddlewareManager } from './core/middleware';
 import { IntelligentRoutingManager } from './core/routing/app-integration';
 import { RouteBuilder, RouteSchema, CompiledRoute } from './core/routing';
 import { AppDocumentationManager, DocsConfig } from './core/docs';
-import { readdirSync, statSync } from 'fs';
-import { join } from 'path';
 import { EventEmitter } from 'events';
 // Configuration System Integration
-import {
-  initializeConfig,
-  getGlobalConfig,
-  loadConfigWithOptions,
-  type AppConfig,
-} from './core/config';
+import { initializeConfig, type AppConfig } from './core/config';
 // Runtime System Integration
-import {
-  RuntimeAdapter,
-  RuntimeType,
-  createRuntimeAdapter,
-  NodeRuntimeAdapter,
-} from './core/runtime';
+import { RuntimeAdapter, RuntimeType, createRuntimeAdapter } from './core/runtime';
 
 export class Moro extends EventEmitter {
   private coreFramework: MoroCore;
   private routes: InternalRouteDefinition[] = [];
   private moduleCounter = 0;
   private loadedModules = new Set<string>();
+  private lazyModules = new Map<string, ModuleConfig>();
   private routeHandlers: Record<string, Function> = {};
+  private moduleDiscovery?: any; // Store for cleanup
   // Enterprise event system integration
   private eventBus: MoroEventBus;
   // Application logger
@@ -133,7 +120,12 @@ export class Moro extends EventEmitter {
 
     // Auto-discover modules if enabled
     if (options.autoDiscover !== false) {
-      this.autoDiscoverModules(options.modulesPath || './modules');
+      // Initialize auto-discovery asynchronously
+      this.initializeAutoDiscovery(options).catch(error => {
+        this.logger.error('Auto-discovery initialization failed', 'Framework', {
+          error: error instanceof Error ? error.message : String(error),
+        });
+      });
     }
 
     // Emit initialization event through enterprise event bus
@@ -890,29 +882,215 @@ export class Moro extends EventEmitter {
     this.use(middleware.bodySize({ limit: '10mb' }));
   }
 
-  private autoDiscoverModules(modulesPath: string) {
+  // Enhanced auto-discovery initialization
+  private async initializeAutoDiscovery(options: MoroOptions): Promise<void> {
+    const { ModuleDiscovery } = await import('./core/modules/auto-discovery');
+
+    // Merge auto-discovery configuration
+    const autoDiscoveryConfig = this.mergeAutoDiscoveryConfig(options);
+
+    if (!autoDiscoveryConfig.enabled) {
+      return;
+    }
+
+    this.moduleDiscovery = new ModuleDiscovery(process.cwd());
+
     try {
-      if (!statSync(modulesPath).isDirectory()) return;
-
-      const items = readdirSync(modulesPath);
-      items.forEach(item => {
-        const fullPath = join(modulesPath, item);
-        if (statSync(fullPath).isDirectory()) {
-          const indexPath = join(fullPath, 'index.ts');
-          try {
-            statSync(indexPath);
-            // Module directory found, will be loaded later
-            this.logger.debug(`Discovered module: ${item}`, 'ModuleDiscovery');
-          } catch {
-            // No index.ts, skip
+      // Discover modules based on configuration
+      const modules = await this.moduleDiscovery.discoverModulesAdvanced(autoDiscoveryConfig);
+
+      // Load modules based on strategy
+      await this.loadDiscoveredModules(modules, autoDiscoveryConfig);
+
+      // Setup file watching if enabled
+      if (autoDiscoveryConfig.watchForChanges) {
+        this.moduleDiscovery.watchModulesAdvanced(
+          autoDiscoveryConfig,
+          async (updatedModules: ModuleConfig[]) => {
+            await this.handleModuleChanges(updatedModules);
           }
+        );
+      }
+
+      this.logger.info(
+        `Auto-discovery completed: ${modules.length} modules loaded`,
+        'ModuleDiscovery'
+      );
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+
+      if (autoDiscoveryConfig.failOnError) {
+        throw new Error(`Module auto-discovery failed: ${errorMsg}`);
+      } else {
+        this.logger.warn(`Module auto-discovery failed: ${errorMsg}`, 'ModuleDiscovery');
+      }
+    }
+  }
+
+  // Merge auto-discovery configuration from multiple sources
+  private mergeAutoDiscoveryConfig(options: MoroOptions) {
+    const defaultConfig = this.config.modules.autoDiscovery;
+
+    // Handle legacy modulesPath option
+    if (options.modulesPath && !options.autoDiscover) {
+      return {
+        ...defaultConfig,
+        paths: [options.modulesPath],
+      };
+    }
+
+    // Handle boolean autoDiscover option
+    if (typeof options.autoDiscover === 'boolean') {
+      return {
+        ...defaultConfig,
+        enabled: options.autoDiscover,
+      };
+    }
+
+    // Handle object autoDiscover option
+    if (typeof options.autoDiscover === 'object') {
+      return {
+        ...defaultConfig,
+        ...options.autoDiscover,
+      };
+    }
+
+    return defaultConfig;
+  }
+
+  // Load discovered modules based on strategy
+  private async loadDiscoveredModules(
+    modules: ModuleConfig[],
+    config: ModuleDefaultsConfig['autoDiscovery']
+  ): Promise<void> {
+    switch (config.loadingStrategy) {
+      case 'eager':
+        // Load all modules immediately
+        for (const module of modules) {
+          await this.loadModule(module);
+        }
+        break;
+
+      case 'lazy':
+        // Register modules for lazy loading
+        this.registerLazyModules(modules);
+        break;
+
+      case 'conditional':
+        // Load modules based on conditions
+        await this.loadConditionalModules(modules);
+        break;
+
+      default:
+        // Default to eager loading
+        for (const module of modules) {
+          await this.loadModule(module);
         }
-      });
-    } catch {
-      // Modules directory doesn't exist, that's fine
     }
   }
 
+  // Register modules for lazy loading
+  private registerLazyModules(modules: ModuleConfig[]): void {
+    modules.forEach(module => {
+      // Store module for lazy loading when first route is accessed
+      this.lazyModules.set(module.name, module);
+
+      // Register placeholder routes that trigger lazy loading
+      if (module.routes) {
+        module.routes.forEach(route => {
+          const basePath = `/api/v${module.version}/${module.name}`;
+          const fullPath = `${basePath}${route.path}`;
+
+          // Note: Lazy loading will be implemented when route is accessed
+          // For now, we'll store the module for later loading
+          this.logger.debug(
+            `Registered lazy route: ${route.method} ${fullPath}`,
+            'ModuleDiscovery'
+          );
+        });
+      }
+    });
+
+    this.logger.info(`Registered ${modules.length} modules for lazy loading`, 'ModuleDiscovery');
+  }
+
+  // Load modules conditionally based on environment or configuration
+  private async loadConditionalModules(modules: ModuleConfig[]): Promise<void> {
+    for (const module of modules) {
+      const shouldLoad = this.shouldLoadModule(module);
+
+      if (shouldLoad) {
+        await this.loadModule(module);
+      } else {
+        this.logger.debug(`Skipping module ${module.name} due to conditions`, 'ModuleDiscovery');
+      }
+    }
+  }
+
+  // Determine if a module should be loaded based on conditions
+  private shouldLoadModule(module: ModuleConfig): boolean {
+    const moduleConfig = module.config as any;
+
+    // Check environment conditions
+    if (moduleConfig?.conditions?.environment) {
+      const requiredEnv = moduleConfig.conditions.environment;
+      const currentEnv = process.env.NODE_ENV || 'development';
+
+      if (Array.isArray(requiredEnv)) {
+        if (!requiredEnv.includes(currentEnv)) {
+          return false;
+        }
+      } else if (requiredEnv !== currentEnv) {
+        return false;
+      }
+    }
+
+    // Check feature flags
+    if (moduleConfig?.conditions?.features) {
+      const requiredFeatures = moduleConfig.conditions.features;
+
+      for (const feature of requiredFeatures) {
+        if (!process.env[`FEATURE_${feature.toUpperCase()}`]) {
+          return false;
+        }
+      }
+    }
+
+    // Check custom conditions
+    if (moduleConfig?.conditions?.custom) {
+      const customCondition = moduleConfig.conditions.custom;
+
+      if (typeof customCondition === 'function') {
+        return customCondition();
+      }
+    }
+
+    return true;
+  }
+
+  // Handle module changes during development
+  private async handleModuleChanges(modules: ModuleConfig[]): Promise<void> {
+    this.logger.info('Module changes detected, reloading...', 'ModuleDiscovery');
+
+    // Unload existing modules (if supported)
+    // For now, just log the change
+    this.eventBus.emit('modules:changed', {
+      modules: modules.map(m => ({ name: m.name, version: m.version })),
+      timestamp: new Date(),
+    });
+  }
+
+  // Legacy method for backward compatibility
+  private autoDiscoverModules(modulesPath: string) {
+    // Redirect to new system
+    this.initializeAutoDiscovery({
+      autoDiscover: {
+        enabled: true,
+        paths: [modulesPath],
+      },
+    });
+  }
+
   private async importModule(modulePath: string): Promise<ModuleConfig> {
     const module = await import(modulePath);
     return module.default || module;
@@ -1216,6 +1394,15 @@ export class Moro extends EventEmitter {
       }
     }
 
+    // Clean up module discovery watchers
+    if (this.moduleDiscovery && typeof this.moduleDiscovery.cleanup === 'function') {
+      try {
+        this.moduleDiscovery.cleanup();
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+
     // Clean up event listeners
     try {
       this.eventBus.removeAllListeners();

package/src/types/config.ts

@@ -84,6 +84,18 @@ export interface ModuleDefaultsConfig {
     stripUnknown: boolean;
     abortEarly: boolean;
   };
+  autoDiscovery: {
+    enabled: boolean;
+    paths: string[];
+    patterns: string[];
+    recursive: boolean;
+    loadingStrategy: 'eager' | 'lazy' | 'conditional';
+    watchForChanges: boolean;
+    ignorePatterns: string[];
+    loadOrder: 'alphabetical' | 'dependency' | 'custom';
+    failOnError: boolean;
+    maxDepth: number;
+  };
 }
 
 export interface LoggingConfig {