@tamyla/clodo-framework 1.0.0

package/dist/orchestration/modules/StateManager.js

@@ -0,0 +1,332 @@
+/**
+ * State Manager Module
+ * Handles portfolio state tracking, audit logging, and rollback planning
+ * Extracted from MultiDomainOrchestrator for focused responsibility
+ */
+
+import { writeFile, mkdir, access } from 'fs/promises';
+import { join } from 'path';
+import { randomBytes } from 'crypto';
+export class StateManager {
+  constructor(options = {}) {
+    this.environment = options.environment || 'production';
+    this.dryRun = options.dryRun || false;
+    this.logDirectory = options.logDirectory || 'deployments';
+    this.enablePersistence = options.enablePersistence !== false;
+    this.rollbackEnabled = options.rollbackEnabled !== false;
+
+    // Initialize portfolio state
+    this.portfolioState = this.initializePortfolioState(options);
+  }
+
+  /**
+   * Initialize portfolio state structure
+   * @param {Object} options - Initialization options
+   * @returns {Object} Portfolio state object
+   */
+  initializePortfolioState(options = {}) {
+    return {
+      orchestrationId: this.generateOrchestrationId(),
+      startTime: new Date(),
+      endTime: null,
+      environment: this.environment,
+      totalDomains: options.domains?.length || 0,
+      completedDomains: 0,
+      failedDomains: 0,
+      domainStates: new Map(),
+      rollbackPlan: [],
+      auditLog: [],
+      metadata: {
+        dryRun: this.dryRun,
+        persistenceEnabled: this.enablePersistence,
+        rollbackEnabled: this.rollbackEnabled
+      }
+    };
+  }
+
+  /**
+   * Generate unique orchestration ID for tracking portfolio deployments
+   * @returns {string} Unique orchestration identifier
+   */
+  generateOrchestrationId() {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const random = randomBytes(6).toString('hex');
+    return `orchestration-${timestamp}-${random}`;
+  }
+
+  /**
+   * Generate deployment ID for individual domain
+   * @param {string} domain - Domain name
+   * @returns {string} Unique deployment identifier
+   */
+  generateDeploymentId(domain) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const random = randomBytes(4).toString('hex');
+    return `deploy-${domain}-${timestamp}-${random}`;
+  }
+
+  /**
+   * Initialize domain states for portfolio
+   * @param {Array} domains - Array of domain names
+   * @returns {Promise<void>}
+   */
+  async initializeDomainStates(domains) {
+    this.portfolioState.totalDomains = domains.length;
+    domains.forEach(domain => {
+      this.portfolioState.domainStates.set(domain, {
+        domain,
+        deploymentId: this.generateDeploymentId(domain),
+        phase: 'pending',
+        status: 'pending',
+        startTime: null,
+        endTime: null,
+        error: null,
+        rollbackActions: [],
+        metadata: {
+          created: new Date().toISOString(),
+          environment: this.environment
+        }
+      });
+    });
+    await this.logAuditEvent('PORTFOLIO_INITIALIZED', 'ALL', {
+      totalDomains: domains.length,
+      domains: domains
+    });
+  }
+
+  /**
+   * Update domain state
+   * @param {string} domain - Domain name
+   * @param {Object} updates - State updates
+   * @returns {Object} Updated domain state
+   */
+  updateDomainState(domain, updates) {
+    const domainState = this.portfolioState.domainStates.get(domain);
+    if (!domainState) {
+      throw new Error(`Domain state not found: ${domain}`);
+    }
+    Object.assign(domainState, updates, {
+      lastUpdated: new Date().toISOString()
+    });
+    return domainState;
+  }
+
+  /**
+   * Get domain state
+   * @param {string} domain - Domain name
+   * @returns {Object|null} Domain state or null if not found
+   */
+  getDomainState(domain) {
+    return this.portfolioState.domainStates.get(domain) || null;
+  }
+
+  /**
+   * Get portfolio state summary
+   * @returns {Object} Portfolio state summary
+   */
+  getPortfolioSummary() {
+    const states = Array.from(this.portfolioState.domainStates.values());
+    return {
+      orchestrationId: this.portfolioState.orchestrationId,
+      environment: this.environment,
+      totalDomains: this.portfolioState.totalDomains,
+      completed: states.filter(s => s.status === 'completed').length,
+      failed: states.filter(s => s.status === 'failed').length,
+      inProgress: states.filter(s => s.status === 'deploying').length,
+      pending: states.filter(s => s.status === 'pending').length,
+      startTime: this.portfolioState.startTime,
+      endTime: this.portfolioState.endTime,
+      duration: this.portfolioState.endTime ? this.portfolioState.endTime - this.portfolioState.startTime : Date.now() - this.portfolioState.startTime,
+      auditLogSize: this.portfolioState.auditLog.length
+    };
+  }
+
+  /**
+   * Log audit event for tracking
+   * @param {string} event - Event type
+   * @param {string} domain - Domain or 'ALL' for portfolio events
+   * @param {Object} details - Event details
+   * @returns {Promise<void>}
+   */
+  async logAuditEvent(event, domain, details = {}) {
+    const auditEntry = {
+      timestamp: new Date().toISOString(),
+      orchestrationId: this.portfolioState.orchestrationId,
+      event,
+      domain,
+      details,
+      sequenceNumber: this.portfolioState.auditLog.length + 1
+    };
+    this.portfolioState.auditLog.push(auditEntry);
+
+    // Save to file for persistence (fire and forget)
+    if (this.enablePersistence && !this.dryRun) {
+      try {
+        await this.saveAuditLog();
+      } catch (error) {
+        console.warn(`⚠️ Failed to save audit log: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Add rollback action for domain
+   * @param {string} domain - Domain name
+   * @param {Object} action - Rollback action
+   */
+  addRollbackAction(domain, action) {
+    const domainState = this.getDomainState(domain);
+    if (domainState) {
+      domainState.rollbackActions.push({
+        ...action,
+        timestamp: new Date().toISOString(),
+        id: randomBytes(4).toString('hex')
+      });
+    }
+
+    // Add to portfolio rollback plan
+    this.portfolioState.rollbackPlan.push({
+      domain,
+      action: {
+        ...action,
+        timestamp: new Date().toISOString()
+      }
+    });
+  }
+
+  /**
+   * Get rollback plan for portfolio or specific domain
+   * @param {string} [domain] - Optional domain filter
+   * @returns {Array} Rollback actions
+   */
+  getRollbackPlan(domain = null) {
+    if (domain) {
+      return this.portfolioState.rollbackPlan.filter(item => item.domain === domain);
+    }
+    return this.portfolioState.rollbackPlan;
+  }
+
+  /**
+   * Mark deployment as started
+   * @param {string} domain - Domain name
+   */
+  markDeploymentStarted(domain) {
+    this.updateDomainState(domain, {
+      status: 'deploying',
+      startTime: new Date()
+    });
+    this.portfolioState.completedDomains++;
+  }
+
+  /**
+   * Mark deployment as completed
+   * @param {string} domain - Domain name
+   * @param {Object} result - Deployment result
+   */
+  markDeploymentCompleted(domain, result = {}) {
+    this.updateDomainState(domain, {
+      status: 'completed',
+      endTime: new Date(),
+      result
+    });
+    this.portfolioState.completedDomains++;
+  }
+
+  /**
+   * Mark deployment as failed
+   * @param {string} domain - Domain name
+   * @param {Error|string} error - Error details
+   */
+  markDeploymentFailed(domain, error) {
+    this.updateDomainState(domain, {
+      status: 'failed',
+      endTime: new Date(),
+      error: error instanceof Error ? error.message : error
+    });
+    this.portfolioState.failedDomains++;
+  }
+
+  /**
+   * Mark portfolio as completed
+   */
+  markPortfolioCompleted() {
+    this.portfolioState.endTime = new Date();
+  }
+
+  /**
+   * Save audit log to file
+   * @returns {Promise<void>}
+   */
+  async saveAuditLog() {
+    if (!this.enablePersistence) return;
+    try {
+      // Ensure log directory exists
+      try {
+        await access(this.logDirectory);
+      } catch {
+        await mkdir(this.logDirectory, {
+          recursive: true
+        });
+      }
+      const logFile = join(this.logDirectory, `${this.portfolioState.orchestrationId}.json`);
+      const logData = {
+        orchestrationId: this.portfolioState.orchestrationId,
+        environment: this.environment,
+        startTime: this.portfolioState.startTime,
+        endTime: this.portfolioState.endTime,
+        summary: this.getPortfolioSummary(),
+        domainStates: Array.from(this.portfolioState.domainStates.entries()).reduce((obj, [key, value]) => {
+          obj[key] = value;
+          return obj;
+        }, {}),
+        rollbackPlan: this.portfolioState.rollbackPlan,
+        auditLog: this.portfolioState.auditLog,
+        metadata: this.portfolioState.metadata
+      };
+      await writeFile(logFile, JSON.stringify(logData, null, 2));
+    } catch (error) {
+      console.warn(`⚠️ Failed to save audit log: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get audit log entries
+   * @param {Object} filter - Filter options
+   * @returns {Array} Filtered audit entries
+   */
+  getAuditLog(filter = {}) {
+    let entries = this.portfolioState.auditLog;
+    if (filter.event) {
+      entries = entries.filter(entry => entry.event === filter.event);
+    }
+    if (filter.domain) {
+      entries = entries.filter(entry => entry.domain === filter.domain);
+    }
+    if (filter.since) {
+      entries = entries.filter(entry => new Date(entry.timestamp) >= filter.since);
+    }
+    return entries;
+  }
+
+  /**
+   * Clear state (for testing or reset)
+   */
+  clearState() {
+    this.portfolioState = this.initializePortfolioState();
+  }
+
+  /**
+   * Get state statistics
+   * @returns {Object} State statistics
+   */
+  getStateStats() {
+    return {
+      orchestrationId: this.portfolioState.orchestrationId,
+      domainCount: this.portfolioState.domainStates.size,
+      auditLogSize: this.portfolioState.auditLog.length,
+      rollbackActionsCount: this.portfolioState.rollbackPlan.length,
+      persistenceEnabled: this.enablePersistence,
+      dryRun: this.dryRun
+    };
+  }
+}

package/dist/orchestration/multi-domain-orchestrator.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+
+/**
+ * Multi-Domain Orchestrator Module
+ * Enterprise-grade deployment orchestration with state management, 
+ * rollback capabilities, and portfolio-wide coordination
+ * 
+ * Now uses modular architecture for improved maintainability and testability
+ */
+import { DomainResolver } from './modules/DomainResolver.js';
+import { DeploymentCoordinator } from './modules/DeploymentCoordinator.js';
+import { StateManager } from './modules/StateManager.js';
+
+/**
+ * Multi-Domain Deployment Orchestrator
+ * Manages enterprise-level deployments across multiple domains with comprehensive state tracking
+ * 
+ * REFACTORED: Now uses modular components for domain resolution, deployment coordination, and state management
+ */
+export class MultiDomainOrchestrator {
+  constructor(options = {}) {
+    this.domains = options.domains || [];
+    this.environment = options.environment || 'production';
+    this.dryRun = options.dryRun || false;
+    this.skipTests = options.skipTests || false;
+    this.parallelDeployments = options.parallelDeployments || 3;
+
+    // Initialize modular components
+    this.domainResolver = new DomainResolver({
+      environment: this.environment,
+      validationLevel: options.validationLevel || 'basic',
+      cacheEnabled: options.cacheEnabled !== false
+    });
+    this.deploymentCoordinator = new DeploymentCoordinator({
+      parallelDeployments: this.parallelDeployments,
+      skipTests: this.skipTests,
+      dryRun: this.dryRun,
+      environment: this.environment,
+      batchPauseMs: options.batchPauseMs || 2000
+    });
+    this.stateManager = new StateManager({
+      environment: this.environment,
+      dryRun: this.dryRun,
+      domains: this.domains,
+      enablePersistence: options.enablePersistence !== false,
+      rollbackEnabled: options.rollbackEnabled !== false
+    });
+
+    // Legacy compatibility: expose portfolioState for backward compatibility
+    this.portfolioState = this.stateManager.portfolioState;
+
+    // Note: Async initialization required - call initialize() after construction
+  }
+
+  /**
+   * Initialize the orchestrator asynchronously
+   * Uses modular components for domain resolution and state initialization
+   */
+  async initialize() {
+    console.log('🌐 Multi-Domain Orchestrator v2.0 (Modular)');
+    console.log('===========================================');
+    console.log(`📊 Portfolio: ${this.domains.length} domains`);
+    console.log(`🌍 Environment: ${this.environment}`);
+    console.log(`🆔 Orchestration ID: ${this.portfolioState.orchestrationId}`);
+    console.log(`🔍 Mode: ${this.dryRun ? 'DRY RUN' : 'LIVE DEPLOYMENT'}`);
+    console.log(`⚡ Parallel Deployments: ${this.parallelDeployments}`);
+    console.log('🧩 Modular Components: DomainResolver, DeploymentCoordinator, StateManager');
+    console.log('');
+
+    // Initialize all modular components
+    await this.stateManager.initializeDomainStates(this.domains);
+
+    // Pre-resolve all domain configurations if domains are specified
+    if (this.domains.length > 0) {
+      const configs = await this.domainResolver.resolveMultipleDomains(this.domains);
+
+      // Update domain states with resolved configurations
+      for (const [domain, config] of Object.entries(configs)) {
+        const domainState = this.portfolioState.domainStates.get(domain);
+        if (domainState) {
+          domainState.config = config;
+          this.stateManager.updateDomainState(domain, {
+            config
+          });
+        }
+      }
+    }
+    await this.stateManager.logAuditEvent('orchestrator_initialized', {
+      domains: this.domains,
+      environment: this.environment,
+      modularComponents: ['DomainResolver', 'DeploymentCoordinator', 'StateManager']
+    });
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use stateManager.generateOrchestrationId() instead
+   */
+  generateOrchestrationId() {
+    return this.stateManager.generateOrchestrationId();
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use stateManager.generateDeploymentId() instead
+   */
+  generateDeploymentId(domain) {
+    return this.stateManager.generateDeploymentId(domain);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use domainResolver.generateDomainConfig() instead
+   */
+  generateDomainConfig(domain) {
+    return this.domainResolver.generateDomainConfig(domain);
+  }
+
+  /**
+   * Deploy to single domain using modular deployment coordinator
+   * @param {string} domain - Domain to deploy
+   * @returns {Promise<Object>} Deployment result
+   */
+  async deploySingleDomain(domain) {
+    const domainState = this.portfolioState.domainStates.get(domain);
+    if (!domainState) {
+      throw new Error(`Domain ${domain} not found in portfolio`);
+    }
+
+    // Create handlers that delegate to our legacy methods for backward compatibility
+    const handlers = {
+      validation: d => this.validateDomainPrerequisites(d),
+      initialization: d => this.initializeDomainDeployment(d),
+      database: d => this.setupDomainDatabase(d),
+      secrets: d => this.handleDomainSecrets(d),
+      deployment: d => this.deployDomainWorker(d),
+      'post-validation': d => this.validateDomainDeployment(d)
+    };
+    return await this.deploymentCoordinator.deploySingleDomain(domain, domainState, handlers);
+  }
+
+  /**
+   * Deploy to multiple domains using modular deployment coordinator
+   * @returns {Promise<Object>} Portfolio deployment results
+   */
+  async deployPortfolio() {
+    // Create handlers that delegate to our legacy methods for backward compatibility
+    const handlers = {
+      validation: d => this.validateDomainPrerequisites(d),
+      initialization: d => this.initializeDomainDeployment(d),
+      database: d => this.setupDomainDatabase(d),
+      secrets: d => this.handleDomainSecrets(d),
+      deployment: d => this.deployDomainWorker(d),
+      'post-validation': d => this.validateDomainDeployment(d)
+    };
+    return await this.deploymentCoordinator.deployPortfolio(this.domains, this.portfolioState.domainStates, handlers);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use deploymentCoordinator.createDeploymentBatches() instead
+   */
+  createDeploymentBatches() {
+    return this.deploymentCoordinator.createDeploymentBatches(this.domains);
+  }
+
+  /**
+   * Legacy method for backward compatibility  
+   * @deprecated Use stateManager.logAuditEvent() instead
+   */
+  logAuditEvent(event, domain, details = {}) {
+    return this.stateManager.logAuditEvent(event, domain, details);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use stateManager.saveAuditLog() instead
+   */
+  async saveAuditLog() {
+    return await this.stateManager.saveAuditLog();
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use domainResolver.validateDomainPrerequisites() instead  
+   */
+  async validateDomainPrerequisites(domain) {
+    return await this.domainResolver.validateDomainPrerequisites(domain);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use deploymentCoordinator.initializeDomainDeployment() instead
+   */
+  async initializeDomainDeployment(domain) {
+    return await this.deploymentCoordinator.initializeDomainDeployment(domain);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use deploymentCoordinator.setupDomainDatabase() instead
+   */
+  async setupDomainDatabase(domain) {
+    return await this.deploymentCoordinator.setupDomainDatabase(domain);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use deploymentCoordinator.handleDomainSecrets() instead
+   */
+  async handleDomainSecrets(domain) {
+    return await this.deploymentCoordinator.handleDomainSecrets(domain);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use deploymentCoordinator.deployDomainWorker() instead
+   */
+  async deployDomainWorker(domain) {
+    return await this.deploymentCoordinator.deployDomainWorker(domain);
+  }
+
+  /**
+   * Legacy method for backward compatibility
+   * @deprecated Use deploymentCoordinator.validateDomainDeployment() instead
+   */
+  async validateDomainDeployment(domain) {
+    return await this.deploymentCoordinator.validateDomainDeployment(domain);
+  }
+
+  /**
+   * Get rollback plan using state manager
+   * @returns {Array} Rollback plan from state manager
+   */
+  getRollbackPlan() {
+    return this.stateManager.portfolioState.rollbackPlan;
+  }
+
+  /**
+   * Execute rollback using state manager  
+   * @returns {Promise<Object>} Rollback result
+   */
+  async executeRollback() {
+    return await this.stateManager.executeRollback();
+  }
+
+  /**
+   * Get portfolio statistics from state manager
+   * @returns {Object} Portfolio statistics
+   */
+  getPortfolioStats() {
+    return this.stateManager.getPortfolioSummary();
+  }
+}
+export default MultiDomainOrchestrator;