conduithub 0.0.3 → 1.0.0

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

@@ -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.mjs

@@ -0,0 +1,304 @@
+import { C as ConduithubError } from '../../shared/conduithub.BDwZXllF.mjs';
+import { a as logger } from '../../shared/conduithub.BNefRQsK.mjs';
+import 'process';
+import 'readline';
+import 'uuid';
+import { E as ERROR_CODE } from '../../shared/conduithub.G7ICpZIy.mjs';
+
+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.info("Service Container initialized successfully");
+  }
+  async shutdown() {
+    if (!this.isInitialized) return;
+    logger.info("Shutting down Service Container...");
+    this.services.clear();
+    this.instances.clear();
+    this.resolutionStack.clear();
+    this.pendingResolutions.clear();
+    this.isInitialized = false;
+    logger.success("Service Container shutdown completed");
+  }
+  ensureInitialized() {
+    if (!this.isInitialized) {
+      throw new ConduithubError(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.info(`Service registered: ${name} (singleton: ${singleton})`);
+  }
+  async resolve(name) {
+    this.ensureInitialized();
+    const service = this.services.get(name);
+    if (!service) {
+      throw new ConduithubError(`${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 ConduithubError(
+        `${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 ConduithubError(`${ERROR_CODE.SERVICE_NOT_FOUND}: ${name}`);
+    }
+    this.instances.delete(name);
+    this.services.delete(name);
+    logger.info(`Service removed: ${name}`);
+  }
+  clear() {
+    this.ensureInitialized();
+    this.instances.clear();
+    this.services.clear();
+    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 ConduithubError(`${ERROR_CODE.SERVICE_NOT_FOUND}: ${name}`);
+    }
+    if (descriptor.singleton) {
+      throw new ConduithubError(`${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.info(`Instance created for service: ${name}`);
+      return instance;
+    } catch (error) {
+      logger.error(`Failed to create instance for service: ${name}`, error);
+      throw new ConduithubError(
+        `${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.info(`Warmed up service: ${name}`);
+        } catch (error) {
+          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 ConduithubError(`${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.warn(`Error disposing service ${name}:`, error);
+      }
+    }
+    this.instances.delete(name);
+    logger.info(`Service disposed: ${name}`);
+  }
+}
+
+export { ServiceContainer };

package/dist/core/state-manager/index.cjs

@@ -0,0 +1,195 @@
+'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 StateManager {
+  state = /* @__PURE__ */ new Map();
+  subscribers = /* @__PURE__ */ new Map();
+  isInitialized = false;
+  async initialize() {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+    logger.logger.success("StateManager initialized successfully");
+  }
+  async shutdown() {
+    if (!this.isInitialized) return;
+    logger.logger.info("Shutting down StateManager...");
+    this.state.clear();
+    this.subscribers.clear();
+    this.isInitialized = false;
+    logger.logger.success("StateManager shutdown successfully");
+  }
+  ensureInitialized() {
+    if (!this.isInitialized) {
+      throw new index.ConduithubError(code.ERROR_CODE.STATE_MANAGER_NOT_INITIALIZED);
+    }
+  }
+  get(key) {
+    this.ensureInitialized();
+    return this.state.get(key);
+  }
+  set(key, value) {
+    this.ensureInitialized();
+    const oldValue = this.state.get(key);
+    this.state.set(key, value);
+    this.notifySubscribers(key, value, oldValue);
+    logger.logger.info(`State set for key '${String(key)}'`);
+  }
+  delete(key) {
+    this.ensureInitialized();
+    const oldValue = this.state.get(key);
+    const wasDeleted = this.state.delete(key);
+    if (wasDeleted) {
+      this.notifySubscribers(key, void 0, oldValue);
+      logger.logger.info(`State deleted for key '${String(key)}'`);
+    }
+    return wasDeleted;
+  }
+  has(key) {
+    this.ensureInitialized();
+    return this.state.has(key);
+  }
+  clear() {
+    this.ensureInitialized();
+    const oldState = new Map(this.state);
+    this.state.clear();
+    for (const [key, subscribers] of this.subscribers) {
+      const oldValue = oldState.get(key);
+      this.notifySubscribersWithErrorHandling(
+        subscribers,
+        void 0,
+        oldValue,
+        key
+      );
+    }
+    logger.logger.info("All state cleared");
+  }
+  keys() {
+    this.ensureInitialized();
+    return Array.from(this.state.keys());
+  }
+  values() {
+    this.ensureInitialized();
+    return Array.from(this.state.values());
+  }
+  entries() {
+    this.ensureInitialized();
+    return Array.from(this.state.entries());
+  }
+  size() {
+    this.ensureInitialized();
+    return this.state.size;
+  }
+  subscribe(key, callback) {
+    this.ensureInitialized();
+    if (!this.subscribers.has(key)) {
+      this.subscribers.set(key, /* @__PURE__ */ new Set());
+    }
+    const subscribers = this.subscribers.get(key);
+    subscribers.add(callback);
+    logger.logger.info(`Subscriber added for key '${String(key)}'`);
+    return () => this.unsubscribeCallback(key, callback);
+  }
+  unsubscribe(key, callback) {
+    this.ensureInitialized();
+    this.unsubscribeCallback(key, callback);
+  }
+  getSubscribersCount(key) {
+    const subscribers = this.subscribers.get(key);
+    return subscribers ? subscribers.size : 0;
+  }
+  getSubscribedKeys() {
+    return Array.from(this.subscribers.keys());
+  }
+  notifySubscribers(key, newValue, oldValue) {
+    const subscribers = this.subscribers.get(key);
+    if (subscribers) {
+      this.notifySubscribersWithErrorHandling(
+        subscribers,
+        newValue,
+        oldValue,
+        key
+      );
+    }
+  }
+  notifySubscribersWithErrorHandling(subscribers, newValue, oldValue, key) {
+    for (const callback of subscribers) {
+      try {
+        callback(newValue, oldValue);
+      } catch (error) {
+        logger.logger.error(
+          `Error in state subscriber for key '${String(key)}'`,
+          error
+        );
+      }
+    }
+  }
+  unsubscribeCallback(key, callback) {
+    const subscribers = this.subscribers.get(key);
+    if (!subscribers) {
+      logger.logger.warn(
+        `No subscribers found for key '${String(key)}' to unsubscribe`
+      );
+      return;
+    }
+    subscribers.delete(callback);
+    if (subscribers.size === 0) {
+      this.subscribers.delete(key);
+      logger.logger.info(
+        `No more subscribers for key '${String(key)}', removed from subscribers map`
+      );
+    } else {
+      logger.logger.info(`Subscriber removed for key '${String(key)}'`);
+    }
+  }
+  getStats() {
+    const subscribedKeys = this.getSubscribedKeys();
+    const subscriberCounts = {};
+    for (const key of subscribedKeys) {
+      subscriberCounts[String(key)] = this.getSubscribersCount(key);
+    }
+    const totalSubscribers = subscribedKeys.reduce(
+      (sum, key) => sum + this.getSubscribersCount(key),
+      0
+    );
+    return {
+      totalKeys: this.size(),
+      totalSubscribers,
+      subscribedKeys,
+      subscribersCount: subscriberCounts
+    };
+  }
+  getStateSnapshot() {
+    const snapshot = {};
+    for (const [key, value] of this.state.entries()) {
+      snapshot[String(key)] = value;
+    }
+    return snapshot;
+  }
+  loadStateSnapshot(snapshot) {
+    this.state.clear();
+    for (const [key, value] of Object.entries(snapshot)) {
+      this.state.set(key, value);
+    }
+  }
+  exportState() {
+    return JSON.stringify(this.getStateSnapshot(), null, 2);
+  }
+  importState(stateJson) {
+    try {
+      const snapshot = JSON.parse(stateJson);
+      this.loadStateSnapshot(snapshot);
+      logger.logger.success("State imported successfully");
+    } catch (error) {
+      logger.logger.error("Failed to import state", error);
+      throw new index.ConduithubError(code.ERROR_CODE.INVALID_STATE_JSON_FORMAT);
+    }
+  }
+}
+
+exports.StateManager = StateManager;

package/dist/core/state-manager/index.d.cts

@@ -0,0 +1,39 @@
+type StateChangeHandler<T> = (newValue: T, oldValue: T | undefined) => void;
+interface StateStats<T> {
+    readonly totalKeys: number;
+    readonly totalSubscribers: number;
+    readonly subscribedKeys: readonly (keyof T)[];
+    readonly subscribersCount: Record<string, number>;
+}
+declare class StateManager<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly state;
+    private readonly subscribers;
+    private isInitialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    private ensureInitialized;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    delete<K extends keyof T>(key: K): boolean;
+    has<K extends keyof T>(key: K): boolean;
+    clear(): void;
+    keys(): (keyof T)[];
+    values(): T[keyof T][];
+    entries(): [keyof T, T[keyof T]][];
+    size(): number;
+    subscribe<K extends keyof T>(key: K, callback: StateChangeHandler<T[K]>): () => void;
+    unsubscribe<K extends keyof T>(key: K, callback: StateChangeHandler<T[K]>): void;
+    getSubscribersCount<K extends keyof T>(key: K): number;
+    getSubscribedKeys(): (keyof T)[];
+    private notifySubscribers;
+    private notifySubscribersWithErrorHandling;
+    private unsubscribeCallback;
+    getStats(): StateStats<T>;
+    private getStateSnapshot;
+    private loadStateSnapshot;
+    exportState(): string;
+    importState(stateJson: string): void;
+}
+
+export { StateManager };
+export type { StateChangeHandler };

package/dist/core/state-manager/index.d.mts

@@ -0,0 +1,39 @@
+type StateChangeHandler<T> = (newValue: T, oldValue: T | undefined) => void;
+interface StateStats<T> {
+    readonly totalKeys: number;
+    readonly totalSubscribers: number;
+    readonly subscribedKeys: readonly (keyof T)[];
+    readonly subscribersCount: Record<string, number>;
+}
+declare class StateManager<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly state;
+    private readonly subscribers;
+    private isInitialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    private ensureInitialized;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    delete<K extends keyof T>(key: K): boolean;
+    has<K extends keyof T>(key: K): boolean;
+    clear(): void;
+    keys(): (keyof T)[];
+    values(): T[keyof T][];
+    entries(): [keyof T, T[keyof T]][];
+    size(): number;
+    subscribe<K extends keyof T>(key: K, callback: StateChangeHandler<T[K]>): () => void;
+    unsubscribe<K extends keyof T>(key: K, callback: StateChangeHandler<T[K]>): void;
+    getSubscribersCount<K extends keyof T>(key: K): number;
+    getSubscribedKeys(): (keyof T)[];
+    private notifySubscribers;
+    private notifySubscribersWithErrorHandling;
+    private unsubscribeCallback;
+    getStats(): StateStats<T>;
+    private getStateSnapshot;
+    private loadStateSnapshot;
+    exportState(): string;
+    importState(stateJson: string): void;
+}
+
+export { StateManager };
+export type { StateChangeHandler };

package/dist/core/state-manager/index.d.ts

@@ -0,0 +1,39 @@
+type StateChangeHandler<T> = (newValue: T, oldValue: T | undefined) => void;
+interface StateStats<T> {
+    readonly totalKeys: number;
+    readonly totalSubscribers: number;
+    readonly subscribedKeys: readonly (keyof T)[];
+    readonly subscribersCount: Record<string, number>;
+}
+declare class StateManager<T extends Record<string, unknown> = Record<string, unknown>> {
+    private readonly state;
+    private readonly subscribers;
+    private isInitialized;
+    initialize(): Promise<void>;
+    shutdown(): Promise<void>;
+    private ensureInitialized;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    delete<K extends keyof T>(key: K): boolean;
+    has<K extends keyof T>(key: K): boolean;
+    clear(): void;
+    keys(): (keyof T)[];
+    values(): T[keyof T][];
+    entries(): [keyof T, T[keyof T]][];
+    size(): number;
+    subscribe<K extends keyof T>(key: K, callback: StateChangeHandler<T[K]>): () => void;
+    unsubscribe<K extends keyof T>(key: K, callback: StateChangeHandler<T[K]>): void;
+    getSubscribersCount<K extends keyof T>(key: K): number;
+    getSubscribedKeys(): (keyof T)[];
+    private notifySubscribers;
+    private notifySubscribersWithErrorHandling;
+    private unsubscribeCallback;
+    getStats(): StateStats<T>;
+    private getStateSnapshot;
+    private loadStateSnapshot;
+    exportState(): string;
+    importState(stateJson: string): void;
+}
+
+export { StateManager };
+export type { StateChangeHandler };