@tamyla/clodo-framework 3.1.8 → 3.1.9

package/dist/shared/deployment/validator.js

@@ -1,670 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Advanced Deployment Validator Module
- * Enterprise-grade validation system for comprehensive deployment verification
- * 
- * Extracted from bulletproof-deploy.js and check-endpoint-structure.js with enhancements
- */
-import { access, readFile } from 'fs/promises';
-import { readFileSync } from 'fs';
-import { promisify } from 'util';
-import { exec } from 'child_process';
-import { join } from 'path';
-import { getCommandConfig } from '../config/command-config-manager.js';
-const execAsync = promisify(exec);
-
-/**
- * Advanced Deployment Validator
- * Provides comprehensive validation pipeline for enterprise deployments
- */
-export class DeploymentValidator {
-  constructor(options = {}) {
-    this.options = options; // Store options for later merging
-    this.environment = options.environment || 'production';
-    this.strictMode = options.strictMode || false;
-    this.timeout = options.timeout || 30000;
-    this.retryAttempts = options.retryAttempts || 3;
-    this.retryDelay = options.retryDelay || 2000;
-
-    // Initialize command configuration
-    this.cmdConfig = getCommandConfig();
-
-    // Load validation configuration from file
-    this.validationConfig = this.loadValidationConfig();
-
-    // Validation results tracking
-    this.results = {
-      overall: 'pending',
-      categories: {
-        prerequisites: 'pending',
-        authentication: 'pending',
-        network: 'pending',
-        configuration: 'pending',
-        endpoints: 'pending',
-        deployment: 'pending'
-      },
-      details: [],
-      warnings: [],
-      errors: [],
-      startTime: null,
-      endTime: null
-    };
-  }
-
-  /**
-   * Load validation configuration from JSON file
-   */
-  loadValidationConfig() {
-    const configPath = join(process.cwd(), 'validation-config.json');
-    try {
-      const configData = readFileSync(configPath, 'utf-8');
-      const userConfig = JSON.parse(configData);
-
-      // Merge with defaults
-      const defaultConfig = {
-        requiredCommands: Object.keys(this.cmdConfig?.config?.requiredCommands || {}) || ['npx', 'node', 'npm', 'wrangler'],
-        requiredFiles: ['package.json', 'wrangler.toml'],
-        requiredEnvironmentVars: [],
-        networkEndpoints: ['https://api.cloudflare.com', 'https://registry.npmjs.org'],
-        expectedEndpoints: this.getExpectedEndpoints()
-      };
-
-      // Handle new format with command objects
-      if (userConfig.requiredCommands && typeof userConfig.requiredCommands === 'object' && !Array.isArray(userConfig.requiredCommands)) {
-        // Convert object format to array for backward compatibility
-        defaultConfig.requiredCommands = Object.values(userConfig.requiredCommands);
-      } else if (userConfig.requiredCommands) {
-        defaultConfig.requiredCommands = userConfig.requiredCommands;
-      }
-
-      // Override other config values
-      if (userConfig.requiredFiles) defaultConfig.requiredFiles = userConfig.requiredFiles;
-      if (userConfig.requiredEnvironmentVars) defaultConfig.requiredEnvironmentVars = userConfig.requiredEnvironmentVars;
-      if (userConfig.networkEndpoints) defaultConfig.networkEndpoints = userConfig.networkEndpoints;
-      console.log('📋 Loaded validation config from validation-config.json');
-      return defaultConfig;
-    } catch (error) {
-      // Fall back to defaults if file doesn't exist or is invalid
-      console.log('📋 Using default validation config (validation-config.json not found or invalid)');
-      return {
-        requiredCommands: Object.keys(this.cmdConfig?.config?.requiredCommands || {}) || ['npx', 'node', 'npm', 'wrangler'],
-        requiredFiles: ['package.json', 'wrangler.toml'],
-        requiredEnvironmentVars: [],
-        networkEndpoints: ['https://api.cloudflare.com', 'https://registry.npmjs.org'],
-        expectedEndpoints: this.getExpectedEndpoints()
-      };
-    }
-  }
-
-  /**
-   * Get expected endpoints for validation
-   * @returns {Array<string>} List of expected endpoints
-   */
-  getExpectedEndpoints() {
-    return [
-    // Authentication
-    'POST /register', 'POST /auth/magic-link', 'GET /auth/me', 'POST /auth/verify', 'POST /auth/session',
-    // User Management
-    'GET /users', 'GET /users/profile', 'PATCH /users/profile',
-    // File Management
-    'GET /files', 'POST /files', 'GET /files/stats', 'GET /files/:id', 'PATCH /files/:id', 'DELETE /files/:id',
-    // Logging
-    'POST /logs/store', 'GET /logs', 'GET /logs/analytics',
-    // Enhanced Framework (Auto-generated CRUD)
-    'GET /api/users', 'POST /api/users', 'GET /api/users/:id', 'PATCH /api/users/:id', 'DELETE /api/users/:id', 'GET /api/files', 'POST /api/files', 'GET /api/files/:id', 'PATCH /api/files/:id', 'DELETE /api/files/:id', 'GET /api/products', 'POST /api/products', 'GET /api/products/:id', 'PATCH /api/products/:id', 'DELETE /api/products/:id', 'GET /api/orders', 'POST /api/orders', 'GET /api/orders/:id', 'PATCH /api/orders/:id', 'DELETE /api/orders/:id',
-    // System
-    'GET /health', 'GET /'];
-  }
-
-  /**
-   * Run comprehensive validation pipeline
-   * @param {string|Array<string>} domains - Domain(s) to validate
-   * @param {Object} options - Validation options
-   * @returns {Promise<Object>} Validation results
-   */
-  async validateDeployment(domains = [], options = {}) {
-    this.options = {
-      ...this.options,
-      ...options
-    }; // Merge with existing options
-    this.results.startTime = new Date();
-    const domainList = Array.isArray(domains) ? domains : [domains];
-    try {
-      console.log('🔍 Advanced Deployment Validation');
-      console.log('=================================');
-      console.log(`🌍 Environment: ${this.environment}`);
-      console.log(`📋 Domains: ${domainList.length > 0 ? domainList.join(', ') : 'Pre-deployment only'}`);
-      console.log(`⚙️ Strict Mode: ${this.strictMode ? 'ON' : 'OFF'}`);
-      console.log('');
-
-      // Phase 1: Prerequisites Validation
-      await this.validatePrerequisites();
-
-      // Phase 2: Authentication Validation
-      await this.validateAuthentication();
-
-      // Phase 3: Network Connectivity
-      await this.validateNetworkConnectivity();
-
-      // Phase 4: Configuration Validation
-      await this.validateConfiguration();
-
-      // Phase 5: Endpoint Structure (if domains provided and not a new deployment)
-      if (domainList.length > 0 && domainList[0] && !this.options.skipEndpointCheck) {
-        await this.validateEndpointStructure(domainList);
-      } else if (this.options.skipEndpointCheck) {
-        console.log('🔗 Phase 5: Endpoint Structure Validation');
-        console.log('   ⏭️ Skipping endpoint validation for new deployment');
-        this.results.categories.endpoints = 'skipped';
-        this.addResult('endpoints', 'Skipped for new deployment', 'info');
-      } else {
-        // No domains to validate
-        console.log('🔗 Phase 5: Endpoint Structure Validation');
-        console.log('   ⏭️ No domains provided for validation');
-        this.results.categories.endpoints = 'skipped';
-        this.addResult('endpoints', 'No domains to validate', 'info');
-      }
-
-      // Phase 6: Deployment Readiness
-      await this.validateDeploymentReadiness();
-      this.results.overall = 'passed';
-      this.results.endTime = new Date();
-      console.log('\n✅ VALIDATION COMPLETE');
-      this.printValidationSummary();
-      return this.results;
-    } catch (error) {
-      this.results.overall = 'failed';
-      this.results.endTime = new Date();
-      this.results.errors.push({
-        phase: 'validation',
-        message: error.message,
-        timestamp: new Date()
-      });
-      console.error('\n❌ VALIDATION FAILED');
-      console.error(`Error: ${error.message}`);
-      this.printValidationSummary();
-      throw error;
-    }
-  }
-
-  /**
-   * Validate system prerequisites
-   */
-  async validatePrerequisites() {
-    console.log('🔧 Phase 1: Prerequisites Validation');
-    try {
-      // Check required commands
-      for (const cmd of this.validationConfig.requiredCommands) {
-        await this.validateCommand(cmd);
-      }
-
-      // Check required files
-      for (const file of this.validationConfig.requiredFiles) {
-        await this.validateFile(file);
-      }
-
-      // Check Node.js version
-      await this.validateNodeVersion();
-      this.results.categories.prerequisites = 'passed';
-      this.addResult('prerequisites', 'All prerequisites validated', 'success');
-    } catch (error) {
-      this.results.categories.prerequisites = 'failed';
-      throw new Error(`Prerequisites validation failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate authentication systems
-   */
-  async validateAuthentication() {
-    console.log('🔐 Phase 2: Authentication Validation');
-    try {
-      // Cloudflare authentication (optional for development)
-      try {
-        await this.validateCloudflareAuth();
-      } catch (error) {
-        console.log(`     ⚠️ Cloudflare: ${error.message} (optional for development)`);
-        this.addResult('cloudflare-auth', 'Cloudflare not authenticated (development mode)', 'warning');
-      }
-
-      // NPM authentication (if needed)
-      await this.validateNpmAuth();
-      this.results.categories.authentication = 'passed';
-      this.addResult('authentication', 'Authentication validation completed', 'success');
-    } catch (error) {
-      this.results.categories.authentication = 'failed';
-      throw new Error(`Authentication validation failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate network connectivity
-   */
-  async validateNetworkConnectivity() {
-    console.log('🌐 Phase 3: Network Connectivity');
-    try {
-      for (const endpoint of this.validationConfig.networkEndpoints) {
-        await this.validateNetworkEndpoint(endpoint);
-      }
-      this.results.categories.network = 'passed';
-      this.addResult('network', 'Network connectivity verified', 'success');
-    } catch (error) {
-      this.results.categories.network = 'failed';
-      throw new Error(`Network validation failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate configuration files
-   */
-  async validateConfiguration() {
-    console.log('⚙️ Phase 4: Configuration Validation');
-    try {
-      // Validate package.json
-      await this.validatePackageJson();
-
-      // Skip wrangler.toml validation for multi-service framework
-      // Each service has its own wrangler.toml
-      console.log('   ⏭️ Skipping wrangler.toml validation (per-service configuration)');
-
-      // 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) {
-      this.results.categories.configuration = 'failed';
-      throw new Error(`Configuration validation failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate endpoint structure for deployed domains
-   * @param {Array<string>} domains - Domains to validate
-   */
-  async validateEndpointStructure(domains) {
-    console.log('🔗 Phase 5: Endpoint Structure Validation');
-
-    // Double-check skip condition
-    if (this.options?.skipEndpointCheck) {
-      console.log('   ⏭️ Skipping endpoint validation (skipEndpointCheck=true)');
-      this.results.categories.endpoints = 'skipped';
-      this.addResult('endpoints', 'Skipped for new deployment', 'info');
-      return;
-    }
-    try {
-      for (const domain of domains) {
-        await this.validateDomainEndpoints(domain);
-      }
-      this.results.categories.endpoints = 'passed';
-      this.addResult('endpoints', 'Endpoint structure validated', 'success');
-    } catch (error) {
-      this.results.categories.endpoints = 'failed';
-      throw new Error(`Endpoint validation failed: ${error.message}`);
-    }
-  }
-
-  /**
-   * Validate deployment readiness
-   */
-  async validateDeploymentReadiness() {
-    console.log('🚀 Phase 6: Deployment Readiness');
-    try {
-      // Check disk space
-      await this.validateDiskSpace();
-
-      // Check memory usage
-      await this.validateMemoryUsage();
-
-      // Validate build process
-      await this.validateBuildProcess();
-      this.results.categories.deployment = 'passed';
-      this.addResult('deployment', 'Deployment readiness confirmed', 'success');
-      return {
-        valid: true
-      };
-    } catch (error) {
-      this.results.categories.deployment = 'failed';
-      this.addResult('deployment', `Deployment readiness failed: ${error.message}`, 'error');
-      return {
-        valid: false,
-        errors: [error.message]
-      };
-    }
-  }
-
-  // Individual validation methods
-
-  async validateCommand(command) {
-    console.log(`   Checking ${command}...`);
-    try {
-      // Get command from configuration if available
-      let actualCommand = command;
-      try {
-        actualCommand = this.cmdConfig.getRequiredCommand(command);
-      } catch (error) {
-        // Use original command if not in config
-      }
-      const result = await this.executeWithRetry(`${actualCommand} --version`);
-      const version = result.trim().split('\\n')[0];
-      console.log(`     ✅ ${command}: ${version}`);
-      this.addResult('command', `${command} available: ${version}`, 'info');
-    } catch (error) {
-      throw new Error(`Required command '${command}' not available: ${error.message}`);
-    }
-  }
-  async validateFile(filePath) {
-    console.log(`   Checking ${filePath}...`);
-    try {
-      await access(filePath);
-      console.log(`     ✅ ${filePath}: exists`);
-      this.addResult('file', `${filePath} exists`, 'info');
-    } catch {
-      throw new Error(`Required file '${filePath}' not found`);
-    }
-  }
-  async validateNodeVersion() {
-    console.log('   Checking Node.js version...');
-    try {
-      const version = process.version;
-      const majorVersion = parseInt(version.slice(1).split('.')[0]);
-      if (majorVersion < 16) {
-        throw new Error(`Node.js version ${version} is too old. Minimum required: v16.0.0`);
-      }
-      console.log(`     ✅ Node.js: ${version}`);
-      this.addResult('node', `Node.js version: ${version}`, 'info');
-    } catch (error) {
-      throw new Error(`Node.js validation failed: ${error.message}`);
-    }
-  }
-  async validateCloudflareAuth() {
-    console.log('   Checking Cloudflare authentication...');
-    try {
-      const whoamiCmd = this.cmdConfig.getCloudflareCommand('whoami');
-      const result = await this.executeWithRetry(whoamiCmd);
-      if (result.includes('You are not authenticated') || result.includes('not logged in')) {
-        const authCmd = this.cmdConfig.getCloudflareCommand('auth_login');
-        throw new Error(`Cloudflare authentication required. Run: ${authCmd}`);
-      }
-      console.log(`     ✅ Cloudflare: authenticated`);
-      this.addResult('cloudflare-auth', 'Cloudflare authenticated', 'success');
-    } catch (error) {
-      throw new Error(`Cloudflare authentication failed: ${error.message}`);
-    }
-  }
-  async validateNpmAuth() {
-    console.log('   Checking NPM authentication...');
-    try {
-      // NPM auth is optional for most deployments
-      const npmCmd = this.cmdConfig.getRequiredCommand('npm');
-      const result = await this.executeWithRetry(`${npmCmd} whoami`);
-      console.log(`     ✅ NPM: authenticated as ${result.trim()}`);
-      this.addResult('npm-auth', `NPM authenticated: ${result.trim()}`, 'info');
-    } catch (error) {
-      // NPM auth failure is usually not critical
-      console.log(`     ⚠️ NPM: not authenticated (optional)`);
-      this.addResult('npm-auth', 'NPM not authenticated (optional)', 'warning');
-    }
-  }
-  async validateNetworkEndpoint(endpoint) {
-    console.log(`   Testing connectivity to ${endpoint}...`);
-    try {
-      // Use configurable network test command
-      const command = this.cmdConfig.getNetworkTestCommand(endpoint);
-      await this.executeWithRetry(command, 15000);
-      console.log(`     ✅ ${endpoint}: reachable`);
-      this.addResult('network', `${endpoint} reachable`, 'info');
-    } catch (error) {
-      throw new Error(`Cannot reach ${endpoint}: ${error.message}`);
-    }
-  }
-  async validatePackageJson() {
-    console.log('   Validating package.json...');
-    try {
-      const packageContent = await readFile('package.json', 'utf8');
-      const packageJson = JSON.parse(packageContent);
-
-      // Check required fields
-      const requiredFields = ['name', 'version', 'scripts'];
-      const missingFields = requiredFields.filter(field => !packageJson[field]);
-      if (missingFields.length > 0) {
-        throw new Error(`Missing required fields in package.json: ${missingFields.join(', ')}`);
-      }
-      console.log(`     ✅ package.json: valid`);
-      this.addResult('package-json', 'package.json validation passed', 'info');
-    } catch (error) {
-      throw new Error(`package.json validation failed: ${error.message}`);
-    }
-  }
-  async validateWranglerConfig() {
-    console.log('   Validating wrangler.toml...');
-    try {
-      const wranglerContent = await readFile('wrangler.toml', 'utf8');
-
-      // Basic validation - check for required sections
-      if (!wranglerContent.includes('name') || !wranglerContent.includes('compatibility_date')) {
-        throw new Error('wrangler.toml missing required configuration');
-      }
-      console.log(`     ✅ wrangler.toml: valid`);
-      this.addResult('wrangler-config', 'wrangler.toml validation passed', 'info');
-    } catch (error) {
-      throw new Error(`wrangler.toml validation failed: ${error.message}`);
-    }
-  }
-  async validateEnvironmentConfig() {
-    console.log('   Validating environment configuration...');
-    // Environment validation logic here
-    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('../../../dist/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}`);
-    console.log(`   🔧 DEBUG: deploymentType = ${this.options?.deploymentType}`);
-    console.log(`   🔧 DEBUG: options = ${JSON.stringify(this.options)}`);
-
-    // Skip endpoint validation for new deployments
-    if (this.options?.skipEndpointCheck) {
-      console.log(`   ⏭️ Skipping endpoint validation for new deployment`);
-      this.addResult('endpoints', 'Skipped for new deployment', 'info');
-      return;
-    }
-    try {
-      // Test health endpoint first
-      const healthUrl = `https://${domain}/health`;
-      const command = this.cmdConfig.getNetworkTestCommand(healthUrl);
-      await this.executeWithRetry(command, 15000);
-      console.log(`     ✅ ${domain}: health endpoint responding`);
-      this.addResult('endpoints', `${domain} endpoints accessible`, 'success');
-    } catch (error) {
-      throw new Error(`Domain ${domain} endpoints validation failed: ${error.message}`);
-    }
-  }
-  async validateDiskSpace() {
-    console.log('   Checking disk space...');
-    // Disk space validation logic
-    console.log(`     ✅ Disk space: sufficient`);
-    this.addResult('disk-space', 'Sufficient disk space available', 'info');
-  }
-  async validateMemoryUsage() {
-    console.log('   Checking memory usage...');
-    // Memory usage validation logic
-    console.log(`     ✅ Memory: sufficient`);
-    this.addResult('memory', 'Sufficient memory available', 'info');
-  }
-  async validateBuildProcess() {
-    console.log('   Validating build process...');
-    try {
-      // Test build without deploying
-      await this.executeWithRetry('npm run build', 60000);
-      console.log(`     ✅ Build: successful`);
-      this.addResult('build', 'Build process validated', 'success');
-    } catch (error) {
-      throw new Error(`Build validation failed: ${error.message}`);
-    }
-  }
-
-  // Utility methods
-
-  async executeWithRetry(command, timeout = this.timeout) {
-    for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-      try {
-        const {
-          stdout
-        } = await execAsync(command, {
-          encoding: 'utf8',
-          stdio: 'pipe',
-          timeout
-        });
-        return stdout;
-      } catch (error) {
-        if (attempt === this.retryAttempts) {
-          throw error;
-        }
-        await new Promise(resolve => setTimeout(resolve, this.retryDelay));
-      }
-    }
-  }
-  addResult(category, message, level) {
-    this.results.details.push({
-      category,
-      message,
-      level,
-      timestamp: new Date()
-    });
-    if (level === 'warning') {
-      this.results.warnings.push(message);
-    } else if (level === 'error') {
-      this.results.errors.push(message);
-    }
-  }
-  addWarning(category, message) {
-    this.addResult(category, message, 'warning');
-  }
-  printValidationSummary() {
-    console.log('\n📊 VALIDATION SUMMARY');
-    console.log('====================');
-    Object.entries(this.results.categories).forEach(([category, status]) => {
-      const icon = status === 'passed' ? '✅' : status === 'failed' ? '❌' : '⏳';
-      console.log(`${icon} ${category}: ${status}`);
-    });
-    if (this.results.warnings.length > 0) {
-      console.log(`\n⚠️ Warnings: ${this.results.warnings.length}`);
-    }
-    if (this.results.errors.length > 0) {
-      console.log(`\n❌ Errors: ${this.results.errors.length}`);
-    }
-    const duration = this.results.endTime ? ((this.results.endTime - this.results.startTime) / 1000).toFixed(1) : 'N/A';
-    console.log(`\n⏱️ Duration: ${duration}s`);
-  }
-}
-export default DeploymentValidator;