conduithub 0.1.0 → 1.0.1

package/dist/core/event-bus/index.cjs

@@ -1,17 +1,62 @@
 'use strict';
 
-const uuid = require('../../shared/conduithub.CvMLTa-R.cjs');
+const error_index = require('../../error/index.cjs');
+const logger = require('../../shared/conduithub.BNQsddJO.cjs');
+require('process');
+require('readline');
+const uuid = require('../../shared/conduithub.Bq_7Xj0J.cjs');
+const code = require('../../shared/conduithub.CmZo_Vuc.cjs');
 require('uuid');
 
 class EventBus {
   handlers = {};
+  locks = /* @__PURE__ */ new Map();
   initialized = false;
   logger;
+  maxHandlersPerEvent;
+  handlerTimeoutMs;
+  onError;
   constructor(options) {
-    this.logger = uuid.createLogger(options?.logger);
+    this.logger = logger.createLogger(options?.logger);
+    this.maxHandlersPerEvent = options?.maxHandlersPerEvent ?? 100;
+    this.handlerTimeoutMs = options?.handlerTimeoutMs ?? 5e3;
+    this.onError = options?.onError;
+  }
+  async withEventLock(type, operation) {
+    const currentLock = this.locks.get(type) ?? Promise.resolve();
+    let resolveLock;
+    const newLock = new Promise((resolve) => {
+      resolveLock = resolve;
+    });
+    this.locks.set(
+      type,
+      currentLock.then(() => newLock)
+    );
+    await currentLock;
+    try {
+      return await operation();
+    } finally {
+      resolveLock();
+    }
   }
   ensureInitialized() {
-    if (!this.initialized) throw new Error("EventBus is not initialized");
+    if (!this.initialized) {
+      throw new error_index.ConduithubError(code.ERROR_CODE.EVENT_BUS_NOT_INITIALIZED);
+    }
+  }
+  sanitizeLog(data) {
+    if (typeof data === "string") {
+      return data.length > 100 ? `${data.substring(0, 100)}...` : data;
+    }
+    if (typeof data === "object" && data !== null) {
+      try {
+        const json = JSON.stringify(data);
+        return json.length > 100 ? `${json.substring(0, 100)}...` : json;
+      } catch {
+        return "[Unserializable Object]";
+      }
+    }
+    return String(data);
   }
   async initialize() {
     if (this.initialized) return;
@@ -20,73 +65,125 @@ class EventBus {
   }
   async shutdown() {
     this.ensureInitialized();
-    this.handlers = {};
+    const totalHandlers = this.getTotalHandlerCount();
+    this.clearAllHandlers();
     this.initialized = false;
-    this.logger.success("EventBus system shutdown completed");
+    this.logger.success(
+      `EventBus system shutdown completed - cleared ${totalHandlers} handlers`
+    );
+  }
+  getTotalHandlerCount() {
+    return Object.values(this.handlers).reduce(
+      (sum, list) => sum + (list?.length ?? 0),
+      0
+    );
+  }
+  clearAllHandlers() {
+    for (const key in this.handlers) {
+      delete this.handlers[key];
+    }
   }
-  on(type, handler) {
+  on(type, handler, priority = 0, customId) {
     this.ensureInitialized();
-    const id = uuid.generateUuid();
-    const record = {
-      id,
-      handler,
-      once: false
-    };
-    (this.handlers[type] ??= []).push(record);
-    this.logger.debug(`Event handler registered: '${String(type)}' \u2192 ${id}`);
-    return id;
+    return this.registerHandler(type, handler, false, priority, customId);
   }
-  once(type, handler) {
+  once(type, handler, priority = 0, customId) {
     this.ensureInitialized();
-    const id = uuid.generateUuid();
+    return this.registerHandler(type, handler, true, priority, customId);
+  }
+  registerHandler(type, handler, once, priority, customId) {
+    const list = this.handlers[type] ??= [];
+    if (list.length >= this.maxHandlersPerEvent) {
+      throw new error_index.ConduithubError(
+        `${code.ERROR_CODE.EVENT_HANDLER_LIMIT_EXCEEDED} ${String(type)} (${this.maxHandlersPerEvent})`
+      );
+    }
+    const id = customId ?? uuid.generateUuid();
+    if (customId && list.some((h) => h.id === customId)) {
+      throw new error_index.ConduithubError(
+        `${code.ERROR_CODE.DUPLICATE_EVENT_HANDLER_ID} ${String(type)}: ${customId}`
+      );
+    }
     const record = {
       id,
       handler,
-      once: true
+      once,
+      priority
     };
-    (this.handlers[type] ??= []).push(record);
+    list.push(record);
+    const handlerType = once ? "One-time event handler" : "Event handler";
     this.logger.debug(
-      `One-time event handler registered: '${String(type)}' \u2192 ${id}`
+      `${handlerType} registered: '${String(type)}' \u2192 ${id} (priority: ${priority})`
     );
     return id;
   }
   off(type, id) {
     this.ensureInitialized();
     const list = this.handlers[type];
-    if (!list) return;
+    if (!list) {
+      this.logger.debug(`No handlers found for event: '${String(type)}'`);
+      return;
+    }
     if (!id) {
       delete this.handlers[type];
       this.logger.debug(`All event handlers removed for: '${String(type)}'`);
       return;
     }
     const index = list.findIndex((h) => h.id === id);
-    if (index !== -1) {
-      list.splice(index, 1);
-      this.logger.debug(`Event handler removed: '${String(type)}' \u2192 ${id}`);
-      if (list.length === 0) delete this.handlers[type];
+    if (index === -1) {
+      this.logger.warn(`Handler not found: '${String(type)}' \u2192 ${id}`);
+      return;
+    }
+    list.splice(index, 1);
+    this.logger.debug(`Event handler removed: '${String(type)}' \u2192 ${id}`);
+    if (list.length === 0) {
+      delete this.handlers[type];
     }
   }
-  async emit(type, payload, source = "event-bus") {
-    this.ensureInitialized();
-    const list = this.handlers[type];
-    if (!list?.length) return;
-    const event = {
-      type,
-      payload,
-      timestamp: Date.now(),
-      source
-    };
-    for (const { id, handler, once } of [...list]) {
-      try {
-        await handler(event);
-        if (once) this.off(type, id);
-      } catch (err) {
-        this.logger.error(
-          `Event handler execution failed: '${String(type)}' \u2192 ${id}`,
-          err
-        );
+  async emit(type, payload, source = "event-bus", context) {
+    await this.withEventLock(type, async () => {
+      this.ensureInitialized();
+      const list = this.handlers[type];
+      if (!list?.length) {
+        this.logger.debug(`No handlers for event: '${String(type)}'`);
+        return;
       }
-    }
+      const sortedList = [...list].sort((a, b) => b.priority - a.priority);
+      const event = {
+        type,
+        payload,
+        timestamp: Date.now(),
+        source,
+        context
+      };
+      let successCount = 0;
+      let errorCount = 0;
+      for (const { id, handler, once } of sortedList) {
+        try {
+          await Promise.race([
+            Promise.resolve(handler(event, context)),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new Error("Handler timeout")),
+                this.handlerTimeoutMs
+              )
+            )
+          ]);
+          successCount++;
+          if (once) this.off(type, id);
+        } catch (err) {
+          errorCount++;
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          this.logger.error(
+            `Event handler execution failed: '${String(type)}' \u2192 ${id} - ${this.sanitizeLog(errorMessage)}`
+          );
+          this.onError?.(err, type);
+        }
+      }
+      this.logger.debug(
+        `Event emitted: '${String(type)}' (${successCount} succeeded, ${errorCount} failed)`
+      );
+    });
   }
   removeAllListeners(type) {
     this.ensureInitialized();
@@ -96,7 +193,7 @@ class EventBus {
         `All listeners removed for event type: '${String(type)}'`
       );
     } else {
-      this.handlers = {};
+      this.clearAllHandlers();
       this.logger.debug("All event listeners cleared from EventBus");
     }
   }
@@ -107,15 +204,19 @@ class EventBus {
     return Object.keys(this.handlers);
   }
   getStats() {
-    const names = this.eventNames();
-    const countMap = Object.fromEntries(
-      names.map((name) => [name, this.listenerCount(name)])
+    const eventNames = this.eventNames();
+    const listenerCount = Object.fromEntries(
+      eventNames.map((name) => [name, this.listenerCount(name)])
+    );
+    const totalListeners = Object.values(listenerCount).reduce(
+      (sum, count) => sum + count,
+      0
     );
     return {
-      totalEvents: names.length,
-      totalListeners: Object.values(countMap).reduce((a, b) => a + b, 0),
-      eventNames: names,
-      listenerCount: countMap
+      totalEvents: eventNames.length,
+      totalListeners,
+      eventNames,
+      listenerCount
     };
   }
   get isInitialized() {

package/dist/core/event-bus/index.d.cts

@@ -1,42 +1,2 @@
-import { a as Logger } from '../../shared/conduithub.B7aryjPG.cjs';
-
-interface EventData<K extends string, P> {
-    type: K;
-    payload: P;
-    timestamp: number;
-    source: string;
-}
-interface EventHandlerRecord<K extends string, P> {
-    id: string;
-    once: boolean;
-    handler: (event: EventData<K, P>) => Promise<void> | void;
-}
-
-declare class EventBus<EM extends Record<string, unknown>> {
-    private handlers;
-    private initialized;
-    private logger;
-    constructor(options?: {
-        logger?: Logger;
-    });
-    private ensureInitialized;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    on<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
-    once<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
-    off<K extends keyof EM>(type: K, id?: string): void;
-    emit<K extends keyof EM>(type: K, payload: EM[K], source?: string): Promise<void>;
-    removeAllListeners<K extends keyof EM>(type?: K): void;
-    listenerCount<K extends keyof EM>(type: K): number;
-    eventNames(): Array<keyof EM>;
-    getStats(): {
-        totalEvents: number;
-        totalListeners: number;
-        eventNames: (keyof EM)[];
-        listenerCount: Record<keyof EM, number>;
-    };
-    get isInitialized(): boolean;
-}
-
-export { EventBus };
-export type { EventData, EventHandlerRecord };
+import '../../shared/conduithub.B7aryjPG.cjs';
+export { E as EventBus } from '../../shared/conduithub.BZQmkQy7.cjs';

package/dist/core/event-bus/index.d.mts

@@ -1,42 +1,2 @@
-import { a as Logger } from '../../shared/conduithub.B7aryjPG.mjs';
-
-interface EventData<K extends string, P> {
-    type: K;
-    payload: P;
-    timestamp: number;
-    source: string;
-}
-interface EventHandlerRecord<K extends string, P> {
-    id: string;
-    once: boolean;
-    handler: (event: EventData<K, P>) => Promise<void> | void;
-}
-
-declare class EventBus<EM extends Record<string, unknown>> {
-    private handlers;
-    private initialized;
-    private logger;
-    constructor(options?: {
-        logger?: Logger;
-    });
-    private ensureInitialized;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    on<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
-    once<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
-    off<K extends keyof EM>(type: K, id?: string): void;
-    emit<K extends keyof EM>(type: K, payload: EM[K], source?: string): Promise<void>;
-    removeAllListeners<K extends keyof EM>(type?: K): void;
-    listenerCount<K extends keyof EM>(type: K): number;
-    eventNames(): Array<keyof EM>;
-    getStats(): {
-        totalEvents: number;
-        totalListeners: number;
-        eventNames: (keyof EM)[];
-        listenerCount: Record<keyof EM, number>;
-    };
-    get isInitialized(): boolean;
-}
-
-export { EventBus };
-export type { EventData, EventHandlerRecord };
+import '../../shared/conduithub.B7aryjPG.mjs';
+export { E as EventBus } from '../../shared/conduithub.BzLwccre.mjs';

package/dist/core/event-bus/index.d.ts

@@ -1,42 +1,2 @@
-import { a as Logger } from '../../shared/conduithub.B7aryjPG.js';
-
-interface EventData<K extends string, P> {
-    type: K;
-    payload: P;
-    timestamp: number;
-    source: string;
-}
-interface EventHandlerRecord<K extends string, P> {
-    id: string;
-    once: boolean;
-    handler: (event: EventData<K, P>) => Promise<void> | void;
-}
-
-declare class EventBus<EM extends Record<string, unknown>> {
-    private handlers;
-    private initialized;
-    private logger;
-    constructor(options?: {
-        logger?: Logger;
-    });
-    private ensureInitialized;
-    initialize(): Promise<void>;
-    shutdown(): Promise<void>;
-    on<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
-    once<K extends keyof EM>(type: K, handler: (event: EventData<K & string, EM[K]>) => Promise<void> | void): string;
-    off<K extends keyof EM>(type: K, id?: string): void;
-    emit<K extends keyof EM>(type: K, payload: EM[K], source?: string): Promise<void>;
-    removeAllListeners<K extends keyof EM>(type?: K): void;
-    listenerCount<K extends keyof EM>(type: K): number;
-    eventNames(): Array<keyof EM>;
-    getStats(): {
-        totalEvents: number;
-        totalListeners: number;
-        eventNames: (keyof EM)[];
-        listenerCount: Record<keyof EM, number>;
-    };
-    get isInitialized(): boolean;
-}
-
-export { EventBus };
-export type { EventData, EventHandlerRecord };
+import '../../shared/conduithub.B7aryjPG.js';
+export { E as EventBus } from '../../shared/conduithub.DQOWQ-Bx.js';

package/dist/core/event-bus/index.mjs

@@ -1,15 +1,60 @@
-import { c as createLogger, g as generateUuid } from '../../shared/conduithub.74V0wiLi.mjs';
+import { ConduithubError } from '../../error/index.mjs';
+import { c as createLogger } from '../../shared/conduithub.BNefRQsK.mjs';
+import 'process';
+import 'readline';
+import { g as generateUuid } from '../../shared/conduithub.CkOQG3cD.mjs';
+import { E as ERROR_CODE } from '../../shared/conduithub.G7ICpZIy.mjs';
 import 'uuid';
 
 class EventBus {
   handlers = {};
+  locks = /* @__PURE__ */ new Map();
   initialized = false;
   logger;
+  maxHandlersPerEvent;
+  handlerTimeoutMs;
+  onError;
   constructor(options) {
     this.logger = createLogger(options?.logger);
+    this.maxHandlersPerEvent = options?.maxHandlersPerEvent ?? 100;
+    this.handlerTimeoutMs = options?.handlerTimeoutMs ?? 5e3;
+    this.onError = options?.onError;
+  }
+  async withEventLock(type, operation) {
+    const currentLock = this.locks.get(type) ?? Promise.resolve();
+    let resolveLock;
+    const newLock = new Promise((resolve) => {
+      resolveLock = resolve;
+    });
+    this.locks.set(
+      type,
+      currentLock.then(() => newLock)
+    );
+    await currentLock;
+    try {
+      return await operation();
+    } finally {
+      resolveLock();
+    }
   }
   ensureInitialized() {
-    if (!this.initialized) throw new Error("EventBus is not initialized");
+    if (!this.initialized) {
+      throw new ConduithubError(ERROR_CODE.EVENT_BUS_NOT_INITIALIZED);
+    }
+  }
+  sanitizeLog(data) {
+    if (typeof data === "string") {
+      return data.length > 100 ? `${data.substring(0, 100)}...` : data;
+    }
+    if (typeof data === "object" && data !== null) {
+      try {
+        const json = JSON.stringify(data);
+        return json.length > 100 ? `${json.substring(0, 100)}...` : json;
+      } catch {
+        return "[Unserializable Object]";
+      }
+    }
+    return String(data);
   }
   async initialize() {
     if (this.initialized) return;
@@ -18,73 +63,125 @@ class EventBus {
   }
   async shutdown() {
     this.ensureInitialized();
-    this.handlers = {};
+    const totalHandlers = this.getTotalHandlerCount();
+    this.clearAllHandlers();
     this.initialized = false;
-    this.logger.success("EventBus system shutdown completed");
+    this.logger.success(
+      `EventBus system shutdown completed - cleared ${totalHandlers} handlers`
+    );
+  }
+  getTotalHandlerCount() {
+    return Object.values(this.handlers).reduce(
+      (sum, list) => sum + (list?.length ?? 0),
+      0
+    );
+  }
+  clearAllHandlers() {
+    for (const key in this.handlers) {
+      delete this.handlers[key];
+    }
   }
-  on(type, handler) {
+  on(type, handler, priority = 0, customId) {
     this.ensureInitialized();
-    const id = generateUuid();
-    const record = {
-      id,
-      handler,
-      once: false
-    };
-    (this.handlers[type] ??= []).push(record);
-    this.logger.debug(`Event handler registered: '${String(type)}' \u2192 ${id}`);
-    return id;
+    return this.registerHandler(type, handler, false, priority, customId);
   }
-  once(type, handler) {
+  once(type, handler, priority = 0, customId) {
     this.ensureInitialized();
-    const id = generateUuid();
+    return this.registerHandler(type, handler, true, priority, customId);
+  }
+  registerHandler(type, handler, once, priority, customId) {
+    const list = this.handlers[type] ??= [];
+    if (list.length >= this.maxHandlersPerEvent) {
+      throw new ConduithubError(
+        `${ERROR_CODE.EVENT_HANDLER_LIMIT_EXCEEDED} ${String(type)} (${this.maxHandlersPerEvent})`
+      );
+    }
+    const id = customId ?? generateUuid();
+    if (customId && list.some((h) => h.id === customId)) {
+      throw new ConduithubError(
+        `${ERROR_CODE.DUPLICATE_EVENT_HANDLER_ID} ${String(type)}: ${customId}`
+      );
+    }
     const record = {
       id,
       handler,
-      once: true
+      once,
+      priority
     };
-    (this.handlers[type] ??= []).push(record);
+    list.push(record);
+    const handlerType = once ? "One-time event handler" : "Event handler";
     this.logger.debug(
-      `One-time event handler registered: '${String(type)}' \u2192 ${id}`
+      `${handlerType} registered: '${String(type)}' \u2192 ${id} (priority: ${priority})`
     );
     return id;
   }
   off(type, id) {
     this.ensureInitialized();
     const list = this.handlers[type];
-    if (!list) return;
+    if (!list) {
+      this.logger.debug(`No handlers found for event: '${String(type)}'`);
+      return;
+    }
     if (!id) {
       delete this.handlers[type];
       this.logger.debug(`All event handlers removed for: '${String(type)}'`);
       return;
     }
     const index = list.findIndex((h) => h.id === id);
-    if (index !== -1) {
-      list.splice(index, 1);
-      this.logger.debug(`Event handler removed: '${String(type)}' \u2192 ${id}`);
-      if (list.length === 0) delete this.handlers[type];
+    if (index === -1) {
+      this.logger.warn(`Handler not found: '${String(type)}' \u2192 ${id}`);
+      return;
+    }
+    list.splice(index, 1);
+    this.logger.debug(`Event handler removed: '${String(type)}' \u2192 ${id}`);
+    if (list.length === 0) {
+      delete this.handlers[type];
     }
   }
-  async emit(type, payload, source = "event-bus") {
-    this.ensureInitialized();
-    const list = this.handlers[type];
-    if (!list?.length) return;
-    const event = {
-      type,
-      payload,
-      timestamp: Date.now(),
-      source
-    };
-    for (const { id, handler, once } of [...list]) {
-      try {
-        await handler(event);
-        if (once) this.off(type, id);
-      } catch (err) {
-        this.logger.error(
-          `Event handler execution failed: '${String(type)}' \u2192 ${id}`,
-          err
-        );
+  async emit(type, payload, source = "event-bus", context) {
+    await this.withEventLock(type, async () => {
+      this.ensureInitialized();
+      const list = this.handlers[type];
+      if (!list?.length) {
+        this.logger.debug(`No handlers for event: '${String(type)}'`);
+        return;
       }
-    }
+      const sortedList = [...list].sort((a, b) => b.priority - a.priority);
+      const event = {
+        type,
+        payload,
+        timestamp: Date.now(),
+        source,
+        context
+      };
+      let successCount = 0;
+      let errorCount = 0;
+      for (const { id, handler, once } of sortedList) {
+        try {
+          await Promise.race([
+            Promise.resolve(handler(event, context)),
+            new Promise(
+              (_, reject) => setTimeout(
+                () => reject(new Error("Handler timeout")),
+                this.handlerTimeoutMs
+              )
+            )
+          ]);
+          successCount++;
+          if (once) this.off(type, id);
+        } catch (err) {
+          errorCount++;
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          this.logger.error(
+            `Event handler execution failed: '${String(type)}' \u2192 ${id} - ${this.sanitizeLog(errorMessage)}`
+          );
+          this.onError?.(err, type);
+        }
+      }
+      this.logger.debug(
+        `Event emitted: '${String(type)}' (${successCount} succeeded, ${errorCount} failed)`
+      );
+    });
   }
   removeAllListeners(type) {
     this.ensureInitialized();
@@ -94,7 +191,7 @@ class EventBus {
         `All listeners removed for event type: '${String(type)}'`
       );
     } else {
-      this.handlers = {};
+      this.clearAllHandlers();
       this.logger.debug("All event listeners cleared from EventBus");
     }
   }
@@ -105,15 +202,19 @@ class EventBus {
     return Object.keys(this.handlers);
   }
   getStats() {
-    const names = this.eventNames();
-    const countMap = Object.fromEntries(
-      names.map((name) => [name, this.listenerCount(name)])
+    const eventNames = this.eventNames();
+    const listenerCount = Object.fromEntries(
+      eventNames.map((name) => [name, this.listenerCount(name)])
+    );
+    const totalListeners = Object.values(listenerCount).reduce(
+      (sum, count) => sum + count,
+      0
     );
     return {
-      totalEvents: names.length,
-      totalListeners: Object.values(countMap).reduce((a, b) => a + b, 0),
-      eventNames: names,
-      listenerCount: countMap
+      totalEvents: eventNames.length,
+      totalListeners,
+      eventNames,
+      listenerCount
     };
   }
   get isInitialized() {