najm-event 0.1.1

package/README.md

@@ -0,0 +1,48 @@
+# najm-events
+
+Optional events (event bus) plugin for Najm framework with decorator-based event handling and async event emission.
+
+## Installation
+
+```bash
+bun install najm-events
+```
+
+## Usage
+
+```typescript
+import { On, Events } from 'najm-events';
+
+// Listen to events with the @On decorator
+@Service()
+class UserService {
+  @On('user.created')
+  async handleUserCreated(data: any) {
+    console.log('User created:', data);
+  }
+}
+
+// Inject event methods using @Events decorator
+@Controller('/api/users')
+class UserController {
+  @Events() private events!: any;
+
+  @Post('/create')
+  async createUser(@Body() userData: any) {
+    // Create user logic here
+    const user = await this.userService.create(userData);
+    
+    // Emit event
+    this.events.emit('user.created', user);
+    
+    return user;
+  }
+}
+```
+
+## Features
+
+- Decorator-based event handling with `@On()` and `@Events()`
+- Async event emission with error handling
+- Integration with Najm's DI system
+- Event statistics and management

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { InjectionDefinition, Constructor } from 'diject';
+import * as najm_core from 'najm-core';
+import { Constructor as Constructor$1 } from 'najm-core';
+import * as mitt from 'mitt';
+import { Handler } from 'mitt';
+
+interface EventEmitter {
+    emit<T = any>(event: string, data?: T): void;
+    emitAsync<T = any>(event: string, data?: T): Promise<void>;
+    on<T = any>(event: string, handler: (data: T) => void): void;
+    off<T = any>(event: string, handler?: (data: T) => void): void;
+    once<T = any>(event: string, handler: (data: T) => void): void;
+    hasListeners(event: string): boolean;
+    listenerCount(event: string): number;
+    eventNames(): string[];
+    all(): any;
+}
+interface EventRegistration extends InjectionDefinition {
+    type: 'event';
+    target: Constructor;
+    eventName: string;
+    methodName: string;
+}
+
+declare const EVENTS_META: unique symbol;
+declare const EVENT_CONFIG: unique symbol;
+
+declare function Events(): any;
+declare function On(eventName: string): MethodDecorator;
+declare const getEventListeners: (t: any) => any;
+
+declare const events: () => najm_core.NajmPlugin;
+
+declare class EventService {
+    private container;
+    private scanner;
+    private log;
+    private emitter;
+    private eventHandlers;
+    scan(): Promise<void>;
+    private setupEventsGetter;
+    configure(): Promise<void>;
+    private registerInjectors;
+    activate(): Promise<void>;
+    private registerEventHandler;
+    onReady(): Promise<void>;
+    emit<T = any>(event: string, data?: T): void;
+    emitAsync<T = any>(event: string, data?: T): Promise<void>;
+    on<T = any>(event: string, handler: Handler<T>): void;
+    off<T = any>(event: string, handler?: Handler<T>): void;
+    once<T = any>(event: string, handler: Handler<T>): void;
+    hasListeners(event: string): boolean;
+    listenerCount(event: string): number;
+    eventNames(): string[];
+    all(): mitt.EventHandlerMap<any>;
+    registerProviderEvents(provider: Constructor$1): Promise<void>;
+    unregisterProviderEvents(provider: Constructor$1): void;
+    clear(): void;
+    getStats(): {
+        totalProviders: number;
+        totalHandlers: number;
+        providers: string[];
+        events: string[];
+        eventCounts: Record<string, number>;
+    };
+}
+
+export { EVENTS_META, EVENT_CONFIG, type EventEmitter, type EventRegistration, EventService, Events, On, events, getEventListeners };

package/dist/index.mjs

@@ -0,0 +1,315 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/tokens.ts
+var EVENTS_META = /* @__PURE__ */ Symbol("events");
+var EVENT_CONFIG = /* @__PURE__ */ Symbol("event:config");
+
+// src/decorator.ts
+import { INJECT_PROPS, MetaHelper } from "najm-core";
+function Events() {
+  return (target, propertyKey) => {
+    MetaHelper.append(INJECT_PROPS, {
+      propertyKey,
+      token: "EventsMethods"
+    }, target.constructor);
+  };
+}
+__name(Events, "Events");
+function On(eventName) {
+  return (target, method) => {
+    MetaHelper.append(EVENTS_META, { eventName, methodName: method }, target.constructor);
+  };
+}
+__name(On, "On");
+var getEventListeners = /* @__PURE__ */ __name((t) => MetaHelper.get(EVENTS_META, t) ?? [], "getEventListeners");
+
+// src/EventPlugin.ts
+import { plugin } from "najm-core";
+
+// src/EventService.ts
+import mitt from "mitt";
+import { LoggerService, Scan, ScannerService, ScanType, INJECTION_TYPES } from "najm-core";
+import { Meta, Container, Inject, getPropertyInjections, DI, Service } from "najm-core";
+var __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 = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+var _b;
+var _c;
+var EventService = class EventService2 {
+  static {
+    __name(this, "EventService");
+  }
+  container;
+  scanner;
+  log;
+  emitter;
+  eventHandlers = /* @__PURE__ */ new Map();
+  // ============================================================================
+  // LIFECYCLE: SCAN
+  // ============================================================================
+  async scan() {
+    this.emitter = mitt();
+    this.scanner.scan(ScanType.APP, {
+      onClass: /* @__PURE__ */ __name((provider) => {
+        const listeners = getEventListeners(provider);
+        for (const { eventName, methodName } of listeners) {
+          this.container.setInjection({
+            type: INJECTION_TYPES.EVENT,
+            target: provider,
+            eventName,
+            methodName
+          });
+        }
+        const propInjections = getPropertyInjections(provider);
+        const eventsInjections = propInjections.filter((inj) => inj.token === "EventsMethods");
+        for (const injection of eventsInjections) {
+          this.setupEventsGetter(provider, injection.propertyKey);
+        }
+      }, "onClass")
+    });
+  }
+  setupEventsGetter(provider, propertyKey) {
+    const eventService = this;
+    const createEventsMethods = /* @__PURE__ */ __name(() => ({
+      emit: eventService.emit.bind(eventService),
+      emitAsync: eventService.emitAsync.bind(eventService),
+      on: eventService.on.bind(eventService),
+      off: eventService.off.bind(eventService),
+      once: eventService.once.bind(eventService),
+      hasListeners: eventService.hasListeners.bind(eventService),
+      listenerCount: eventService.listenerCount.bind(eventService),
+      eventNames: eventService.eventNames.bind(eventService),
+      all: eventService.all.bind(eventService)
+    }), "createEventsMethods");
+    const instanceCache = /* @__PURE__ */ new WeakMap();
+    Object.defineProperty(provider.prototype, propertyKey, {
+      configurable: true,
+      enumerable: true,
+      get() {
+        let methods = instanceCache.get(this);
+        if (!methods) {
+          methods = createEventsMethods();
+          instanceCache.set(this, methods);
+        }
+        return methods;
+      },
+      set(value) {
+        Object.defineProperty(this, propertyKey, {
+          configurable: true,
+          enumerable: true,
+          writable: true,
+          value
+        });
+      }
+    });
+  }
+  // ============================================================================
+  // LIFECYCLE: CONFIGURE
+  // ============================================================================
+  async configure() {
+    this.registerInjectors();
+  }
+  registerInjectors() {
+    this.container.use({
+      name: "Events",
+      global: true,
+      inject: /* @__PURE__ */ __name((instance) => {
+        instance.events = this;
+      }, "inject")
+    });
+    this.container.use({
+      name: "EventsMethods",
+      global: true,
+      inject: /* @__PURE__ */ __name((instance, _ctor, _registry, injections) => {
+        if (!injections)
+          return;
+        const eventsInjections = injections.filter((inj) => inj.token === "EventsMethods");
+        for (const injection of eventsInjections) {
+          const { propertyKey } = injection;
+          instance[propertyKey] = {
+            emit: this.emit.bind(this),
+            emitAsync: this.emitAsync.bind(this),
+            on: this.on.bind(this),
+            off: this.off.bind(this),
+            once: this.once.bind(this),
+            hasListeners: this.hasListeners.bind(this),
+            listenerCount: this.listenerCount.bind(this),
+            eventNames: this.eventNames.bind(this),
+            all: this.all.bind(this)
+          };
+        }
+      }, "inject")
+    });
+  }
+  // ============================================================================
+  // LIFECYCLE: ACTIVATE
+  // ============================================================================
+  async activate() {
+    const registrations = this.container.getInjections(INJECTION_TYPES.EVENT);
+    const providersWithHandlers = new Set(registrations.map((r) => r.target));
+    for (const provider of providersWithHandlers) {
+      await this.container.resolve(provider);
+    }
+    for (const registration of registrations) {
+      await this.registerEventHandler(registration);
+    }
+  }
+  async registerEventHandler(registration) {
+    const { target, eventName, methodName } = registration;
+    if (!this.eventHandlers.has(target)) {
+      this.eventHandlers.set(target, []);
+    }
+    const instance = await this.container.resolve(target);
+    const handler = /* @__PURE__ */ __name(async (data) => {
+      return instance[methodName]?.(data);
+    }, "handler");
+    this.on(eventName, handler);
+    this.eventHandlers.get(target).push({ eventName, handler });
+  }
+  // ============================================================================
+  // LIFECYCLE: READY
+  // ============================================================================
+  async onReady() {
+    const count = this.container.getInjections(INJECTION_TYPES.EVENT).length;
+    this.log.info(`Event plugin ready: ${count} handler(s) registered`);
+  }
+  // ============================================================================
+  // EVENT EMITTER API
+  // ============================================================================
+  emit(event, data) {
+    this.emitter.emit(event, data);
+  }
+  async emitAsync(event, data) {
+    const handlers = this.emitter.all.get(event);
+    if (!handlers || handlers.size === 0)
+      return;
+    const results = await Promise.allSettled([...handlers].map((h) => Promise.resolve(h(data))));
+    const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
+    if (errors.length > 0) {
+      const errorMessage = `${errors.length} handler(s) failed for event "${event}"`;
+      this.log.error(errorMessage, errors[0], { event, failedHandlers: errors.length });
+      throw new AggregateError(errors, errorMessage);
+    }
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    if (handler) {
+      this.emitter.off(event, handler);
+    } else {
+      this.emitter.all.delete(event);
+    }
+  }
+  once(event, handler) {
+    const onceHandler = /* @__PURE__ */ __name((data) => {
+      this.off(event, onceHandler);
+      handler(data);
+    }, "onceHandler");
+    this.on(event, onceHandler);
+  }
+  hasListeners(event) {
+    const handlers = this.emitter.all.get(event);
+    return handlers ? handlers.length > 0 : false;
+  }
+  listenerCount(event) {
+    const handlers = this.emitter.all.get(event);
+    return handlers ? handlers.length : 0;
+  }
+  eventNames() {
+    return Array.from(this.emitter.all.keys());
+  }
+  all() {
+    return this.emitter.all;
+  }
+  // ============================================================================
+  // DYNAMIC REGISTRATION
+  // ============================================================================
+  async registerProviderEvents(provider) {
+    if (this.eventHandlers.has(provider))
+      return;
+    const listeners = getEventListeners(provider);
+    if (listeners.length === 0)
+      return;
+    const instance = await this.container.resolve(provider);
+    const handlers = [];
+    for (const { eventName, methodName } of listeners) {
+      const handler = /* @__PURE__ */ __name(async (data) => {
+        return instance[methodName]?.(data);
+      }, "handler");
+      this.on(eventName, handler);
+      handlers.push({ eventName, handler });
+    }
+    this.eventHandlers.set(provider, handlers);
+  }
+  unregisterProviderEvents(provider) {
+    const handlers = this.eventHandlers.get(provider);
+    if (!handlers)
+      return;
+    for (const { eventName, handler } of handlers) {
+      this.emitter.off(eventName, handler);
+    }
+    this.eventHandlers.delete(provider);
+  }
+  // ============================================================================
+  // UTILITIES
+  // ============================================================================
+  clear() {
+    this.eventHandlers.clear();
+    this.emitter.all.clear();
+  }
+  getStats() {
+    const events2 = this.eventNames();
+    const eventCounts = {};
+    for (const event of events2) {
+      const count = this.listenerCount(event);
+      if (count > 0) {
+        eventCounts[event] = count;
+      }
+    }
+    const totalHandlers = Array.from(this.eventHandlers.values()).reduce((sum, handlers) => sum + handlers.length, 0);
+    return {
+      totalProviders: this.eventHandlers.size,
+      totalHandlers,
+      providers: Array.from(this.eventHandlers.keys()).map((p) => p.name),
+      events: events2,
+      eventCounts
+    };
+  }
+};
+__decorate([
+  DI(),
+  __metadata("design:type", typeof (_a = typeof Container !== "undefined" && Container) === "function" ? _a : Object)
+], EventService.prototype, "container", void 0);
+__decorate([
+  Scan(),
+  __metadata("design:type", typeof (_b = typeof ScannerService !== "undefined" && ScannerService) === "function" ? _b : Object)
+], EventService.prototype, "scanner", void 0);
+__decorate([
+  Inject(LoggerService),
+  __metadata("design:type", typeof (_c = typeof LoggerService !== "undefined" && LoggerService) === "function" ? _c : Object)
+], EventService.prototype, "log", void 0);
+EventService = __decorate([
+  Service(),
+  Meta({ layer: "plugin" })
+], EventService);
+
+// src/EventPlugin.ts
+var events = /* @__PURE__ */ __name(() => plugin("events").services(EventService).build(), "events");
+export {
+  EVENTS_META,
+  EVENT_CONFIG,
+  EventService,
+  Events,
+  On,
+  events,
+  getEventListeners
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "najm-event",
+  "version": "0.1.1",
+  "description": "Event .",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./*": {
+      "bun": "./src/*.ts",
+      "types": "./src/*.ts",
+      "import": "./src/*.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "start": "bun --watch src/main.ts",
+    "clean": "rimraf dist tsconfig.tsbuildinfo"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "rimraf": "^6.0.1"
+  },
+  "dependencies": {
+    "mitt": "^3.0.1"
+  },
+  "peerDependencies": {
+    "najm-core": "^0.1.1",
+    "reflect-metadata": "^0.2.0"
+  }
+}