@asenajs/asena 0.5.0 → 0.6.0-beta.0

package/dist/lib/server/event/EventDispatchService.d.ts

@@ -0,0 +1,104 @@
+import type { ICoreService } from '../../ioc';
+import type { EventHandler, EventSubscription } from './types';
+/**
+ * @description Internal event dispatch service
+ * Handles pattern matching, storage, and dispatching of events
+ *
+ * Architecture:
+ * - EventEmitter (public API) → EventDispatchService (internal logic)
+ * - Similar to: AsenaWebSocketService → AsenaWebSocketServer
+ *
+ * Performance:
+ * - Exact patterns: O(1) lookup via Map
+ * - Wildcard patterns: O(n) check via Array
+ * - Lazy warmup: Indexes built on first dispatch
+ *
+ * @internal This service should not be used directly by users
+ */
+export declare class EventDispatchService implements ICoreService {
+    readonly serviceName = "EventDispatchService";
+    /**
+     * All registered event subscriptions
+     */
+    private handlers;
+    /**
+     * Warmup state - lazy initialization on first dispatch
+     */
+    private warmedUp;
+    /**
+     * Exact pattern cache for O(1) lookup
+     * Key: exact event pattern, Value: handlers for that pattern
+     */
+    private exactMatches;
+    /**
+     * Wildcard patterns that need O(n) matching
+     */
+    private wildcardPatterns;
+    /**
+     * Register a handler for an event pattern
+     *
+     * @param pattern - Event pattern (supports wildcards: 'user.*', '*.error')
+     * @param handler - Handler function to execute
+     * @param once - If true, handler will be removed after first execution
+     *
+     * @example
+     * registerHandler('user.created', (eventName, data) => { ... });
+     * registerHandler('download.*', (eventName, data) => { ... });
+     */
+    registerHandler(pattern: string, handler: EventHandler, once?: boolean): void;
+    /**
+     * Unregister a specific handler for a pattern
+     *
+     * @param pattern - Event pattern to unregister from
+     * @param handler - Handler function to remove
+     * @returns true if handler was found and removed, false otherwise
+     */
+    unregisterHandler(pattern: string, handler: EventHandler): boolean;
+    /**
+     * Dispatch an event to all matching handlers
+     *
+     * Fire-and-forget pattern:
+     * - Returns immediately, doesn't wait for async handlers
+     * - Async handler errors are caught and logged
+     * - Handlers are isolated (one error doesn't affect others)
+     *
+     * @param eventName - Event name to dispatch
+     * @param data - Optional data to pass to handlers
+     * @returns true if any handler was called, false if no handlers matched
+     *
+     * @example
+     * dispatch('user.created', { id: 123, name: 'John' }); // Returns true/false
+     */
+    dispatch(eventName: string, data?: any): boolean;
+    /**
+     * Warmup - Build indexes for faster lookup
+     *
+     * Strategy (Hybrid):
+     * - Exact patterns → Map (O(1) lookup)
+     * - Wildcard patterns → Array (O(n) check needed)
+     *
+     * This is lazy initialization:
+     * - Called automatically on first dispatch
+     * - Invalidated when handlers change
+     *
+     * Performance:
+     * - Exact patterns: O(1) - Most common case
+     * - Wildcard patterns: O(n) - Less common, smaller n
+     *
+     * @private
+     */
+    private warmup;
+    /**
+     * Get all registered handlers (for debugging/testing)
+     *
+     * @returns Array of all event subscriptions
+     * @internal
+     */
+    getHandlers(): EventSubscription[];
+    /**
+     * Clear all registered handlers
+     *
+     * @internal Used for testing and cleanup
+     */
+    clearHandlers(): void;
+}

package/dist/lib/server/event/EventDispatchService.js

@@ -0,0 +1,203 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { CoreService } from '../../ioc';
+import { ICoreServiceNames } from '../../ioc';
+import { matchesEventPattern } from './eventPatternMatcher';
+/**
+ * @description Internal event dispatch service
+ * Handles pattern matching, storage, and dispatching of events
+ *
+ * Architecture:
+ * - EventEmitter (public API) → EventDispatchService (internal logic)
+ * - Similar to: AsenaWebSocketService → AsenaWebSocketServer
+ *
+ * Performance:
+ * - Exact patterns: O(1) lookup via Map
+ * - Wildcard patterns: O(n) check via Array
+ * - Lazy warmup: Indexes built on first dispatch
+ *
+ * @internal This service should not be used directly by users
+ */
+let EventDispatchService = class EventDispatchService {
+    serviceName = 'EventDispatchService';
+    /**
+     * All registered event subscriptions
+     */
+    handlers = [];
+    /**
+     * Warmup state - lazy initialization on first dispatch
+     */
+    warmedUp = false;
+    /**
+     * Exact pattern cache for O(1) lookup
+     * Key: exact event pattern, Value: handlers for that pattern
+     */
+    exactMatches = new Map();
+    /**
+     * Wildcard patterns that need O(n) matching
+     */
+    wildcardPatterns = [];
+    /**
+     * Register a handler for an event pattern
+     *
+     * @param pattern - Event pattern (supports wildcards: 'user.*', '*.error')
+     * @param handler - Handler function to execute
+     * @param once - If true, handler will be removed after first execution
+     *
+     * @example
+     * registerHandler('user.created', (eventName, data) => { ... });
+     * registerHandler('download.*', (eventName, data) => { ... });
+     */
+    registerHandler(pattern, handler, once = false) {
+        this.handlers.push({ pattern, handler, once });
+        // Invalidate warmup cache - will rebuild on next dispatch
+        this.warmedUp = false;
+    }
+    /**
+     * Unregister a specific handler for a pattern
+     *
+     * @param pattern - Event pattern to unregister from
+     * @param handler - Handler function to remove
+     * @returns true if handler was found and removed, false otherwise
+     */
+    unregisterHandler(pattern, handler) {
+        const index = this.handlers.findIndex((sub) => sub.pattern === pattern && sub.handler === handler);
+        if (index !== -1) {
+            this.handlers.splice(index, 1);
+            // Invalidate warmup cache
+            this.warmedUp = false;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Dispatch an event to all matching handlers
+     *
+     * Fire-and-forget pattern:
+     * - Returns immediately, doesn't wait for async handlers
+     * - Async handler errors are caught and logged
+     * - Handlers are isolated (one error doesn't affect others)
+     *
+     * @param eventName - Event name to dispatch
+     * @param data - Optional data to pass to handlers
+     * @returns true if any handler was called, false if no handlers matched
+     *
+     * @example
+     * dispatch('user.created', { id: 123, name: 'John' }); // Returns true/false
+     */
+    dispatch(eventName, data) {
+        // Lazy warmup - build indexes on first dispatch
+        if (!this.warmedUp) {
+            this.warmup();
+        }
+        const handlersToCall = [];
+        // 1. Check exact match cache - O(1)
+        const exactHandlers = this.exactMatches.get(eventName);
+        if (exactHandlers) {
+            for (const handler of exactHandlers) {
+                // Find full subscription info (for 'once' support)
+                const sub = this.handlers.find((s) => s.handler === handler && s.pattern === eventName);
+                if (sub) {
+                    handlersToCall.push(sub);
+                }
+            }
+        }
+        // 2. Check wildcard patterns - O(n) but smaller n
+        for (const sub of this.wildcardPatterns) {
+            if (matchesEventPattern(eventName, sub.pattern)) {
+                handlersToCall.push(sub);
+            }
+        }
+        // 3. No handlers matched
+        if (handlersToCall.length === 0) {
+            return false;
+        }
+        // 4. Call all matching handlers (fire-and-forget, error isolation)
+        for (const sub of handlersToCall) {
+            try {
+                const result = sub.handler(eventName, data);
+                // Smart async detection: If Promise, handle errors but DON'T await
+                // Benchmark showed await Promise.resolve(syncHandler()) is 13x slower!
+                if (result instanceof Promise) {
+                    result.catch((error) => {
+                        console.error(`[EventDispatchService] Async error in handler for event "${eventName}":`, error);
+                    });
+                }
+            }
+            catch (error) {
+                // Sync handler error - log but continue with other handlers
+                console.error(`[EventDispatchService] Sync error in handler for event "${eventName}":`, error);
+            }
+        }
+        // 5. Remove 'once' handlers
+        for (const sub of handlersToCall) {
+            if (sub.once) {
+                this.unregisterHandler(sub.pattern, sub.handler);
+            }
+        }
+        return true;
+    }
+    /**
+     * Warmup - Build indexes for faster lookup
+     *
+     * Strategy (Hybrid):
+     * - Exact patterns → Map (O(1) lookup)
+     * - Wildcard patterns → Array (O(n) check needed)
+     *
+     * This is lazy initialization:
+     * - Called automatically on first dispatch
+     * - Invalidated when handlers change
+     *
+     * Performance:
+     * - Exact patterns: O(1) - Most common case
+     * - Wildcard patterns: O(n) - Less common, smaller n
+     *
+     * @private
+     */
+    warmup() {
+        this.exactMatches.clear();
+        this.wildcardPatterns = [];
+        for (const sub of this.handlers) {
+            if (sub.pattern.includes('*')) {
+                // Wildcard pattern - needs O(n) matching on dispatch
+                this.wildcardPatterns.push(sub);
+            }
+            else {
+                // Exact pattern - O(1) lookup on dispatch
+                const handlers = this.exactMatches.get(sub.pattern) || [];
+                handlers.push(sub.handler);
+                this.exactMatches.set(sub.pattern, handlers);
+            }
+        }
+        this.warmedUp = true;
+    }
+    /**
+     * Get all registered handlers (for debugging/testing)
+     *
+     * @returns Array of all event subscriptions
+     * @internal
+     */
+    getHandlers() {
+        return [...this.handlers];
+    }
+    /**
+     * Clear all registered handlers
+     *
+     * @internal Used for testing and cleanup
+     */
+    clearHandlers() {
+        this.handlers = [];
+        this.exactMatches.clear();
+        this.wildcardPatterns = [];
+        this.warmedUp = false;
+    }
+};
+EventDispatchService = __decorate([
+    CoreService(ICoreServiceNames.EVENT_DISPATCH_SERVICE)
+], EventDispatchService);
+export { EventDispatchService };
+//# sourceMappingURL=EventDispatchService.js.map

package/dist/lib/server/event/EventDispatchService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventDispatchService.js","sourceRoot":"","sources":["../../../../lib/server/event/EventDispatchService.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D;;;;;;;;;;;;;;GAcG;AAEI,IAAM,oBAAoB,GAA1B,MAAM,oBAAoB;IACf,WAAW,GAAG,sBAAsB,CAAC;IAErD;;OAEG;IACK,QAAQ,GAAwB,EAAE,CAAC;IAE3C;;OAEG;IACK,QAAQ,GAAG,KAAK,CAAC;IAEzB;;;OAGG;IACK,YAAY,GAAgC,IAAI,GAAG,EAAE,CAAC;IAE9D;;OAEG;IACK,gBAAgB,GAAwB,EAAE,CAAC;IAEnD;;;;;;;;;;OAUG;IACI,eAAe,CAAC,OAAe,EAAE,OAAqB,EAAE,IAAI,GAAG,KAAK;QACzE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QAE/C,0DAA0D;QAC1D,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;IAED;;;;;;OAMG;IACI,iBAAiB,CAAC,OAAe,EAAE,OAAqB;QAC7D,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,KAAK,OAAO,IAAI,GAAG,CAAC,OAAO,KAAK,OAAO,CAAC,CAAC;QAEnG,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAE/B,0BAA0B;YAC1B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YAEtB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACI,QAAQ,CAAC,SAAiB,EAAE,IAAU;QAC3C,gDAAgD;QAChD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,IAAI,CAAC,MAAM,EAAE,CAAC;QAChB,CAAC;QAED,MAAM,cAAc,GAAwB,EAAE,CAAC;QAE/C,oCAAoC;QACpC,MAAM,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACvD,IAAI,aAAa,EAAE,CAAC;YAClB,KAAK,MAAM,OAAO,IAAI,aAAa,EAAE,CAAC;gBACpC,mDAAmD;gBACnD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,OAAO,IAAI,CAAC,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC;gBACxF,IAAI,GAAG,EAAE,CAAC;oBACR,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC3B,CAAC;YACH,CAAC;QACH,CAAC;QAED,kDAAkD;QAClD,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACxC,IAAI,mBAAmB,CAAC,SAAS,EAAE,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;gBAChD,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,yBAAyB;QACzB,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,mEAAmE;QACnE,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;gBAE5C,mEAAmE;gBACnE,uEAAuE;gBACvE,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;oBAC9B,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;wBACrB,OAAO,CAAC,KAAK,CAAC,4DAA4D,SAAS,IAAI,EAAE,KAAK,CAAC,CAAC;oBAClG,CAAC,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,4DAA4D;gBAC5D,OAAO,CAAC,KAAK,CAAC,2DAA2D,SAAS,IAAI,EAAE,KAAK,CAAC,CAAC;YACjG,CAAC;QACH,CAAC;QAED,4BAA4B;QAC5B,KAAK,MAAM,GAAG,IAAI,cAAc,EAAE,CAAC;YACjC,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;gBACb,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YACnD,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACK,MAAM;QACZ,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAC1B,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;QAE3B,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChC,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC9B,qDAAqD;gBACrD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClC,CAAC;iBAAM,CAAC;gBACN,0CAA0C;gBAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;gBAC1D,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC3B,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;QAED,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACI,WAAW;QAChB,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACI,aAAa;QAClB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;QACnB,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAC1B,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;QAC3B,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;CACF,CAAA;AApMY,oBAAoB;IADhC,WAAW,CAAC,iBAAiB,CAAC,sBAAsB,CAAC;GACzC,oBAAoB,CAoMhC"}

package/dist/lib/server/event/EventEmitter.d.ts

@@ -0,0 +1,67 @@
+import type { ICoreService } from '../../ioc';
+/**
+ * @description Event Emitter - Public API for event-driven architecture
+ *
+ * Architecture:
+ * - EventEmitter (public API) → EventDispatchService (internal logic)
+ * - Similar pattern to: AsenaWebSocketService → AsenaWebSocketServer
+ *
+ * Usage:
+ * ```typescript
+ * // In your code
+ * @Inject(emitter())
+ * private emitter!: EventEmitter;
+ *
+ * // Emit events
+ * this.emitter.emit('user.created', { id: 123, name: 'John' });
+ * ```
+ *
+ * Event handlers are registered via decorators:
+ * ```typescript
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')
+ *   handleUserCreated(eventName: string, data: any) {
+ *     // Handle event
+ *   }
+ * }
+ * ```
+ *
+ * Fire-and-Forget Pattern:
+ * - emit() returns immediately (doesn't wait for handlers)
+ * - Async handlers are executed without blocking
+ * - Handler errors are isolated and logged
+ *
+ * @see EventDispatchService for internal implementation details
+ */
+export declare class EventEmitter implements ICoreService {
+    readonly serviceName = "EventEmitter";
+    private dispatcher;
+    /**
+     * Emit an event to all registered handlers
+     *
+     * Fire-and-forget pattern (Spring style):
+     * - Returns immediately without waiting for handlers
+     * - Async handlers execute in background
+     * - Handler errors are caught and logged
+     *
+     * @param eventName - Event name to emit (e.g., 'user.created', 'download.complete')
+     * @param data - Optional data to pass to handlers
+     * @returns true if any handler was called, false if no handlers matched
+     *
+     * @example
+     * // Emit event with data
+     * const success = this.emitter.emit('user.created', { id: 123, name: 'John' });
+     *
+     * @example
+     * // Emit event without data
+     * this.emitter.emit('app.started');
+     *
+     * @example
+     * // Check if event was handled
+     * if (!this.emitter.emit('user.created', data)) {
+     *   console.warn('No handlers registered for user.created event');
+     * }
+     */
+    emit(eventName: string, data?: any): boolean;
+}

package/dist/lib/server/event/EventEmitter.js

@@ -0,0 +1,88 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { CoreService, ICoreServiceNames } from '../../ioc';
+import { Inject } from '../../ioc/component';
+/**
+ * @description Event Emitter - Public API for event-driven architecture
+ *
+ * Architecture:
+ * - EventEmitter (public API) → EventDispatchService (internal logic)
+ * - Similar pattern to: AsenaWebSocketService → AsenaWebSocketServer
+ *
+ * Usage:
+ * ```typescript
+ * // In your code
+ * @Inject(emitter())
+ * private emitter!: EventEmitter;
+ *
+ * // Emit events
+ * this.emitter.emit('user.created', { id: 123, name: 'John' });
+ * ```
+ *
+ * Event handlers are registered via decorators:
+ * ```typescript
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')
+ *   handleUserCreated(eventName: string, data: any) {
+ *     // Handle event
+ *   }
+ * }
+ * ```
+ *
+ * Fire-and-Forget Pattern:
+ * - emit() returns immediately (doesn't wait for handlers)
+ * - Async handlers are executed without blocking
+ * - Handler errors are isolated and logged
+ *
+ * @see EventDispatchService for internal implementation details
+ */
+let EventEmitter = class EventEmitter {
+    serviceName = 'EventEmitter';
+    dispatcher;
+    /**
+     * Emit an event to all registered handlers
+     *
+     * Fire-and-forget pattern (Spring style):
+     * - Returns immediately without waiting for handlers
+     * - Async handlers execute in background
+     * - Handler errors are caught and logged
+     *
+     * @param eventName - Event name to emit (e.g., 'user.created', 'download.complete')
+     * @param data - Optional data to pass to handlers
+     * @returns true if any handler was called, false if no handlers matched
+     *
+     * @example
+     * // Emit event with data
+     * const success = this.emitter.emit('user.created', { id: 123, name: 'John' });
+     *
+     * @example
+     * // Emit event without data
+     * this.emitter.emit('app.started');
+     *
+     * @example
+     * // Check if event was handled
+     * if (!this.emitter.emit('user.created', data)) {
+     *   console.warn('No handlers registered for user.created event');
+     * }
+     */
+    emit(eventName, data) {
+        return this.dispatcher.dispatch(eventName, data);
+    }
+};
+__decorate([
+    Inject(ICoreServiceNames.EVENT_DISPATCH_SERVICE),
+    __metadata("design:type", Function)
+], EventEmitter.prototype, "dispatcher", void 0);
+EventEmitter = __decorate([
+    CoreService(ICoreServiceNames.EVENT_EMITTER)
+], EventEmitter);
+export { EventEmitter };
+//# sourceMappingURL=EventEmitter.js.map

package/dist/lib/server/event/EventEmitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.js","sourceRoot":"","sources":["../../../../lib/server/event/EventEmitter.ts"],"names":[],"mappings":";;;;;;;;;AACA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEI,IAAM,YAAY,GAAlB,MAAM,YAAY;IACP,WAAW,GAAG,cAAc,CAAC;IAGrC,UAAU,CAAwB;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,IAAI,CAAC,SAAiB,EAAE,IAAU;QACvC,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACnD,CAAC;CACF,CAAA;AA/BS;IADP,MAAM,CAAC,iBAAiB,CAAC,sBAAsB,CAAC;;gDACP;AAJ/B,YAAY;IADxB,WAAW,CAAC,iBAAiB,CAAC,aAAa,CAAC;GAChC,YAAY,CAmCxB"}

package/dist/lib/server/event/EventService.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A service class for handling Events.
+ */
+export declare class AsenaEventHandler {
+}

package/dist/lib/server/event/EventService.js

@@ -0,0 +1,6 @@
+/**
+ * A service class for handling Events.
+ */
+export class AsenaEventHandler {
+}
+//# sourceMappingURL=EventService.js.map

package/dist/lib/server/event/EventService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventService.js","sourceRoot":"","sources":["../../../../lib/server/event/EventService.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,iBAAiB;CAAG"}

package/dist/lib/server/event/decorators/On.d.ts

@@ -0,0 +1,38 @@
+import type { OnParams } from '../types';
+/**
+ * @description On decorator - Marks a method as an event handler
+ *
+ * Methods decorated with @On will be automatically registered when
+ * the event system boots up (via PrepareEventService).
+ *
+ * @param params - Event pattern or configuration object
+ *
+ * @example
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')  // Handles 'user.created'
+ *   handleCreated(eventName: string, data: any) {
+ *     console.log('User created:', data);
+ *   }
+ *
+ *   @On('*.updated')  // Handles 'user.*.updated'
+ *   handleUpdated(eventName: string, data: any) { }
+ *
+ *   @On({ event: 'deleted', skip: true })  // Temporarily disabled
+ *   handleDeleted(eventName: string, data: any) { }
+ * }
+ *
+ * @example
+ * // Without prefix (absolute pattern)
+ * @EventService()
+ * export class GlobalEventService {
+ *   @On('*')  // Handles ALL events
+ *   handleAll(eventName: string, data: any) {
+ *     console.log('Event:', eventName);
+ *   }
+ *
+ *   @On('*.error')  // Handles all error events
+ *   handleErrors(eventName: string, data: any) { }
+ * }
+ */
+export declare function On(params: OnParams | string): MethodDecorator;

package/dist/lib/server/event/decorators/On.js

@@ -0,0 +1,56 @@
+import { ComponentConstants } from '../../../ioc';
+import { defineTypedMetadata, getOwnTypedMetadata } from '../../../utils';
+/**
+ * @description On decorator - Marks a method as an event handler
+ *
+ * Methods decorated with @On will be automatically registered when
+ * the event system boots up (via PrepareEventService).
+ *
+ * @param params - Event pattern or configuration object
+ *
+ * @example
+ * @EventService({ prefix: 'user' })
+ * export class UserEventService {
+ *   @On('created')  // Handles 'user.created'
+ *   handleCreated(eventName: string, data: any) {
+ *     console.log('User created:', data);
+ *   }
+ *
+ *   @On('*.updated')  // Handles 'user.*.updated'
+ *   handleUpdated(eventName: string, data: any) { }
+ *
+ *   @On({ event: 'deleted', skip: true })  // Temporarily disabled
+ *   handleDeleted(eventName: string, data: any) { }
+ * }
+ *
+ * @example
+ * // Without prefix (absolute pattern)
+ * @EventService()
+ * export class GlobalEventService {
+ *   @On('*')  // Handles ALL events
+ *   handleAll(eventName: string, data: any) {
+ *     console.log('Event:', eventName);
+ *   }
+ *
+ *   @On('*.error')  // Handles all error events
+ *   handleErrors(eventName: string, data: any) { }
+ * }
+ */
+export function On(params) {
+    // Normalize params - support both object and string
+    const _params = typeof params === 'string' ? { event: params, skip: false } : params;
+    return function (target, propertyKey, descriptor) {
+        // Get existing handlers metadata (other @On methods)
+        const handlers = getOwnTypedMetadata(ComponentConstants.EventHandlersKey, target.constructor) || {};
+        // Add this handler's metadata
+        handlers[propertyKey.toString()] = {
+            pattern: _params.event,
+            methodName: propertyKey.toString(),
+            skip: _params.skip || false,
+        };
+        // Store updated metadata
+        defineTypedMetadata(ComponentConstants.EventHandlersKey, handlers, target.constructor);
+        return descriptor;
+    };
+}
+//# sourceMappingURL=On.js.map

package/dist/lib/server/event/decorators/On.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"On.js","sourceRoot":"","sources":["../../../../../lib/server/event/decorators/On.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAG1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,EAAE,CAAC,MAAyB;IAC1C,oDAAoD;IACpD,MAAM,OAAO,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;IAErF,OAAO,UAAU,MAAc,EAAE,WAA4B,EAAE,UAA8B;QAC3F,qDAAqD;QACrD,MAAM,QAAQ,GACZ,mBAAmB,CACjB,kBAAkB,CAAC,gBAAgB,EACnC,MAAM,CAAC,WAAW,CACnB,IAAI,EAAE,CAAC;QAEV,8BAA8B;QAC9B,QAAQ,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,GAAG;YACjC,OAAO,EAAE,OAAO,CAAC,KAAK;YACtB,UAAU,EAAE,WAAW,CAAC,QAAQ,EAAE;YAClC,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,KAAK;SAC5B,CAAC;QAEF,yBAAyB;QACzB,mBAAmB,CAAC,kBAAkB,CAAC,gBAAgB,EAAE,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC;QAEvF,OAAO,UAAU,CAAC;IACpB,CAAC,CAAC;AACJ,CAAC"}

package/dist/lib/server/event/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './On';

package/dist/lib/server/event/decorators/index.js

@@ -0,0 +1,2 @@
+export * from './On';
+//# sourceMappingURL=index.js.map

package/dist/lib/server/event/decorators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../lib/server/event/decorators/index.ts"],"names":[],"mappings":"AAAA,cAAc,MAAM,CAAC"}

package/dist/lib/server/event/emitter.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @description Utility for injecting EventEmitter
+ *
+ * Returns the EventEmitter service key for use with @Inject decorator.
+ *
+ * @returns The EventEmitter service key
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * export class UserService {
+ *   @Inject(emitter())
+ *   private emitter!: EventEmitter;
+ *
+ *   createUser(name: string) {
+ *     this.emitter.emit('user.created', { name });
+ *   }
+ * }
+ * ```
+ */
+export declare function emitter(): string;

package/dist/lib/server/event/emitter.js

@@ -0,0 +1,25 @@
+import { ICoreServiceNames } from '../../ioc';
+/**
+ * @description Utility for injecting EventEmitter
+ *
+ * Returns the EventEmitter service key for use with @Inject decorator.
+ *
+ * @returns The EventEmitter service key
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * export class UserService {
+ *   @Inject(emitter())
+ *   private emitter!: EventEmitter;
+ *
+ *   createUser(name: string) {
+ *     this.emitter.emit('user.created', { name });
+ *   }
+ * }
+ * ```
+ */
+export function emitter() {
+    return ICoreServiceNames.EVENT_EMITTER;
+}
+//# sourceMappingURL=emitter.js.map

package/dist/lib/server/event/emitter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../../../../lib/server/event/emitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,OAAO;IACrB,OAAO,iBAAiB,CAAC,aAAa,CAAC;AACzC,CAAC"}