cleaner dev experience refactor

libs/core/handlers/src/registry/auto-register.ts

@@ -0,0 +1,174 @@
+/**
+ * Auto-registration utilities for handlers
+ * Automatically discovers and registers handlers based on file patterns
+ */
+
+import { getLogger } from '@stock-bot/logger';
+import type { IServiceContainer } from '../types/service-container';
+import { BaseHandler } from '../base/BaseHandler';
+import { readdirSync, statSync } from 'fs';
+import { join, relative } from 'path';
+
+const logger = getLogger('handler-auto-register');
+
+/**
+ * Recursively find all handler files in a directory
+ */
+function findHandlerFiles(dir: string, pattern = '.handler.'): string[] {
+  const files: string[] = [];
+  
+  function scan(currentDir: string) {
+    const entries = readdirSync(currentDir);
+    
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry);
+      const stat = statSync(fullPath);
+      
+      if (stat.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
+        scan(fullPath);
+      } else if (stat.isFile() && entry.includes(pattern) && entry.endsWith('.ts')) {
+        files.push(fullPath);
+      }
+    }
+  }
+  
+  scan(dir);
+  return files;
+}
+
+/**
+ * Extract handler classes from a module
+ */
+function extractHandlerClasses(module: any): Array<new (services: IServiceContainer) => BaseHandler> {
+  const handlers: Array<new (services: IServiceContainer) => BaseHandler> = [];
+  
+  for (const key of Object.keys(module)) {
+    const exported = module[key];
+    
+    // Check if it's a class that extends BaseHandler
+    if (
+      typeof exported === 'function' &&
+      exported.prototype &&
+      exported.prototype instanceof BaseHandler
+    ) {
+      handlers.push(exported);
+    }
+  }
+  
+  return handlers;
+}
+
+/**
+ * Auto-register all handlers in a directory
+ * @param directory The directory to scan for handlers
+ * @param services The service container to inject into handlers
+ * @param options Configuration options
+ */
+export async function autoRegisterHandlers(
+  directory: string,
+  services: IServiceContainer,
+  options: {
+    pattern?: string;
+    exclude?: string[];
+    dryRun?: boolean;
+  } = {}
+): Promise<{ registered: string[]; failed: string[] }> {
+  const { pattern = '.handler.', exclude = [], dryRun = false } = options;
+  const registered: string[] = [];
+  const failed: string[] = [];
+  
+  try {
+    logger.info('Starting auto-registration of handlers', { directory, pattern });
+    
+    // Find all handler files
+    const handlerFiles = findHandlerFiles(directory, pattern);
+    logger.debug(`Found ${handlerFiles.length} handler files`, { files: handlerFiles });
+    
+    // Process each handler file
+    for (const file of handlerFiles) {
+      const relativePath = relative(directory, file);
+      
+      // Skip excluded files
+      if (exclude.some(ex => relativePath.includes(ex))) {
+        logger.debug(`Skipping excluded file: ${relativePath}`);
+        continue;
+      }
+      
+      try {
+        // Import the module
+        const module = await import(file);
+        const handlerClasses = extractHandlerClasses(module);
+        
+        if (handlerClasses.length === 0) {
+          logger.warn(`No handler classes found in ${relativePath}`);
+          continue;
+        }
+        
+        // Register each handler class
+        for (const HandlerClass of handlerClasses) {
+          const handlerName = HandlerClass.name;
+          
+          if (dryRun) {
+            logger.info(`[DRY RUN] Would register handler: ${handlerName} from ${relativePath}`);
+            registered.push(handlerName);
+          } else {
+            logger.info(`Registering handler: ${handlerName} from ${relativePath}`);
+            
+            // Create instance and register
+            const handler = new HandlerClass(services);
+            handler.register();
+            
+            registered.push(handlerName);
+            logger.info(`Successfully registered handler: ${handlerName}`);
+          }
+        }
+      } catch (error) {
+        logger.error(`Failed to process handler file: ${relativePath}`, { error });
+        failed.push(relativePath);
+      }
+    }
+    
+    logger.info('Auto-registration complete', {
+      totalFiles: handlerFiles.length,
+      registered: registered.length,
+      failed: failed.length
+    });
+    
+    return { registered, failed };
+  } catch (error) {
+    logger.error('Auto-registration failed', { error });
+    throw error;
+  }
+}
+
+/**
+ * Create a handler registry that auto-discovers handlers
+ */
+export function createAutoHandlerRegistry(services: IServiceContainer) {
+  return {
+    /**
+     * Register all handlers from a directory
+     */
+    async registerDirectory(directory: string, options?: Parameters<typeof autoRegisterHandlers>[2]) {
+      return autoRegisterHandlers(directory, services, options);
+    },
+    
+    /**
+     * Register handlers from multiple directories
+     */
+    async registerDirectories(directories: string[], options?: Parameters<typeof autoRegisterHandlers>[2]) {
+      const results = {
+        registered: [] as string[],
+        failed: [] as string[]
+      };
+      
+      for (const dir of directories) {
+        const result = await autoRegisterHandlers(dir, services, options);
+        results.registered.push(...result.registered);
+        results.failed.push(...result.failed);
+      }
+      
+      return results;
+    }
+  };
+}