@tamyla/clodo-framework 2.0.0 → 2.0.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [2.0.1](https://github.com/tamylaa/clodo-framework/compare/v2.0.0...v2.0.1) (2025-10-10)
+
+
+### Bug Fixes
+
+* reorganize documentation structure and fix package distribution ([598d44b](https://github.com/tamylaa/clodo-framework/commit/598d44b669f65c222d215ba33d0361d736a15ac9))
+
 # [2.0.0](https://github.com/tamylaa/clodo-framework/compare/v1.0.0...v2.0.0) (2025-10-10)
 
 

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('====================');

package/dist/deployment/wrangler-deployer.js

@@ -2,10 +2,13 @@ import { spawn } from 'child_process';
 import { execSync } from 'child_process';
 import fs from 'fs';
 import path from 'path';
+import { WranglerD1Manager } from '../../bin/database/wrangler-d1-manager.js';
 
 /**
  * WranglerDeployer - Executes actual Cloudflare Workers deployments using wrangler CLI
  * Provides integration between Clodo Framework orchestration and wrangler deployment
+ * 
+ * Now integrated with WranglerD1Manager for comprehensive D1 database operations
  */
 export class WranglerDeployer {
   constructor(options = {}) {
@@ -15,6 +18,12 @@ export class WranglerDeployer {
     this.maxRetries = options.maxRetries || 1;
     this.environment = options.environment || this.detectEnvironment();
     this.serviceInfo = options.serviceInfo || this.discoverServiceInfo();
+
+    // Initialize D1 manager for database operations
+    this.d1Manager = new WranglerD1Manager({
+      cwd: this.cwd,
+      timeout: 60000 // 1 minute for D1 operations
+    });
   }
 
   /**
@@ -487,14 +496,19 @@ export class WranglerDeployer {
 
       // Validate configuration can be parsed
       const configValidation = await this.validateWranglerConfig(deployConfig, environment);
+
+      // Validate D1 database bindings using D1Manager
+      const d1Validation = await this.d1Manager.validateD1Bindings(deployConfig);
+      const overallValid = configValidation.valid && d1Validation.valid;
       return {
-        valid: true,
+        valid: overallValid,
         version: versionResult.output.trim(),
         config: deployConfig,
         account: accountInfo,
         configValidation,
+        d1Validation,
         authenticated: true,
-        ready: configValidation.valid
+        ready: overallValid
       };
     } catch (error) {
       return {
@@ -570,5 +584,36 @@ export class WranglerDeployer {
     }
     return warnings;
   }
+
+  /**
+   * Handle D1 binding errors with interactive recovery options (delegated to D1Manager)
+   * @param {string} error - Error message
+   * @param {Object} context - Error context
+   * @returns {Promise<Object>} Recovery result
+   */
+  async handleD1BindingError(error, context = {}) {
+    return await this.d1Manager.handleD1BindingError(error, context);
+  }
+
+  /**
+   * Validate D1 bindings using D1Manager (delegated)
+   */
+  async validateD1Bindings(deployConfig) {
+    return await this.d1Manager.validateD1Bindings(deployConfig);
+  }
+
+  /**
+   * Extract D1 bindings using D1Manager (delegated)  
+   */
+  extractD1Bindings(configContent) {
+    return this.d1Manager.extractD1Bindings(configContent);
+  }
+
+  /**
+   * Check D1 database existence using D1Manager (delegated)
+   */
+  async checkD1DatabaseExists(nameOrId) {
+    return await this.d1Manager.checkD1DatabaseExists(nameOrId);
+  }
 }
 export default WranglerDeployer;

package/dist/service-management/InputCollector.js

@@ -14,6 +14,7 @@
 import { createInterface } from 'readline';
 import chalk from 'chalk';
 import { validateServiceName, validateDomainName } from '../utils/validation.js';
+import { uiStructuresLoader } from '../utils/ui-structures-loader.js';
 export class InputCollector {
   constructor(options = {}) {
     this.interactive = options.interactive !== false;
@@ -24,34 +25,221 @@ export class InputCollector {
   }
 
   /**
-   * Collect all 6 core inputs interactively
+   * Collect all inputs using three-tier template-driven approach
+   * Tier 1: 6 core inputs (required)
+   * Tier 2: 15 smart confirmations (assumed, user can modify)
+   * Tier 3: 67 automated generations (framework handles)
    */
-  async collectCoreInputs() {
-    const inputs = {};
-    console.log(chalk.cyan('📝 Collecting Core Service Information'));
-    console.log(chalk.white('These 6 inputs are required to create your Clodo service.\n'));
+  async collectInputsWithTransparency() {
+    await uiStructuresLoader.loadTemplates();
+    const result = {
+      collectionMetadata: {
+        method: 'three-tier-template-driven',
+        timestamp: new Date().toISOString(),
+        tiers: {
+          core: 6,
+          confirmable: 15,
+          automated: 67
+        }
+      },
+      coreInputs: {},
+      smartConfirmations: {},
+      automatedGenerations: {},
+      userModifications: []
+    };
+
+    // Tier 1: Core Inputs (required from user)
+    console.log(chalk.cyan('\n📝 Tier 1: Core Service Information'));
+    console.log(chalk.white('These 6 inputs are required to create your service.\n'));
+    const coreTemplate = uiStructuresLoader.getCoreInputsTemplate();
+    if (!coreTemplate) {
+      throw new Error('Core inputs template not found. Cannot proceed with input collection.');
+    }
+    if (coreTemplate) {
+      for (const inputDef of coreTemplate.inputs) {
+        const value = await this.collectInputFromDefinition(inputDef);
+        result.coreInputs[inputDef.id] = {
+          value,
+          source: 'user-provided',
+          required: true
+        };
+      }
+    }
 
-    // 1. Service Name
-    inputs.serviceName = await this.collectServiceName();
+    // Tier 2: Smart Confirmations (framework assumptions, user can modify)
+    console.log(chalk.cyan('\n🤔 Tier 2: Smart Confirmations'));
+    console.log(chalk.white('Based on your core inputs, we\'ve made smart assumptions. Review and modify as needed.\n'));
+    const confirmTemplate = uiStructuresLoader.getSmartConfirmableTemplate();
+    if (confirmTemplate) {
+      for (const category of confirmTemplate.categories) {
+        console.log(chalk.yellow(`\n${category.title}`));
+        console.log(chalk.gray(`${category.description}\n`));
+        for (const inputId of category.inputs) {
+          // Generate smart default based on core inputs
+          const smartDefault = this.generateSmartDefault(inputId, result.coreInputs);
+          const userValue = await this.confirmOrModifyValue(inputId, smartDefault);
+          result.smartConfirmations[inputId] = {
+            value: userValue,
+            defaultAssumed: smartDefault,
+            userModified: userValue !== smartDefault,
+            source: userValue === smartDefault ? 'framework-assumed' : 'user-modified'
+          };
+          if (userValue !== smartDefault) {
+            result.userModifications.push({
+              field: inputId,
+              assumed: smartDefault,
+              chosen: userValue
+            });
+          }
+        }
+      }
+    }
 
-    // 2. Service Type
-    inputs.serviceType = await this.collectServiceType();
+    // Tier 3: Automated Generation (show transparency)
+    console.log(chalk.cyan('\n⚡ Tier 3: Automated Generation'));
+    console.log(chalk.white('The following will be automatically generated from your inputs:\n'));
+    const autoTemplate = uiStructuresLoader.getAutomatedGenerationTemplate();
+    if (autoTemplate) {
+      console.log(chalk.gray(`📊 ${autoTemplate.collectionStrategy.inputCount} configurations will be generated automatically`));
+      console.log(chalk.gray(`⏱️ Estimated time: ${autoTemplate.template.estimatedTime}`));
 
-    // 3. Domain Name
-    inputs.domainName = await this.collectDomainName();
+      // Show some examples of what will be automated
+      result.automatedGenerations = {
+        count: autoTemplate.collectionStrategy.inputCount,
+        estimatedTime: autoTemplate.template.estimatedTime,
+        examples: ['Database connection strings', 'Environment variables', 'API endpoints', 'Security configurations', 'Deployment scripts']
+      };
+    }
 
-    // 4. Cloudflare API Token
-    inputs.cloudflareToken = await this.collectCloudflareToken();
+    // Summary
+    console.log(chalk.green('\n✅ Collection Complete!'));
+    console.log(chalk.white(`Core inputs: ${Object.keys(result.coreInputs).length}`));
+    console.log(chalk.white(`Smart confirmations: ${Object.keys(result.smartConfirmations).length}`));
+    console.log(chalk.white(`Automated generations: ${result.automatedGenerations.count || 0}`));
+    if (result.userModifications.length > 0) {
+      console.log(chalk.yellow(`User modifications: ${result.userModifications.length}`));
+    }
+    return result;
+  }
 
-    // 5. Cloudflare Account ID
-    inputs.cloudflareAccountId = await this.collectCloudflareAccountId();
+  /**
+   * Generate smart defaults based on core inputs
+   */
+  generateSmartDefault(inputId, coreInputs) {
+    const serviceName = coreInputs.serviceName?.value || '';
+    const environment = coreInputs.environment?.value || 'development';
+    const domainName = coreInputs.domainName?.value || '';
+    switch (inputId) {
+      case 'display-name':
+        return serviceName ? serviceName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase()) : '';
+      case 'description':
+        return `A service built with CLODO Framework`;
+      case 'version':
+        return '1.0.0';
+      case 'author':
+        return 'CLODO Framework';
+      case 'production-url':
+        return domainName ? `https://api.${domainName}` : '';
+      case 'staging-url':
+        return domainName ? `https://staging-api.${domainName}` : '';
+      case 'development-url':
+        return domainName ? `https://dev-api.${domainName}` : '';
+      case 'service-directory':
+        return serviceName ? `./services/${serviceName}` : '';
+      case 'database-name':
+        return serviceName ? `${serviceName}-db` : '';
+      case 'worker-name':
+        return serviceName ? `${serviceName}-worker` : '';
+      case 'log-level':
+        return environment === 'production' ? 'warn' : environment === 'staging' ? 'info' : 'debug';
+      case 'env-prefix':
+        return environment === 'production' ? 'PROD_' : environment === 'staging' ? 'STAGING_' : 'DEV_';
+      default:
+        return '';
+    }
+  }
 
-    // 6. Cloudflare Zone ID
-    inputs.cloudflareZoneId = await this.collectCloudflareZoneId();
+  /**
+   * Allow user to confirm or modify a smart default
+   */
+  async confirmOrModifyValue(inputId, defaultValue) {
+    console.log(chalk.blue(`❓ ${this.formatFieldName(inputId)}`));
+    console.log(chalk.gray(`   Suggested: ${defaultValue}`));
+    const answer = await this.question(`Press Enter to accept, or enter new value: `);
+    return answer.trim() || defaultValue;
+  }
 
-    // 7. Target Environment
-    inputs.environment = await this.collectEnvironment();
-    return inputs;
+  /**
+   * Format field names for display
+   */
+  formatFieldName(inputId) {
+    return inputId.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+  }
+
+  /**
+   * Collect a single input based on UI definition
+   */
+  async collectInputFromDefinition(inputDef) {
+    const {
+      id,
+      ui,
+      validation,
+      examples,
+      followUp
+    } = inputDef;
+
+    // Display prompt
+    console.log(chalk.blue(`❓ ${ui.label}`));
+    if (ui.description) {
+      console.log(chalk.gray(`   ${ui.description}`));
+    }
+    if (examples && examples.length > 0) {
+      console.log(chalk.gray(`   Examples: ${examples.join(', ')}`));
+    }
+    for (;;) {
+      const answer = await this.question(`${ui.placeholder || 'Enter value'}: `);
+
+      // Basic validation
+      if (validation) {
+        if (validation.required && !answer) {
+          console.log(chalk.red('❌ This field is required'));
+          continue;
+        }
+        if (validation.minLength && answer.length < validation.minLength) {
+          console.log(chalk.red(`❌ Minimum length: ${validation.minLength}`));
+          continue;
+        }
+        if (validation.maxLength && answer.length > validation.maxLength) {
+          console.log(chalk.red(`❌ Maximum length: ${validation.maxLength}`));
+          continue;
+        }
+        if (validation.pattern && !new RegExp(validation.pattern).test(answer)) {
+          console.log(chalk.red(`❌ ${validation.customMessage || 'Invalid format'}`));
+          continue;
+        }
+      }
+
+      // Follow-up message
+      if (followUp) {
+        const message = followUp.message.replace('{value}', answer);
+        console.log(chalk.green(`✅ ${message}`));
+        if (followUp.preview) {
+          console.log(chalk.gray(`   ${followUp.preview.replace('{value}', answer)}`));
+        }
+      }
+      return answer;
+    }
+  }
+
+  /**
+   * Promisified readline question
+   */
+  question(prompt) {
+    return new Promise(resolve => {
+      this.rl.question(prompt, answer => {
+        resolve(answer.trim());
+      });
+    });
   }
 
   /**

package/dist/shared/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('====================');