@tamyla/clodo-framework 2.0.16 → 2.0.18

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.0.18](https://github.com/tamylaa/clodo-framework/compare/v2.0.17...v2.0.18) (2025-10-12)
+
+
+### Bug Fixes
+
+* **deployment:** Critical deployment fixes - migrations, worker deployment, status tracking ([23c07e9](https://github.com/tamylaa/clodo-framework/commit/23c07e9a68fa4eb52ccd0df9421eff7d91919cb1)), closes [#2](https://github.com/tamylaa/clodo-framework/issues/2) [#3](https://github.com/tamylaa/clodo-framework/issues/3) [#4](https://github.com/tamylaa/clodo-framework/issues/4)
+
+## [2.0.17](https://github.com/tamylaa/clodo-framework/compare/v2.0.16...v2.0.17) (2025-10-12)
+
+
+### Bug Fixes
+
+* use ConfigurationValidator as static class, not instance ([12caaeb](https://github.com/tamylaa/clodo-framework/commit/12caaeba17426239f98dacd2fdb36ac45a7a496b))
+
 ## [2.0.16](https://github.com/tamylaa/clodo-framework/compare/v2.0.15...v2.0.16) (2025-10-12)
 
 

package/dist/database/database-orchestrator.js

@@ -628,8 +628,16 @@ export class DatabaseOrchestrator {
   // Command builders and utility methods
 
   buildMigrationCommand(databaseName, environment, isRemote) {
-    const remoteFlag = isRemote ? '--remote' : '--local';
-    return `npx wrangler d1 migrations apply ${databaseName} --env ${environment} ${remoteFlag}`;
+    let command = `npx wrangler d1 migrations apply ${databaseName}`;
+
+    // For remote environments, add --env flag
+    // For local development, use --local WITHOUT --env (wrangler requirement)
+    if (isRemote) {
+      command += ` --env ${environment} --remote`;
+    } else {
+      command += ` --local`;
+    }
+    return command;
   }
   buildBackupCommand(databaseName, environment, backupFile, isRemote) {
     const remoteFlag = isRemote ? '--remote' : '--local';

package/dist/orchestration/modules/DeploymentCoordinator.js

@@ -22,6 +22,38 @@ export class DeploymentCoordinator {
    * @returns {Promise<Object>} Deployment result
    */
   async deploySingleDomain(domain, domainState, handlers) {
+    const phaseResults = {
+      validation: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      initialization: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      database: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      secrets: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      deployment: {
+        success: false,
+        errors: [],
+        warnings: []
+      },
+      'post-validation': {
+        success: false,
+        errors: [],
+        warnings: []
+      }
+    };
     try {
       domainState.startTime = new Date();
       domainState.status = 'deploying';
@@ -29,38 +61,105 @@ export class DeploymentCoordinator {
       console.log(`   Deployment ID: ${domainState.deploymentId}`);
       console.log(`   Environment: ${this.environment}`);
       let deploymentUrl = null;
+      let hasCriticalErrors = false;
 
       // Execute deployment phases
       for (const phase of this.deploymentPhases) {
-        const phaseResult = await this.executeDeploymentPhase(domain, phase, domainState, handlers);
-        domainState.phase = `${phase}-complete`;
+        try {
+          const phaseResult = await this.executeDeploymentPhase(domain, phase, domainState, handlers);
+          domainState.phase = `${phase}-complete`;
+
+          // Mark phase as successful
+          phaseResults[phase].success = true;
+
+          // Capture deployment URL from deployment phase
+          if (phase === 'deployment' && phaseResult) {
+            if (phaseResult.url) {
+              deploymentUrl = phaseResult.url;
+            }
+            if (phaseResult.deployed === false) {
+              phaseResults[phase].warnings.push('Worker deployed in dry-run mode');
+            }
+          }
 
-        // Capture deployment URL from deployment phase
-        if (phase === 'deployment' && phaseResult && phaseResult.url) {
-          deploymentUrl = phaseResult.url;
+          // Capture database warnings
+          if (phase === 'database' && phaseResult) {
+            if (phaseResult.error) {
+              phaseResults[phase].warnings.push(phaseResult.error);
+            }
+          }
+        } catch (phaseError) {
+          phaseResults[phase].success = false;
+          phaseResults[phase].errors.push(phaseError.message);
+
+          // Determine if error is critical (stops deployment)
+          const criticalPhases = ['validation', 'initialization', 'deployment'];
+          if (criticalPhases.includes(phase)) {
+            console.error(`   ❌ Critical error in ${phase} phase: ${phaseError.message}`);
+            hasCriticalErrors = true;
+            throw phaseError; // Stop deployment on critical errors
+          } else {
+            // Non-critical errors (database migrations, health checks) - log but continue
+            console.warn(`   ⚠️  ${phase} phase warning: ${phaseError.message}`);
+            console.warn(`   💡 Deployment will continue - this can be fixed manually`);
+          }
         }
       }
-      domainState.status = 'completed';
+
+      // Determine overall success based on phase results
+      const allPhasesSuccessful = Object.values(phaseResults).every(result => result.success);
+      const hasWarnings = Object.values(phaseResults).some(result => result.warnings.length > 0 || result.success === false && result.errors.length === 0);
+      domainState.status = hasCriticalErrors ? 'failed' : allPhasesSuccessful ? 'completed' : 'completed-with-warnings';
       domainState.endTime = new Date();
-      console.log(`   ✅ ${domain} deployed successfully`);
+      domainState.phaseResults = phaseResults;
+
+      // Show appropriate completion message
+      if (allPhasesSuccessful) {
+        console.log(`   ✅ ${domain} deployed successfully`);
+      } else if (!hasCriticalErrors) {
+        console.log(`   ⚠️  ${domain} deployed with warnings`);
+        this.displayPhaseWarnings(phaseResults);
+      }
       return {
         domain,
-        success: true,
+        success: !hasCriticalErrors,
+        allPhasesSuccessful,
         deploymentId: domainState.deploymentId,
         duration: domainState.endTime - domainState.startTime,
         phases: this.deploymentPhases.length,
         url: deploymentUrl || domainState.deploymentUrl,
-        status: 'deployed'
+        status: domainState.status,
+        phaseResults
       };
     } catch (error) {
       domainState.status = 'failed';
       domainState.error = error.message;
       domainState.endTime = new Date();
+      domainState.phaseResults = phaseResults;
       console.error(`   ❌ ${domain} deployment failed: ${error.message}`);
       throw error;
     }
   }
 
+  /**
+   * Display warnings for phases that had issues
+   * @param {Object} phaseResults - Phase results object
+   */
+  displayPhaseWarnings(phaseResults) {
+    console.log(`\n   📊 Phase Status Summary:`);
+    for (const [phase, result] of Object.entries(phaseResults)) {
+      if (result.success && result.warnings.length === 0) {
+        console.log(`   ✅ ${phase}: Success`);
+      } else if (result.success && result.warnings.length > 0) {
+        console.log(`   ⚠️  ${phase}: Success with warnings`);
+        result.warnings.forEach(warn => console.log(`      • ${warn}`));
+      } else {
+        console.log(`   ❌ ${phase}: Failed`);
+        result.errors.forEach(err => console.log(`      • ${err}`));
+      }
+    }
+  }
+
   /**
    * Execute specific deployment phase
    * @param {string} domain - Domain being deployed

package/dist/orchestration/multi-domain-orchestrator.js

@@ -13,6 +13,10 @@ import { StateManager } from './modules/StateManager.js';
 import { DatabaseOrchestrator } from '../database/database-orchestrator.js';
 import { EnhancedSecretManager } from '../utils/deployment/secret-generator.js';
 import { ConfigurationValidator } from '../security/ConfigurationValidator.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { join } from 'path';
+const execAsync = promisify(exec);
 
 /**
  * Multi-Domain Deployment Orchestrator
@@ -59,7 +63,9 @@ export class MultiDomainOrchestrator {
       projectRoot: this.servicePath,
       dryRun: this.dryRun
     });
-    this.configValidator = new ConfigurationValidator();
+
+    // ConfigurationValidator is a static class - don't instantiate
+    // Access via ConfigurationValidator.validate() directly
 
     // Legacy compatibility: expose portfolioState for backward compatibility
     this.portfolioState = this.stateManager.portfolioState;
@@ -214,8 +220,8 @@ export class MultiDomainOrchestrator {
       const domainState = this.portfolioState.domainStates.get(domain);
       const config = domainState?.config || {};
 
-      // Perform security validation
-      const validationIssues = this.configValidator.validate(config, this.environment);
+      // Perform security validation using static method
+      const validationIssues = ConfigurationValidator.validate(config, this.environment);
       if (validationIssues.length > 0) {
         console.log(`   ⚠️  Found ${validationIssues.length} configuration warnings:`);
         validationIssues.forEach(issue => {
@@ -357,26 +363,100 @@ export class MultiDomainOrchestrator {
   }
 
   /**
-   * Deploy domain worker (returns worker URL)
+   * Deploy domain worker (executes actual wrangler deploy)
    */
   async deployDomainWorker(domain) {
-    // Placeholder: Add actual worker deployment logic here
     console.log(`   🚀 Deploying worker for ${domain}`);
+    if (this.dryRun) {
+      console.log(`   🔍 DRY RUN: Would deploy worker for ${domain}`);
+      const subdomain = this.environment === 'production' ? 'api' : `${this.environment}-api`;
+      return {
+        url: `https://${subdomain}.${domain}`,
+        deployed: false,
+        dryRun: true
+      };
+    }
+    try {
+      // Find wrangler.toml in service path
+      const wranglerConfigPath = join(this.servicePath, 'wrangler.toml');
 
-    // TODO: Execute actual wrangler deploy command here
-    // For now, construct the expected URL from domain and environment
-    const subdomain = this.environment === 'production' ? 'api' : `${this.environment}-api`;
-    const workerUrl = `https://${subdomain}.${domain}`;
+      // Build deploy command with environment
+      let deployCommand = `npx wrangler deploy`;
 
-    // Store URL in domain state for later retrieval
-    const domainState = this.portfolioState.domainStates.get(domain);
-    if (domainState) {
-      domainState.deploymentUrl = workerUrl;
+      // Add environment flag for non-production
+      if (this.environment !== 'production') {
+        deployCommand += ` --env ${this.environment}`;
+      }
+      console.log(`   � Executing: ${deployCommand}`);
+      console.log(`   📁 Working directory: ${this.servicePath}`);
+
+      // Execute deployment with timeout
+      const {
+        stdout,
+        stderr
+      } = await execAsync(deployCommand, {
+        cwd: this.servicePath,
+        timeout: 120000,
+        // 2 minute timeout
+        maxBuffer: 1024 * 1024 * 10 // 10MB buffer for large outputs
+      });
+
+      // Log output for debugging
+      if (stdout) {
+        console.log(`   📄 Deployment output:`);
+        stdout.split('\n').filter(line => line.trim()).forEach(line => {
+          console.log(`     ${line}`);
+        });
+      }
+      if (stderr && !stderr.includes('deprecated')) {
+        console.warn(`   ⚠️  Deployment warnings: ${stderr}`);
+      }
+
+      // Parse worker URL from wrangler output
+      // Wrangler outputs: "Published service-name (version) to https://worker-url"
+      const urlMatch = stdout.match(/https:\/\/[^\s]+/);
+      const workerUrl = urlMatch ? urlMatch[0] : null;
+
+      // Also construct custom domain URL
+      const subdomain = this.environment === 'production' ? 'api' : `${this.environment}-api`;
+      const customUrl = `https://${subdomain}.${domain}`;
+
+      // Store URLs in domain state
+      const domainState = this.portfolioState.domainStates.get(domain);
+      if (domainState) {
+        domainState.workerUrl = workerUrl;
+        domainState.deploymentUrl = customUrl;
+      }
+      if (workerUrl) {
+        console.log(`   ✅ Worker deployed successfully`);
+        console.log(`   🔗 Worker URL: ${workerUrl}`);
+        console.log(`   🔗 Custom URL: ${customUrl}`);
+      } else {
+        console.log(`   ✅ Deployment completed (URL not detected in output)`);
+        console.log(`   🔗 Expected URL: ${customUrl}`);
+      }
+      return {
+        url: customUrl,
+        workerUrl: workerUrl,
+        deployed: true,
+        stdout,
+        stderr
+      };
+    } catch (error) {
+      console.error(`   ❌ Worker deployment failed: ${error.message}`);
+
+      // Parse error for helpful diagnostics
+      if (error.message.includes('wrangler.toml')) {
+        console.error(`   💡 Ensure wrangler.toml exists in ${this.servicePath}`);
+      }
+      if (error.message.includes('No environment found')) {
+        console.error(`   💡 Add [env.${this.environment}] section to wrangler.toml`);
+      }
+      if (error.stderr) {
+        console.error(`   📄 Error details: ${error.stderr}`);
+      }
+      throw new Error(`Worker deployment failed for ${domain}: ${error.message}`);
     }
-    return {
-      url: workerUrl,
-      deployed: true
-    };
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [