@tamyla/clodo-framework 2.0.0 → 2.0.2

package/bin/shared/config/command-config-manager.js

@@ -0,0 +1,184 @@
+/**
+ * Command Configuration Manager
+ * Loads and manages configurable system commands from validation-config.json
+ * 
+ * Ensures all commands are configurable and platform-specific
+ * No hardcoded commands in the codebase
+ */
+
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+export class CommandConfigManager {
+  constructor(configPath = null) {
+    this.configPath = configPath || join(process.cwd(), 'validation-config.json');
+    this.config = null;
+    this.loadConfig();
+  }
+
+  /**
+   * Load configuration from JSON file
+   */
+  loadConfig() {
+    try {
+      const configData = readFileSync(this.configPath, 'utf-8');
+      this.config = JSON.parse(configData);
+      console.log('📋 Loaded command configuration from validation-config.json');
+    } catch (error) {
+      console.log('⚠️ Could not load command config, using defaults');
+      this.config = this.getDefaultConfig();
+    }
+  }
+
+  /**
+   * Get default configuration fallback
+   */
+  getDefaultConfig() {
+    return {
+      requiredCommands: {
+        npx: 'npx',
+        node: 'node',
+        npm: 'npm',
+        wrangler: 'npx wrangler'
+      },
+      cloudflareCommands: {
+        whoami: 'npx wrangler whoami',
+        auth_login: 'npx wrangler auth login',
+        deployments_list: 'npx wrangler deployments list',
+        list_workers: 'npx wrangler dev --help',
+        deploy: 'npx wrangler deploy',
+        list_zones: 'npx wrangler zone list',
+        worker_status: 'npx wrangler status'
+      },
+      systemCommands: {
+        powershell_web_request: 'powershell -Command "try { Invoke-WebRequest -Uri \'{url}\' -TimeoutSec 10 -UseBasicParsing | Out-Null } catch { exit 1 }"',
+        curl_test: 'curl -s --connect-timeout 10 {url} -o /dev/null'
+      }
+    };
+  }
+
+  /**
+   * Get a Cloudflare command
+   */
+  getCloudflareCommand(commandName, params = {}) {
+    const command = this.config?.cloudflareCommands?.[commandName];
+    if (!command) {
+      throw new Error(`Cloudflare command '${commandName}' not found in configuration`);
+    }
+    
+    return this.interpolateParams(command, params);
+  }
+
+  /**
+   * Get a system command
+   */
+  getSystemCommand(commandName, params = {}) {
+    const command = this.config?.systemCommands?.[commandName];
+    if (!command) {
+      throw new Error(`System command '${commandName}' not found in configuration`);
+    }
+    
+    return this.interpolateParams(command, params);
+  }
+
+  /**
+   * Get a required command
+   */
+  getRequiredCommand(commandName) {
+    const command = this.config?.requiredCommands?.[commandName];
+    if (!command) {
+      throw new Error(`Required command '${commandName}' not found in configuration`);
+    }
+    
+    return command;
+  }
+
+  /**
+   * Get network test command for current platform
+   */
+  getNetworkTestCommand(url) {
+    const isWindows = process.platform === 'win32';
+    const commandName = isWindows ? 'powershell_web_request' : 'curl_test';
+    
+    return this.getSystemCommand(commandName, { url });
+  }
+
+  /**
+   * Interpolate parameters in command strings
+   */
+  interpolateParams(command, params) {
+    let result = command;
+    
+    for (const [key, value] of Object.entries(params)) {
+      const placeholder = `{${key}}`;
+      result = result.replace(new RegExp(placeholder.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'), 'g'), value);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Get all available commands for debugging
+   */
+  getAllCommands() {
+    return {
+      requiredCommands: this.config?.requiredCommands || {},
+      cloudflareCommands: this.config?.cloudflareCommands || {},
+      systemCommands: this.config?.systemCommands || {}
+    };
+  }
+
+  /**
+   * Validate command configuration
+   */
+  validateConfig() {
+    const errors = [];
+    
+    // Check required sections
+    const requiredSections = ['requiredCommands', 'cloudflareCommands', 'systemCommands'];
+    
+    for (const section of requiredSections) {
+      if (!this.config[section] || typeof this.config[section] !== 'object') {
+        errors.push(`Missing or invalid section: ${section}`);
+      }
+    }
+
+    // Check essential Cloudflare commands
+    const essentialCfCommands = ['whoami', 'auth_login', 'deployments_list'];
+    
+    for (const cmd of essentialCfCommands) {
+      if (!this.config?.cloudflareCommands?.[cmd]) {
+        errors.push(`Missing essential Cloudflare command: ${cmd}`);
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new Error(`Command configuration validation failed:\\n${errors.join('\\n')}`);
+    }
+
+    return true;
+  }
+
+  /**
+   * Reload configuration
+   */
+  reload() {
+    this.loadConfig();
+    this.validateConfig();
+  }
+}
+
+// Singleton instance
+let commandConfigInstance = null;
+
+/**
+ * Get singleton instance of command config manager
+ */
+export function getCommandConfig(configPath = null) {
+  if (!commandConfigInstance || configPath) {
+    commandConfigInstance = new CommandConfigManager(configPath);
+  }
+  return commandConfigInstance;
+}
+
+export default CommandConfigManager;

package/bin/shared/config/customer-cli.js

@@ -6,7 +6,7 @@
  * Integrates with Clodo Framework domain and feature flag systems
  */
 
-import { CustomerConfigCLI } from '../../../src/config/CustomerConfigCLI.js';
+import { CustomerConfigCLI } from '../../../dist/config/CustomerConfigCLI.js';
 
 const command = process.argv[2];
 const args = process.argv.slice(3);

package/bin/shared/config/index.js

@@ -0,0 +1,9 @@
+/**
+ * Configuration Module
+ * Exports all configuration management utilities
+ */
+
+export { ConfigCache } from './cache.js';
+export { ConfigManager } from './manager.js';
+export { CommandConfigManager } from './command-config-manager.js';
+export { CustomerConfigurationManager } from '../../../src/config/customers.js';

package/bin/shared/config/manager.js

@@ -0,0 +1,315 @@
+/**
+ * Configuration Manager Module
+ * Configuration file management and validation
+ * 
+ * Consolidates config management across 34+ scripts
+ */
+
+import { readFileSync, writeFileSync, existsSync, copyFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+
+export function updateWranglerConfig(updates, configPath = 'wrangler.toml') {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+
+  let config = readFileSync(configPath, 'utf8');
+  let changesMade = [];
+
+  // Apply updates systematically
+  for (const [key, value] of Object.entries(updates)) {
+    switch (key) {
+      case 'workerName':
+        // Update main worker name
+        if (config.match(/^name = "[^"]*"/m)) {
+          config = config.replace(/^name = "[^"]*"/m, `name = "${value}"`);
+          changesMade.push(`Updated main worker name to: ${value}`);
+        }
+        
+        // Update production environment name  
+        if (config.match(/^\[env\.production\]\s*\nname = "[^"]*"/m)) {
+          config = config.replace(/^\[env\.production\]\s*\nname = "[^"]*"/m, `[env.production]\nname = "${value}"`);
+          changesMade.push(`Updated production worker name to: ${value}`);
+        }
+        break;
+        
+      case 'databaseName': {
+        const dbNameRegex = /database_name = "[^"]*"/g;
+        if (config.match(dbNameRegex)) {
+          config = config.replace(dbNameRegex, `database_name = "${value}"`);
+          changesMade.push(`Updated database name to: ${value}`);
+        }
+        break;
+      }
+        
+      case 'databaseId': {
+        const dbIdRegex = /database_id = "[^"]*"/g;
+        if (config.match(dbIdRegex)) {
+          config = config.replace(dbIdRegex, `database_id = "${value}"`);
+          changesMade.push(`Updated database ID to: ${value}`);
+        }
+        break;
+      }
+        
+      case 'serviceDomain': {
+        const domainRegex = /SERVICE_DOMAIN = "[^"]*"/g;
+        if (config.match(domainRegex)) {
+          config = config.replace(domainRegex, `SERVICE_DOMAIN = "${value}"`);
+          changesMade.push(`Updated service domain to: ${value}`);
+        }
+        break;
+      }
+        
+      case 'compatibilityDate': {
+        const dateRegex = /^compatibility_date = "[^"]*"/m;
+        if (config.match(dateRegex)) {
+          config = config.replace(dateRegex, `compatibility_date = "${value}"`);
+          changesMade.push(`Updated compatibility date to: ${value}`);
+        }
+        break;
+      }
+        
+      default:
+        console.warn(`Unknown config update key: ${key}`);
+    }
+  }
+
+  writeFileSync(configPath, config);
+  
+  return {
+    configPath,
+    changesMade,
+    success: changesMade.length > 0
+  };
+}
+
+export function backupConfig(configPath = 'wrangler.toml', suffix = null) {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  
+  const timestamp = suffix || new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${configPath}.backup.${timestamp}`;
+  
+  copyFileSync(configPath, backupPath);
+  
+  return {
+    originalPath: configPath,
+    backupPath,
+    timestamp: new Date().toISOString()
+  };
+}
+
+export function validateConfig(configPath = 'wrangler.toml') {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+
+  const config = readFileSync(configPath, 'utf8');
+  const issues = [];
+  const warnings = [];
+  
+  // Required fields validation
+  const requiredFields = [
+    { pattern: /^name = "/m, description: 'Worker name' },
+    { pattern: /^compatibility_date = "/m, description: 'Compatibility date' },
+    { pattern: /^main = "/m, description: 'Main entry point' }
+  ];
+
+  requiredFields.forEach(field => {
+    if (!config.match(field.pattern)) {
+      issues.push(`Missing required field: ${field.description}`);
+    }
+  });
+
+  // Database configuration validation
+  const hasDatabaseBinding = config.includes('[[d1_databases]]');
+  if (hasDatabaseBinding) {
+    if (!config.includes('database_name =')) {
+      issues.push('Database binding found but missing database_name');
+    }
+    if (!config.includes('database_id =')) {
+      issues.push('Database binding found but missing database_id');
+    }
+  }
+
+  // Environment validation
+  const hasProductionEnv = config.includes('[env.production]');
+  if (hasProductionEnv) {
+    const prodSection = config.split('[env.production]')[1];
+    if (prodSection && !prodSection.includes('name =')) {
+      warnings.push('Production environment missing explicit name');
+    }
+  }
+
+  // Compatibility date validation
+  const compatMatch = config.match(/compatibility_date = "([^"]+)"/);
+  if (compatMatch) {
+    const date = new Date(compatMatch[1]);
+    const now = new Date();
+    const daysDiff = (now - date) / (1000 * 60 * 60 * 24);
+    
+    if (daysDiff > 365) {
+      warnings.push(`Compatibility date is ${Math.floor(daysDiff)} days old`);
+    }
+  }
+  
+  return {
+    isValid: issues.length === 0,
+    issues,
+    warnings,
+    summary: {
+      errors: issues.length,
+      warnings: warnings.length,
+      status: issues.length === 0 ? 'valid' : 'invalid'
+    }
+  };
+}
+
+export function parseWranglerConfig(configPath = 'wrangler.toml') {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+
+  const config = readFileSync(configPath, 'utf8');
+  const parsed = {};
+
+  // Extract main fields
+  const extractField = (pattern, key) => {
+    const match = config.match(pattern);
+    if (match) parsed[key] = match[1];
+  };
+
+  extractField(/^name = "([^"]+)"/m, 'name');
+  extractField(/^compatibility_date = "([^"]+)"/m, 'compatibilityDate');
+  extractField(/^main = "([^"]+)"/m, 'main');
+
+  // Extract database configuration
+  if (config.includes('[[d1_databases]]')) {
+    parsed.database = {};
+    extractField(/database_name = "([^"]+)"/m, 'name');
+    extractField(/database_id = "([^"]+)"/m, 'id');
+    
+    if (parsed.name) parsed.database.name = parsed.name;
+    if (parsed.id) parsed.database.id = parsed.id;
+    delete parsed.name;
+    delete parsed.id;
+  }
+
+  // Extract environment configurations
+  parsed.environments = {};
+  const envMatches = config.matchAll(/\[env\.([^\]]+)\]/g);
+  for (const match of envMatches) {
+    const envName = match[1];
+    parsed.environments[envName] = {};
+    
+    // Extract env-specific settings (simplified parsing)
+    const envSection = config.split(`[env.${envName}]`)[1];
+    if (envSection) {
+      const nextEnv = envSection.indexOf('[env.');
+      const sectionContent = nextEnv > 0 ? envSection.substring(0, nextEnv) : envSection;
+      
+      const nameMatch = sectionContent.match(/name = "([^"]+)"/);
+      if (nameMatch) parsed.environments[envName].name = nameMatch[1];
+    }
+  }
+
+  return parsed;
+}
+
+export function generateWranglerConfig(options) {
+  const {
+    name,
+    main = 'src/worker/index.js',
+    compatibilityDate = new Date().toISOString().split('T')[0],
+    database = null,
+    environments = {},
+    vars = {},
+    secrets = []
+  } = options;
+
+  let config = `# Generated Wrangler Configuration
+# Timestamp: ${new Date().toISOString()}
+
+name = "${name}"
+main = "${main}"
+compatibility_date = "${compatibilityDate}"
+`;
+
+  // Add variables
+  if (Object.keys(vars).length > 0) {
+    config += '\n[vars]\n';
+    Object.entries(vars).forEach(([key, value]) => {
+      config += `${key} = "${value}"\n`;
+    });
+  }
+
+  // Add database configuration
+  if (database) {
+    config += `
+[[d1_databases]]
+binding = "DB"
+database_name = "${database.name}"
+database_id = "${database.id}"
+`;
+  }
+
+  // Add environments
+  Object.entries(environments).forEach(([envName, envConfig]) => {
+    config += `\n[env.${envName}]\n`;
+    if (envConfig.name) config += `name = "${envConfig.name}"\n`;
+    
+    if (envConfig.vars) {
+      Object.entries(envConfig.vars).forEach(([key, value]) => {
+        config += `${key} = "${value}"\n`;
+      });
+    }
+    
+    if (envConfig.database) {
+      config += `
+[[env.${envName}.d1_databases]]
+binding = "DB"
+database_name = "${envConfig.database.name}"
+database_id = "${envConfig.database.id}"
+`;
+    }
+  });
+
+  return config;
+}
+
+export function listConfigFiles(directory = '.') {
+  const configFiles = [];
+  const patterns = ['wrangler.toml', 'package.json', '.env*'];
+  
+  try {
+    const items = readdirSync(directory);
+    
+    items.forEach(item => {
+      const path = join(directory, item);
+      const stat = statSync(path);
+      
+      if (stat.isFile()) {
+        const matches = patterns.some(pattern => {
+          if (pattern.includes('*')) {
+            return item.startsWith(pattern.replace('*', ''));
+          }
+          return item === pattern;
+        });
+        
+        if (matches) {
+          configFiles.push({
+            name: item,
+            path,
+            size: stat.size,
+            modified: stat.mtime
+          });
+        }
+      }
+    });
+    
+    return configFiles.sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    return [];
+  }
+}

package/dist/deployment/validator.js

@@ -270,6 +270,9 @@ export class DeploymentValidator {
 
       // Validate environment configuration
       await this.validateEnvironmentConfig();
+
+      // Validate D1 database bindings
+      await this.validateD1Configuration();
       this.results.categories.configuration = 'passed';
       this.addResult('configuration', 'Configuration files validated', 'success');
     } catch (error) {
@@ -457,6 +460,112 @@ export class DeploymentValidator {
     console.log(`     ✅ Environment: ${this.environment} configuration valid`);
     this.addResult('environment', `${this.environment} environment validated`, 'info');
   }
+
+  /**
+   * Validate D1 database configuration across all services
+   */
+  async validateD1Configuration() {
+    console.log('   🗄️ Validating D1 database configuration...');
+    try {
+      // Import WranglerDeployer for D1 validation capabilities
+      const {
+        WranglerDeployer
+      } = await import('../../../src/deployment/wrangler-deployer.js');
+
+      // Check if this is a framework-level validation (no specific service)
+      if (!this.options?.servicePath) {
+        console.log('     ⏭️ Skipping D1 validation (framework-level validation)');
+        this.addResult('d1-config', 'D1 validation skipped for framework-level validation', 'info');
+        return;
+      }
+
+      // Create deployer instance for the specific service
+      const deployer = new WranglerDeployer({
+        cwd: this.options.servicePath,
+        environment: this.environment
+      });
+
+      // Discover deployment configuration
+      const deployConfig = await deployer.discoverDeploymentConfig(this.environment);
+      if (!deployConfig.configPath) {
+        console.log('     ⏭️ No wrangler.toml found, skipping D1 validation');
+        this.addResult('d1-config', 'No wrangler.toml found', 'info');
+        return;
+      }
+
+      // Validate D1 bindings
+      const d1Validation = await deployer.validateD1Bindings(deployConfig);
+      if (d1Validation.valid) {
+        if (d1Validation.bindings.length === 0) {
+          console.log('     ✅ No D1 databases configured');
+          this.addResult('d1-config', 'No D1 databases configured', 'info');
+        } else {
+          console.log(`     ✅ All ${d1Validation.summary.total} D1 database bindings valid`);
+          this.addResult('d1-config', `${d1Validation.summary.total} D1 bindings validated`, 'success');
+
+          // Log details about each binding
+          d1Validation.bindings.forEach(binding => {
+            if (binding.valid) {
+              console.log(`       ✅ ${binding.binding}: ${binding.database_name}`);
+            }
+          });
+        }
+      } else {
+        console.log(`     ❌ D1 validation failed: ${d1Validation.summary.invalid} invalid bindings`);
+
+        // Log details about invalid bindings
+        d1Validation.invalidBindings.forEach(binding => {
+          console.log(`       ❌ ${binding.binding || 'unnamed'}: ${binding.issues.join(', ')}`);
+        });
+
+        // Add warning with suggestions
+        const suggestions = this.generateD1Suggestions(d1Validation);
+        this.addWarning('d1-config', `D1 configuration issues found. ${suggestions}`);
+
+        // Don't fail validation entirely for D1 issues if not in strict mode
+        if (!this.strictMode) {
+          console.log('     ⚠️ Continuing with warnings (non-strict mode)');
+          this.addResult('d1-config', 'D1 issues found but continuing', 'warning');
+        } else {
+          throw new Error(`D1 validation failed: ${d1Validation.summary.invalid} invalid bindings`);
+        }
+      }
+    } catch (error) {
+      if (error.message.includes('D1 validation failed')) {
+        throw error; // Re-throw D1 validation errors
+      }
+
+      // Handle other errors (import errors, etc.)
+      console.log(`     ⚠️ D1 validation error: ${error.message}`);
+      this.addWarning('d1-config', `D1 validation error: ${error.message}`);
+      if (this.strictMode) {
+        throw new Error(`D1 validation failed: ${error.message}`);
+      }
+    }
+  }
+
+  /**
+   * Generate helpful suggestions for D1 configuration issues
+   * @param {Object} d1Validation - D1 validation results
+   * @returns {string} Suggestions text
+   */
+  generateD1Suggestions(d1Validation) {
+    const suggestions = [];
+    d1Validation.invalidBindings.forEach(binding => {
+      binding.issues.forEach(issue => {
+        if (issue.includes('not found')) {
+          suggestions.push('Run "wrangler d1 list" to see available databases');
+          suggestions.push('Create missing database with "wrangler d1 create <name>"');
+        } else if (issue.includes('Missing')) {
+          suggestions.push('Check wrangler.toml [[d1_databases]] section completeness');
+        }
+      });
+    });
+
+    // Remove duplicates
+    const uniqueSuggestions = [...new Set(suggestions)];
+    return uniqueSuggestions.length > 0 ? `Suggestions: ${uniqueSuggestions.slice(0, 2).join('; ')}` : 'Check D1 database configuration in wrangler.toml';
+  }
   async validateDomainEndpoints(domain) {
     console.log(`   Validating endpoints for ${domain}...`);
     console.log(`   🔧 DEBUG: skipEndpointCheck = ${this.options?.skipEndpointCheck}`);
@@ -538,6 +647,9 @@ export class DeploymentValidator {
       this.results.errors.push(message);
     }
   }
+  addWarning(category, message) {
+    this.addResult(category, message, 'warning');
+  }
   printValidationSummary() {
     console.log('\n📊 VALIDATION SUMMARY');
     console.log('====================');