conduithub 0.1.0 → 1.0.0

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

@@ -0,0 +1,216 @@
+'use strict';
+
+const code = require('../../shared/conduithub.CmZo_Vuc.cjs');
+const json = require('../../shared/conduithub.DQO1dRnn.cjs');
+const logger = require('../../shared/conduithub.BNQsddJO.cjs');
+require('process');
+require('readline');
+require('uuid');
+
+class ConfigManager {
+  config = /* @__PURE__ */ new Map();
+  pluginConfigs = /* @__PURE__ */ new Map();
+  isInitialized = false;
+  async initialize(config) {
+    if (this.isInitialized) return;
+    logger.logger.info("Initializing ConfigManager....");
+    this.isInitialized = true;
+    if (config) {
+      this.loadConfig(config);
+    }
+    logger.logger.success("ConfigManager initialized successfully");
+  }
+  async shutdown() {
+    if (!this.isInitialized) {
+      return;
+    }
+    this.config.clear();
+    this.pluginConfigs.clear();
+    this.isInitialized = false;
+    logger.logger.success("ConfigManager shutdown successfully");
+  }
+  get(key, defaultValue) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.config.has(key) ? this.config.get(key) : defaultValue;
+  }
+  set(key, value) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    this.config.set(key, value);
+    logger.logger.success(`Configuration set successfully for key: ${key}`);
+  }
+  has(key) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.config.has(key);
+  }
+  delete(key) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.config.delete(key);
+  }
+  loadConfig(config) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    for (const [key, value] of Object.entries(config)) {
+      this.config.set(key, value);
+    }
+    logger.logger.success("Configuration loaded successfully");
+  }
+  clearConfig() {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    this.config.clear();
+    logger.logger.success("Configuration cleared successfully");
+  }
+  getPluginConfig(pluginName) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    let config = this.pluginConfigs.get(pluginName);
+    if (!config) {
+      config = {
+        name: pluginName,
+        version: "1.0.0",
+        enabled: true,
+        dependencies: [],
+        config: {}
+      };
+      this.pluginConfigs.set(pluginName, config);
+    }
+    return config;
+  }
+  setPluginConfig(pluginName, config) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    this.pluginConfigs.set(pluginName, config);
+    logger.logger.success(`Plugin config set successfully for plugin: ${pluginName}`);
+  }
+  updatePluginConfig(pluginName, updates) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const currentConfig = this.pluginConfigs.get(pluginName);
+    if (!currentConfig) {
+      throw new Error(`Plugin config not found for plugin: ${pluginName}`);
+    }
+    const updatedConfig = { ...currentConfig, ...updates };
+    this.pluginConfigs.set(pluginName, updatedConfig);
+    logger.logger.success(
+      `Plugin config updated successfully for plugin: ${pluginName}`
+    );
+  }
+  hasPluginConfig(pluginName) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.pluginConfigs.has(pluginName);
+  }
+  deletePluginConfig(pluginName) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const deleted = this.pluginConfigs.delete(pluginName);
+    if (deleted) {
+      logger.logger.success(
+        `Plugin config deleted successfully for plugin: ${pluginName}`
+      );
+    }
+    return deleted;
+  }
+  getAllPluginConfigs() {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return Object.fromEntries(this.pluginConfigs);
+  }
+  loadPluginConfigs(configs) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    for (const [pluginName, config] of Object.entries(configs)) {
+      this.pluginConfigs.set(pluginName, config);
+    }
+    logger.logger.success("Plugin configs loaded successfully");
+  }
+  validateConfig(schema, config) {
+    const result = schema.safeParse(config);
+    if (result.success) {
+      return { valid: true, errors: [] };
+    }
+    const errors = result.error.issues.map((issue) => {
+      const path = issue.path.join(".");
+      return path ? `${path}: ${issue.message}` : issue.message;
+    });
+    return { valid: false, errors };
+  }
+  exportConfig(format = "json") {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const fullConfig = {
+      global: Object.fromEntries(this.config),
+      plugins: this.getAllPluginConfigs()
+    };
+    if (format === "json") {
+      return JSON.stringify(fullConfig, null, 2);
+    }
+    throw new Error(`Unsupported format: ${format}`);
+  }
+  importConfig(configJson) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    try {
+      const fullConfig = json.parseJson(configJson);
+      if (fullConfig.global) {
+        this.loadConfig(fullConfig.global);
+      }
+      if (fullConfig.plugins) {
+        this.loadPluginConfigs(fullConfig.plugins);
+      }
+      logger.logger.success("Configuration imported successfully");
+    } catch (error) {
+      logger.logger.error("Failed to import configuration", error);
+      throw error;
+    }
+  }
+  getPluginConfigNames() {
+    if (!this.isInitialized) {
+      throw new Error("ConfigManager is not initialized");
+    }
+    return Array.from(this.pluginConfigs.keys());
+  }
+  getStats() {
+    return {
+      totalConfigKeys: this.config.size,
+      totalPluginConfigs: this.pluginConfigs.size,
+      configKeys: Array.from(this.config.keys()),
+      pluginConfigNames: this.getPluginConfigNames()
+    };
+  }
+  watchConfig(key, callback) {
+    if (!this.isInitialized) {
+      throw new Error(code.ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const checkInterval = setInterval(() => {
+      const value = this.get(key);
+      callback(value);
+    }, 1e3);
+    logger.logger.info(`Configuration watch started for key: ${key}`);
+    return () => {
+      clearInterval(checkInterval);
+      logger.logger.info(`Configuration watch stopped for key: ${key}`);
+    };
+  }
+}
+
+exports.ConfigManager = ConfigManager;

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

@@ -0,0 +1,7 @@
+import 'zod';
+export { ConfigManager } from '../index.cjs';
+import '../hook/index.cjs';
+import '../../shared/conduithub.B7aryjPG.cjs';
+import '../../shared/conduithub.BZQmkQy7.cjs';
+import '../service-container/index.cjs';
+import '../state-manager/index.cjs';

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

@@ -0,0 +1,7 @@
+import 'zod';
+export { ConfigManager } from '../index.mjs';
+import '../hook/index.mjs';
+import '../../shared/conduithub.B7aryjPG.mjs';
+import '../../shared/conduithub.BzLwccre.mjs';
+import '../service-container/index.mjs';
+import '../state-manager/index.mjs';

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

@@ -0,0 +1,7 @@
+import 'zod';
+export { ConfigManager } from '../index.js';
+import '../hook/index.js';
+import '../../shared/conduithub.B7aryjPG.js';
+import '../../shared/conduithub.DQOWQ-Bx.js';
+import '../service-container/index.js';
+import '../state-manager/index.js';

package/dist/core/config-manager/index.mjs

@@ -0,0 +1,214 @@
+import { E as ERROR_CODE } from '../../shared/conduithub.G7ICpZIy.mjs';
+import { p as parseJson } from '../../shared/conduithub.alPiaJax.mjs';
+import { a as logger } from '../../shared/conduithub.BNefRQsK.mjs';
+import 'process';
+import 'readline';
+import 'uuid';
+
+class ConfigManager {
+  config = /* @__PURE__ */ new Map();
+  pluginConfigs = /* @__PURE__ */ new Map();
+  isInitialized = false;
+  async initialize(config) {
+    if (this.isInitialized) return;
+    logger.info("Initializing ConfigManager....");
+    this.isInitialized = true;
+    if (config) {
+      this.loadConfig(config);
+    }
+    logger.success("ConfigManager initialized successfully");
+  }
+  async shutdown() {
+    if (!this.isInitialized) {
+      return;
+    }
+    this.config.clear();
+    this.pluginConfigs.clear();
+    this.isInitialized = false;
+    logger.success("ConfigManager shutdown successfully");
+  }
+  get(key, defaultValue) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.config.has(key) ? this.config.get(key) : defaultValue;
+  }
+  set(key, value) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    this.config.set(key, value);
+    logger.success(`Configuration set successfully for key: ${key}`);
+  }
+  has(key) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.config.has(key);
+  }
+  delete(key) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.config.delete(key);
+  }
+  loadConfig(config) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    for (const [key, value] of Object.entries(config)) {
+      this.config.set(key, value);
+    }
+    logger.success("Configuration loaded successfully");
+  }
+  clearConfig() {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    this.config.clear();
+    logger.success("Configuration cleared successfully");
+  }
+  getPluginConfig(pluginName) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    let config = this.pluginConfigs.get(pluginName);
+    if (!config) {
+      config = {
+        name: pluginName,
+        version: "1.0.0",
+        enabled: true,
+        dependencies: [],
+        config: {}
+      };
+      this.pluginConfigs.set(pluginName, config);
+    }
+    return config;
+  }
+  setPluginConfig(pluginName, config) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    this.pluginConfigs.set(pluginName, config);
+    logger.success(`Plugin config set successfully for plugin: ${pluginName}`);
+  }
+  updatePluginConfig(pluginName, updates) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const currentConfig = this.pluginConfigs.get(pluginName);
+    if (!currentConfig) {
+      throw new Error(`Plugin config not found for plugin: ${pluginName}`);
+    }
+    const updatedConfig = { ...currentConfig, ...updates };
+    this.pluginConfigs.set(pluginName, updatedConfig);
+    logger.success(
+      `Plugin config updated successfully for plugin: ${pluginName}`
+    );
+  }
+  hasPluginConfig(pluginName) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return this.pluginConfigs.has(pluginName);
+  }
+  deletePluginConfig(pluginName) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const deleted = this.pluginConfigs.delete(pluginName);
+    if (deleted) {
+      logger.success(
+        `Plugin config deleted successfully for plugin: ${pluginName}`
+      );
+    }
+    return deleted;
+  }
+  getAllPluginConfigs() {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    return Object.fromEntries(this.pluginConfigs);
+  }
+  loadPluginConfigs(configs) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    for (const [pluginName, config] of Object.entries(configs)) {
+      this.pluginConfigs.set(pluginName, config);
+    }
+    logger.success("Plugin configs loaded successfully");
+  }
+  validateConfig(schema, config) {
+    const result = schema.safeParse(config);
+    if (result.success) {
+      return { valid: true, errors: [] };
+    }
+    const errors = result.error.issues.map((issue) => {
+      const path = issue.path.join(".");
+      return path ? `${path}: ${issue.message}` : issue.message;
+    });
+    return { valid: false, errors };
+  }
+  exportConfig(format = "json") {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const fullConfig = {
+      global: Object.fromEntries(this.config),
+      plugins: this.getAllPluginConfigs()
+    };
+    if (format === "json") {
+      return JSON.stringify(fullConfig, null, 2);
+    }
+    throw new Error(`Unsupported format: ${format}`);
+  }
+  importConfig(configJson) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    try {
+      const fullConfig = parseJson(configJson);
+      if (fullConfig.global) {
+        this.loadConfig(fullConfig.global);
+      }
+      if (fullConfig.plugins) {
+        this.loadPluginConfigs(fullConfig.plugins);
+      }
+      logger.success("Configuration imported successfully");
+    } catch (error) {
+      logger.error("Failed to import configuration", error);
+      throw error;
+    }
+  }
+  getPluginConfigNames() {
+    if (!this.isInitialized) {
+      throw new Error("ConfigManager is not initialized");
+    }
+    return Array.from(this.pluginConfigs.keys());
+  }
+  getStats() {
+    return {
+      totalConfigKeys: this.config.size,
+      totalPluginConfigs: this.pluginConfigs.size,
+      configKeys: Array.from(this.config.keys()),
+      pluginConfigNames: this.getPluginConfigNames()
+    };
+  }
+  watchConfig(key, callback) {
+    if (!this.isInitialized) {
+      throw new Error(ERROR_CODE.CONFIG_MANAGER_NOT_INITIALIZED);
+    }
+    const checkInterval = setInterval(() => {
+      const value = this.get(key);
+      callback(value);
+    }, 1e3);
+    logger.info(`Configuration watch started for key: ${key}`);
+    return () => {
+      clearInterval(checkInterval);
+      logger.info(`Configuration watch stopped for key: ${key}`);
+    };
+  }
+}
+
+export { ConfigManager };