conduithub 0.0.1 → 0.0.2

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

@@ -0,0 +1,126 @@
+'use strict';
+
+const uuid = require('../../shared/conduithub.CvMLTa-R.cjs');
+require('uuid');
+
+class EventBus {
+  handlers = {};
+  initialized = false;
+  logger;
+  constructor(options) {
+    this.logger = uuid.createLogger(options?.logger);
+  }
+  ensureInitialized() {
+    if (!this.initialized) throw new Error("EventBus is not initialized");
+  }
+  async initialize() {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.logger.success("EventBus system initialized successfully");
+  }
+  async shutdown() {
+    this.ensureInitialized();
+    this.handlers = {};
+    this.initialized = false;
+    this.logger.success("EventBus system shutdown completed");
+  }
+  on(type, handler) {
+    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;
+  }
+  once(type, handler) {
+    this.ensureInitialized();
+    const id = uuid.generateUuid();
+    const record = {
+      id,
+      handler,
+      once: true
+    };
+    (this.handlers[type] ??= []).push(record);
+    this.logger.debug(
+      `One-time event handler registered: '${String(type)}' \u2192 ${id}`
+    );
+    return id;
+  }
+  off(type, id) {
+    this.ensureInitialized();
+    const list = this.handlers[type];
+    if (!list) 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];
+    }
+  }
+  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
+        );
+      }
+    }
+  }
+  removeAllListeners(type) {
+    this.ensureInitialized();
+    if (type) {
+      delete this.handlers[type];
+      this.logger.debug(
+        `All listeners removed for event type: '${String(type)}'`
+      );
+    } else {
+      this.handlers = {};
+      this.logger.debug("All event listeners cleared from EventBus");
+    }
+  }
+  listenerCount(type) {
+    return this.handlers[type]?.length ?? 0;
+  }
+  eventNames() {
+    return Object.keys(this.handlers);
+  }
+  getStats() {
+    const names = this.eventNames();
+    const countMap = Object.fromEntries(
+      names.map((name) => [name, this.listenerCount(name)])
+    );
+    return {
+      totalEvents: names.length,
+      totalListeners: Object.values(countMap).reduce((a, b) => a + b, 0),
+      eventNames: names,
+      listenerCount: countMap
+    };
+  }
+  get isInitialized() {
+    return this.initialized;
+  }
+}
+
+exports.EventBus = EventBus;

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

@@ -0,0 +1,42 @@
+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 };

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

@@ -0,0 +1,42 @@
+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 };

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

@@ -0,0 +1,42 @@
+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 };

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

@@ -0,0 +1,124 @@
+import { c as createLogger, g as generateUuid } from '../../shared/conduithub.74V0wiLi.mjs';
+import 'uuid';
+
+class EventBus {
+  handlers = {};
+  initialized = false;
+  logger;
+  constructor(options) {
+    this.logger = createLogger(options?.logger);
+  }
+  ensureInitialized() {
+    if (!this.initialized) throw new Error("EventBus is not initialized");
+  }
+  async initialize() {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.logger.success("EventBus system initialized successfully");
+  }
+  async shutdown() {
+    this.ensureInitialized();
+    this.handlers = {};
+    this.initialized = false;
+    this.logger.success("EventBus system shutdown completed");
+  }
+  on(type, handler) {
+    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;
+  }
+  once(type, handler) {
+    this.ensureInitialized();
+    const id = generateUuid();
+    const record = {
+      id,
+      handler,
+      once: true
+    };
+    (this.handlers[type] ??= []).push(record);
+    this.logger.debug(
+      `One-time event handler registered: '${String(type)}' \u2192 ${id}`
+    );
+    return id;
+  }
+  off(type, id) {
+    this.ensureInitialized();
+    const list = this.handlers[type];
+    if (!list) 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];
+    }
+  }
+  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
+        );
+      }
+    }
+  }
+  removeAllListeners(type) {
+    this.ensureInitialized();
+    if (type) {
+      delete this.handlers[type];
+      this.logger.debug(
+        `All listeners removed for event type: '${String(type)}'`
+      );
+    } else {
+      this.handlers = {};
+      this.logger.debug("All event listeners cleared from EventBus");
+    }
+  }
+  listenerCount(type) {
+    return this.handlers[type]?.length ?? 0;
+  }
+  eventNames() {
+    return Object.keys(this.handlers);
+  }
+  getStats() {
+    const names = this.eventNames();
+    const countMap = Object.fromEntries(
+      names.map((name) => [name, this.listenerCount(name)])
+    );
+    return {
+      totalEvents: names.length,
+      totalListeners: Object.values(countMap).reduce((a, b) => a + b, 0),
+      eventNames: names,
+      listenerCount: countMap
+    };
+  }
+  get isInitialized() {
+    return this.initialized;
+  }
+}
+
+export { EventBus };

package/dist/core/hook/index.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+const uuid = require('../../shared/conduithub.CvMLTa-R.cjs');
+require('uuid');
+
+class Hook {
+  hooks = /* @__PURE__ */ new Map();
+  initialized = false;
+  logger;
+  failFast;
+  onError;
+  constructor(options, logger) {
+    this.failFast = options?.failFast ?? false;
+    this.onError = options?.onError;
+    this.logger = logger ?? uuid.createLogger({ name: "Hook" });
+  }
+  ensure() {
+    if (!this.initialized) throw new Error("Hook system is not initialized");
+  }
+  async initialize() {
+    if (!this.initialized) {
+      this.initialized = true;
+      this.logger.success("Hook system initialized successfully");
+    }
+  }
+  async shutdown() {
+    this.ensure();
+    const hookCount = Array.from(this.hooks.values()).reduce(
+      (total, handlers) => total + handlers.length,
+      0
+    );
+    this.hooks.clear();
+    this.initialized = false;
+    this.logger.success(
+      `Hook system shutdown completed - cleared ${hookCount} handlers`
+    );
+  }
+  registerHook(hook, handler, priority = 0, customId) {
+    this.ensure();
+    if (!this.hooks.has(hook)) this.hooks.set(hook, []);
+    const id = customId ?? uuid.generateUuid();
+    const entry = {
+      id,
+      hook: String(hook),
+      handler,
+      priority
+    };
+    this.hooks.get(hook).push(entry);
+    this.hooks.get(hook).sort((a, b) => b.priority - a.priority);
+    const handlerCount = this.hooks.get(hook).length;
+    this.logger.debug(
+      `Hook registered: '${String(hook)}' \u2192 ${id} (priority: ${priority}, total handlers: ${handlerCount})`
+    );
+    return id;
+  }
+  unregisterHook(hook, id) {
+    this.ensure();
+    const list = this.hooks.get(hook);
+    if (!list) {
+      this.logger.warn(
+        `Failed to unregister hook: '${String(hook)}' \u2192 ${id} (handler not found)`
+      );
+      return false;
+    }
+    const index = list.findIndex((h) => h.id === id);
+    if (index >= 0) {
+      list.splice(index, 1);
+      const remainingCount = list.length;
+      if (remainingCount === 0) this.hooks.delete(hook);
+      this.logger.debug(
+        `Hook unregistered: '${String(hook)}' \u2192 ${id} (remaining handlers: ${remainingCount})`
+      );
+      return true;
+    }
+    this.logger.warn(
+      `Failed to unregister hook: '${String(hook)}' \u2192 ${id} (handler not found)`
+    );
+    return false;
+  }
+  async handleHookResult(raw, failFast, hook, handlerId) {
+    try {
+      const result = await raw;
+      if (typeof result === "object" && result && "success" in result) {
+        const res = result;
+        if (!res.success && failFast) throw new Error(res.error);
+        this.logger.debug(
+          `Hook handler completed: '${String(hook)}' \u2192 ${handlerId} (success: ${res.success})`
+        );
+        return res;
+      }
+      this.logger.debug(
+        `Hook handler completed: '${String(hook)}' \u2192 ${handlerId} (success: true)`
+      );
+      return { success: true, data: result };
+    } catch (err) {
+      if (failFast) throw err;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      this.logger.error(
+        `Hook handler failed: '${String(hook)}' \u2192 ${handlerId} - ${errorMessage}`
+      );
+      this.onError?.(err, hook);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  async executeHook(hook, data) {
+    this.ensure();
+    const list = this.hooks.get(hook);
+    if (!list?.length) {
+      this.logger.debug(
+        `Hook execution skipped: '${String(hook)}' (no handlers registered)`
+      );
+      return data;
+    }
+    this.logger.debug(
+      `Hook execution started: '${String(hook)}' (${list.length} handlers)`
+    );
+    let result = data;
+    let successCount = 0;
+    let errorCount = 0;
+    for (const { handler, id } of list) {
+      const {
+        success,
+        data: output,
+        error
+      } = await this.handleHookResult(
+        Promise.resolve().then(() => handler(result)),
+        this.failFast,
+        hook,
+        id
+      );
+      if (success) {
+        successCount++;
+        if (output !== void 0) result = output;
+      } else {
+        errorCount++;
+        if (this.failFast) throw new Error(error);
+      }
+    }
+    this.logger.debug(
+      `Hook execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
+    );
+    return result;
+  }
+  async executeHookSeries(hook, data) {
+    this.ensure();
+    const list = this.hooks.get(hook);
+    if (!list?.length) {
+      this.logger.debug(
+        `Hook series execution skipped: '${String(hook)}' (no handlers registered)`
+      );
+      return [];
+    }
+    this.logger.debug(
+      `Hook series execution started: '${String(hook)}' (${list.length} handlers)`
+    );
+    const results = [];
+    for (const { handler, id } of list) {
+      const result = await this.handleHookResult(
+        Promise.resolve().then(() => handler(data)),
+        false,
+        // Never fail fast in series execution, just collect results
+        hook,
+        id
+      );
+      results.push(result);
+      if (!result.success && this.failFast) break;
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const errorCount = results.filter((r) => !r.success).length;
+    this.logger.debug(
+      `Hook series execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
+    );
+    return results;
+  }
+  async executeHookSeriesWithContext(hook, data, context) {
+    this.ensure();
+    const handlers = this.hooks.get(hook);
+    if (!handlers || handlers.length === 0) {
+      this.logger.debug(
+        `Hook series execution skipped: '${String(hook)}' (no handlers registered)`
+      );
+      return [];
+    }
+    this.logger.debug(
+      `Hook series execution started: '${String(hook)}' (${handlers.length} handlers)`
+    );
+    const results = [];
+    for (const { handler, id } of handlers) {
+      const result = await this.handleHookResult(
+        Promise.resolve().then(() => handler(data)),
+        this.failFast,
+        hook,
+        id
+      );
+      results.push(result);
+      if (!result.success && this.failFast) break;
+    }
+    const successCount = results.filter((r) => r.success).length;
+    const errorCount = results.filter((r) => !r.success).length;
+    this.logger.debug(
+      `Hook series execution completed: '${String(hook)}' (${successCount} succeeded, ${errorCount} failed)`
+    );
+    return results;
+  }
+}
+
+exports.Hook = Hook;

package/dist/core/hook/index.d.cts

@@ -0,0 +1,40 @@
+import { c as createLogger } from '../../shared/conduithub.B7aryjPG.cjs';
+
+interface HookResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+interface HookHandler<I = unknown, O = unknown> {
+    id: string;
+    hook: string;
+    handler: (data: I) => Promise<HookResult<O> | O> | HookResult<O> | O;
+    priority: number;
+}
+
+declare class Hook<HM extends Record<string, {
+    input: any;
+    output: any;
+}>> {
+    private hooks;
+    private initialized;
+    private logger;
+    private failFast;
+    private onError?;
+    constructor(options?: {
+        failFast?: boolean;
+        onError?: (err: unknown, hook: keyof HM) => void;
+    }, logger?: ReturnType<typeof createLogger>);
+    private ensure;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    registerHook<K extends keyof HM>(hook: K, handler: (data: HM[K]["input"]) => HookResult<HM[K]["output"]> | Promise<HookResult<HM[K]["output"]>> | HM[K]["output"] | Promise<HM[K]["output"]>, priority?: number, customId?: string): string;
+    unregisterHook<K extends keyof HM>(hook: K, id: string): boolean;
+    private handleHookResult;
+    executeHook<K extends keyof HM>(hook: K, data: HM[K]["input"]): Promise<HM[K]["output"]>;
+    executeHookSeries<K extends keyof HM>(hook: K, data: HM[K]["input"]): Promise<HookResult<HM[K]["output"]>[]>;
+    executeHookSeriesWithContext<K extends keyof HM>(hook: K, data: HM[K]["input"], context: Record<string, unknown>): Promise<HookResult<HM[K]["output"]>[]>;
+}
+
+export { Hook };
+export type { HookHandler, HookResult };

package/dist/core/hook/index.d.mts

@@ -0,0 +1,40 @@
+import { c as createLogger } from '../../shared/conduithub.B7aryjPG.mjs';
+
+interface HookResult<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+interface HookHandler<I = unknown, O = unknown> {
+    id: string;
+    hook: string;
+    handler: (data: I) => Promise<HookResult<O> | O> | HookResult<O> | O;
+    priority: number;
+}
+
+declare class Hook<HM extends Record<string, {
+    input: any;
+    output: any;
+}>> {
+    private hooks;
+    private initialized;
+    private logger;
+    private failFast;
+    private onError?;
+    constructor(options?: {
+        failFast?: boolean;
+        onError?: (err: unknown, hook: keyof HM) => void;
+    }, logger?: ReturnType<typeof createLogger>);
+    private ensure;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    registerHook<K extends keyof HM>(hook: K, handler: (data: HM[K]["input"]) => HookResult<HM[K]["output"]> | Promise<HookResult<HM[K]["output"]>> | HM[K]["output"] | Promise<HM[K]["output"]>, priority?: number, customId?: string): string;
+    unregisterHook<K extends keyof HM>(hook: K, id: string): boolean;
+    private handleHookResult;
+    executeHook<K extends keyof HM>(hook: K, data: HM[K]["input"]): Promise<HM[K]["output"]>;
+    executeHookSeries<K extends keyof HM>(hook: K, data: HM[K]["input"]): Promise<HookResult<HM[K]["output"]>[]>;
+    executeHookSeriesWithContext<K extends keyof HM>(hook: K, data: HM[K]["input"], context: Record<string, unknown>): Promise<HookResult<HM[K]["output"]>[]>;
+}
+
+export { Hook };
+export type { HookHandler, HookResult };