@tamyla/clodo-framework 2.0.2 → 2.0.3

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [2.0.3](https://github.com/tamylaa/clodo-framework/compare/v2.0.2...v2.0.3) (2025-10-11)
+
+
+### Bug Fixes
+
+* Add reusable deployment command with Three-Tier input architecture ([0e13bfc](https://github.com/tamylaa/clodo-framework/commit/0e13bfcdda56d0a137bcd44cfd8a9ca49af30503))
+* test - Remove placeholder tests that require unimplemented classes ([b009b34](https://github.com/tamylaa/clodo-framework/commit/b009b34cf1f9f7542fbaab2fa2419b2766c72f10))
+
 ## [2.0.2](https://github.com/tamylaa/clodo-framework/compare/v2.0.1...v2.0.2) (2025-10-11)
 
 

package/bin/clodo-service.js

@@ -413,4 +413,169 @@ program
     }
   });
 
+// Deploy command - using existing InputCollector + CustomerConfigLoader (reusable pattern)
+program
+  .command('deploy')
+  .description('Deploy service using three-tier input architecture')
+  .option('-c, --customer <name>', 'Customer name')
+  .option('-e, --env <environment>', 'Target environment (development, staging, production)')
+  .option('-i, --interactive', 'Interactive mode (review confirmations)', true)
+  .option('--non-interactive', 'Non-interactive mode (use stored config)')
+  .option('--dry-run', 'Simulate deployment without making changes')
+  .option('--domain <domain>', 'Domain name (overrides stored config)')
+  .option('--service-path <path>', 'Path to service directory', '.')
+  .action(async (options) => {
+    try {
+      // Use existing reusable components
+      const { InputCollector } = await import('../dist/service-management/InputCollector.js');
+      const { CustomerConfigLoader } = await import('../dist/config/customer-config-loader.js');
+      const { ConfirmationHandler } = await import('../dist/service-management/handlers/ConfirmationHandler.js');
+      const { MultiDomainOrchestrator } = await import('../dist/orchestration/multi-domain-orchestrator.js');
+      
+      console.log(chalk.cyan('\n🚀 Clodo Framework Deployment'));
+      console.log(chalk.white('Using Three-Tier Input Architecture\n'));
+      
+      const isInteractive = options.interactive && !options.nonInteractive;
+      const configLoader = new CustomerConfigLoader();
+      const inputCollector = new InputCollector({ interactive: isInteractive });
+      const confirmationHandler = new ConfirmationHandler({ interactive: isInteractive });
+      
+      let coreInputs = {};
+      let source = 'interactive';
+      
+      try {
+        // Try to load existing customer config first
+        if (options.customer && options.env) {
+          const storedConfig = configLoader.loadConfig(options.customer, options.env);
+          
+          if (storedConfig) {
+            source = 'stored-config';
+            console.log(chalk.cyan('📋 Found Existing Configuration\n'));
+            configLoader.displayConfig(storedConfig.parsed);
+            
+            if (!isInteractive) {
+              // Non-interactive: use stored config as-is
+              coreInputs = storedConfig.parsed;
+              console.log(chalk.green('\n✅ Using stored configuration (non-interactive mode)\n'));
+            } else {
+              // Interactive: ask to confirm or re-collect
+              const useStored = await inputCollector.question('\nUse this configuration? (Y/n): ');
+              
+              if (useStored.toLowerCase() !== 'n') {
+                coreInputs = storedConfig.parsed;
+                console.log(chalk.green('\n✅ Using stored configuration\n'));
+              } else {
+                console.log(chalk.white('\nCollecting new configuration...\n'));
+                source = 'interactive';
+              }
+            }
+          } else {
+            console.log(chalk.yellow(`⚠️  No configuration found for ${options.customer}/${options.env}`));
+            console.log(chalk.white('Collecting inputs interactively...\n'));
+          }
+        }
+        
+        // Collect inputs if we don't have them from stored config
+        if (!coreInputs.cloudflareAccountId) {
+          console.log(chalk.cyan('📊 Tier 1: Core Input Collection\n'));
+          
+          // Use InputCollector for what it does best - collecting inputs
+          coreInputs = {
+            customer: options.customer || await inputCollector.question('Customer name: '),
+            environment: options.env || await inputCollector.collectEnvironment(),
+            serviceName: await inputCollector.collectServiceName(),
+            serviceType: await inputCollector.collectServiceType(),
+            domainName: options.domain || await inputCollector.collectDomainName(),
+            cloudflareToken: process.env.CLOUDFLARE_API_TOKEN || await inputCollector.collectCloudflareToken(),
+            cloudflareAccountId: process.env.CLOUDFLARE_ACCOUNT_ID || await inputCollector.collectCloudflareAccountId(),
+            cloudflareZoneId: process.env.CLOUDFLARE_ZONE_ID || await inputCollector.collectCloudflareZoneId()
+          };
+          
+          source = 'interactive';
+        }
+        
+        // Allow domain override
+        if (options.domain) {
+          coreInputs.domainName = options.domain;
+        }
+        
+        // Tier 2: Generate smart confirmations using existing ConfirmationHandler
+        console.log(chalk.cyan('⚙️  Tier 2: Smart Confirmations\n'));
+        const confirmations = await confirmationHandler.generateAndConfirm(coreInputs);
+        
+        // Show deployment summary
+        console.log(chalk.cyan('\n📊 Deployment Summary'));
+        console.log(chalk.gray('─'.repeat(60)));
+        
+        console.log(chalk.white(`Source:        ${source}`));
+        console.log(chalk.white(`Customer:      ${coreInputs.customer}`));
+        console.log(chalk.white(`Environment:   ${coreInputs.environment}`));
+        console.log(chalk.white(`Domain:        ${coreInputs.domainName}`));
+        console.log(chalk.white(`Account ID:    ${coreInputs.cloudflareAccountId?.substring(0, 8)}...`));
+        console.log(chalk.white(`Zone ID:       ${coreInputs.cloudflareZoneId?.substring(0, 8)}...`));
+        
+        if (confirmations.workerName) {
+          console.log(chalk.white(`Worker:        ${confirmations.workerName}`));
+        }
+        if (confirmations.databaseName) {
+          console.log(chalk.white(`Database:      ${confirmations.databaseName}`));
+        }
+        
+        console.log(chalk.gray('─'.repeat(60)));
+        
+        if (options.dryRun) {
+          console.log(chalk.yellow('\n🔍 DRY RUN MODE - No changes will be made\n'));
+        }
+        
+        // Tier 3: Execute deployment
+        console.log(chalk.cyan('\n⚙️  Tier 3: Automated Deployment\n'));
+        
+        const orchestrator = new MultiDomainOrchestrator({
+          domains: [coreInputs.domainName],
+          environment: coreInputs.environment,
+          dryRun: options.dryRun,
+          servicePath: options.servicePath
+        });
+        
+        await orchestrator.initialize();
+        
+        console.log(chalk.cyan('🚀 Starting deployment...\n'));
+        
+        const result = await orchestrator.deployDomain(coreInputs.domainName, {
+          ...coreInputs,
+          ...confirmations,
+          servicePath: options.servicePath
+        });
+        
+        // Display results
+        console.log(chalk.green('\n✅ Deployment Completed Successfully!'));
+        console.log(chalk.gray('─'.repeat(60)));
+        console.log(chalk.white(`   Worker:   ${confirmations.workerName || 'N/A'}`));
+        console.log(chalk.white(`   URL:      ${result.url || confirmations.deploymentUrl || 'N/A'}`));
+        console.log(chalk.white(`   Status:   ${result.status || 'deployed'}`));
+        
+        if (result.health) {
+          console.log(chalk.white(`   Health:   ${result.health}`));
+        }
+        
+        console.log(chalk.gray('─'.repeat(60)));
+        
+        console.log(chalk.cyan('\n📋 Next Steps:'));
+        console.log(chalk.white(`   • Test deployment: curl ${result.url || confirmations.deploymentUrl}/health`));
+        console.log(chalk.white(`   • Monitor logs: wrangler tail ${confirmations.workerName}`));
+        console.log(chalk.white(`   • View dashboard: https://dash.cloudflare.com`));
+        
+      } finally {
+        inputCollector.close();
+      }
+      
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Deployment failed: ${error.message}`));
+      if (error.stack && process.env.DEBUG) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exit(1);
+    }
+  });
+
 program.parse();

package/dist/config/customer-config-loader.js

@@ -0,0 +1,247 @@
+/**
+ * CustomerConfigLoader - Reusable Utility for Loading Customer Configurations
+ * 
+ * This utility:
+ * 1. Loads existing customer configs from config/customers/{customer}/{env}.env
+ * 2. Provides defaults that can be merged with InputCollector results
+ * 3. Works for both service creation and deployment
+ * 
+ * PATTERN: Separation of Concerns
+ * - InputCollector: Collects user inputs (pure, reusable)
+ * - CustomerConfigLoader: Loads stored configs (pure, reusable)
+ * - ServiceOrchestrator/DeploymentOrchestrator: Uses both to orchestrate workflows
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { getDirname } from '../utils/esm-helper.js';
+import { createLogger } from '../utils/index.js';
+import chalk from 'chalk';
+const __dirname = getDirname(import.meta.url, 'src/config');
+const logger = createLogger('CustomerConfigLoader');
+
+/**
+ * Parse .env file into key-value pairs
+ */
+function parseEnvFile(filePath) {
+  const content = readFileSync(filePath, 'utf-8');
+  const result = {};
+  content.split('\n').forEach(line => {
+    line = line.trim();
+
+    // Skip empty lines and comments
+    if (!line || line.startsWith('#')) {
+      return;
+    }
+
+    // Parse KEY=VALUE
+    const match = line.match(/^([^=]+)=(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      let value = match[2].trim();
+
+      // Remove quotes if present
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      result[key] = value;
+    }
+  });
+  return result;
+}
+
+/**
+ * Check if config is a template (not real data)
+ */
+function isTemplateConfig(envVars) {
+  return envVars.CUSTOMER_NAME?.includes('{{') || envVars.CLOUDFLARE_ACCOUNT_ID === '00000000000000000000000000000000' || !envVars.CLOUDFLARE_ACCOUNT_ID || !envVars.DOMAIN;
+}
+
+/**
+ * CustomerConfigLoader - Load and parse customer configurations
+ */
+export class CustomerConfigLoader {
+  constructor(options = {}) {
+    this.configDir = options.configDir || resolve(__dirname, '..', '..', 'config', 'customers');
+  }
+
+  /**
+   * Load customer configuration if it exists
+   * Returns null if not found or is a template
+   * 
+   * @param {string} customer - Customer name
+   * @param {string} environment - Environment (development, staging, production)
+   * @returns {Object|null} - Parsed config or null
+   */
+  loadConfig(customer, environment) {
+    const configPath = resolve(this.configDir, customer, `${environment}.env`);
+    if (!existsSync(configPath)) {
+      logger.debug('Config file not found', {
+        customer,
+        environment,
+        configPath
+      });
+      return null;
+    }
+    try {
+      const envVars = parseEnvFile(configPath);
+
+      // Check if it's a template
+      if (isTemplateConfig(envVars)) {
+        logger.debug('Config is a template, treating as non-existent', {
+          customer,
+          environment
+        });
+        return null;
+      }
+      logger.info('Loaded customer config', {
+        customer,
+        environment
+      });
+      return {
+        customer,
+        environment,
+        configPath,
+        raw: envVars,
+        parsed: this.parseToStandardFormat(envVars, customer, environment)
+      };
+    } catch (error) {
+      logger.error('Failed to load config', {
+        customer,
+        environment,
+        error: error.message
+      });
+      return null;
+    }
+  }
+
+  /**
+   * Parse env vars into standard format that matches InputCollector output
+   * This ensures compatibility between stored configs and collected inputs
+   */
+  parseToStandardFormat(envVars, customer, environment) {
+    return {
+      // Core inputs (Tier 1) - matches InputCollector.collectCoreInputs()
+      serviceName: envVars.SERVICE_NAME || customer,
+      serviceType: envVars.SERVICE_TYPE || 'generic',
+      domainName: envVars.DOMAIN || envVars.CUSTOMER_DOMAIN,
+      cloudflareToken: envVars.CLOUDFLARE_API_TOKEN || process.env.CLOUDFLARE_API_TOKEN,
+      cloudflareAccountId: envVars.CLOUDFLARE_ACCOUNT_ID,
+      cloudflareZoneId: envVars.CLOUDFLARE_ZONE_ID,
+      environment: environment,
+      // Additional metadata
+      customer: customer,
+      // Deployment-specific (Tier 2 confirmations)
+      workerName: envVars.WORKER_NAME,
+      databaseName: envVars.DATABASE_NAME || envVars.D1_DATABASE_NAME,
+      deploymentUrl: envVars.DEPLOYMENT_URL || envVars.API_DOMAIN,
+      healthCheckPath: envVars.HEALTH_CHECK_PATH || '/health',
+      apiBasePath: envVars.API_BASE_PATH || '/api/v1',
+      logLevel: envVars.LOG_LEVEL || 'info',
+      nodeCompatibility: envVars.NODE_COMPATIBILITY || 'v18',
+      // All raw env vars for other use cases
+      envVars: envVars
+    };
+  }
+
+  /**
+   * Load config or return empty defaults
+   * Never throws - always returns an object
+   */
+  loadConfigSafe(customer, environment) {
+    const config = this.loadConfig(customer, environment);
+    if (config) {
+      return config.parsed;
+    }
+
+    // Return defaults if no config found
+    return {
+      customer,
+      environment,
+      serviceName: customer,
+      serviceType: 'generic',
+      domainName: '',
+      cloudflareToken: process.env.CLOUDFLARE_API_TOKEN || '',
+      cloudflareAccountId: process.env.CLOUDFLARE_ACCOUNT_ID || '',
+      cloudflareZoneId: process.env.CLOUDFLARE_ZONE_ID || '',
+      envVars: {}
+    };
+  }
+
+  /**
+   * Check if customer config exists (and is not a template)
+   */
+  hasConfig(customer, environment) {
+    return this.loadConfig(customer, environment) !== null;
+  }
+
+  /**
+   * Display loaded config for user review
+   */
+  displayConfig(config, options = {}) {
+    const {
+      showSecrets = false
+    } = options;
+    console.log(chalk.cyan('\n📋 Loaded Customer Configuration'));
+    console.log(chalk.gray('─'.repeat(60)));
+    console.log(chalk.white(`Customer:     ${config.customer}`));
+    console.log(chalk.white(`Environment:  ${config.environment}`));
+    console.log(chalk.white(`Domain:       ${config.domainName}`));
+    if (showSecrets) {
+      console.log(chalk.white(`Account ID:   ${config.cloudflareAccountId}`));
+      console.log(chalk.white(`Zone ID:      ${config.cloudflareZoneId}`));
+    } else {
+      console.log(chalk.white(`Account ID:   ${config.cloudflareAccountId?.substring(0, 8)}...`));
+      console.log(chalk.white(`Zone ID:      ${config.cloudflareZoneId?.substring(0, 8)}...`));
+    }
+    if (config.workerName) {
+      console.log(chalk.white(`Worker:       ${config.workerName}`));
+    }
+    if (config.databaseName) {
+      console.log(chalk.white(`Database:     ${config.databaseName}`));
+    }
+    if (config.deploymentUrl) {
+      console.log(chalk.white(`URL:          ${config.deploymentUrl}`));
+    }
+    console.log(chalk.gray('─'.repeat(60)));
+  }
+
+  /**
+   * Merge loaded config with collected inputs
+   * Collected inputs take precedence over stored config
+   * 
+   * @param {Object} storedConfig - Config from file
+   * @param {Object} collectedInputs - Inputs from InputCollector
+   * @returns {Object} - Merged configuration
+   */
+  mergeConfigs(storedConfig, collectedInputs) {
+    return {
+      ...storedConfig,
+      ...collectedInputs,
+      // Track source of each value
+      _sources: {
+        storedConfig: Object.keys(storedConfig),
+        collectedInputs: Object.keys(collectedInputs)
+      }
+    };
+  }
+
+  /**
+   * Get missing fields that need to be collected
+   * Compares stored config against required fields
+   */
+  getMissingFields(config, requiredFields = []) {
+    if (!requiredFields.length) {
+      // Default required fields for deployment
+      requiredFields = ['customer', 'environment', 'domainName', 'cloudflareToken', 'cloudflareAccountId', 'cloudflareZoneId'];
+    }
+    return requiredFields.filter(field => !config[field] || config[field] === '');
+  }
+}
+
+/**
+ * Factory function for convenience
+ */
+export function createCustomerConfigLoader(options = {}) {
+  return new CustomerConfigLoader(options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -20,6 +20,7 @@
     "./handlers": "./dist/handlers/GenericRouteHandler.js",
     "./config": "./dist/config/index.js",
     "./config/discovery": "./dist/config/discovery/domain-discovery.js",
+    "./config/customer-loader": "./dist/config/customer-config-loader.js",
     "./worker": "./dist/worker/index.js",
     "./utils": "./dist/utils/index.js",
     "./utils/deployment": "./dist/utils/deployment/index.js",