@tamyla/clodo-framework 4.0.14 → 4.1.0

package/dist/service-management/generators/BaseGenerator.js

@@ -180,6 +180,9 @@ export class BaseGenerator {
     const fullPath = path.join(this.servicePath, relativePath);
     const overwrite = options.overwrite !== false; // Default to true
 
+    // Debug: log the target file path for diagnosis
+    this.logger.info(`BaseGenerator: writing file -> ${fullPath}`);
+
     // Check if file exists and overwrite is disabled
     try {
       await fs.access(fullPath);
@@ -197,13 +200,35 @@ export class BaseGenerator {
       recursive: true
     });
 
-    // Write file
-    try {
-      await fs.writeFile(fullPath, content, 'utf8');
-      this.logger.info(`Generated: ${relativePath}`);
-    } catch (error) {
-      throw new Error(`Failed to write file '${relativePath}': ${error.message}`);
+    // Write file with retry logic for filesystem stability
+    const maxRetries = 3;
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        this.logger.info(`BaseGenerator: attempt ${attempt} - writing to ${fullPath}`);
+        await fs.writeFile(fullPath, content, 'utf8');
+
+        // Add a small delay to let file system settle, especially on Windows
+        if (attempt === 1) {
+          await new Promise(resolve => setTimeout(resolve, 10));
+        }
+
+        // Verify the file was written successfully by checking it exists
+        await fs.access(fullPath, fs.constants.F_OK);
+        this.logger.info(`Generated: ${relativePath}`);
+        return; // Success
+      } catch (error) {
+        lastError = error;
+        this.logger.warn(`Write attempt ${attempt}/${maxRetries} failed for ${relativePath}: ${error.message}`);
+        if (attempt < maxRetries) {
+          // Wait before retry (exponential backoff)
+          await new Promise(resolve => setTimeout(resolve, 50 * attempt));
+        }
+      }
     }
+
+    // If all retries failed, throw the last error
+    throw new Error(`Failed to write and verify file '${relativePath}' after ${maxRetries} attempts: ${lastError.message}`);
   }
 
   /**

package/dist/service-management/generators/utils/FileWriter.js

@@ -69,12 +69,22 @@ export class FileWriter {
     }
 
     // Ensure parent directory exists
-    await this.ensureDirectory(path.dirname(fullPath));
+    const dirPath = path.dirname(fullPath);
+    await this.ensureDirectory(dirPath);
 
     // Write file atomically (write to temp file, then rename)
     const tempPath = `${fullPath}.tmp`;
     try {
+      // Write to temp file first
       await fs.writeFile(tempPath, content, encoding);
+
+      // Small delay to ensure file is fully written on Windows
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      // Verify temp file exists before rename (prevents ENOENT)
+      await fs.access(tempPath);
+
+      // Rename to final destination
       await fs.rename(tempPath, fullPath);
       this.writtenFiles.push(fullPath);
       return {
@@ -106,6 +116,8 @@ export class FileWriter {
       await fs.mkdir(dirPath, {
         recursive: true
       });
+      // Verify the directory was created
+      await fs.access(dirPath);
     } catch (error) {
       // Ignore error if directory already exists
       if (error.code !== 'EEXIST') {

package/dist/services/ServiceClient.js

@@ -0,0 +1,239 @@
+/**
+ * Service Client for Inter-Service Communication
+ * Provides circuit breaker, retry logic, and service discovery
+ */
+
+import { CircuitBreaker } from '../utils/CircuitBreaker.js';
+
+/**
+ * Service Client for inter-service communication
+ */
+export class ServiceClient {
+  constructor(options = {}) {
+    this.options = {
+      timeout: options.timeout || 10000,
+      retries: options.retries || 3,
+      retryDelay: options.retryDelay || 1000,
+      circuitBreakerEnabled: options.circuitBreakerEnabled !== false,
+      serviceDiscovery: options.serviceDiscovery || this.defaultServiceDiscovery,
+      ...options
+    };
+
+    // Initialize circuit breaker if enabled
+    if (this.options.circuitBreakerEnabled) {
+      this.circuitBreaker = new CircuitBreaker({
+        failureThreshold: options.failureThreshold || 5,
+        recoveryTimeout: options.recoveryTimeout || 60000,
+        monitoringPeriod: options.monitoringPeriod || 10000
+      });
+    }
+
+    // Service URL cache
+    this.serviceCache = new Map();
+    this.cacheTimeout = options.cacheTimeout || 300000; // 5 minutes
+  }
+
+  /**
+   * Make a call to another service
+   * @param {string} serviceName - Name of the target service
+   * @param {string} endpoint - API endpoint path
+   * @param {Object} options - Call options
+   * @returns {Promise<Object>} Response data
+   */
+  async call(serviceName, endpoint, options = {}) {
+    const callOptions = {
+      method: options.method || 'GET',
+      headers: options.headers || {},
+      body: options.body,
+      timeout: options.timeout || this.options.timeout,
+      retries: options.retries || this.options.retries,
+      ...options
+    };
+
+    // Get service URL
+    const serviceUrl = await this.getServiceUrl(serviceName);
+    if (!serviceUrl) {
+      throw new Error(`Service ${serviceName} not found`);
+    }
+    const fullUrl = `${serviceUrl}${endpoint}`;
+
+    // Check circuit breaker
+    if (this.circuitBreaker && !this.circuitBreaker.canExecute(serviceName)) {
+      throw new Error(`Circuit breaker open for service ${serviceName}`);
+    }
+    let lastError;
+
+    // Retry logic
+    for (let attempt = 0; attempt <= callOptions.retries; attempt++) {
+      try {
+        const response = await this.makeRequest(fullUrl, callOptions);
+
+        // Record success for circuit breaker
+        if (this.circuitBreaker) {
+          this.circuitBreaker.recordSuccess(serviceName);
+        }
+        return response;
+      } catch (error) {
+        lastError = error;
+
+        // Record failure for circuit breaker
+        if (this.circuitBreaker) {
+          this.circuitBreaker.recordFailure(serviceName);
+        }
+
+        // Don't retry on the last attempt
+        if (attempt === callOptions.retries) {
+          break;
+        }
+
+        // Wait before retry
+        const delay = this.options.retryDelay * Math.pow(2, attempt); // Exponential backoff
+        await this.sleep(delay);
+      }
+    }
+    throw lastError;
+  }
+
+  /**
+   * Make an HTTP request with timeout
+   * @param {string} url - Request URL
+   * @param {Object} options - Request options
+   * @returns {Promise<Object>} Response data
+   */
+  async makeRequest(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+    try {
+      const fetchOptions = {
+        method: options.method,
+        headers: {
+          'Content-Type': 'application/json',
+          ...options.headers
+        },
+        signal: controller.signal
+      };
+      if (options.body && typeof options.body === 'object') {
+        fetchOptions.body = JSON.stringify(options.body);
+      } else if (options.body) {
+        fetchOptions.body = options.body;
+      }
+      const response = await fetch(url, fetchOptions);
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const contentType = response.headers.get('content-type');
+      if (contentType && contentType.includes('application/json')) {
+        return await response.json();
+      } else {
+        return await response.text();
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === 'AbortError') {
+        throw new Error(`Request timeout after ${options.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get service URL using service discovery
+   * @param {string} serviceName - Name of the service
+   * @returns {Promise<string|null>} Service URL or null if not found
+   */
+  async getServiceUrl(serviceName) {
+    // Check cache first
+    const cached = this.serviceCache.get(serviceName);
+    if (cached && Date.now() - cached.timestamp < this.cacheTimeout) {
+      return cached.url;
+    }
+
+    // Use service discovery
+    const url = await this.options.serviceDiscovery(serviceName);
+    if (url) {
+      this.serviceCache.set(serviceName, {
+        url: url,
+        timestamp: Date.now()
+      });
+    }
+    return url;
+  }
+
+  /**
+   * Default service discovery implementation
+   * Uses environment variables for service URLs
+   * @param {string} serviceName - Name of the service
+   * @returns {Promise<string|null>} Service URL
+   */
+  async defaultServiceDiscovery(serviceName) {
+    // Try environment-based discovery
+    const envKey = `SERVICE_URL_${serviceName.toUpperCase().replace(/-/g, '_')}`;
+    const envUrl = process.env[envKey];
+    if (envUrl) {
+      return envUrl;
+    }
+
+    // Try development localhost patterns
+    if (process.env.NODE_ENV === 'development') {
+      const localhostUrl = `http://localhost:8787`; // Default Cloudflare Workers dev port
+      return localhostUrl;
+    }
+
+    // Try production Cloudflare Workers pattern
+    const productionUrl = `https://${serviceName}.your-domain.workers.dev`;
+    return productionUrl;
+  }
+
+  /**
+   * Health check for a service
+   * @param {string} serviceName - Name of the service
+   * @returns {Promise<boolean>} True if service is healthy
+   */
+  async healthCheck(serviceName) {
+    try {
+      await this.call(serviceName, '/health', {
+        timeout: 5000,
+        retries: 0
+      });
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get circuit breaker status
+   * @param {string} serviceName - Name of the service
+   * @returns {Object} Circuit breaker status
+   */
+  getCircuitBreakerStatus(serviceName) {
+    if (!this.circuitBreaker) {
+      return {
+        enabled: false
+      };
+    }
+    return this.circuitBreaker.getStatus(serviceName);
+  }
+
+  /**
+   * Clear service URL cache
+   * @param {string} serviceName - Specific service to clear (optional)
+   */
+  clearCache(serviceName = null) {
+    if (serviceName) {
+      this.serviceCache.delete(serviceName);
+    } else {
+      this.serviceCache.clear();
+    }
+  }
+
+  /**
+   * Sleep utility
+   * @param {number} ms - Milliseconds to sleep
+   * @returns {Promise<void>}
+   */
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}

package/dist/utils/CircuitBreaker.js

@@ -0,0 +1,192 @@
+/**
+ * Circuit Breaker Implementation
+ * Prevents cascading failures in distributed systems
+ */
+
+/**
+ * Circuit Breaker for resilient service communication
+ */
+export class CircuitBreaker {
+  constructor(options = {}) {
+    this.options = {
+      failureThreshold: options.failureThreshold || 5,
+      recoveryTimeout: options.recoveryTimeout || 60000,
+      monitoringPeriod: options.monitoringPeriod || 10000,
+      ...options
+    };
+
+    // State: 'closed', 'open', 'half-open'
+    this.state = 'closed';
+
+    // Failure tracking
+    this.failureCount = 0;
+    this.lastFailureTime = null;
+    this.nextAttemptTime = null;
+
+    // Success tracking for half-open state
+    this.successCount = 0;
+    this.requiredSuccessCount = options.requiredSuccessCount || 3;
+
+    // Service-specific tracking
+    this.services = new Map();
+  }
+
+  /**
+   * Check if an operation can be executed
+   * @param {string} serviceName - Name of the service
+   * @returns {boolean} True if operation can proceed
+   */
+  canExecute(serviceName) {
+    const serviceState = this.getServiceState(serviceName);
+    switch (serviceState.state) {
+      case 'closed':
+        return true;
+      case 'open':
+        if (Date.now() >= serviceState.nextAttemptTime) {
+          // Transition to half-open
+          this.setServiceState(serviceName, 'half-open');
+          return true;
+        }
+        return false;
+      case 'half-open':
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * Record a successful operation
+   * @param {string} serviceName - Name of the service
+   */
+  recordSuccess(serviceName) {
+    const serviceState = this.getServiceState(serviceName);
+    switch (serviceState.state) {
+      case 'half-open':
+        serviceState.successCount++;
+        if (serviceState.successCount >= this.requiredSuccessCount) {
+          // Transition back to closed
+          this.setServiceState(serviceName, 'closed');
+        }
+        break;
+      case 'closed':
+        // Reset failure count on success
+        serviceState.failureCount = 0;
+        serviceState.lastFailureTime = null;
+        break;
+    }
+  }
+
+  /**
+   * Record a failed operation
+   * @param {string} serviceName - Name of the service
+   */
+  recordFailure(serviceName) {
+    const serviceState = this.getServiceState(serviceName);
+    serviceState.failureCount++;
+    serviceState.lastFailureTime = Date.now();
+    if (serviceState.failureCount >= this.options.failureThreshold) {
+      // Transition to open
+      this.setServiceState(serviceName, 'open');
+    }
+  }
+
+  /**
+   * Get the current state for a service
+   * @param {string} serviceName - Name of the service
+   * @returns {Object} Service state information
+   */
+  getStatus(serviceName) {
+    const serviceState = this.getServiceState(serviceName);
+    return {
+      service: serviceName,
+      state: serviceState.state,
+      failureCount: serviceState.failureCount,
+      lastFailureTime: serviceState.lastFailureTime,
+      nextAttemptTime: serviceState.nextAttemptTime,
+      successCount: serviceState.successCount,
+      canExecute: this.canExecute(serviceName)
+    };
+  }
+
+  /**
+   * Get service state (internal)
+   * @param {string} serviceName - Name of the service
+   * @returns {Object} Service state
+   */
+  getServiceState(serviceName) {
+    if (!this.services.has(serviceName)) {
+      this.services.set(serviceName, {
+        state: 'closed',
+        failureCount: 0,
+        lastFailureTime: null,
+        nextAttemptTime: null,
+        successCount: 0
+      });
+    }
+    return this.services.get(serviceName);
+  }
+
+  /**
+   * Set service state (internal)
+   * @param {string} serviceName - Name of the service
+   * @param {string} state - New state
+   */
+  setServiceState(serviceName, state) {
+    const serviceState = this.getServiceState(serviceName);
+    serviceState.state = state;
+    if (state === 'open') {
+      serviceState.nextAttemptTime = Date.now() + this.options.recoveryTimeout;
+      serviceState.successCount = 0;
+    } else if (state === 'half-open') {
+      serviceState.successCount = 0;
+    } else if (state === 'closed') {
+      serviceState.failureCount = 0;
+      serviceState.lastFailureTime = null;
+      serviceState.nextAttemptTime = null;
+      serviceState.successCount = 0;
+    }
+  }
+
+  /**
+   * Manually reset a service's circuit breaker
+   * @param {string} serviceName - Name of the service
+   */
+  reset(serviceName) {
+    this.setServiceState(serviceName, 'closed');
+  }
+
+  /**
+   * Force a service into open state
+   * @param {string} serviceName - Name of the service
+   */
+  trip(serviceName) {
+    this.setServiceState(serviceName, 'open');
+  }
+
+  /**
+   * Get all service statuses
+   * @returns {Object} All service statuses
+   */
+  getAllStatuses() {
+    const statuses = {};
+    for (const [serviceName] of this.services) {
+      statuses[serviceName] = this.getStatus(serviceName);
+    }
+    return statuses;
+  }
+
+  /**
+   * Clean up old service states (optional maintenance)
+   */
+  cleanup() {
+    const now = Date.now();
+    const maxAge = this.options.monitoringPeriod * 10; // 10 monitoring periods
+
+    for (const [serviceName, serviceState] of this.services.entries()) {
+      if (serviceState.lastFailureTime && now - serviceState.lastFailureTime > maxAge && serviceState.state === 'closed') {
+        this.services.delete(serviceName);
+      }
+    }
+  }
+}

package/dist/utils/EnvironmentValidator.js

@@ -0,0 +1,147 @@
+/**
+ * Environment Variable Validator
+ * Validates required environment variables at runtime
+ */
+
+/**
+ * Environment Variable Validation
+ */
+export class EnvironmentValidator {
+  /**
+   * Common required environment variables for Cloudflare services
+   */
+  static COMMON_REQUIRED_VARS = ['CLOUDFLARE_ACCOUNT_ID', 'CLOUDFLARE_API_TOKEN'];
+
+  /**
+   * Validate that all required environment variables are set
+   * @param {string[]} requiredVars - Array of required environment variable names
+   * @param {Object} env - Environment object (defaults to process.env)
+   * @throws {Error} Throws descriptive error if any required vars are missing
+   */
+  static validateRequired(requiredVars, env = process.env) {
+    const missing = [];
+    const empty = [];
+    for (const varName of requiredVars) {
+      const value = env[varName];
+      if (value === undefined || value === null) {
+        missing.push(varName);
+      } else if (typeof value === 'string' && value.trim() === '') {
+        empty.push(varName);
+      }
+    }
+    if (missing.length > 0 || empty.length > 0) {
+      const errors = [];
+      if (missing.length > 0) {
+        errors.push(`Missing required environment variables: ${missing.join(', ')}`);
+      }
+      if (empty.length > 0) {
+        errors.push(`Empty required environment variables: ${empty.join(', ')}`);
+      }
+      const errorMessage = `Environment validation failed:\n${errors.join('\n')}\n\nPlease set these variables in your wrangler.toml or deployment environment.`;
+      throw new Error(errorMessage);
+    }
+  }
+
+  /**
+   * Validate Cloudflare-specific environment variables
+   * @param {Object} env - Environment object (defaults to process.env)
+   * @throws {Error} Throws error if Cloudflare vars are missing
+   */
+  static validateCloudflareVars(env = process.env) {
+    const cloudflareVars = ['CLOUDFLARE_ACCOUNT_ID', 'CLOUDFLARE_API_TOKEN'];
+    this.validateRequired(cloudflareVars, env);
+  }
+
+  /**
+   * Validate service-specific environment variables
+   * @param {string[]} serviceVars - Service-specific required variables
+   * @param {Object} env - Environment object (defaults to process.env)
+   * @throws {Error} Throws error if service vars are missing
+   */
+  static validateServiceVars(serviceVars, env = process.env) {
+    this.validateRequired(serviceVars, env);
+  }
+
+  /**
+   * Validate all environment variables for a service
+   * @param {Object} config - Service configuration with required vars
+   * @param {Object} env - Environment object (defaults to process.env)
+   * @throws {Error} Throws error if any vars are missing
+   */
+  static validateServiceConfig(config, env = process.env) {
+    const requiredVars = [];
+
+    // Add common Cloudflare vars
+    requiredVars.push(...this.COMMON_REQUIRED_VARS);
+
+    // Add service-specific vars from config
+    if (config.requiredEnvironmentVars) {
+      requiredVars.push(...config.requiredEnvironmentVars);
+    }
+
+    // Add feature-specific vars
+    if (config.features) {
+      if (config.features.d1) {
+        // D1 might require additional vars, but usually handled by wrangler
+      }
+      if (config.features.kv) {
+        // KV vars are usually handled by wrangler binding
+      }
+      if (config.features.r2) {
+        // R2 vars are usually handled by wrangler binding
+      }
+    }
+    this.validateRequired(requiredVars, env);
+  }
+
+  /**
+   * Get a summary of environment variable status
+   * @param {string[]} vars - Variables to check
+   * @param {Object} env - Environment object (defaults to process.env)
+   * @returns {Object} Status summary
+   */
+  static getStatus(vars, env = process.env) {
+    const status = {
+      total: vars.length,
+      set: 0,
+      missing: [],
+      empty: []
+    };
+    for (const varName of vars) {
+      const value = env[varName];
+      if (value === undefined || value === null) {
+        status.missing.push(varName);
+      } else if (typeof value === 'string' && value.trim() === '') {
+        status.empty.push(varName);
+      } else {
+        status.set++;
+      }
+    }
+    status.valid = status.missing.length === 0 && status.empty.length === 0;
+    return status;
+  }
+
+  /**
+   * Log environment variable validation results
+   * @param {string[]} vars - Variables that were checked
+   * @param {Object} status - Status from getStatus()
+   */
+  static logValidationResults(vars, status) {
+    console.log('\n🌍 Environment Variable Validation');
+    console.log('='.repeat(40));
+    if (status.valid) {
+      console.log(`✅ PASSED - All ${status.total} variables are set`);
+    } else {
+      console.log(`❌ ISSUES - ${status.missing.length + status.empty.length} problems found`);
+      if (status.missing.length > 0) {
+        console.log('\n📭 MISSING VARIABLES:');
+        status.missing.forEach(variable => console.log(`   - ${variable}`));
+      }
+      if (status.empty.length > 0) {
+        console.log('\n📝 EMPTY VARIABLES:');
+        status.empty.forEach(variable => console.log(`   - ${variable}`));
+      }
+      console.log('\n💡 Set these in your wrangler.toml [vars] section or deployment environment');
+    }
+  }
+}