conduithub 0.1.0 → 1.0.0

package/dist/core/plugin/index.mjs

@@ -0,0 +1,268 @@
+import { E as ERROR_CODE } from '../../shared/conduithub.G7ICpZIy.mjs';
+export { P as PluginManager } from '../../shared/conduithub.DyQQrHW9.mjs';
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+class BasePlugin {
+  config;
+  context;
+  metadata;
+  isInitialized = false;
+  isRunning = false;
+  managedEventHandlers = [];
+  managedHookHandlers = [];
+  lock = Promise.resolve();
+  constructor(config) {
+    this.config = config;
+    this.metadata = this.getMetadata();
+  }
+  async initialize(context) {
+    await this.withLock(async () => {
+      if (this.isInitialized) return;
+      this.context = context;
+      try {
+        await this.executeLifecycleHook("beforeInit");
+        await this.onInitialize();
+        this.isInitialized = true;
+        await this.executeLifecycleHook("afterInit");
+        this.context.logger.log?.(
+          "info",
+          `Plugin ${this.config.name} initialized successfully`
+        );
+      } catch (error) {
+        this.context.logger.log?.(
+          "error",
+          `Failed to initialize plugin ${this.config.name}:`,
+          error
+        );
+        throw error;
+      }
+    });
+  }
+  async start() {
+    await this.withLock(async () => {
+      if (!this.isInitialized)
+        throw new Error(ERROR_CODE.PLUGIN_NOT_INITIALIZED);
+      if (this.isRunning) return;
+      try {
+        await this.executeLifecycleHook("beforeStart");
+        await this.onStart();
+        this.isRunning = true;
+        await this.executeLifecycleHook("afterStart");
+        this.context.logger.log?.(
+          "info",
+          `Plugin ${this.config.name} started successfully`
+        );
+      } catch (error) {
+        this.context.logger.log?.(
+          "error",
+          `Failed to start plugin ${this.config.name}:`,
+          error
+        );
+        throw error;
+      }
+    });
+  }
+  async stop() {
+    await this.withLock(async () => {
+      if (!this.isRunning) return;
+      try {
+        await this.executeLifecycleHook("beforeStop");
+        await this.onStop();
+        this.isRunning = false;
+        await this.executeLifecycleHook("afterStop");
+        this.context.logger.log?.(
+          "info",
+          `Plugin ${this.config.name} stopped successfully`
+        );
+      } catch (error) {
+        this.context.logger.log?.(
+          "error",
+          `Failed to stop plugin ${this.config.name}:`,
+          error
+        );
+        throw error;
+      }
+    });
+  }
+  async destroy() {
+    await this.withLock(async () => {
+      if (!this.isInitialized)
+        throw new Error(ERROR_CODE.PLUGIN_NOT_INITIALIZED);
+      try {
+        await this.executeLifecycleHook("beforeDestroy");
+        await this.onDestroy();
+        await this.cleanupManagedHandlers();
+        await this.cleanupManagedHooks();
+        this.isInitialized = false;
+        await this.executeLifecycleHook("afterDestroy");
+        this.context.logger.log?.(
+          "info",
+          `Plugin ${this.config.name} destroyed successfully`
+        );
+      } catch (error) {
+        this.context.logger.log?.(
+          "error",
+          `Failed to destroy plugin ${this.config.name}:`,
+          error
+        );
+        throw error;
+      }
+    });
+  }
+  async executeLifecycleHook(hook) {
+    try {
+      await this.context.hookSystem.executeHook(
+        `plugin:${this.config.name}:${hook}`,
+        {
+          plugin: this,
+          config: this.config,
+          context: this.context
+        }
+      );
+    } catch (error) {
+      this.context.logger.log?.(
+        "warn",
+        `Lifecycle hook ${hook} for plugin ${this.config.name} failed:`,
+        error
+      );
+    }
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  getContext() {
+    return this.context;
+  }
+  isPluginInitialized() {
+    return this.isInitialized;
+  }
+  isPluginRunning() {
+    return this.isRunning;
+  }
+  async emit(event, data) {
+    await this.context.eventBus.emit(event, data);
+  }
+  on(event, listener) {
+    return this.context.eventBus.on(
+      event,
+      (eventData) => listener(eventData.payload, eventData)
+    );
+  }
+  once(event, listener) {
+    return this.context.eventBus.once(
+      event,
+      (eventData) => listener(eventData.payload, eventData)
+    );
+  }
+  onManaged(event, listener) {
+    const id = this.on(event, listener);
+    this.managedEventHandlers.push({ event, id });
+    return id;
+  }
+  onceManaged(event, listener) {
+    const id = this.once(event, listener);
+    this.managedEventHandlers.push({ event, id });
+    return id;
+  }
+  off(event, handlerId) {
+    this.context.eventBus.off(event, handlerId);
+  }
+  async executeHook(hook, input) {
+    return await this.context.hookSystem.executeHook(hook, input);
+  }
+  async executeHookSeries(hook, input) {
+    return await this.context.hookSystem.executeHookSeries(hook, input);
+  }
+  async executeHookSeriesWithContext(hook, input, context) {
+    return await this.context.hookSystem.executeHookSeriesWithContext(
+      hook,
+      input,
+      context
+    );
+  }
+  async registerHook(hook, handler, priority = 0, customId) {
+    return await this.context.hookSystem.registerHook(
+      hook,
+      handler,
+      priority,
+      customId
+    );
+  }
+  async registerHookManaged(hook, handler, priority = 0, customId) {
+    const id = await this.registerHook(hook, handler, priority, customId);
+    this.managedHookHandlers.push({ hook, id });
+    return id;
+  }
+  async unregisterHook(hook, handlerId) {
+    return await this.context.hookSystem.unregisterHook(hook, handlerId);
+  }
+  getStatus() {
+    return { initialized: this.isInitialized, running: this.isRunning };
+  }
+  getName() {
+    return this.config.name;
+  }
+  getVersion() {
+    return this.config.version;
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  getState(key) {
+    return this.context.stateManager.get(key);
+  }
+  setState(key, value) {
+    this.context.stateManager.set(key, value);
+  }
+  deleteState(key) {
+    this.context.stateManager.delete(key);
+  }
+  get logger() {
+    return this.context.logger;
+  }
+  updateConfig(update) {
+    const next = {
+      ...this.config,
+      ...update
+    };
+    if (isRecord(update) && "config" in update && isRecord(update.config) && isRecord(next.config)) {
+      next.config = { ...next.config, ...update.config };
+    }
+    this.config = next;
+  }
+  async cleanupManagedHandlers() {
+    for (const { event, id } of this.managedEventHandlers) {
+      try {
+        this.off(event, id);
+      } catch {
+      }
+    }
+    this.managedEventHandlers = [];
+  }
+  async cleanupManagedHooks() {
+    for (const { hook, id } of this.managedHookHandlers) {
+      try {
+        await this.unregisterHook(hook, id);
+      } catch {
+      }
+    }
+    this.managedHookHandlers = [];
+  }
+  async withLock(operation) {
+    const currentLock = this.lock;
+    let resolveLock;
+    this.lock = new Promise((resolve) => {
+      resolveLock = resolve;
+    });
+    await currentLock;
+    try {
+      return await operation();
+    } finally {
+      resolveLock();
+    }
+  }
+}
+
+export { BasePlugin };

package/dist/core/service-container/index.cjs

@@ -0,0 +1,306 @@
+'use strict';
+
+const index = require('../../shared/conduithub.BqUYv04j.cjs');
+const logger = require('../../shared/conduithub.BNQsddJO.cjs');
+require('process');
+require('readline');
+require('uuid');
+const code = require('../../shared/conduithub.CmZo_Vuc.cjs');
+
+class ServiceContainer {
+  services = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  resolutionStack = /* @__PURE__ */ new Set();
+  pendingResolutions = /* @__PURE__ */ new Map();
+  isInitialized = false;
+  async initialize() {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+    logger.logger.info("Service Container initialized successfully");
+  }
+  async shutdown() {
+    if (!this.isInitialized) return;
+    logger.logger.info("Shutting down Service Container...");
+    this.services.clear();
+    this.instances.clear();
+    this.resolutionStack.clear();
+    this.pendingResolutions.clear();
+    this.isInitialized = false;
+    logger.logger.success("Service Container shutdown completed");
+  }
+  ensureInitialized() {
+    if (!this.isInitialized) {
+      throw new index.ConduithubError(code.ERROR_CODE.SERVICE_CONTAINER_NOT_INITIALIZED);
+    }
+  }
+  register(name, factory, singleton = true, dependencies, metadata) {
+    this.ensureInitialized();
+    const descriptor = {
+      name,
+      factory,
+      singleton,
+      dependencies,
+      metadata
+    };
+    this.services.set(name, descriptor);
+    logger.logger.info(`Service registered: ${name} (singleton: ${singleton})`);
+  }
+  async resolve(name) {
+    this.ensureInitialized();
+    const service = this.services.get(name);
+    if (!service) {
+      throw new index.ConduithubError(`${code.ERROR_CODE.SERVICE_NOT_FOUND}: ${name}`);
+    }
+    if (service.singleton && this.instances.has(name)) {
+      return this.instances.get(name);
+    }
+    if (service.singleton && this.pendingResolutions.has(name)) {
+      return this.pendingResolutions.get(name);
+    }
+    if (this.resolutionStack.has(name)) {
+      throw new index.ConduithubError(
+        `${code.ERROR_CODE.CIRCULAR_DEPENDENCY_DETECTED}: ${name}`
+      );
+    }
+    this.resolutionStack.add(name);
+    const resolutionPromise = (async () => {
+      try {
+        await this.resolveDependencies(service.dependencies);
+        const instance = await Promise.resolve(service.factory());
+        if (service.singleton) {
+          this.instances.set(name, instance);
+        }
+        return instance;
+      } finally {
+        this.resolutionStack.delete(name);
+        if (service.singleton) {
+          this.pendingResolutions.delete(name);
+        }
+      }
+    })();
+    if (service.singleton) {
+      this.pendingResolutions.set(name, resolutionPromise);
+    }
+    return resolutionPromise;
+  }
+  async resolveDependencies(dependencies) {
+    if (!dependencies?.length) return;
+    await Promise.all(dependencies.map((dep) => this.resolve(dep)));
+  }
+  has(name) {
+    return this.services.has(name);
+  }
+  remove(name) {
+    this.ensureInitialized();
+    if (!this.services.has(name)) {
+      throw new index.ConduithubError(`${code.ERROR_CODE.SERVICE_NOT_FOUND}: ${name}`);
+    }
+    this.instances.delete(name);
+    this.services.delete(name);
+    logger.logger.info(`Service removed: ${name}`);
+  }
+  clear() {
+    this.ensureInitialized();
+    this.instances.clear();
+    this.services.clear();
+    logger.logger.info("All services cleared from the Service Container");
+  }
+  list() {
+    this.ensureInitialized();
+    return Array.from(this.services.values());
+  }
+  isSingleton(name) {
+    const descriptor = this.services.get(name);
+    return descriptor ? descriptor.singleton : false;
+  }
+  getDescriptor(name) {
+    return this.services.get(name);
+  }
+  getAllDescriptors() {
+    return Array.from(this.services.values());
+  }
+  async createInstance(name) {
+    this.ensureInitialized();
+    const descriptor = this.services.get(name);
+    if (!descriptor) {
+      throw new index.ConduithubError(`${code.ERROR_CODE.SERVICE_NOT_FOUND}: ${name}`);
+    }
+    if (descriptor.singleton) {
+      throw new index.ConduithubError(`${code.ERROR_CODE.SERVICE_IS_SINGLETON}: ${name}`);
+    }
+    if (this.instances.has(name)) {
+      return this.instances.get(name);
+    }
+    try {
+      await this.resolveDependencies(descriptor.dependencies);
+      const instance = await Promise.resolve(descriptor.factory());
+      this.instances.set(name, instance);
+      logger.logger.info(`Instance created for service: ${name}`);
+      return instance;
+    } catch (error) {
+      logger.logger.error(`Failed to create instance for service: ${name}`, error);
+      throw new index.ConduithubError(
+        `${code.ERROR_CODE.SERVICE_CREATION_FAILED}: ${name}`,
+        {
+          code: "SERVICE_CREATION_FAILED",
+          details: {
+            serviceName: name,
+            error: error instanceof Error ? error.message : String(error)
+          }
+        }
+      );
+    }
+  }
+  getStats() {
+    const descriptors = this.list();
+    let singletonCount = 0;
+    let transientCount = 0;
+    descriptors.forEach((descriptor) => {
+      if (descriptor.singleton) {
+        singletonCount++;
+      } else {
+        transientCount++;
+      }
+    });
+    return {
+      totalServices: descriptors.length,
+      singletonCount,
+      transientCount,
+      instanceCount: this.instances.size,
+      serviceNames: descriptors.map((d) => d.name)
+    };
+  }
+  validateDependencies() {
+    const errors = [];
+    for (const [name, descriptor] of this.services) {
+      if (descriptor.dependencies) {
+        for (const dependency of descriptor.dependencies) {
+          if (!this.services.has(dependency)) {
+            errors.push(
+              `Service '${name}' depends on '${dependency}', which is not registered.`
+            );
+          }
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  getDependencyGraph() {
+    const graph = {};
+    for (const [name, descriptor] of this.services) {
+      graph[name] = descriptor.dependencies ? [...descriptor.dependencies] : [];
+    }
+    return graph;
+  }
+  getServiceNames() {
+    return Array.from(this.services.keys());
+  }
+  detectCircularDependencies() {
+    const graph = this.getDependencyGraph();
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const cycles = [];
+    const dfs = (node, path) => {
+      if (recursionStack.has(node)) {
+        const cycleStart = path.indexOf(node);
+        const cycle = path.slice(cycleStart).concat([node]);
+        cycles.push(cycle);
+        return;
+      }
+      if (visited.has(node)) {
+        return;
+      }
+      visited.add(node);
+      recursionStack.add(node);
+      path.push(node);
+      for (const dependency of graph[node] || []) {
+        dfs(dependency, [...path]);
+      }
+      recursionStack.delete(node);
+      path.pop();
+    };
+    for (const node of Object.keys(graph)) {
+      if (!visited.has(node)) {
+        dfs(node, []);
+      }
+    }
+    return cycles;
+  }
+  async resolveAll(names) {
+    this.ensureInitialized();
+    return Promise.all(names.map((name) => this.resolve(name)));
+  }
+  findServicesByMetadata(key, value) {
+    this.ensureInitialized();
+    return this.list().filter((descriptor) => {
+      if (!descriptor.metadata || !(key in descriptor.metadata)) {
+        return false;
+      }
+      return value === void 0 || descriptor.metadata[key] === value;
+    });
+  }
+  getTopologicalOrder() {
+    const graph = this.getDependencyGraph();
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const dfs = (node) => {
+      if (visited.has(node)) return;
+      visited.add(node);
+      for (const dependency of graph[node] || []) {
+        dfs(dependency);
+      }
+      result.push(node);
+    };
+    for (const node of Object.keys(graph)) {
+      dfs(node);
+    }
+    return result;
+  }
+  async warmup(serviceNames) {
+    this.ensureInitialized();
+    const namesToWarmup = serviceNames || this.getServiceNames();
+    const singletonServices = namesToWarmup.filter(
+      (name) => this.isSingleton(name)
+    );
+    await Promise.all(
+      singletonServices.map(async (name) => {
+        try {
+          await this.resolve(name);
+          logger.logger.info(`Warmed up service: ${name}`);
+        } catch (error) {
+          logger.logger.error(`Failed to warm up service: ${name}`, error);
+        }
+      })
+    );
+  }
+  clone() {
+    const newContainer = new ServiceContainer();
+    for (const [name, descriptor] of this.services) {
+      newContainer.services.set(name, { ...descriptor });
+    }
+    return newContainer;
+  }
+  dispose(name) {
+    this.ensureInitialized();
+    if (!this.services.has(name)) {
+      throw new index.ConduithubError(`${code.ERROR_CODE.SERVICE_NOT_FOUND}: ${name}`);
+    }
+    const instance = this.instances.get(name);
+    if (instance && typeof instance === "object" && "dispose" in instance) {
+      try {
+        if (typeof instance.dispose === "function") {
+          instance.dispose();
+        }
+      } catch (error) {
+        logger.logger.warn(`Error disposing service ${name}:`, error);
+      }
+    }
+    this.instances.delete(name);
+    logger.logger.info(`Service disposed: ${name}`);
+  }
+}
+
+exports.ServiceContainer = ServiceContainer;

package/dist/core/service-container/index.d.cts

@@ -0,0 +1,51 @@
+interface ServiceDescriptor<T = unknown> {
+    readonly name: string;
+    readonly factory: () => Promise<T> | T;
+    readonly singleton: boolean;
+    readonly dependencies?: readonly string[];
+    readonly metadata?: Record<string, unknown>;
+}
+declare class ServiceContainer {
+    private readonly services;
+    private readonly instances;
+    private readonly resolutionStack;
+    private readonly pendingResolutions;
+    private isInitialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    private ensureInitialized;
+    register<T>(name: string, factory: () => T | Promise<T>, singleton?: boolean, dependencies?: readonly string[], metadata?: Record<string, unknown>): void;
+    resolve<T = unknown>(name: string): Promise<T>;
+    private resolveDependencies;
+    has(name: string): boolean;
+    remove(name: string): void;
+    clear(): void;
+    list(): readonly ServiceDescriptor[];
+    isSingleton(name: string): boolean;
+    getDescriptor(name: string): ServiceDescriptor | undefined;
+    getAllDescriptors(): readonly ServiceDescriptor[];
+    createInstance(name: string): Promise<unknown>;
+    getStats(): {
+        totalServices: number;
+        singletonCount: number;
+        transientCount: number;
+        instanceCount: number;
+        serviceNames: readonly string[];
+    };
+    validateDependencies(): {
+        valid: boolean;
+        errors: string[];
+    };
+    getDependencyGraph(): Record<string, string[]>;
+    getServiceNames(): readonly string[];
+    detectCircularDependencies(): string[][];
+    resolveAll(names: readonly string[]): Promise<unknown[]>;
+    findServicesByMetadata(key: string, value?: unknown): ServiceDescriptor[];
+    getTopologicalOrder(): string[];
+    warmup(serviceNames?: readonly string[]): Promise<void>;
+    clone(): ServiceContainer;
+    dispose(name: string): void;
+}
+
+export { ServiceContainer };
+export type { ServiceDescriptor };

package/dist/core/service-container/index.d.mts

@@ -0,0 +1,51 @@
+interface ServiceDescriptor<T = unknown> {
+    readonly name: string;
+    readonly factory: () => Promise<T> | T;
+    readonly singleton: boolean;
+    readonly dependencies?: readonly string[];
+    readonly metadata?: Record<string, unknown>;
+}
+declare class ServiceContainer {
+    private readonly services;
+    private readonly instances;
+    private readonly resolutionStack;
+    private readonly pendingResolutions;
+    private isInitialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    private ensureInitialized;
+    register<T>(name: string, factory: () => T | Promise<T>, singleton?: boolean, dependencies?: readonly string[], metadata?: Record<string, unknown>): void;
+    resolve<T = unknown>(name: string): Promise<T>;
+    private resolveDependencies;
+    has(name: string): boolean;
+    remove(name: string): void;
+    clear(): void;
+    list(): readonly ServiceDescriptor[];
+    isSingleton(name: string): boolean;
+    getDescriptor(name: string): ServiceDescriptor | undefined;
+    getAllDescriptors(): readonly ServiceDescriptor[];
+    createInstance(name: string): Promise<unknown>;
+    getStats(): {
+        totalServices: number;
+        singletonCount: number;
+        transientCount: number;
+        instanceCount: number;
+        serviceNames: readonly string[];
+    };
+    validateDependencies(): {
+        valid: boolean;
+        errors: string[];
+    };
+    getDependencyGraph(): Record<string, string[]>;
+    getServiceNames(): readonly string[];
+    detectCircularDependencies(): string[][];
+    resolveAll(names: readonly string[]): Promise<unknown[]>;
+    findServicesByMetadata(key: string, value?: unknown): ServiceDescriptor[];
+    getTopologicalOrder(): string[];
+    warmup(serviceNames?: readonly string[]): Promise<void>;
+    clone(): ServiceContainer;
+    dispose(name: string): void;
+}
+
+export { ServiceContainer };
+export type { ServiceDescriptor };