@morojs/moro 1.6.0 → 1.6.1

package/src/core/middleware/built-in/session.ts

@@ -1,11 +1,10 @@
 // Session Middleware
-import crypto from 'crypto';
-import { MiddlewareInterface, HookContext } from '../../../types/hooks.js';
-import { createFrameworkLogger } from '../../logger/index.js';
-import { CacheAdapter } from '../../../types/cache.js';
-import { MemoryCacheAdapter } from './adapters/cache/memory.js';
-import { RedisCacheAdapter } from './adapters/cache/redis.js';
-import { FileCacheAdapter } from './adapters/cache/file.js';
+import { MiddlewareInterface, HookContext } from '../../../types/hooks';
+import { createFrameworkLogger } from '../../logger';
+import { CacheAdapter } from '../../../types/cache';
+import { MemoryCacheAdapter } from './adapters/cache/memory';
+import { RedisCacheAdapter } from './adapters/cache/redis';
+import { FileCacheAdapter } from './adapters/cache/file';
 
 const logger = createFrameworkLogger('SessionMiddleware');
 
@@ -158,6 +157,7 @@ class Session {
       return this.options.genid();
     }
 
+    const crypto = require('crypto');
     return crypto.randomBytes(24).toString('hex');
   }
 
@@ -229,6 +229,7 @@ export const session = (options: SessionOptions = {}): MiddlewareInterface => ({
       if (config.genid) {
         return config.genid();
       }
+      const crypto = require('crypto');
       return crypto.randomBytes(24).toString('hex');
     };
 

package/src/core/middleware/built-in/sse.ts

@@ -1,6 +1,6 @@
 // Server-Sent Events Middleware
-import { MiddlewareInterface, HookContext } from '../../../types/hooks.js';
-import { createFrameworkLogger } from '../../logger/index.js';
+import { MiddlewareInterface, HookContext } from '../../../types/hooks';
+import { createFrameworkLogger } from '../../logger';
 
 const logger = createFrameworkLogger('SSEMiddleware');
 
@@ -35,15 +35,13 @@ export const sse = (
       logger.debug('Setting up SSE connection', 'SSESetup');
 
       // Set SSE headers
-      if (!res.headersSent) {
-        res.writeHead(200, {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          Connection: 'keep-alive',
-          'Access-Control-Allow-Origin': options.cors ? '*' : undefined,
-          'Access-Control-Allow-Headers': options.cors ? 'Cache-Control' : undefined,
-        });
-      }
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'Access-Control-Allow-Origin': options.cors ? '*' : undefined,
+        'Access-Control-Allow-Headers': options.cors ? 'Cache-Control' : undefined,
+      });
 
       // Add SSE methods to response
       res.sendEvent = (data: any, event?: string, id?: string) => {

package/src/core/middleware/built-in/validation.ts

@@ -1,6 +1,6 @@
 // Validation Middleware
-import { MiddlewareInterface, HookContext } from '../../../types/hooks.js';
-import { createFrameworkLogger } from '../../logger/index.js';
+import { MiddlewareInterface, HookContext } from '../../../types/hooks';
+import { createFrameworkLogger } from '../../logger';
 
 const logger = createFrameworkLogger('ValidationMiddleware');
 

package/src/core/middleware/index.ts

@@ -1,17 +1,17 @@
 // Middleware System for Moro
 import { EventEmitter } from 'events';
-import { HookManager } from '../utilities/index.js';
+import { HookManager } from '../utilities';
 import {
   MiddlewareMetadata,
   MiddlewareContext,
   MiddlewareInterface,
   SimpleMiddlewareFunction,
   MoroMiddleware,
-} from '../../types/hooks.js';
-import { createFrameworkLogger } from '../logger/index.js';
+} from '../../types/hooks';
+import { createFrameworkLogger } from '../logger';
 
 // Export types needed by built-in middleware
-export type { MiddlewareInterface, MoroMiddleware } from '../../types/hooks.js';
+export type { MiddlewareInterface, MoroMiddleware } from '../../types/hooks';
 
 export class MiddlewareManager extends EventEmitter {
   private middleware = new Map<string, MiddlewareInterface>();
@@ -173,5 +173,5 @@ export class MiddlewareManager extends EventEmitter {
 }
 
 // Built-in middleware exports
-export { builtInMiddleware, simpleMiddleware } from './built-in/index.js';
-export * from './built-in/index.js';
+export { builtInMiddleware, simpleMiddleware } from './built-in';
+export * from './built-in';

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

@@ -1,16 +1,14 @@
 // Auto-discovery system for Moro modules
 import { readdirSync, statSync } from 'fs';
-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';
+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');
-  private watchers: any[] = []; // Store file watchers for cleanup
 
   constructor(baseDir: string = process.cwd(), options: DiscoveryOptions = {}) {
     this.baseDir = baseDir;
@@ -37,7 +35,7 @@ export class ModuleDiscovery {
           );
         }
       } catch (error) {
-        this.discoveryLogger.warn(`Failed to load module from ${modulePath}`, 'MODULE_DISCOVERY', {
+        this.discoveryLogger.warn(`Failed to load module from ${modulePath}:`, 'ModuleDiscovery', {
           error: error instanceof Error ? error.message : String(error),
         });
       }
@@ -179,483 +177,22 @@ 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 {
-    // 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);
-            });
-          } 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);
-                  }
-                }
-              );
+    const fs = require('fs');
+    const modulePaths = this.findModuleFiles();
 
-              // Store watcher for cleanup
-              this.watchers.push(watcher);
-            }
-          } catch {
-            // Path doesn't exist or not accessible
-          }
+    modulePaths.forEach(path => {
+      try {
+        fs.watchFile(path, async () => {
+          this.discoveryLogger.info(`Module file changed: ${path}`);
+          const modules = await this.discoverModules();
+          callback(modules);
         });
-      })
-      .catch(() => {
-        // fs module not available
-      });
-  }
-
-  // Clean up file watchers
-  cleanup(): void {
-    this.watchers.forEach(watcher => {
-      if (watcher && typeof watcher.close === 'function') {
-        watcher.close();
+      } catch {
+        // File watching not supported or failed
       }
     });
-    this.watchers = [];
   }
 }
 

package/src/core/modules/index.ts

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