@tamyla/clodo-framework 2.0.18 → 2.0.20

package/dist/utils/deployment/wrangler-config-manager.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+
+/**
+ * Wrangler Configuration Manager
+ * Manages wrangler.toml configuration files for Cloudflare Workers deployment
+ * Handles environment sections, D1 database bindings, and other Cloudflare resources
+ * 
+ * @module WranglerConfigManager
+ */
+import { readFile, writeFile, access, mkdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { parse as parseToml, stringify as stringifyToml } from '@iarna/toml';
+import { constants } from 'fs';
+export class WranglerConfigManager {
+  constructor(options = {}) {
+    // Handle both string path and options object
+    if (typeof options === 'string') {
+      this.configPath = options;
+      this.projectRoot = dirname(options);
+      this.dryRun = false;
+      this.verbose = false;
+    } else {
+      this.projectRoot = options.projectRoot || process.cwd();
+      this.configPath = options.configPath || join(this.projectRoot, 'wrangler.toml');
+      this.dryRun = options.dryRun || false;
+      this.verbose = options.verbose || false;
+    }
+  }
+
+  /**
+   * Read and parse wrangler.toml file
+   * @returns {Promise<Object>} Parsed TOML configuration
+   */
+  async readConfig() {
+    try {
+      const content = await readFile(this.configPath, 'utf-8');
+      return parseToml(content);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // File doesn't exist - return minimal default config
+        if (this.verbose) {
+          console.log(`   ℹ️  wrangler.toml not found at ${this.configPath}`);
+        }
+        return {
+          name: 'worker',
+          main: 'src/index.js',
+          compatibility_date: new Date().toISOString().split('T')[0],
+          env: {}
+        };
+      }
+      throw new Error(`Failed to read wrangler.toml: ${error.message}`);
+    }
+  }
+
+  /**
+   * Write configuration back to wrangler.toml
+   * @param {Object} config - Configuration object to write
+   */
+  async writeConfig(config) {
+    if (this.dryRun) {
+      console.log(`   🔍 DRY RUN: Would write wrangler.toml`);
+      console.log(stringifyToml(config));
+      return;
+    }
+    try {
+      // Ensure directory exists
+      await mkdir(dirname(this.configPath), {
+        recursive: true
+      });
+
+      // Convert to TOML string
+      const tomlContent = stringifyToml(config);
+
+      // Write to file
+      await writeFile(this.configPath, tomlContent, 'utf-8');
+      if (this.verbose) {
+        console.log(`   ✅ Updated wrangler.toml at ${this.configPath}`);
+      }
+    } catch (error) {
+      throw new Error(`Failed to write wrangler.toml: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if wrangler.toml exists
+   * @returns {Promise<boolean>}
+   */
+  async exists() {
+    try {
+      await access(this.configPath, constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Ensure environment section exists in wrangler.toml
+   * @param {string} environment - Environment name (development, staging, production)
+   * @returns {Promise<boolean>} True if environment was added, false if already existed
+   */
+  async ensureEnvironment(environment) {
+    const config = await this.readConfig();
+
+    // For production, check top-level only
+    if (environment === 'production') {
+      // Production config is typically at top level
+      if (!config.name) {
+        console.log(`   ⚠️  wrangler.toml missing 'name' field`);
+        return false;
+      }
+      return false; // Already exists (implicitly)
+    }
+
+    // For non-production environments, check env.{environment} section
+    if (!config.env) {
+      config.env = {};
+    }
+    if (!config.env[environment]) {
+      console.log(`   📝 Adding [env.${environment}] section to wrangler.toml`);
+
+      // Create environment section with basic structure
+      config.env[environment] = {
+        name: config.name || 'worker'
+        // Don't add workers_dev by default - let wrangler decide
+      };
+      await this.writeConfig(config);
+      return true;
+    }
+    if (this.verbose) {
+      console.log(`   ✓ [env.${environment}] section already exists`);
+    }
+    return false;
+  }
+
+  /**
+   * Add D1 database binding to wrangler.toml
+   * @param {string} environment - Environment name
+   * @param {Object} databaseInfo - Database information
+   * @param {string} databaseInfo.binding - Binding name (e.g., 'DB')
+   * @param {string} databaseInfo.database_name - Database name
+   * @param {string} databaseInfo.database_id - Database ID
+   * @returns {Promise<boolean>} True if binding was added
+   */
+  async addDatabaseBinding(environment, databaseInfo) {
+    // Support both camelCase and snake_case for flexibility
+    const binding = databaseInfo.binding || 'DB';
+    const databaseName = databaseInfo.database_name || databaseInfo.databaseName;
+    const databaseId = databaseInfo.database_id || databaseInfo.databaseId;
+    if (!databaseName || !databaseId) {
+      throw new Error('Database name and ID are required');
+    }
+    const config = await this.readConfig();
+    console.log(`   📝 Adding D1 database binding to wrangler.toml`);
+    console.log(`      Environment: ${environment}`);
+    console.log(`      Binding: ${binding}`);
+    console.log(`      Database: ${databaseName}`);
+    console.log(`      ID: ${databaseId}`);
+    const dbBinding = {
+      binding,
+      database_name: databaseName,
+      database_id: databaseId
+    };
+    if (environment === 'production') {
+      // Add to top-level d1_databases array
+      if (!config.d1_databases) {
+        config.d1_databases = [];
+      }
+
+      // Check if binding already exists
+      const existingIndex = config.d1_databases.findIndex(db => db.binding === binding || db.database_name === databaseName);
+      if (existingIndex >= 0) {
+        console.log(`   🔄 Updating existing database binding`);
+        config.d1_databases[existingIndex] = dbBinding;
+      } else {
+        console.log(`   ➕ Adding new database binding`);
+        config.d1_databases.push(dbBinding);
+      }
+    } else {
+      // Add to environment-specific section
+      if (!config.env) {
+        config.env = {};
+      }
+      if (!config.env[environment]) {
+        config.env[environment] = {
+          name: config.name || 'worker'
+        };
+      }
+      if (!config.env[environment].d1_databases) {
+        config.env[environment].d1_databases = [];
+      }
+
+      // Check if binding already exists
+      const existingIndex = config.env[environment].d1_databases.findIndex(db => db.binding === binding || db.database_name === databaseName);
+      if (existingIndex >= 0) {
+        console.log(`   🔄 Updating existing database binding`);
+        config.env[environment].d1_databases[existingIndex] = dbBinding;
+      } else {
+        console.log(`   ➕ Adding new database binding`);
+        config.env[environment].d1_databases.push(dbBinding);
+      }
+    }
+    await this.writeConfig(config);
+    console.log(`   ✅ D1 database binding added successfully`);
+    return true;
+  }
+
+  /**
+   * Remove D1 database binding from wrangler.toml
+   * @param {string} environment - Environment name
+   * @param {string} bindingOrName - Binding name or database name
+   * @returns {Promise<boolean>} True if binding was removed
+   */
+  async removeDatabaseBinding(environment, bindingOrName) {
+    const config = await this.readConfig();
+    let removed = false;
+    if (environment === 'production') {
+      if (config.d1_databases) {
+        const initialLength = config.d1_databases.length;
+        config.d1_databases = config.d1_databases.filter(db => db.binding !== bindingOrName && db.database_name !== bindingOrName);
+        removed = config.d1_databases.length < initialLength;
+      }
+    } else {
+      if (config.env?.[environment]?.d1_databases) {
+        const initialLength = config.env[environment].d1_databases.length;
+        config.env[environment].d1_databases = config.env[environment].d1_databases.filter(db => db.binding !== bindingOrName && db.database_name !== bindingOrName);
+        removed = config.env[environment].d1_databases.length < initialLength;
+      }
+    }
+    if (removed) {
+      await this.writeConfig(config);
+      console.log(`   ✅ Removed database binding: ${bindingOrName}`);
+    } else {
+      console.log(`   ℹ️  Database binding not found: ${bindingOrName}`);
+    }
+    return removed;
+  }
+
+  /**
+   * Get all database bindings for an environment
+   * @param {string} environment - Environment name
+   * @returns {Promise<Array>} Array of database bindings
+   */
+  async getDatabaseBindings(environment) {
+    const config = await this.readConfig();
+    if (environment === 'production') {
+      return config.d1_databases || [];
+    } else {
+      return config.env?.[environment]?.d1_databases || [];
+    }
+  }
+
+  /**
+   * Create minimal wrangler.toml if it doesn't exist
+   * @param {string} name - Worker name
+   * @param {string} environment - Initial environment to create (optional)
+   * @param {Object} options - Additional configuration options
+   * @returns {Promise<Object>} The created config object
+   */
+  async createMinimalConfig(name = 'worker', environment = null, options = {}) {
+    const exists = await this.exists();
+    if (exists) {
+      console.log(`   ✓ wrangler.toml already exists`);
+      return await this.readConfig();
+    }
+    console.log(`   📝 Creating minimal wrangler.toml`);
+    const today = new Date().toISOString().split('T')[0];
+    const minimalConfig = {
+      name: name,
+      main: options.main || 'src/index.js',
+      compatibility_date: options.compatibility_date || today,
+      // Environment sections will be added as needed
+      env: {}
+    };
+
+    // Add initial environment if specified
+    if (environment && environment !== 'production') {
+      minimalConfig.env[environment] = {};
+    }
+    await this.writeConfig(minimalConfig);
+    console.log(`   ✅ Created wrangler.toml at ${this.configPath}`);
+    return minimalConfig;
+  }
+
+  /**
+   * Validate wrangler.toml configuration
+   * @returns {Promise<Object>} Validation result with errors and warnings arrays
+   */
+  async validate() {
+    const errors = [];
+    const warnings = [];
+
+    // Check if file exists
+    const exists = await this.exists();
+    if (!exists) {
+      errors.push('wrangler.toml file not found');
+      return {
+        valid: false,
+        errors,
+        warnings
+      };
+    }
+    try {
+      const config = await this.readConfig();
+
+      // Check required fields
+      if (!config.name) {
+        errors.push('Missing required field: name');
+      }
+      if (!config.main) {
+        warnings.push('Missing main field (entry point)');
+      }
+      if (!config.compatibility_date) {
+        warnings.push('Missing compatibility_date field');
+      }
+      return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        config
+      };
+    } catch (error) {
+      errors.push(`Invalid TOML syntax: ${error.message}`);
+      return {
+        valid: false,
+        errors,
+        warnings
+      };
+    }
+  }
+
+  /**
+   * Display configuration summary
+   * @param {string} environment - Environment to display (optional)
+   */
+  async displaySummary(environment = null) {
+    const config = await this.readConfig();
+    console.log(`\n📋 Wrangler Configuration Summary`);
+    console.log(`   File: ${this.configPath}`);
+    console.log(`   Worker Name: ${config.name || 'N/A'}`);
+    console.log(`   Entry Point: ${config.main || 'N/A'}`);
+    console.log(`   Compatibility: ${config.compatibility_date || 'N/A'}`);
+    if (environment) {
+      console.log(`\n   Environment: ${environment}`);
+      const bindings = await this.getDatabaseBindings(environment);
+      if (bindings.length > 0) {
+        console.log(`   D1 Databases (${bindings.length}):`);
+        bindings.forEach(db => {
+          console.log(`     • ${db.binding}: ${db.database_name} (${db.database_id})`);
+        });
+      } else {
+        console.log(`   D1 Databases: None configured`);
+      }
+    } else {
+      // Show all environments
+      if (config.env && Object.keys(config.env).length > 0) {
+        console.log(`\n   Environments: ${Object.keys(config.env).join(', ')}`);
+      }
+    }
+    console.log('');
+  }
+}
+export default WranglerConfigManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "2.0.18",
+  "version": "2.0.20",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -20,7 +20,8 @@
     "./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",
+    "./config/customers": "./dist/config/customers.js",
+    "./utils/config": "./dist/utils/config/unified-config-manager.js",
     "./worker": "./dist/worker/index.js",
     "./utils": "./dist/utils/index.js",
     "./utils/deployment": "./dist/utils/deployment/index.js",
@@ -38,15 +39,13 @@
     "./service-management": "./dist/service-management/index.js",
     "./service-management/create": "./dist/service-management/ServiceCreator.js",
     "./service-management/init": "./dist/service-management/ServiceInitializer.js",
-    "./config/cli": "./dist/config/CustomerConfigCLI.js",
     "./modules/security": "./dist/modules/security.js"
   },
   "bin": {
     "clodo-service": "./bin/clodo-service.js",
     "clodo-create-service": "./bin/service-management/create-service.js",
     "clodo-init-service": "./bin/service-management/init-service.js",
-    "clodo-security": "./bin/security/security-cli.js",
-    "clodo-customer-config": "./bin/shared/config/customer-cli.js"
+    "clodo-security": "./bin/security/security-cli.js"
   },
   "publishConfig": {
     "access": "public"

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

@@ -1,182 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Customer Configuration Management CLI
- * Manages multi-environment, multi-customer configuration structure
- * Integrates with Clodo Framework domain and feature flag systems
- */
-
-import { CustomerConfigCLI } from '../../../dist/config/CustomerConfigCLI.js';
-import { resolve } from 'path';
-
-// Parse command line arguments
-const argv = process.argv.slice(2);
-let configDir = null;
-let command = null;
-let args = [];
-
-// Extract --config-dir parameter if present
-for (let i = 0; i < argv.length; i++) {
-  if (argv[i] === '--config-dir' && i + 1 < argv.length) {
-    configDir = resolve(argv[i + 1]);
-    i++; // Skip the next argument (the path)
-  } else if (!command) {
-    command = argv[i];
-  } else {
-    args.push(argv[i]);
-  }
-}
-
-// Default to current working directory if not specified
-if (!configDir) {
-  configDir = resolve(process.cwd(), 'config');
-}
-
-async function main() {
-  const cli = new CustomerConfigCLI({ configDir });
-  await cli.initialize();
-
-  try {
-    switch (command) {
-      case 'create-customer':
-        const [customerName, domain] = args;
-        const result = await cli.createCustomer(customerName, domain);
-        if (result.success) {
-          console.log(`\n🎉 Customer ${customerName} configuration created successfully!`);
-          console.log(`\n📋 Customer Details:`);
-          console.log(`   Name: ${result.customer.name}`);
-          console.log(`   Domain: ${result.customer.domain || 'Not specified'}`);
-          console.log(`   Config Path: ${result.customer.configPath}`);
-          console.log(`   Environments: ${result.customer.environments.join(', ')}`);
-          console.log(`\n📋 Next steps:`);
-          console.log(`1. Review generated configs in: config/customers/${customerName}/`);
-          console.log(`2. Update domain-specific URLs if needed`);
-          console.log(`3. Generate production secrets: npm run security:generate-key ${customerName}`);
-          console.log(`4. Set production secrets: wrangler secret put KEY_NAME --env production`);
-        } else {
-          console.error(`❌ Failed to create customer: ${result.error}`);
-          process.exit(1);
-        }
-        break;
-
-      case 'validate':
-        const validateResult = await cli.validateConfigurations();
-        if (validateResult.valid) {
-          console.log('✅ All customer configurations are valid');
-        } else {
-          console.log('❌ Configuration validation failed');
-          validateResult.errors.forEach(error => console.log(`   - ${error}`));
-          process.exit(1);
-        }
-        break;
-
-      case 'show':
-        const [customerNameShow, environment] = args;
-        const showResult = cli.showConfiguration(customerNameShow, environment);
-        if (showResult.success) {
-          console.log(`🔍 Effective configuration: ${customerNameShow}/${environment}\n`);
-          if (showResult.config.variables?.base) {
-            console.log('📋 Base variables:');
-            Object.entries(showResult.config.variables.base).slice(0, 10).forEach(([key, value]) => {
-              console.log(`   ${key}=${value}`);
-            });
-            if (Object.keys(showResult.config.variables.base).length > 10) {
-              console.log('   ...');
-            }
-            console.log('');
-          }
-          if (showResult.config.variables?.customer) {
-            console.log(`📋 Customer ${environment} variables:`);
-            Object.entries(showResult.config.variables.customer).slice(0, 15).forEach(([key, value]) => {
-              console.log(`   ${key}=${value}`);
-            });
-            if (Object.keys(showResult.config.variables.customer).length > 15) {
-              console.log('   ...');
-            }
-            console.log('');
-          }
-          if (showResult.config.features && Object.keys(showResult.config.features).length > 0) {
-            console.log('🚩 Customer features:');
-            Object.entries(showResult.config.features).forEach(([feature, enabled]) => {
-              console.log(`   ${feature}: ${enabled ? '✅' : '❌'}`);
-            });
-          }
-        } else {
-          console.error(`❌ Failed to show configuration: ${showResult.error}`);
-          process.exit(1);
-        }
-        break;
-
-      case 'deploy-command':
-        const [customerNameDeploy, environmentDeploy] = args;
-        const deployResult = cli.getDeployCommand(customerNameDeploy, environmentDeploy);
-        if (deployResult.success) {
-          console.log(`📋 Deploy command for ${customerNameDeploy}/${environmentDeploy}:`);
-          console.log(`   ${deployResult.command}`);
-          console.log(`\n💡 Ensure customer config is loaded: ${deployResult.configPath}`);
-        } else {
-          console.error(`❌ Failed to get deploy command: ${deployResult.error}`);
-          process.exit(1);
-        }
-        break;
-
-      case 'list':
-        const listResult = cli.listCustomers();
-        if (listResult.success && listResult.customers.length > 0) {
-          console.log('📋 Configured customers:\n');
-          listResult.customers.forEach(customer => {
-            console.log(`🏢 ${customer.name}`);
-            console.log(`   Domain: ${customer.customerDomain || customer.domain || 'Not configured'}`);
-            console.log(`   Account ID: ${customer.accountId ? `${customer.accountId.substring(0, 8)}...${customer.accountId.substring(24)}` : 'Not configured'}`);
-            console.log(`   Zone ID: ${customer.zoneId ? `${customer.zoneId.substring(0, 8)}...` : 'Not configured'}`);
-            if (customer.databaseId) {
-              console.log(`   Database: ${customer.databaseName || 'Unnamed'} (${customer.databaseId.substring(0, 8)}...)`);
-            }
-            console.log(`   Secrets: ${customer.hasSecrets ? '✅ Managed via wrangler secret commands' : '❌ Not configured'}`);
-            console.log(`   Environments: ${customer.environments.join(', ')}`);
-            console.log(`   Config Path: config/customers/${customer.name}/`);
-            console.log('');
-          });
-        } else if (listResult.success) {
-          console.log('📋 No customers configured');
-          console.log('\n💡 Tip: Run "clodo-customer-config create-customer <name>" to create your first customer');
-        } else {
-          console.error(`❌ Failed to list customers: ${listResult.error}`);
-          process.exit(1);
-        }
-        break;
-
-      default:
-        console.log('Customer Configuration Management Tool\n');
-        console.log('Usage:');
-        console.log('  clodo-customer-config [--config-dir <path>] <command> [args]\n');
-        console.log('Options:');
-        console.log('  --config-dir <path>  - Path to config directory (default: ./config)\n');
-        console.log('Available commands:');
-        console.log('  create-customer <name> [domain]  - Create new customer config from template');
-        console.log('  validate                         - Validate configuration structure');
-        console.log('  show <customer> <environment>    - Show effective configuration');
-        console.log('  deploy-command <customer> <env>  - Get deployment command');
-        console.log('  list                             - List all configured customers');
-        console.log('\nExamples:');
-        console.log('  clodo-customer-config create-customer acmecorp acmecorp.com');
-        console.log('  clodo-customer-config validate');
-        console.log('  clodo-customer-config show acmecorp production');
-        console.log('  clodo-customer-config list');
-        console.log('  clodo-customer-config --config-dir /path/to/service/config validate');
-        console.log('\nIntegration:');
-        console.log('  This tool integrates with Clodo Framework domain and feature flag systems.');
-        console.log('  Customer configurations are automatically registered as domains.');
-        console.log('  When run from a service directory, it uses ./config by default.');
-        break;
-    }
-  } catch (error) {
-    console.error(`❌ Error: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-main().catch(error => {
-  console.error(`❌ Unexpected error: ${error.message}`);
-  process.exit(1);
-});