@tamyla/clodo-framework 3.1.22 → 3.1.23

package/dist/orchestration/index.js

@@ -0,0 +1,5 @@
+// Orchestration Module
+// Enterprise-grade deployment orchestration and coordination
+
+export { MultiDomainOrchestrator } from './multi-domain-orchestrator.js';
+export { CrossDomainCoordinator } from './cross-domain-coordinator.js';

package/dist/orchestration/modules/DeploymentCoordinator.js

@@ -0,0 +1,368 @@
+/**
+ * Deployment Coordinator Module
+ * Handles deployment orchestration, batching, and parallel execution
+ * Extracted from MultiDomainOrchestrator for focused responsibility
+ */
+
+export class DeploymentCoordinator {
+  constructor(options = {}) {
+    this.parallelDeployments = options.parallelDeployments || 3;
+    this.skipTests = options.skipTests || false;
+    this.dryRun = options.dryRun || false;
+    this.environment = options.environment || 'production';
+    this.batchPauseMs = options.batchPauseMs || 2000;
+    this.deploymentPhases = options.phases || ['validation', 'initialization', 'database', 'secrets', 'deployment', 'post-validation'];
+  }
+
+  /**
+   * Deploy to single domain with comprehensive phase management
+   * @param {string} domain - Domain to deploy
+   * @param {Object} domainState - Domain state object
+   * @param {Object} handlers - Handler functions for each phase
+   * @returns {Promise<Object>} Deployment result
+   */
+  async deploySingleDomain(domain, domainState, handlers) {
+    const phaseResults = {
+      validation: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      initialization: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      database: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      secrets: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      deployment: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      'post-validation': {
+        success: false,
+        errors: [],
+        warnings: []
+      }
+    };
+    try {
+      domainState.startTime = new Date();
+      domainState.status = 'deploying';
+      console.log(`\n🚀 Deploying ${domain}`);
+      console.log(`   Deployment ID: ${domainState.deploymentId}`);
+      console.log(`   Environment: ${this.environment}`);
+      let deploymentUrl = null;
+      let hasCriticalErrors = false;
+
+      // Execute deployment phases
+      for (const phase of this.deploymentPhases) {
+        try {
+          const phaseResult = await this.executeDeploymentPhase(domain, phase, domainState, handlers);
+          domainState.phase = `${phase}-complete`;
+
+          // Mark phase as successful
+          phaseResults[phase].success = true;
+
+          // Capture deployment URL from deployment phase
+          if (phase === 'deployment' && phaseResult) {
+            if (phaseResult.url) {
+              deploymentUrl = phaseResult.url;
+            }
+            if (phaseResult.deployed === false) {
+              phaseResults[phase].warnings.push('Worker deployed in dry-run mode');
+            }
+          }
+
+          // Capture database warnings
+          if (phase === 'database' && phaseResult) {
+            if (phaseResult.error) {
+              phaseResults[phase].warnings.push(phaseResult.error);
+            }
+          }
+        } catch (phaseError) {
+          phaseResults[phase].success = false;
+          phaseResults[phase].errors.push(phaseError.message);
+
+          // Determine if error is critical (stops deployment)
+          const criticalPhases = ['validation', 'initialization', 'deployment'];
+          if (criticalPhases.includes(phase)) {
+            console.error(`   ❌ Critical error in ${phase} phase: ${phaseError.message}`);
+            hasCriticalErrors = true;
+            throw phaseError; // Stop deployment on critical errors
+          } else {
+            // Non-critical errors (database migrations, health checks) - log but continue
+            console.warn(`   ⚠️  ${phase} phase warning: ${phaseError.message}`);
+            console.warn(`   💡 Deployment will continue - this can be fixed manually`);
+          }
+        }
+      }
+
+      // Determine overall success based on phase results
+      const allPhasesSuccessful = Object.values(phaseResults).every(result => result.success);
+      const hasWarnings = Object.values(phaseResults).some(result => result.warnings.length > 0 || result.success === false && result.errors.length === 0);
+      domainState.status = hasCriticalErrors ? 'failed' : allPhasesSuccessful ? 'completed' : 'completed-with-warnings';
+      domainState.endTime = new Date();
+      domainState.phaseResults = phaseResults;
+
+      // Show appropriate completion message
+      if (allPhasesSuccessful) {
+        console.log(`   ✅ ${domain} deployed successfully`);
+      } else if (!hasCriticalErrors) {
+        console.log(`   ⚠️  ${domain} deployed with warnings`);
+        this.displayPhaseWarnings(phaseResults);
+      }
+      return {
+        domain,
+        success: !hasCriticalErrors,
+        allPhasesSuccessful,
+        deploymentId: domainState.deploymentId,
+        duration: domainState.endTime - domainState.startTime,
+        phases: this.deploymentPhases.length,
+        url: deploymentUrl || domainState.deploymentUrl,
+        status: domainState.status,
+        phaseResults
+      };
+    } catch (error) {
+      domainState.status = 'failed';
+      domainState.error = error.message;
+      domainState.endTime = new Date();
+      domainState.phaseResults = phaseResults;
+      console.error(`   ❌ ${domain} deployment failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Display warnings for phases that had issues
+   * @param {Object} phaseResults - Phase results object
+   */
+  displayPhaseWarnings(phaseResults) {
+    console.log(`\n   📊 Phase Status Summary:`);
+    for (const [phase, result] of Object.entries(phaseResults)) {
+      if (result.success && result.warnings.length === 0) {
+        console.log(`   ✅ ${phase}: Success`);
+      } else if (result.success && result.warnings.length > 0) {
+        console.log(`   ⚠️  ${phase}: Success with warnings`);
+        result.warnings.forEach(warn => console.log(`      • ${warn}`));
+      } else {
+        console.log(`   ❌ ${phase}: Failed`);
+        result.errors.forEach(err => console.log(`      • ${err}`));
+      }
+    }
+  }
+
+  /**
+   * Execute specific deployment phase
+   * @param {string} domain - Domain being deployed
+   * @param {string} phase - Phase name
+   * @param {Object} domainState - Domain state object
+   * @param {Object} handlers - Phase handler functions
+   * @returns {Promise<any>} Phase handler result
+   */
+  async executeDeploymentPhase(domain, phase, domainState, handlers) {
+    const phaseHandler = handlers[phase];
+    if (!phaseHandler) {
+      console.warn(`   ⚠️ No handler for phase: ${phase}`);
+      return null;
+    }
+    console.log(`   📋 Phase: ${phase}`);
+    if (this.dryRun) {
+      console.log(`   🔍 DRY RUN: Would execute ${phase} for ${domain}`);
+      await new Promise(resolve => setTimeout(resolve, 100)); // Simulate work
+      return null;
+    }
+
+    // Skip post-validation if tests are disabled
+    if (phase === 'post-validation' && this.skipTests) {
+      console.log(`   ⏭️ Skipping ${phase} (tests disabled)`);
+      return null;
+    }
+
+    // Execute handler and return result (important for capturing URLs, database IDs, etc.)
+    return await phaseHandler(domain, domainState);
+  }
+
+  /**
+   * Deploy to multiple domains with orchestrated coordination
+   * @param {Array} domains - Domains to deploy
+   * @param {Map} domainStates - Map of domain states
+   * @param {Object} handlers - Phase handler functions
+   * @returns {Promise<Object>} Portfolio deployment results
+   */
+  async deployPortfolio(domains, domainStates, handlers) {
+    const startTime = Date.now();
+    const results = {
+      successful: [],
+      failed: [],
+      totalDuration: 0,
+      summary: {},
+      batches: []
+    };
+    try {
+      console.log('🌐 Starting Portfolio Deployment');
+      console.log(`📊 Total Domains: ${domains.length}`);
+      console.log(`⚡ Parallel Limit: ${this.parallelDeployments}`);
+      console.log('');
+
+      // Deploy domains in batches based on parallel limit
+      const batches = this.createDeploymentBatches(domains);
+      for (let batchIndex = 0; batchIndex < batches.length; batchIndex++) {
+        const batch = batches[batchIndex];
+        console.log(`📦 Batch ${batchIndex + 1}/${batches.length}: ${batch.join(', ')}`);
+        const batchResult = await this.deployBatch(batch, domainStates, handlers);
+        results.batches.push(batchResult);
+
+        // Merge batch results
+        results.successful.push(...batchResult.successful);
+        results.failed.push(...batchResult.failed);
+
+        // Brief pause between batches
+        if (batchIndex < batches.length - 1) {
+          console.log('   ⏳ Pausing between batches...\n');
+          await new Promise(resolve => setTimeout(resolve, this.batchPauseMs));
+        }
+      }
+      results.totalDuration = Date.now() - startTime;
+      results.summary = this.generateDeploymentSummary(domains.length, results);
+      this.logDeploymentComplete(results);
+      return results;
+    } catch (error) {
+      console.error('❌ Portfolio deployment failed:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Deploy a single batch of domains in parallel
+   * @param {Array} batch - Domains in this batch
+   * @param {Map} domainStates - Domain states map
+   * @param {Object} handlers - Phase handlers
+   * @returns {Promise<Object>} Batch results
+   */
+  async deployBatch(batch, domainStates, handlers) {
+    const batchResults = await Promise.allSettled(batch.map(domain => {
+      const domainState = domainStates.get(domain);
+      return this.deploySingleDomain(domain, domainState, handlers);
+    }));
+    const successful = [];
+    const failed = [];
+    batchResults.forEach((result, index) => {
+      const domain = batch[index];
+      if (result.status === 'fulfilled') {
+        successful.push({
+          domain,
+          ...result.value
+        });
+      } else {
+        failed.push({
+          domain,
+          error: result.reason.message
+        });
+      }
+    });
+    return {
+      successful,
+      failed,
+      batchSize: batch.length
+    };
+  }
+
+  /**
+   * Create deployment batches based on parallel limit
+   * @param {Array} domains - Domains to batch
+   * @returns {Array<Array<string>>} Batches of domains
+   */
+  createDeploymentBatches(domains) {
+    const batches = [];
+    for (let i = 0; i < domains.length; i += this.parallelDeployments) {
+      batches.push(domains.slice(i, i + this.parallelDeployments));
+    }
+    return batches;
+  }
+
+  /**
+   * Generate deployment summary statistics
+   * @param {number} totalDomains - Total domain count
+   * @param {Object} results - Deployment results
+   * @returns {Object} Summary statistics
+   */
+  generateDeploymentSummary(totalDomains, results) {
+    return {
+      total: totalDomains,
+      successful: results.successful.length,
+      failed: results.failed.length,
+      successRate: (results.successful.length / totalDomains * 100).toFixed(1),
+      averageDuration: results.successful.length > 0 ? (results.successful.reduce((sum, r) => sum + r.duration, 0) / results.successful.length / 1000).toFixed(1) : 0,
+      totalBatches: results.batches.length
+    };
+  }
+
+  /**
+   * Log deployment completion with formatted output
+   * @param {Object} results - Deployment results
+   */
+  logDeploymentComplete(results) {
+    console.log('\n🎉 PORTFOLIO DEPLOYMENT COMPLETE');
+    console.log('================================');
+    console.log(`✅ Successful: ${results.summary.successful}/${results.summary.total}`);
+    console.log(`❌ Failed: ${results.summary.failed}/${results.summary.total}`);
+    console.log(`📊 Success Rate: ${results.summary.successRate}%`);
+    console.log(`⏱️ Total Duration: ${(results.totalDuration / 1000).toFixed(1)}s`);
+    console.log(`📦 Batches Processed: ${results.summary.totalBatches}`);
+    if (results.summary.averageDuration > 0) {
+      console.log(`⏱️ Average Duration: ${results.summary.averageDuration}s per domain`);
+    }
+    if (results.failed.length > 0) {
+      console.log('\n❌ Failed Domains:');
+      results.failed.forEach(failure => {
+        console.log(`   - ${failure.domain}: ${failure.error}`);
+      });
+    }
+  }
+
+  /**
+   * Validate deployment coordination configuration
+   * @returns {Object} Validation result
+   */
+  validateConfiguration() {
+    const issues = [];
+    if (this.parallelDeployments < 1) {
+      issues.push('parallelDeployments must be at least 1');
+    }
+    if (this.parallelDeployments > 10) {
+      issues.push('parallelDeployments exceeds recommended maximum of 10');
+    }
+    if (this.batchPauseMs < 0) {
+      issues.push('batchPauseMs cannot be negative');
+    }
+    return {
+      valid: issues.length === 0,
+      issues,
+      warnings: this.parallelDeployments > 5 ? ['High parallelism may cause rate limiting'] : []
+    };
+  }
+
+  /**
+   * Get coordination statistics
+   * @returns {Object} Coordinator statistics
+   */
+  getStats() {
+    return {
+      parallelDeployments: this.parallelDeployments,
+      batchPauseMs: this.batchPauseMs,
+      phasesCount: this.deploymentPhases.length,
+      dryRun: this.dryRun,
+      skipTests: this.skipTests,
+      environment: this.environment
+    };
+  }
+}

package/dist/orchestration/modules/DomainResolver.js

@@ -0,0 +1,198 @@
+/**
+ * Domain Resolver Module
+ * Handles domain discovery, validation, and configuration generation
+ * Extracted from MultiDomainOrchestrator for focused responsibility
+ */
+
+export class DomainResolver {
+  constructor(options = {}) {
+    this.environment = options.environment || 'production';
+    this.validationLevel = options.validationLevel || 'basic';
+    this.cacheEnabled = options.cacheEnabled !== false;
+    this.domainCache = new Map();
+  }
+
+  /**
+   * Generate standardized domain configuration
+   * @param {string} domain - Domain name
+   * @returns {Object} Domain configuration object
+   */
+  generateDomainConfig(domain) {
+    if (this.cacheEnabled && this.domainCache.has(domain)) {
+      return this.domainCache.get(domain);
+    }
+    const cleanDomain = domain.replace(/\./g, '-').replace(/[^a-zA-Z0-9-]/g, '');
+    const config = {
+      name: domain,
+      cleanName: cleanDomain,
+      productionName: `${cleanDomain}-data-service`,
+      database: {
+        name: `${cleanDomain}-auth-db`,
+        id: null // Will be discovered/created
+      },
+      worker: {
+        name: `${cleanDomain}-data-service`
+      },
+      environments: {
+        production: domain,
+        staging: `staging.${domain}`,
+        development: `dev.${domain}`
+      },
+      metadata: {
+        generated: new Date().toISOString(),
+        environment: this.environment
+      }
+    };
+    if (this.cacheEnabled) {
+      this.domainCache.set(domain, config);
+    }
+    return config;
+  }
+
+  /**
+   * Validate domain prerequisites
+   * @param {string} domain - Domain to validate
+   * @returns {Promise<Object>} Validation result
+   */
+  async validateDomainPrerequisites(domain) {
+    console.log(`   🔍 Validating ${domain} prerequisites...`);
+    const validation = {
+      domain,
+      valid: true,
+      issues: [],
+      warnings: []
+    };
+    try {
+      // Validate Cloudflare token
+      if (!process.env.CLOUDFLARE_API_TOKEN) {
+        validation.warnings.push('CLOUDFLARE_API_TOKEN not yet configured (will be set during deployment)');
+      }
+
+      // Validate Cloudflare account ID
+      if (!process.env.CLOUDFLARE_ACCOUNT_ID) {
+        validation.warnings.push('CLOUDFLARE_ACCOUNT_ID not yet configured (will be set during deployment)');
+      }
+
+      // Validate domain format
+      if (!this.isValidDomainFormat(domain)) {
+        validation.valid = false;
+        validation.issues.push(`Invalid domain format: ${domain}`);
+      }
+
+      // Additional validation based on level
+      if (this.validationLevel === 'comprehensive') {
+        await this.performComprehensiveValidation(domain, validation);
+      }
+    } catch (error) {
+      validation.valid = false;
+      validation.issues.push(`Validation error: ${error.message}`);
+    }
+    return validation;
+  }
+
+  /**
+   * Resolve multiple domains with their configurations
+   * @param {Array} domains - Array of domain names
+   * @returns {Promise<Array>} Array of resolved domain configurations
+   */
+  async resolveMultipleDomains(domains) {
+    const resolved = [];
+    for (const domain of domains) {
+      const config = this.generateDomainConfig(domain);
+      const validation = await this.validateDomainPrerequisites(domain);
+      resolved.push({
+        ...config,
+        validation,
+        isValid: validation.valid
+      });
+    }
+    return resolved;
+  }
+
+  /**
+   * Discover domains from configuration files or runtime
+   * @param {Object} options - Discovery options
+   * @returns {Promise<Array>} Discovered domains
+   */
+  async discoverDomains(options = {}) {
+    const discovered = [];
+    if (options.sources?.includes('config')) {
+      const configDomains = await this.discoverFromConfig();
+      discovered.push(...configDomains);
+    }
+    if (options.sources?.includes('runtime')) {
+      const runtimeDomains = await this.discoverFromRuntime();
+      discovered.push(...runtimeDomains);
+    }
+
+    // Remove duplicates and validate
+    const uniqueDomains = [...new Set(discovered)];
+    return await this.resolveMultipleDomains(uniqueDomains);
+  }
+
+  /**
+   * Check if domain format is valid
+   * @param {string} domain - Domain to check
+   * @returns {boolean} Valid status
+   */
+  isValidDomainFormat(domain) {
+    const domainRegex = /^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]*\.[a-zA-Z]{2,}$/;
+    return domainRegex.test(domain);
+  }
+
+  /**
+   * Perform comprehensive domain validation
+   * @param {string} domain - Domain to validate
+   * @param {Object} validation - Validation object to update
+   */
+  async performComprehensiveValidation(domain, validation) {
+    // Check domain accessibility (basic DNS check)
+    try {
+      // Note: In a real implementation, this would do DNS lookups
+      // For now, just simulate validation
+      if (domain.includes('localhost') || domain.includes('127.0.0.1')) {
+        validation.warnings.push('Using local domain - may not be accessible externally');
+      }
+    } catch (error) {
+      validation.warnings.push(`DNS validation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Discover domains from configuration files
+   * @returns {Promise<Array>} Configuration-based domains
+   */
+  async discoverFromConfig() {
+    // Placeholder - would read from actual config files
+    console.log('   📂 Discovering domains from configuration...');
+    return [];
+  }
+
+  /**
+   * Discover domains from runtime (e.g., Cloudflare API)
+   * @returns {Promise<Array>} Runtime-discovered domains
+   */
+  async discoverFromRuntime() {
+    // Placeholder - would query Cloudflare API or other runtime sources
+    console.log('   🌐 Discovering domains from runtime...');
+    return [];
+  }
+
+  /**
+   * Clear domain configuration cache
+   */
+  clearCache() {
+    this.domainCache.clear();
+  }
+
+  /**
+   * Get cache statistics
+   * @returns {Object} Cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.domainCache.size,
+      enabled: this.cacheEnabled
+    };
+  }
+}