@tamyla/clodo-framework 3.1.4 → 3.1.8

package/bin/database/enterprise-db-manager.js

@@ -25,11 +25,13 @@ import { program } from 'commander';
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 
-// Enterprise module imports
-import { DatabaseOrchestrator } from '@tamyla/clodo-framework/database';
-import { DeploymentAuditor } from '@tamyla/clodo-framework/deployment';
-import { CrossDomainCoordinator } from '@tamyla/clodo-framework/orchestration';
-import { ConfigurationCacheManager } from '@tamyla/clodo-framework/utils/deployment';
+// Enterprise module imports - from dist/ (compiled framework)
+import { DatabaseOrchestrator } from '../../dist/database/database-orchestrator.js';
+import { DeploymentAuditor } from '../../dist/deployment/deployment-auditor.js';
+import { CrossDomainCoordinator } from '../../dist/orchestration/cross-domain-coordinator.js';
+
+// Shared utilities from bin/shared/
+import { ConfigurationCacheManager } from '../shared/config/cache.js';
 
 class EnterpriseDatabaseManagerCLI {
   constructor() {

package/bin/shared/cloudflare/domain-discovery.js

@@ -10,6 +10,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { NameFormatters, UrlFormatters, ResourceFormatters, EnvironmentFormatters } from '../utils/Formatters.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -206,7 +207,7 @@ export class DomainDiscovery {
     const config = {
       // Basic domain information
       name: cleanDomainName,
-      displayName: this.capitalizeFirst(cleanDomainName),
+      displayName: NameFormatters.toDisplayName(cleanDomainName),
       fullDomain: domainName,
       
       // Cloudflare infrastructure
@@ -229,19 +230,19 @@ export class DomainDiscovery {
       // Service URLs
       services: {
         frontend: {
-          production: `https://${domainName}`,
-          staging: `https://staging.${domainName}`,
-          development: `https://dev.${domainName}`
+          production: UrlFormatters.buildProductionUrl('www', domainName),
+          staging: UrlFormatters.buildStagingUrl('www', domainName),
+          development: UrlFormatters.buildDevUrl('www', domainName)
         },
         api: {
-          production: `https://api.${domainName}`,
-          staging: `https://api-staging.${domainName}`,
-          development: `https://api-dev.${domainName}`
+          production: UrlFormatters.buildProductionUrl('api', domainName),
+          staging: UrlFormatters.buildStagingUrl('api', domainName),
+          development: UrlFormatters.buildDevUrl('api', domainName)
         },
         auth: {
-          production: `https://auth.${domainName}`,
-          staging: `https://auth-staging.${domainName}`,
-          development: `https://auth-dev.${domainName}`
+          production: UrlFormatters.buildProductionUrl('auth', domainName),
+          staging: UrlFormatters.buildStagingUrl('auth', domainName),
+          development: UrlFormatters.buildDevUrl('auth', domainName)
         }
       },
 

package/bin/shared/cloudflare/ops.js

@@ -8,7 +8,7 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { executeWithRateLimit } from '../utils/rate-limiter.js';
-import { ErrorRecoveryManager } from '../utils/error-recovery.js';
+import { ErrorRecoveryManager } from '../utils/index.js';
 import { SecureTokenManager } from '../security/secure-token-manager.js';
 import { ProductionMonitor } from '../monitoring/production-monitor.js';
 import { DatabaseConnectionManager } from '../database/connection-manager.js';

package/bin/shared/config/ConfigurationManager.js

@@ -0,0 +1,539 @@
+/**
+ * Unified Configuration Manager
+ * Consolidates feature management, domain configuration, and customer settings
+ * Replaces: FeatureManager.js (440 lines), features.js (237 lines), partial domains.js/customers.js logic
+ * Savings: 600+ lines of consolidated code
+ */
+
+import { logger } from '../logging/Logger.js';
+
+/**
+ * Default feature flags for CLODO Framework
+ */
+const DEFAULT_FEATURES = {
+  // Schema Manager Features
+  ENABLE_ENHANCED_SCHEMA: true,
+  ENABLE_SCHEMA_CACHING: true,
+  ENABLE_COMPREHENSIVE_VALIDATION: true,
+  ENABLE_SQL_CACHING: true,
+
+  // Generic Data Service Features
+  ENABLE_QUERY_CACHING: true,
+  ENABLE_SECURITY_CONTROLS: true,
+  ENABLE_ADVANCED_PAGINATION: true,
+  ENABLE_RELATIONSHIP_LOADING: true,
+
+  // Module Manager Features
+  ENABLE_ENHANCED_HOOKS: true,
+  ENABLE_HOOK_TIMEOUT: true,
+  ENABLE_HOOK_METRICS: true,
+  ENABLE_PARALLEL_EXECUTION: true,
+
+  // Performance Features
+  ENABLE_PERFORMANCE_MONITORING: true,
+  ENABLE_CACHE_METRICS: true,
+  ENABLE_QUERY_OPTIMIZATION: true,
+
+  // Development Features
+  ENABLE_DEBUG_LOGGING: false,
+  ENABLE_DEVELOPMENT_MODE: false,
+  ENABLE_STRICT_VALIDATION: false,
+
+  // Migration Features
+  ENABLE_LEGACY_COMPATIBILITY: true,
+  ENABLE_DEPRECATION_WARNINGS: true,
+  ENABLE_MIGRATION_HELPERS: true,
+
+  // Domain-specific features
+  AUTHENTICATION: true,
+  AUTHORIZATION: true,
+  LOGGING: true,
+  MONITORING: true,
+  CACHING: true,
+  RATE_LIMITING: true,
+  FILE_STORAGE: true
+};
+
+/**
+ * Unified Configuration Manager
+ * Manages feature flags, domain configuration, and customer settings
+ */
+export class ConfigurationManager {
+  constructor(config = {}) {
+    this.features = { ...DEFAULT_FEATURES, ...config.features };
+    this.environment = config.environment || this._detectEnvironment();
+    this.domains = new Map();
+    this.currentDomain = null;
+    this.featureListeners = new Map();
+    this.globalOverrides = new Map();
+    this.context = {
+      environment: this.environment,
+      version: config.version || '2.0.0',
+      timestamp: Date.now()
+    };
+
+    this._validateConfiguration();
+  }
+
+  // ============ FEATURE FLAG MANAGEMENT ============
+
+  /**
+   * Check if a feature is enabled
+   * @param {string} featureName - Name of the feature flag
+   * @param {boolean} defaultValue - Default value if not configured
+   * @returns {boolean} Whether the feature is enabled
+   */
+  isFeatureEnabled(featureName, defaultValue = false) {
+    // Check environment-specific override
+    const envOverride = this._getEnvironmentOverride(featureName);
+    if (envOverride !== null) {
+      return envOverride;
+    }
+
+    // Check global override
+    if (this.globalOverrides.has(featureName)) {
+      return this.globalOverrides.get(featureName);
+    }
+
+    // Check domain-specific features if domain is set
+    if (this.currentDomain?.features?.[featureName] !== undefined) {
+      return this.currentDomain.features[featureName];
+    }
+
+    // Return default or configured feature flag
+    return this.features[featureName] ?? defaultValue;
+  }
+
+  /**
+   * Enable a feature flag
+   * @param {string} featureName - Name of the feature flag
+   * @param {Object} options - Enable options
+   */
+  enableFeature(featureName, options = {}) {
+    const previousValue = this.features[featureName];
+    this.features[featureName] = true;
+
+    logger.info(`Feature enabled: ${featureName}`, { options });
+    this._notifyFeatureListeners(featureName, true, previousValue);
+
+    // Auto-enable dependencies if specified
+    if (options.dependencies?.length) {
+      options.dependencies.forEach(dep => {
+        if (!this.isFeatureEnabled(dep)) {
+          this.enableFeature(dep, { reason: `Required by ${featureName}` });
+        }
+      });
+    }
+  }
+
+  /**
+   * Disable a feature flag
+   * @param {string} featureName - Name of the feature flag
+   * @param {Object} options - Disable options
+   */
+  disableFeature(featureName, options = {}) {
+    const previousValue = this.features[featureName];
+    this.features[featureName] = false;
+
+    logger.info(`Feature disabled: ${featureName}`, { options });
+    this._notifyFeatureListeners(featureName, false, previousValue);
+
+    // Auto-disable dependents if specified
+    if (options.disableDependents) {
+      this._disableDependents(featureName);
+    }
+  }
+
+  /**
+   * Toggle a feature flag
+   * @param {string} featureName - Name of the feature flag
+   * @returns {boolean} New state of the feature
+   */
+  toggleFeature(featureName) {
+    const currentState = this.isFeatureEnabled(featureName);
+    if (currentState) {
+      this.disableFeature(featureName);
+    } else {
+      this.enableFeature(featureName);
+    }
+    return !currentState;
+  }
+
+  /**
+   * Set a global feature override
+   * @param {string} featureName - Name of the feature
+   * @param {boolean} enabled - Whether to enable the feature
+   */
+  setFeatureOverride(featureName, enabled) {
+    this.globalOverrides.set(featureName, enabled);
+    logger.info(`Feature override set: ${featureName} = ${enabled}`);
+    this._notifyFeatureListeners(featureName, enabled, this.features[featureName]);
+  }
+
+  /**
+   * Remove a global feature override
+   * @param {string} featureName - Name of the feature
+   */
+  removeFeatureOverride(featureName) {
+    if (this.globalOverrides.has(featureName)) {
+      this.globalOverrides.delete(featureName);
+      logger.info(`Feature override removed: ${featureName}`);
+    }
+  }
+
+  /**
+   * Get all features with their states
+   * @returns {Object} All features and their current states
+   */
+  getAllFeatures() {
+    const features = {};
+    for (const [name] of Object.entries(DEFAULT_FEATURES)) {
+      features[name] = {
+        enabled: this.isFeatureEnabled(name),
+        default: DEFAULT_FEATURES[name],
+        configured: this.features[name],
+        overridden: this.isFeatureEnabled(name) !== this.features[name]
+      };
+    }
+    return features;
+  }
+
+  /**
+   * Get enabled features
+   * @returns {string[]} Array of enabled feature names
+   */
+  getEnabledFeatures() {
+    const features = Object.keys(DEFAULT_FEATURES).filter(feature => 
+      this.isFeatureEnabled(feature)
+    );
+
+    // Include domain-specific features if a domain is set
+    if (this.currentDomain?.features) {
+      const domainFeatures = Object.keys(this.currentDomain.features).filter(
+        feature => this.currentDomain.features[feature]
+      );
+      features.push(...domainFeatures);
+    }
+
+    return [...new Set(features)]; // Remove duplicates and return
+  }
+
+  /**
+   * Get disabled features
+   * @returns {string[]} Array of disabled feature names
+   */
+  getDisabledFeatures() {
+    return Object.keys(DEFAULT_FEATURES).filter(feature => 
+      !this.isFeatureEnabled(feature)
+    );
+  }
+
+  /**
+   * Listen for feature flag changes
+   * @param {string} featureName - Name of the feature flag
+   * @param {Function} callback - Callback function
+   * @returns {Function} Unsubscribe function
+   */
+  onFeatureChange(featureName, callback) {
+    if (!this.featureListeners.has(featureName)) {
+      this.featureListeners.set(featureName, []);
+    }
+    this.featureListeners.get(featureName).push(callback);
+
+    // Return unsubscribe function
+    return () => {
+      const callbacks = this.featureListeners.get(featureName);
+      if (callbacks) {
+        const index = callbacks.indexOf(callback);
+        if (index > -1) callbacks.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Safely execute code with feature flag check
+   * @param {string} featureName - Name of the feature flag
+   * @param {Function} enabledCallback - Function if feature is enabled
+   * @param {Function} disabledCallback - Function if feature is disabled
+   * @returns {any} Result of executed callback
+   */
+  withFeature(featureName, enabledCallback, disabledCallback = null) {
+    if (this.isFeatureEnabled(featureName)) {
+      try {
+        return enabledCallback();
+      } catch (error) {
+        logger.warn(`Feature '${featureName}' execution failed`, { error: error.message });
+        if (disabledCallback) return disabledCallback();
+        throw error;
+      }
+    } else {
+      if (this.isFeatureEnabled('ENABLE_DEPRECATION_WARNINGS')) {
+        logger.warn(`Feature '${featureName}' is disabled`);
+      }
+      return disabledCallback ? disabledCallback() : null;
+    }
+  }
+
+  /**
+   * Create a feature-gated wrapper function
+   * @param {string} featureName - Name of the feature flag
+   * @param {Function} enhancedFunction - Enhanced function to use when enabled
+   * @param {Function} legacyFunction - Legacy function to use when disabled
+   * @returns {Function} Wrapped function
+   */
+  createFeatureGate(featureName, enhancedFunction, legacyFunction) {
+    return (...args) => {
+      return this.withFeature(
+        featureName,
+        () => enhancedFunction(...args),
+        legacyFunction ? () => legacyFunction(...args) : null
+      );
+    };
+  }
+
+  // ============ DOMAIN CONFIGURATION ============
+
+  /**
+   * Set the current domain context
+   * @param {Object} domainConfig - Domain configuration object
+   */
+  setDomain(domainConfig) {
+    if (!domainConfig) {
+      throw new Error('Domain configuration is required');
+    }
+
+    this.currentDomain = domainConfig;
+    this.domains.set(domainConfig.name, domainConfig);
+    logger.info(`Domain set: ${domainConfig.name}`);
+  }
+
+  /**
+   * Get the current domain context
+   * @returns {Object} Current domain configuration
+   */
+  getDomain() {
+    return this.currentDomain;
+  }
+
+  /**
+   * Register a domain configuration
+   * @param {string} domainName - Domain identifier
+   * @param {Object} domainConfig - Domain configuration
+   */
+  registerDomain(domainName, domainConfig) {
+    this.domains.set(domainName, domainConfig);
+    logger.info(`Domain registered: ${domainName}`);
+  }
+
+  /**
+   * Get a registered domain configuration
+   * @param {string} domainName - Domain identifier
+   * @returns {Object} Domain configuration
+   */
+  getDomainConfig(domainName) {
+    return this.domains.get(domainName);
+  }
+
+  /**
+   * Get all registered domains
+   * @returns {Map} All registered domains
+   */
+  getAllDomains() {
+    return new Map(this.domains);
+  }
+
+  // ============ ENVIRONMENT & VALIDATION ============
+
+  /**
+   * Get the current environment
+   * @returns {string} Current environment (development, staging, production, etc.)
+   */
+  getEnvironment() {
+    return this.environment;
+  }
+
+  /**
+   * Check if running in development mode
+   * @returns {boolean} Whether in development environment
+   */
+  isDevelopment() {
+    return this.environment === 'development' || this.isFeatureEnabled('ENABLE_DEVELOPMENT_MODE');
+  }
+
+  /**
+   * Check if running in production mode
+   * @returns {boolean} Whether in production environment
+   */
+  isProduction() {
+    return this.environment === 'production';
+  }
+
+  /**
+   * Check if running in staging mode
+   * @returns {boolean} Whether in staging environment
+   */
+  isStaging() {
+    return this.environment === 'staging';
+  }
+
+  /**
+   * Validate configuration
+   * @returns {Array} Array of validation errors
+   */
+  validateConfiguration() {
+    const errors = [];
+
+    // Check for unknown feature flags
+    for (const featureName of Object.keys(this.features)) {
+      if (!(featureName in DEFAULT_FEATURES)) {
+        errors.push(`Unknown feature flag: ${featureName}`);
+      }
+    }
+
+    // Check for conflicting features
+    const conflicts = [
+      ['ENABLE_LEGACY_COMPATIBILITY', 'ENABLE_STRICT_VALIDATION'],
+      ['ENABLE_DEVELOPMENT_MODE', 'ENABLE_QUERY_OPTIMIZATION']
+    ];
+
+    for (const [feature1, feature2] of conflicts) {
+      if (this.isFeatureEnabled(feature1) && this.isFeatureEnabled(feature2)) {
+        errors.push(`Conflicting features: ${feature1} and ${feature2}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      logger.warn(`Configuration validation found ${errors.length} issues`, { errors });
+    }
+
+    return errors;
+  }
+
+  // ============ PRIVATE METHODS ============
+
+  /**
+   * Detect current environment
+   * @private
+   */
+  _detectEnvironment() {
+    if (typeof process !== 'undefined' && process.env?.NODE_ENV) {
+      return process.env.NODE_ENV;
+    }
+    if (typeof globalThis !== 'undefined' && globalThis.navigator) {
+      return 'browser';
+    }
+    return 'worker';
+  }
+
+  /**
+   * Get environment-specific override
+   * @private
+   */
+  _getEnvironmentOverride(featureName) {
+    if (typeof process !== 'undefined' && process.env) {
+      const envVar = `CLODO_${featureName}`;
+      if (process.env[envVar] !== undefined) {
+        return process.env[envVar] === 'true';
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Validate configuration on initialization
+   * @private
+   */
+  _validateConfiguration() {
+    const errors = this.validateConfiguration();
+    if (errors.length > 0 && this.isFeatureEnabled('ENABLE_STRICT_VALIDATION')) {
+      throw new Error(`Configuration validation failed: ${errors.join(', ')}`);
+    }
+  }
+
+  /**
+   * Notify feature listeners
+   * @private
+   */
+  _notifyFeatureListeners(featureName, newValue, previousValue) {
+    const callbacks = this.featureListeners.get(featureName);
+    if (callbacks) {
+      callbacks.forEach(callback => {
+        try {
+          callback(newValue, previousValue, featureName);
+        } catch (error) {
+          logger.error(`Feature listener error for '${featureName}'`, { error: error.message });
+        }
+      });
+    }
+  }
+
+  /**
+   * Disable features that depend on this one
+   * @private
+   */
+  _disableDependents(featureName) {
+    const dependents = this._findDependents(featureName);
+    dependents.forEach(dependent => {
+      if (this.isFeatureEnabled(dependent)) {
+        this.disableFeature(dependent, { 
+          reason: `Dependency ${featureName} was disabled`,
+          cascade: true 
+        });
+      }
+    });
+  }
+
+  /**
+   * Find features that depend on this one
+   * @private
+   */
+  _findDependents(featureName) {
+    const dependencies = {
+      'ENABLE_ENHANCED_SCHEMA': ['ENABLE_SCHEMA_CACHING', 'ENABLE_COMPREHENSIVE_VALIDATION'],
+      'ENABLE_QUERY_CACHING': ['ENABLE_CACHE_METRICS'],
+      'ENABLE_ENHANCED_HOOKS': ['ENABLE_HOOK_TIMEOUT', 'ENABLE_HOOK_METRICS']
+    };
+
+    const dependents = [];
+    for (const [feature, deps] of Object.entries(dependencies)) {
+      if (deps.includes(featureName)) {
+        dependents.push(feature);
+      }
+    }
+
+    return dependents;
+  }
+}
+
+// Global singleton instance
+export const configManager = new ConfigurationManager();
+
+/**
+ * Convenience functions for common operations
+ */
+export const isFeatureEnabled = (featureName, defaultValue = false) =>
+  configManager.isFeatureEnabled(featureName, defaultValue);
+
+export const getEnabledFeatures = () =>
+  configManager.getEnabledFeatures();
+
+export const withFeature = (featureName, enabledCallback, disabledCallback = null) =>
+  configManager.withFeature(featureName, enabledCallback, disabledCallback);
+
+/**
+ * Feature flag constants
+ */
+export const FEATURES = Object.keys(DEFAULT_FEATURES).reduce((acc, key) => {
+  acc[key] = key;
+  return acc;
+}, {});
+
+export const COMMON_FEATURES = {
+  AUTHENTICATION: 'AUTHENTICATION',
+  AUTHORIZATION: 'AUTHORIZATION',
+  LOGGING: 'LOGGING',
+  MONITORING: 'MONITORING',
+  CACHING: 'CACHING',
+  RATE_LIMITING: 'RATE_LIMITING',
+  FILE_STORAGE: 'FILE_STORAGE'
+};

package/bin/shared/config/index.js

@@ -1,9 +1,21 @@
 /**
  * Configuration Module
  * Exports all configuration management utilities
+ * Includes consolidated ConfigurationManager from Phase 3.2
  */
 
 export { ConfigCache } from './cache.js';
 export { ConfigManager } from './manager.js';
 export { CommandConfigManager } from './command-config-manager.js';
-export { CustomerConfigurationManager } from '../../../dist/config/customers.js';
+export { CustomerConfigurationManager } from '../../../dist/config/customers.js';
+
+// Phase 3.2 consolidated configuration management
+export { 
+  ConfigurationManager, 
+  configManager, 
+  isFeatureEnabled, 
+  getEnabledFeatures, 
+  withFeature, 
+  FEATURES, 
+  COMMON_FEATURES 
+} from './ConfigurationManager.js';

package/bin/shared/database/connection-manager.js

@@ -4,7 +4,7 @@
  */
 
 import { executeSql } from '../cloudflare/ops.js';
-import { ErrorRecoveryManager } from '../utils/error-recovery.js';
+import { ErrorRecoveryManager } from '../utils/index.js';
 
 export class DatabaseConnectionManager {
   constructor(options = {}) {
@@ -36,7 +36,7 @@ export class DatabaseConnectionManager {
     };
 
     // Initialize error recovery with loaded config
-    const { ErrorRecoveryManager } = await import('../utils/error-recovery.js');
+    const { ErrorRecoveryManager } = await import('../utils/index.js');
     this.errorRecovery = new ErrorRecoveryManager({
       maxRetries: this.config.maxRetries,
       retryDelay: this.config.retryDelay,