@tamyla/clodo-framework 3.1.21 → 3.1.22

package/dist/bin/deployment/modules/EnvironmentManager.js

@@ -1,517 +0,0 @@
-/**
- * EnvironmentManager - Manages environment-specific deployment logic and domain orchestration
- * Handles environment configuration, domain mapping, deployment mode selection, and cross-domain coordination
- */
-
-import { MultiDomainOrchestrator } from "../../../orchestration/multi-domain-orchestrator.js";
-import { CrossDomainCoordinator } from "../../../orchestration/cross-domain-coordinator.js";
-import { DomainDiscovery } from '../../shared/cloudflare/domain-discovery.js';
-import { askChoice, askUser, askYesNo, DeploymentInteractiveUtils } from '../../shared/utils/interactive-utils.js';
-export class EnvironmentManager {
-  constructor(config) {
-    this.config = config;
-    this.orchestrator = null;
-    this.coordinator = null;
-    this.domainDiscovery = null;
-    this.supportedEnvironments = ['production', 'staging', 'development', 'preview'];
-    this.deploymentModes = ['single', 'multi-domain', 'portfolio'];
-
-    // Enhanced interactive utilities
-    this.interactiveUtils = new DeploymentInteractiveUtils({
-      enableColors: true,
-      enableProgress: true,
-      validateInputs: true
-    });
-  }
-
-  /**
-   * Initialize environment-specific components based on configuration
-   */
-  async initializeEnvironment() {
-    console.log('\n🌍 Initializing Environment Manager');
-    console.log('===================================');
-
-    // Initialize multi-domain orchestrator if needed
-    if (this.config.deploymentMode !== 'single') {
-      this.orchestrator = new MultiDomainOrchestrator({
-        portfolioName: this.config.portfolioName || 'default-portfolio',
-        enableContinuousMonitoring: this.config.deployment?.enableMonitoring || false,
-        validationLevel: this.config.deployment?.validationLevel || 'standard',
-        environment: this.config.environment
-      });
-      console.log('   ✅ Multi-domain orchestrator initialized');
-    }
-
-    // Initialize cross-domain coordinator for portfolio mode
-    if (this.config.deploymentMode === 'portfolio') {
-      this.coordinator = new CrossDomainCoordinator({
-        portfolioName: this.config.portfolioName || 'interactive-portfolio',
-        enableContinuousMonitoring: true,
-        crossDomainCoordination: this.config.secrets?.crossDomainSharing || false
-      });
-      console.log('   ✅ Cross-domain coordinator initialized');
-    }
-
-    // Initialize domain discovery
-    this.domainDiscovery = new DomainDiscovery({
-      environment: this.config.environment,
-      enableConfigDiscovery: true
-    });
-    console.log('   ✅ Domain discovery service initialized');
-  }
-
-  /**
-   * Interactive deployment mode selection
-   */
-  async selectDeploymentMode() {
-    console.log('\n🎯 Deployment Mode Selection');
-    console.log('============================');
-    console.log('');
-    console.log('The Enterprise Deployment System supports multiple deployment modes:');
-    console.log('');
-    console.log('📱 Single Domain    - Deploy one domain with full enterprise features');
-    console.log('🌍 Multi-Domain     - Deploy multiple domains with coordination');
-    console.log('📊 Portfolio Mode   - Manage entire domain portfolio');
-    console.log('');
-    const modes = ['Single Domain (Recommended for first-time users)', 'Multi-Domain (Deploy multiple domains together)', 'Portfolio Mode (Advanced: Full portfolio management)'];
-
-    // Use enhanced deployment mode selector
-    const modeChoice = await this.interactiveUtils.askDeploymentMode(0);
-    switch (modeChoice) {
-      case 0:
-        this.config.deploymentMode = 'single';
-        console.log('\n✅ Selected: Single Domain Deployment');
-        break;
-      case 1:
-        this.config.deploymentMode = 'multi-domain';
-        this.config.enterprise = this.config.enterprise || {};
-        this.config.enterprise.enableCrossDomainCoordination = true;
-        console.log('\n✅ Selected: Multi-Domain Deployment');
-        break;
-      case 2:
-        this.config.deploymentMode = 'portfolio';
-        this.config.enterprise = this.config.enterprise || {};
-        this.config.enterprise.enableCrossDomainCoordination = true;
-        console.log('\n✅ Selected: Portfolio Mode');
-        break;
-    }
-    return this.config.deploymentMode;
-  }
-
-  /**
-   * Gather configuration based on selected deployment mode
-   */
-  async gatherEnvironmentConfiguration() {
-    console.log('\n📋 Environment Configuration');
-    console.log('============================');
-    switch (this.config.deploymentMode) {
-      case 'single':
-        return await this.gatherSingleDomainConfiguration();
-      case 'multi-domain':
-        return await this.gatherMultiDomainConfiguration();
-      case 'portfolio':
-        return await this.gatherPortfolioConfiguration();
-      default:
-        throw new Error(`Unsupported deployment mode: ${this.config.deploymentMode}`);
-    }
-  }
-
-  /**
-   * Gather single domain configuration
-   */
-  async gatherSingleDomainConfiguration() {
-    console.log('\n📱 Single Domain Configuration');
-    console.log('------------------------------');
-
-    // Enhanced domain input with built-in validation
-    this.config.domain = await this.interactiveUtils.askDomain('Enter the domain name for deployment (e.g., "newclient", "democorp")');
-    console.log(`\n✅ Domain: ${this.config.domain}`);
-
-    // Configuration discovery
-    const tryDiscovery = await askYesNo('🔍 Try to discover existing configuration for this domain?', 'y');
-    if (tryDiscovery) {
-      await this.tryConfigurationDiscovery();
-    }
-
-    // Environment selection
-    await this.selectEnvironment();
-
-    // Generate worker configuration
-    this.generateWorkerConfiguration();
-
-    // Validate configuration
-    const confirmConfig = await askYesNo('Is this configuration correct?', 'y');
-    if (!confirmConfig) {
-      throw new Error('Configuration cancelled by user');
-    }
-    return {
-      domain: this.config.domain,
-      environment: this.config.environment,
-      worker: this.config.worker
-    };
-  }
-
-  /**
-   * Gather multi-domain configuration
-   */
-  async gatherMultiDomainConfiguration() {
-    console.log('\n🌍 Multi-Domain Configuration');
-    console.log('-----------------------------');
-    console.log('This feature allows coordinated deployment across multiple domains');
-    const domainCount = parseInt(await askUser('How many domains to deploy? (2-10)', '2'));
-    if (domainCount < 2 || domainCount > 10) {
-      throw new Error('Domain count must be between 2 and 10');
-    }
-    const domains = [];
-    for (let i = 0; i < domainCount; i++) {
-      const domain = await askUser(`Enter domain ${i + 1}:`);
-      if (!domain || !/^[a-z0-9-]+$/.test(domain)) {
-        throw new Error(`Invalid domain format for domain ${i + 1}`);
-      }
-      domains.push(domain);
-    }
-
-    // Environment selection applies to all domains
-    await this.selectEnvironment();
-
-    // Configure coordination settings
-    const enableSharedSecrets = await askYesNo('Enable shared secrets across domains?', 'n');
-    this.config.domains = domains;
-    this.config.secrets = this.config.secrets || {};
-    this.config.secrets.crossDomainSharing = enableSharedSecrets;
-    console.log(`\n✅ Multi-domain mode: ${domainCount} domains configured`);
-    domains.forEach((domain, idx) => {
-      console.log(`   ${idx + 1}. ${domain}`);
-    });
-    return {
-      domains: this.config.domains,
-      environment: this.config.environment,
-      coordination: {
-        crossDomainSharing: enableSharedSecrets
-      }
-    };
-  }
-
-  /**
-   * Gather portfolio configuration
-   */
-  async gatherPortfolioConfiguration() {
-    console.log('\n📊 Portfolio Management Configuration');
-    console.log('------------------------------------');
-    console.log('This feature provides advanced portfolio management capabilities');
-    const portfolioName = await askUser('Enter portfolio name (e.g., "enterprise-suite", "client-portfolio")', 'default-portfolio');
-    if (!/^[a-z0-9-]+$/.test(portfolioName)) {
-      throw new Error('Portfolio name must contain only lowercase letters, numbers, and hyphens');
-    }
-
-    // Environment selection
-    await this.selectEnvironment();
-
-    // Portfolio-specific settings
-    const enableContinuousMonitoring = await askYesNo('Enable continuous monitoring for portfolio?', 'y');
-    const enableAutomaticScaling = await askYesNo('Enable automatic scaling across portfolio?', 'n');
-    this.config.portfolioName = portfolioName;
-    this.config.portfolio = {
-      enableContinuousMonitoring,
-      enableAutomaticScaling,
-      crossDomainCoordination: true
-    };
-    console.log('\n✅ Portfolio mode configured:');
-    console.log(`   Portfolio: ${portfolioName}`);
-    console.log(`   Environment: ${this.config.environment}`);
-    console.log(`   Monitoring: ${enableContinuousMonitoring ? 'Enabled' : 'Disabled'}`);
-    return {
-      portfolioName: this.config.portfolioName,
-      environment: this.config.environment,
-      portfolio: this.config.portfolio
-    };
-  }
-
-  /**
-   * Enhanced interactive environment selection
-   */
-  async selectEnvironment() {
-    // Use enhanced environment selector with built-in warnings
-    const envChoice = await this.interactiveUtils.askEnvironment(0);
-    this.config.environment = this.supportedEnvironments[envChoice];
-
-    // Environment-specific warnings
-    if (this.config.environment === 'production') {
-      console.log('\n⚠️  Production Environment Selected:');
-      console.log('   - Enhanced security validation will be performed');
-      console.log('   - Backup and recovery mechanisms will be enabled');
-      console.log('   - Performance monitoring will be activated');
-      const confirmProd = await askYesNo('Continue with production deployment?', 'y');
-      if (!confirmProd) {
-        throw new Error('Production deployment cancelled');
-      }
-    }
-    console.log(`✅ Environment: ${this.config.environment}`);
-    return this.config.environment;
-  }
-
-  /**
-   * Generate worker configuration based on domain and environment
-   */
-  generateWorkerConfiguration() {
-    if (!this.config.domain) {
-      throw new Error('Domain is required to generate worker configuration');
-    }
-    const baseName = `${this.config.domain}-data-service`;
-    const envSuffix = this.config.environment === 'production' ? '' : `-${this.config.environment}`;
-    this.config.worker = {
-      name: `${baseName}${envSuffix}`,
-      url: `https://${baseName}${envSuffix}.tamylatrading.workers.dev`,
-      environment: this.config.environment,
-      script: `src/workers/${this.config.domain}/index.js`
-    };
-    console.log(`\n🔧 Generated Worker Configuration:`);
-    console.log(`   Name: ${this.config.worker.name}`);
-    console.log(`   URL: ${this.config.worker.url}`);
-    console.log(`   Script: ${this.config.worker.script}`);
-    return this.config.worker;
-  }
-
-  /**
-   * Try to discover existing configuration for the domain
-   */
-  async tryConfigurationDiscovery() {
-    if (!this.domainDiscovery) {
-      console.log('   ⚠️ Domain discovery not available');
-      return null;
-    }
-    try {
-      console.log('   🔍 Searching for existing configuration...');
-      const discoveredConfig = await this.domainDiscovery.discoverConfiguration(this.config.domain);
-      if (discoveredConfig) {
-        console.log('   ✅ Found existing configuration:');
-        console.log(`      Worker: ${discoveredConfig.workerName}`);
-        console.log(`      Database: ${discoveredConfig.databaseName}`);
-        const useDiscovered = await askYesNo('Use discovered configuration?', 'y');
-        if (useDiscovered) {
-          this.config.worker = {
-            ...this.config.worker,
-            ...discoveredConfig.worker
-          };
-          this.config.database = {
-            ...this.config.database,
-            ...discoveredConfig.database
-          };
-          console.log('   ✅ Using discovered configuration');
-          return discoveredConfig;
-        }
-      } else {
-        console.log('   ℹ️ No existing configuration found');
-      }
-    } catch (error) {
-      console.log(`   ⚠️ Configuration discovery failed: ${error.message}`);
-    }
-    return null;
-  }
-
-  /**
-   * Validate environment configuration
-   */
-  validateEnvironmentConfiguration() {
-    const errors = [];
-    const warnings = [];
-
-    // Basic validation
-    if (!this.config.environment) {
-      errors.push('Environment not selected');
-    }
-    if (!this.supportedEnvironments.includes(this.config.environment)) {
-      errors.push(`Unsupported environment: ${this.config.environment}`);
-    }
-    if (!this.config.deploymentMode) {
-      errors.push('Deployment mode not selected');
-    }
-    if (!this.deploymentModes.includes(this.config.deploymentMode)) {
-      errors.push(`Unsupported deployment mode: ${this.config.deploymentMode}`);
-    }
-
-    // Mode-specific validation
-    switch (this.config.deploymentMode) {
-      case 'single':
-        if (!this.config.domain) {
-          errors.push('Domain required for single-domain deployment');
-        }
-        break;
-      case 'multi-domain':
-        if (!this.config.domains || this.config.domains.length < 2) {
-          errors.push('At least 2 domains required for multi-domain deployment');
-        }
-        break;
-      case 'portfolio':
-        if (!this.config.portfolioName) {
-          errors.push('Portfolio name required for portfolio deployment');
-        }
-        break;
-    }
-
-    // Environment-specific warnings
-    if (this.config.environment === 'production' && !this.config.database?.enableBackup) {
-      warnings.push('Database backup not enabled for production environment');
-    }
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings
-    };
-  }
-
-  /**
-   * Get environment-specific configuration
-   */
-  getEnvironmentConfig() {
-    return {
-      environment: this.config.environment,
-      deploymentMode: this.config.deploymentMode,
-      domain: this.config.domain,
-      domains: this.config.domains,
-      portfolioName: this.config.portfolioName,
-      worker: this.config.worker,
-      orchestrator: this.orchestrator,
-      coordinator: this.coordinator,
-      domainDiscovery: this.domainDiscovery
-    };
-  }
-
-  /**
-   * Consolidated CLI option definitions from enterprise-deploy.js
-   * Replaces scattered -e, --env definitions across command handlers
-   */
-  static getEnvironmentOption() {
-    return {
-      flag: '-e, --env',
-      description: 'deployment environment',
-      default: 'production',
-      validate: env => {
-        const valid = ['production', 'staging', 'development', 'preview'].includes(env);
-        if (!valid) throw new Error(`Invalid environment: ${env}. Must be one of: production, staging, development, preview`);
-        return env;
-      }
-    };
-  }
-
-  /**
-   * Consolidated deployment mode option definition
-   */
-  static getDeploymentModeOption() {
-    return {
-      flag: '--mode',
-      description: 'deployment mode',
-      default: 'single',
-      choices: ['single', 'multi-domain', 'portfolio'],
-      validate: mode => {
-        const valid = ['single', 'multi-domain', 'portfolio'].includes(mode);
-        if (!valid) throw new Error(`Invalid mode: ${mode}`);
-        return mode;
-      }
-    };
-  }
-
-  /**
-   * Parse environment from CLI arguments
-   * Consolidates environment parsing from enterprise-deploy.js and master-deploy.js
-   */
-  static parseEnvironmentFromArgs(options) {
-    let environment = options.env || options.environment || process.env.DEPLOY_ENV || 'production';
-
-    // Validate environment
-    const validEnvs = ['production', 'staging', 'development', 'preview'];
-    if (!validEnvs.includes(environment)) {
-      console.warn(`⚠️  Invalid environment '${environment}', defaulting to 'production'`);
-      environment = 'production';
-    }
-    return environment;
-  }
-
-  /**
-   * Parse deployment mode from CLI arguments
-   */
-  static parseDeploymentModeFromArgs(options) {
-    let mode = options.mode || options.deploymentMode || 'single';
-
-    // Validate mode
-    const validModes = ['single', 'multi-domain', 'portfolio'];
-    if (!validModes.includes(mode)) {
-      console.warn(`⚠️  Invalid mode '${mode}', defaulting to 'single'`);
-      mode = 'single';
-    }
-    return mode;
-  }
-
-  /**
-   * Factory method to create EnvironmentManager from CLI arguments
-   * Consolidates initialization patterns from all three deployment systems
-   */
-  static fromCLIArgs(options = {}) {
-    const config = {
-      environment: this.parseEnvironmentFromArgs(options),
-      deploymentMode: this.parseDeploymentModeFromArgs(options),
-      defaultEnvironment: options.defaultEnv || 'production',
-      validationLevel: options.validationLevel || 'comprehensive',
-      auditLevel: options.auditLevel || 'detailed',
-      enableRollback: options.enableRollback !== false,
-      enableTesting: options.enableTesting !== false,
-      ...options
-    };
-    return new EnvironmentManager(config);
-  }
-
-  /**
-   * Confirm deployment mode before proceeding
-   * Consolidates confirmation logic from master-deploy.js
-   */
-  async confirmDeploymentMode() {
-    console.log('\n🔍 Deployment Mode Confirmation');
-    console.log('================================');
-    console.log(`Selected Mode: ${this.config.deploymentMode.toUpperCase()}`);
-    let modeDescription = '';
-    switch (this.config.deploymentMode) {
-      case 'single':
-        modeDescription = 'Deploy a single domain with full enterprise features';
-        break;
-      case 'multi-domain':
-        modeDescription = 'Deploy multiple domains with cross-domain coordination';
-        break;
-      case 'portfolio':
-        modeDescription = 'Manage entire domain portfolio';
-        break;
-    }
-    console.log(`Description: ${modeDescription}`);
-    const confirm = await askYesNo('Proceed with this deployment mode?', 'y');
-    if (!confirm) {
-      throw new Error('Deployment mode selection cancelled');
-    }
-    return true;
-  }
-
-  /**
-   * Get all supported environments
-   */
-  getSupportedEnvironments() {
-    return this.supportedEnvironments;
-  }
-
-  /**
-   * Get all supported deployment modes
-   */
-  getSupportedDeploymentModes() {
-    return this.deploymentModes;
-  }
-
-  /**
-   * Clean up environment resources
-   */
-  async cleanup() {
-    if (this.coordinator) {
-      await this.coordinator.cleanup();
-    }
-    if (this.orchestrator) {
-      await this.orchestrator.cleanup();
-    }
-    console.log('✅ Environment manager cleanup completed');
-  }
-}