@tamyla/clodo-framework 3.1.21 → 3.1.22

package/dist/bin/shared/deployment/workflows/interactive-database-workflow.js

@@ -0,0 +1,234 @@
+/**
+ * Interactive Database Workflow Module
+ * 
+ * Provides reusable interactive database creation and configuration workflows.
+ * Extracted from enterprise-deployment/master-deploy.js for modularity.
+ * 
+ * @module interactive-database-workflow
+ */
+
+import { askUser, askYesNo, askChoice } from '../../utils/interactive-prompts.js';
+import { databaseExists, createDatabase, deleteDatabase } from '../../cloudflare/ops.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+
+/**
+ * Interactive Database Workflow
+ * Handles database naming, existence checking, and creation with user interaction
+ */
+export class InteractiveDatabaseWorkflow {
+  /**
+   * @param {Object} options - Configuration options
+   * @param {Array} options.rollbackActions - Array to track rollback actions
+   */
+  constructor(options = {}) {
+    this.rollbackActions = options.rollbackActions || [];
+  }
+
+  /**
+   * Handle complete database setup workflow
+   * 
+   * @param {string} domain - Domain name for database
+   * @param {string} environment - Deployment environment
+   * @param {Object} options - Additional options
+   * @param {string} [options.suggestedName] - Suggested database name
+   * @param {boolean} [options.interactive=true] - Enable interactive prompts
+   * @returns {Promise<Object>} Database configuration { name, id, created, reused }
+   */
+  async handleDatabaseSetup(domain, environment, options = {}) {
+    console.log('\n🗄️ Database Configuration');
+    console.log('=========================');
+
+    // Generate default database name
+    const suggestedName = options.suggestedName || `${domain}-auth-db`;
+
+    // Get final database name
+    const databaseName = await this.promptForDatabaseName(suggestedName, options.interactive);
+
+    // Check if database exists
+    const existingInfo = await this.checkExistingDatabase(databaseName);
+    if (existingInfo.exists) {
+      return await this.handleExistingDatabase(databaseName, existingInfo, options.interactive);
+    } else {
+      return await this.createNewDatabase(databaseName, options.interactive);
+    }
+  }
+
+  /**
+   * Prompt user for database name
+   * 
+   * @param {string} suggested - Suggested database name
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<string>} Final database name
+   */
+  async promptForDatabaseName(suggested, interactive = true) {
+    console.log(`\n📋 Generated database name: ${suggested}`);
+    if (!interactive) {
+      return suggested;
+    }
+    const useGeneratedName = await askYesNo('Use this database name?', 'y');
+    if (!useGeneratedName) {
+      return await askUser('Enter custom database name', suggested);
+    }
+    return suggested;
+  }
+
+  /**
+   * Check if database exists and get its details
+   * 
+   * @param {string} name - Database name
+   * @returns {Promise<Object>} { exists: boolean, id?: string, error?: string }
+   */
+  async checkExistingDatabase(name) {
+    console.log('\n🔍 Checking for existing database...');
+    try {
+      const exists = await databaseExists(name);
+      if (exists) {
+        console.log(`   📋 Database '${name}' already exists`);
+
+        // Extract database ID from the list command
+        try {
+          const dbListResult = await execAsync('npx wrangler d1 list');
+          const lines = dbListResult.stdout.split('\n');
+          for (const line of lines) {
+            if (line.includes(name)) {
+              const match = line.match(/([a-f0-9-]{36})/);
+              if (match) {
+                return {
+                  exists: true,
+                  id: match[1]
+                };
+              }
+            }
+          }
+        } catch (error) {
+          console.log('   ⚠️ Could not extract database ID');
+        }
+        return {
+          exists: true
+        };
+      } else {
+        console.log(`   ✅ Database '${name}' does not exist`);
+        return {
+          exists: false
+        };
+      }
+    } catch (error) {
+      console.log('   ⚠️ Could not check existing databases');
+      return {
+        exists: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Handle workflow for existing database
+   * 
+   * @param {string} name - Database name
+   * @param {Object} existingInfo - Information about existing database
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<Object>} Database configuration
+   */
+  async handleExistingDatabase(name, existingInfo, interactive = true) {
+    if (!interactive) {
+      // Non-interactive mode: reuse existing
+      console.log(`   ✅ Using existing database: ${name}`);
+      return {
+        name,
+        id: existingInfo.id,
+        created: false,
+        reused: true
+      };
+    }
+    const databaseChoice = await askChoice('What would you like to do with the existing database?', ['Use the existing database (recommended)', 'Create a new database with different name', 'Delete existing and create new (DANGER: DATA LOSS)'], 0);
+    switch (databaseChoice) {
+      case 0:
+        {
+          // Use existing database
+          if (existingInfo.id) {
+            console.log(`   ✅ Using existing database ID: ${existingInfo.id}`);
+          }
+          return {
+            name,
+            id: existingInfo.id,
+            created: false,
+            reused: true
+          };
+        }
+      case 1:
+        {
+          // Create new database with different name
+          const newName = await askUser('Enter new database name');
+          return await this.createNewDatabase(newName, interactive);
+        }
+      case 2:
+        {
+          // Delete and recreate
+          const confirmDelete = await askYesNo('⚠️ ARE YOU SURE? This will DELETE all data in the existing database!', 'n');
+          if (!confirmDelete) {
+            throw new Error('Database deletion cancelled');
+          }
+          console.log(`\n🗑️ Deleting existing database...`);
+          await deleteDatabase(name);
+          return await this.createNewDatabase(name, interactive);
+        }
+      default:
+        throw new Error('Invalid database choice');
+    }
+  }
+
+  /**
+   * Create a new database
+   * 
+   * @param {string} name - Database name
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<Object>} Database configuration
+   */
+  async createNewDatabase(name, interactive = true) {
+    console.log(`\n🆕 Creating new database: ${name}`);
+    if (interactive) {
+      const confirmCreate = await askYesNo('Proceed with database creation?', 'y');
+      if (!confirmCreate) {
+        throw new Error('Database creation cancelled');
+      }
+    }
+    try {
+      const databaseId = await createDatabase(name);
+      console.log(`   ✅ Database created with ID: ${databaseId}`);
+
+      // Add to rollback actions
+      this.rollbackActions.push({
+        type: 'delete-database',
+        name: name,
+        command: `npx wrangler d1 delete ${name} --skip-confirmation`,
+        description: `Delete database '${name}' created during deployment`
+      });
+      return {
+        name,
+        id: databaseId,
+        created: true,
+        reused: false
+      };
+    } catch (error) {
+      throw new Error(`Database creation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get database configuration summary
+   * 
+   * @param {Object} dbConfig - Database configuration
+   * @returns {string} Summary message
+   */
+  getSummary(dbConfig) {
+    if (dbConfig.created) {
+      return `✅ Database configured: ${dbConfig.name} (${dbConfig.id}) - CREATED`;
+    } else if (dbConfig.reused) {
+      return `✅ Database configured: ${dbConfig.name} (${dbConfig.id}) - REUSED`;
+    } else {
+      return `✅ Database configured: ${dbConfig.name} (${dbConfig.id})`;
+    }
+  }
+}

package/dist/bin/shared/deployment/workflows/interactive-domain-info-gatherer.js

@@ -0,0 +1,240 @@
+/**
+ * Interactive Domain Info Gatherer Module
+ * 
+ * Provides reusable domain configuration gathering workflows.
+ * Extracted from enterprise-deployment/master-deploy.js for modularity.
+ * 
+ * @module interactive-domain-info-gatherer
+ */
+
+import { askUser, askYesNo, askChoice } from '../utils/interactive-prompts.js';
+
+/**
+ * Interactive Domain Info Gatherer
+ * Handles domain information gathering with configuration discovery
+ */
+export class InteractiveDomainInfoGatherer {
+  /**
+   * @param {Object} options - Configuration options
+   * @param {Object} options.configCache - ConfigurationCacheManager instance
+   * @param {boolean} options.interactive - Enable interactive prompts
+   */
+  constructor(options = {}) {
+    this.configCache = options.configCache;
+    this.interactive = options.interactive !== false;
+  }
+
+  /**
+   * Gather single domain information
+   * 
+   * @param {Object} config - Configuration object to populate
+   * @returns {Promise<Object>} Updated configuration
+   */
+  async gatherSingleDomainInfo(config) {
+    console.log('\n📱 Single Domain Configuration');
+    console.log('------------------------------');
+
+    // Domain name with enhanced validation
+    config.domain = await this.promptForDomain();
+    console.log(`\n✅ Domain: ${config.domain}`);
+
+    // Try configuration discovery if available
+    if (this.configCache) {
+      const discovered = await this.tryConfigurationDiscovery(config.domain);
+      if (discovered) {
+        this.applyDiscoveredConfig(config, discovered);
+      }
+    }
+
+    // Environment selection
+    config.environment = await this.selectEnvironment();
+    console.log(`✅ Environment: ${config.environment}`);
+
+    // Generate worker configuration
+    await this.configureWorker(config);
+    return config;
+  }
+
+  /**
+   * Prompt for domain name
+   * 
+   * @returns {Promise<string>} Domain name
+   */
+  async promptForDomain() {
+    const domain = await askUser('Enter the domain name for deployment (e.g., "newclient", "democorp")');
+    if (!domain || domain.trim().length === 0) {
+      throw new Error('Domain name is required');
+    }
+    return domain.trim();
+  }
+
+  /**
+   * Select deployment environment
+   * 
+   * @returns {Promise<string>} Selected environment
+   */
+  async selectEnvironment() {
+    const environments = ['production', 'staging', 'development'];
+    if (!this.interactive) {
+      return environments[0]; // Default to production in non-interactive mode
+    }
+    const envChoice = await askChoice('Select deployment environment:', environments, 0);
+    return environments[envChoice];
+  }
+
+  /**
+   * Configure worker settings
+   * 
+   * @param {Object} config - Configuration object
+   * @returns {Promise<void>}
+   */
+  async configureWorker(config) {
+    // Generate default worker configuration
+    config.worker = config.worker || {};
+    config.worker.name = `${config.domain}-data-service`;
+    config.worker.url = `https://${config.worker.name}.tamylatrading.workers.dev`;
+    console.log(`\n🔧 Generated Configuration:`);
+    console.log(`   Worker Name: ${config.worker.name}`);
+    console.log(`   Worker URL: ${config.worker.url}`);
+    if (!this.interactive) {
+      return; // Use defaults in non-interactive mode
+    }
+    const confirmWorkerConfig = await askYesNo('Is this worker configuration correct?', 'y');
+    if (!confirmWorkerConfig) {
+      config.worker.name = await askUser('Enter custom worker name', config.worker.name);
+      config.worker.url = `https://${config.worker.name}.tamylatrading.workers.dev`;
+      console.log(`\n✅ Updated worker configuration`);
+    }
+  }
+
+  /**
+   * Try to discover existing configuration for domain
+   * 
+   * @param {string} domain - Domain name
+   * @returns {Promise<Object|null>} Discovered configuration or null
+   */
+  async tryConfigurationDiscovery(domain) {
+    if (!this.configCache) {
+      return null;
+    }
+    if (!this.interactive) {
+      // Non-interactive mode: silently try discovery
+      try {
+        return await this.configCache.getOrCreateDomainConfig(domain, {
+          environment: 'production',
+          forceRefresh: false
+        });
+      } catch (error) {
+        return null;
+      }
+    }
+
+    // Interactive mode: ask user
+    const tryDiscovery = await askYesNo('🔍 Try to discover existing configuration for this domain?', 'y');
+    if (!tryDiscovery) {
+      return null;
+    }
+    try {
+      console.log('\n🔍 Attempting configuration discovery...');
+      const discoveredConfig = await this.configCache.getOrCreateDomainConfig(domain, {
+        environment: 'production',
+        forceRefresh: false
+      });
+      if (discoveredConfig) {
+        console.log('\n✅ Found existing configuration!');
+        console.log(`   📝 Type: ${discoveredConfig.metadata?.type || 'unknown'}`);
+        console.log(`   📅 Last updated: ${discoveredConfig.metadata?.timestamp || 'unknown'}`);
+        const useDiscovered = await askYesNo('Use discovered configuration?', 'y');
+        if (useDiscovered) {
+          return discoveredConfig;
+        }
+      } else {
+        console.log('   ℹ️  No existing configuration found, will generate new one');
+      }
+    } catch (error) {
+      console.log(`   ⚠️  Discovery failed: ${error.message}`);
+    }
+    return null;
+  }
+
+  /**
+   * Apply discovered configuration to config object
+   * 
+   * @param {Object} config - Configuration object to update
+   * @param {Object} discovered - Discovered configuration
+   */
+  applyDiscoveredConfig(config, discovered) {
+    if (discovered.worker) {
+      config.worker = config.worker || {};
+      config.worker.name = discovered.worker.name || `${config.domain}-data-service`;
+      config.worker.url = discovered.worker.url;
+    }
+    if (discovered.database) {
+      config.database = config.database || {};
+      config.database.name = discovered.database.name;
+      config.database.id = discovered.database.id;
+    }
+    if (discovered.environment) {
+      config.environment = discovered.environment;
+    }
+    console.log('\n✅ Applied discovered configuration');
+  }
+
+  /**
+   * Gather multi-domain information
+   * 
+   * @returns {Promise<Object>} Multi-domain configuration
+   */
+  async gatherMultiDomainInfo() {
+    console.log('\n🌍 Multi-Domain Configuration');
+    console.log('-----------------------------');
+    console.log('This feature allows coordinated deployment across multiple domains');
+    const domainCount = await askUser('How many domains to deploy? (2-10)', '2');
+    const count = parseInt(domainCount, 10);
+    if (isNaN(count) || count < 2 || count > 10) {
+      throw new Error('Domain count must be between 2 and 10');
+    }
+    console.log(`\n✅ Multi-domain mode: ${count} domains`);
+    const domains = [];
+    for (let i = 0; i < count; i++) {
+      const domain = await askUser(`Enter domain ${i + 1} name:`);
+      domains.push(domain);
+    }
+    return {
+      mode: 'multi-domain',
+      count,
+      domains
+    };
+  }
+
+  /**
+   * Gather portfolio information
+   * 
+   * @returns {Promise<Object>} Portfolio configuration
+   */
+  async gatherPortfolioInfo() {
+    console.log('\n📊 Portfolio Management Configuration');
+    console.log('------------------------------------');
+    console.log('This feature provides advanced portfolio management capabilities');
+    const portfolioName = await askUser('Enter portfolio name:', 'default-portfolio');
+    console.log(`\n✅ Portfolio mode activated: ${portfolioName}`);
+    return {
+      mode: 'portfolio',
+      name: portfolioName
+    };
+  }
+
+  /**
+   * Get domain info summary
+   * 
+   * @param {Object} config - Configuration
+   * @returns {string} Summary message
+   */
+  getSummary(config) {
+    const parts = [`Domain: ${config.domain}`, `Environment: ${config.environment}`, `Worker: ${config.worker?.name}`];
+    if (config.database?.name) {
+      parts.push(`Database: ${config.database.name}`);
+    }
+    return `✅ Domain configuration: ${parts.join(' | ')}`;
+  }
+}

package/dist/bin/shared/deployment/workflows/interactive-secret-workflow.js

@@ -0,0 +1,228 @@
+/**
+ * Interactive Secret Workflow Module
+ * 
+ * Provides reusable interactive secret management workflows.
+ * Extracted from enterprise-deployment/master-deploy.js for modularity.
+ * 
+ * @module interactive-secret-workflow
+ */
+
+import { askYesNo } from '../utils/interactive-prompts.js';
+import { generateSecrets, saveSecrets, distributeSecrets } from '../security/secret-generator.js';
+import { deploySecret } from '../cloudflare/ops.js';
+import { join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+
+/**
+ * Interactive Secret Workflow
+ * Handles secret generation, deployment, and distribution with user interaction
+ */
+export class InteractiveSecretWorkflow {
+  /**
+   * @param {Object} options - Configuration options
+   * @param {Array} options.rollbackActions - Array to track rollback actions
+   */
+  constructor(options = {}) {
+    this.rollbackActions = options.rollbackActions || [];
+  }
+
+  /**
+   * Handle complete secret management workflow
+   * 
+   * @param {string} domain - Domain name
+   * @param {string} environment - Deployment environment
+   * @param {string} workerName - Worker name for deployment
+   * @param {Object} options - Additional options
+   * @param {boolean} [options.interactive=true] - Enable interactive prompts
+   * @param {boolean} [options.generateDistribution=true] - Generate distribution files
+   * @returns {Promise<Object>} Secret configuration { secrets, distributionPath, file }
+   */
+  async handleSecretManagement(domain, environment, workerName, options = {}) {
+    console.log('\n🔐 Secret Management');
+    console.log('====================');
+
+    // Discover existing secrets
+    const existingSecrets = await this.discoverExistingSecrets(domain, options.interactive);
+
+    // Obtain secrets (reuse or generate new)
+    const secrets = await this.obtainSecrets(domain, environment, existingSecrets, options.interactive);
+
+    // Deploy secrets to Cloudflare
+    await this.deploySecrets(secrets, workerName, environment, options.interactive);
+
+    // Generate distribution files
+    let distributionPath = null;
+    if (options.generateDistribution !== false) {
+      distributionPath = await this.generateDistribution(domain, secrets, options.interactive);
+    }
+    return {
+      secrets,
+      distributionPath,
+      file: join('secrets', `${domain}-secrets.json`)
+    };
+  }
+
+  /**
+   * Discover existing secrets from file system
+   * 
+   * @param {string} domain - Domain name
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<Object>} Existing secrets or empty object
+   */
+  async discoverExistingSecrets(domain, interactive = true) {
+    const secretsFile = join('secrets', `${domain}-secrets.json`);
+    if (!existsSync(secretsFile)) {
+      return {};
+    }
+    console.log(`\n📂 Found existing secrets file: ${secretsFile}`);
+    try {
+      const data = JSON.parse(readFileSync(secretsFile, 'utf8'));
+      const {
+        domain: fileDomain,
+        environment,
+        generated,
+        note,
+        ...secrets
+      } = data;
+      console.log(`   🔑 Contains ${Object.keys(secrets).length} secrets`);
+      console.log(`   📅 Generated: ${generated}`);
+      return secrets;
+    } catch (error) {
+      console.log('   ⚠️ Could not read existing secrets file');
+      return {};
+    }
+  }
+
+  /**
+   * Obtain secrets (reuse existing or generate new)
+   * 
+   * @param {string} domain - Domain name
+   * @param {string} environment - Deployment environment
+   * @param {Object} existingSecrets - Existing secrets
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<Object>} Final secrets
+   */
+  async obtainSecrets(domain, environment, existingSecrets, interactive = true) {
+    const hasExisting = Object.keys(existingSecrets).length > 0;
+
+    // If existing secrets found, ask to reuse
+    if (hasExisting && interactive) {
+      const reuseSecrets = await askYesNo('Do you want to reuse these existing secrets? (Recommended for consistency)', 'y');
+      if (reuseSecrets) {
+        console.log('   ✅ Will reuse existing secrets');
+        return existingSecrets;
+      }
+    } else if (hasExisting && !interactive) {
+      // Non-interactive mode: reuse existing by default
+      console.log('   ✅ Reusing existing secrets (non-interactive mode)');
+      return existingSecrets;
+    }
+
+    // Generate new secrets
+    return await this.generateNewSecrets(domain, environment, interactive);
+  }
+
+  /**
+   * Generate new secrets
+   * 
+   * @param {string} domain - Domain name
+   * @param {string} environment - Deployment environment
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<Object>} Generated secrets
+   */
+  async generateNewSecrets(domain, environment, interactive = true) {
+    console.log('\n🔑 Generating new secrets using shared module...');
+    if (interactive) {
+      const confirmGenerate = await askYesNo('Proceed with secret generation?', 'y');
+      if (!confirmGenerate) {
+        throw new Error('Secret generation cancelled');
+      }
+    }
+
+    // Generate secrets using shared module
+    const secrets = generateSecrets();
+
+    // Save secrets using shared module
+    const savedFile = saveSecrets(domain, environment, secrets, {
+      note: 'Generated by Interactive Secret Workflow'
+    });
+    console.log(`\n💾 Secrets saved to: ${savedFile}`);
+    return secrets;
+  }
+
+  /**
+   * Deploy secrets to Cloudflare Workers
+   * 
+   * @param {Object} secrets - Secrets to deploy
+   * @param {string} workerName - Worker name
+   * @param {string} environment - Deployment environment
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<void>}
+   */
+  async deploySecrets(secrets, workerName, environment, interactive = true) {
+    console.log('\n☁️ Deploying secrets to Cloudflare Workers...');
+    if (interactive) {
+      const deployConfirmed = await askYesNo(`Deploy ${Object.keys(secrets).length} secrets to worker '${workerName}'?`, 'y');
+      if (!deployConfirmed) {
+        throw new Error('Secret deployment cancelled');
+      }
+    }
+    for (const [key, value] of Object.entries(secrets)) {
+      console.log(`   🔑 Deploying ${key}...`);
+      try {
+        await deploySecret(key, value, environment);
+        console.log(`      ✅ ${key} deployed`);
+
+        // Add to rollback actions
+        this.rollbackActions.push({
+          type: 'delete-secret',
+          key: key,
+          command: `npx wrangler secret delete ${key} --env ${environment}`,
+          description: `Delete secret '${key}' deployed to environment '${environment}'`
+        });
+      } catch (error) {
+        throw new Error(`Failed to deploy secret ${key}: ${error.message}`);
+      }
+    }
+    console.log(`\n✅ All ${Object.keys(secrets).length} secrets deployed successfully`);
+  }
+
+  /**
+   * Generate secret distribution files
+   * 
+   * @param {string} domain - Domain name
+   * @param {Object} secrets - Secrets to distribute
+   * @param {boolean} interactive - Enable interactive prompts
+   * @returns {Promise<string|null>} Distribution directory path or null
+   */
+  async generateDistribution(domain, secrets, interactive = true) {
+    console.log('\n📤 Generating secret distribution files...');
+    if (interactive) {
+      const generateDistribution = await askYesNo('Generate secret distribution files for upstream/downstream applications?', 'y');
+      if (!generateDistribution) {
+        console.log('   ⏭️ Distribution generation skipped');
+        return null;
+      }
+    }
+
+    // Use shared module for secret distribution
+    const distribution = distributeSecrets(domain, secrets);
+    console.log(`   📂 Distribution files created in: ${distribution.directory}`);
+    return distribution.directory;
+  }
+
+  /**
+   * Get secret workflow summary
+   * 
+   * @param {Object} secretConfig - Secret configuration result
+   * @returns {string} Summary message
+   */
+  getSummary(secretConfig) {
+    const secretCount = Object.keys(secretConfig.secrets).length;
+    const parts = [`✅ Secret management complete: ${secretCount} secrets deployed`];
+    if (secretConfig.distributionPath) {
+      parts.push(`Distribution: ${secretConfig.distributionPath}`);
+    }
+    return parts.join(' | ');
+  }
+}