@dangao/bun-server 1.8.3 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dangao/bun-server",
-  "version": "1.8.3",
+  "version": "1.9.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/core/application.ts

@@ -18,6 +18,7 @@ import { ConfigService } from '../config/service';
 import { ConfigModule } from '../config/config-module';
 import { CacheModule, CACHE_POST_PROCESSOR_TOKEN } from '../cache';
 import { LoggerManager } from '@dangao/logsmith';
+import { EventModule } from '../events/event-module';
 
 /**
  * 应用配置选项
@@ -102,6 +103,9 @@ export class Application {
     // 初始化配置中心集成（在所有模块注册完成后）
     await this.initializeConfigCenter();
 
+    // 自动初始化事件监听器（如果 EventModule 已注册且启用了 autoScan）
+    this.initializeEventListeners();
+
     const finalPort = port ?? this.options.port ?? 3000;
     const finalHostname = hostname ?? this.options.hostname;
 
@@ -178,6 +182,31 @@ export class Application {
     }
   }
 
+  /**
+   * 初始化事件监听器
+   * 在所有模块注册完成后调用，自动扫描并注册使用 @OnEvent 装饰器的类
+   */
+  private initializeEventListeners(): void {
+    const container = this.getContainer();
+    
+    // 检查 EventModule 是否已注册
+    const registry = ModuleRegistry.getInstance();
+    const eventModuleRef = registry.getModuleRef(EventModule);
+    
+    if (!eventModuleRef) {
+      // EventModule 未注册，跳过
+      return;
+    }
+
+    // 调用自动初始化
+    const initialized = EventModule.autoInitialize(container);
+    
+    if (initialized) {
+      const logger = LoggerManager.getLogger();
+      logger.debug('[Application] Event listeners initialized automatically');
+    }
+  }
+
   /**
    * 停止应用（立即停止，不等待请求完成）
    */

package/src/events/event-module.ts

@@ -102,6 +102,11 @@ export class EventModule {
    */
   private static listenerClasses: Function[] = [];
 
+  /**
+   * 模块选项
+   */
+  private static options: EventModuleOptions & { autoScan?: boolean } = {};
+
   /**
    * 创建事件模块
    * @param options - 模块配置
@@ -121,6 +126,12 @@ export class EventModule {
    * ```
    */
   public static forRoot(options: EventModuleOptions = {}): typeof EventModule {
+    // 保存选项（默认启用自动扫描）
+    EventModule.options = {
+      ...options,
+      autoScan: options.autoScan ?? true,
+    };
+
     const providers: ModuleProvider[] = [];
 
     // 创建事件发射器服务
@@ -269,4 +280,101 @@ export class EventModule {
 
     return undefined;
   }
+
+  /**
+   * 自动初始化事件监听器
+   * 由框架在应用启动时自动调用，扫描所有模块中使用 @OnEvent 装饰器的类并注册
+   * 
+   * @param rootContainer - 根容器
+   * @returns 是否成功初始化
+   * 
+   * @internal 此方法由框架内部调用，用户通常不需要手动调用
+   */
+  public static autoInitialize(rootContainer: Container): boolean {
+    // 检查是否启用自动扫描
+    if (EventModule.options.autoScan === false) {
+      return false;
+    }
+
+    // 获取 EventEmitter
+    const registry = ModuleRegistry.getInstance();
+    const eventModuleRef = registry.getModuleRef(EventModule);
+
+    if (!eventModuleRef) {
+      return false;
+    }
+
+    let eventEmitter: EventEmitter | undefined;
+    try {
+      eventEmitter = eventModuleRef.container.resolve<EventEmitter>(EVENT_EMITTER_TOKEN);
+    } catch {
+      return false;
+    }
+
+    if (!eventEmitter) {
+      return false;
+    }
+
+    // 收集所有监听器类
+    const listenerClasses = new Set<Function>();
+
+    // 1. 添加通过 registerListeners 注册的类
+    for (const listenerClass of EventModule.listenerClasses) {
+      listenerClasses.add(listenerClass);
+    }
+
+    // 2. 添加通过选项配置的强制包含类
+    if (EventModule.options.includeListeners) {
+      for (const listenerClass of EventModule.options.includeListeners) {
+        listenerClasses.add(listenerClass);
+      }
+    }
+
+    // 3. 自动扫描所有模块的 providers，并从对应的模块容器中解析实例
+    const shouldAutoScan = EventModule.options.autoScan ?? true;
+    if (shouldAutoScan === true) {
+      const allModuleRefs = Array.from(registry['moduleRefs'].values());
+      
+      for (const moduleRef of allModuleRefs) {
+        for (const provider of moduleRef.metadata.providers) {
+          // 提取提供者类
+          let providerClass: Function | undefined;
+
+          if (typeof provider === 'function') {
+            providerClass = provider;
+          } else if ('useClass' in provider && provider.useClass) {
+            providerClass = provider.useClass;
+          }
+
+          // 检查是否是事件监听器类
+          if (providerClass && isEventListenerClass(providerClass)) {
+            // 检查是否被排除
+            const isExcluded = EventModule.options.excludeListeners?.includes(providerClass);
+            if (!isExcluded) {
+              // 使用模块容器创建 scanner 并注册监听器
+              // 这样可以确保解析的实例和控制器中注入的是同一个
+              const scanner = new EventListenerScanner(eventEmitter, moduleRef.container);
+              scanner.registerListenerClass(providerClass);
+            }
+          }
+        }
+      }
+    }
+
+    // 4. 注册通过选项配置的强制包含类（使用根容器）
+    if (EventModule.options.includeListeners) {
+      const scanner = new EventListenerScanner(eventEmitter, rootContainer);
+      for (const listenerClass of EventModule.options.includeListeners) {
+        scanner.registerListenerClass(listenerClass);
+      }
+    }
+
+    // 5. 注册通过 registerListeners 注册的类（使用根容器）
+    if (EventModule.listenerClasses.length > 0) {
+      const scanner = new EventListenerScanner(eventEmitter, rootContainer);
+      scanner.scanAndRegister(EventModule.listenerClasses);
+    }
+
+    return true;
+  }
 }

package/src/events/types.ts

@@ -173,6 +173,25 @@ export interface EventModuleOptions {
    * @param payload - 事件负载
    */
   onError?: (error: Error, event: string | symbol, payload: unknown) => void;
+
+  /**
+   * 是否自动扫描和注册事件监听器
+   * 当设置为 true 时，框架会在应用启动时自动扫描所有模块中使用 @OnEvent 装饰器的类
+   * @default true
+   */
+  autoScan?: boolean;
+
+  /**
+   * 需要排除的监听器类（不自动注册）
+   * 用于在自动扫描时排除某些类
+   */
+  excludeListeners?: Function[];
+
+  /**
+   * 额外的监听器类（强制注册）
+   * 即使 autoScan 为 false，这些类也会被注册
+   */
+  includeListeners?: Function[];
 }
 
 /**