@onlineapps/conn-orch-validator 2.0.0

package/src/ValidationOrchestrator.js

@@ -0,0 +1,506 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { ValidationProofCodec, FingerprintUtils } = require('@onlineapps/service-validator-core');
+const { ServiceStructureValidator } = require('./validators/ServiceStructureValidator');
+const ServiceReadinessValidator = require('./ServiceReadinessValidator');
+const CookbookTestRunner = require('./CookbookTestRunner');
+
+/**
+ * ValidationOrchestrator
+ *
+ * Orchestrates complete service validation (Tier 1 Pre-Validation)
+ * Runs 6-step validation process and generates validation proof.
+ *
+ * Called automatically by ServiceWrapper during initialization.
+ */
+class ValidationOrchestrator {
+  constructor(options = {}) {
+    this.serviceRoot = options.serviceRoot;
+    this.serviceName = options.serviceName;
+    this.serviceVersion = options.serviceVersion;
+    this.logger = options.logger || console;
+
+    // Paths
+    this.configPath = path.join(this.serviceRoot, 'conn-config');
+    this.runtimePath = path.join(this.serviceRoot, 'conn-runtime');
+    this.proofPath = path.join(this.runtimePath, 'validation-proof.json');
+
+    // Validators
+    this.structureValidator = new ServiceStructureValidator(this.serviceRoot);
+    this.readinessValidator = new ServiceReadinessValidator();
+    this.cookbookRunner = new CookbookTestRunner({
+      servicePath: this.serviceRoot,
+      serviceName: this.serviceName
+    });
+  }
+
+  /**
+   * Main validation entry point
+   * Checks if proof exists and is valid, or runs full validation
+   */
+  async validate() {
+    this.logger.info('[ValidationOrchestrator] Starting validation...');
+
+    // Check if proof exists and is valid
+    const existingProof = await this.loadExistingProof();
+    if (existingProof && await this.isProofValid(existingProof)) {
+      this.logger.info('[ValidationOrchestrator] ✓ Valid proof found, skipping validation');
+      return {
+        success: true,
+        proofExists: true,
+        proof: existingProof,
+        skipped: true
+      };
+    }
+
+    // Run full validation
+    this.logger.info('[ValidationOrchestrator] No valid proof, running validation...');
+    return await this.runFullValidation();
+  }
+
+  /**
+   * Load existing validation proof from conn-runtime/
+   */
+  async loadExistingProof() {
+    try {
+      if (!fs.existsSync(this.proofPath)) {
+        return null;
+      }
+
+      const content = fs.readFileSync(this.proofPath, 'utf8');
+      const proof = JSON.parse(content);
+
+      return proof;
+    } catch (error) {
+      this.logger.warn(`[ValidationOrchestrator] Failed to load proof: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Check if proof is still valid
+   * Valid = correct fingerprint + not expired
+   */
+  async isProofValid(proof) {
+    try {
+      // Calculate current fingerprint
+      const currentFingerprint = await this.calculateFingerprint();
+
+      // Check if fingerprint matches
+      if (proof.fingerprint !== currentFingerprint) {
+        this.logger.info('[ValidationOrchestrator] Fingerprint mismatch (service changed)');
+        return false;
+      }
+
+      // Check expiration (proof valid for 30 days)
+      const proofDate = new Date(proof.validatedAt);
+      const now = new Date();
+      const daysSinceValidation = (now - proofDate) / (1000 * 60 * 60 * 24);
+
+      if (daysSinceValidation > 30) {
+        this.logger.info('[ValidationOrchestrator] Proof expired (>30 days old)');
+        return false;
+      }
+
+      // Verify proof signature
+      const isValid = ValidationProofCodec.verify(proof);
+      if (!isValid) {
+        this.logger.warn('[ValidationOrchestrator] Proof signature invalid');
+        return false;
+      }
+
+      return true;
+    } catch (error) {
+      this.logger.error(`[ValidationOrchestrator] Proof validation error: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Calculate service fingerprint
+   * Based on: version + operations.json + dependencies + config
+   */
+  async calculateFingerprint() {
+    try {
+      const configFile = path.join(this.configPath, 'config.json');
+      const operationsFile = path.join(this.configPath, 'operations.json');
+      const packageFile = path.join(this.serviceRoot, 'package.json');
+
+      const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+      const operations = JSON.parse(fs.readFileSync(operationsFile, 'utf8'));
+      const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+
+      // Extract @onlineapps/* dependencies
+      const deps = {};
+      if (pkg.dependencies) {
+        Object.keys(pkg.dependencies).forEach(name => {
+          if (name.startsWith('@onlineapps/')) {
+            deps[name] = pkg.dependencies[name];
+          }
+        });
+      }
+
+      return FingerprintUtils.calculate({
+        serviceVersion: config.service?.version || pkg.version,
+        operations: operations,
+        dependencies: deps,
+        configHash: FingerprintUtils.hashObject(config)
+      });
+    } catch (error) {
+      throw new Error(`Failed to calculate fingerprint: ${error.message}`);
+    }
+  }
+
+  /**
+   * Run full 6-step validation process
+   */
+  async runFullValidation() {
+    const startTime = Date.now();
+    const results = {
+      success: true,
+      steps: {},
+      errors: [],
+      warnings: [],
+      totalTests: 0,
+      passedTests: 0,
+      failedTests: 0
+    };
+
+    try {
+      // Step 1: Service Structure
+      this.logger.info('[ValidationOrchestrator] Step 1/6: Service Structure');
+      results.steps.structure = await this.validateStructure();
+      if (!results.steps.structure.valid) {
+        results.success = false;
+        results.errors.push(...results.steps.structure.errors);
+        // Fail fast - can't continue without proper structure
+        return this.finalizeResults(results, startTime);
+      }
+
+      // Step 2: Config Files
+      this.logger.info('[ValidationOrchestrator] Step 2/6: Config Files');
+      results.steps.config = await this.validateConfig();
+      if (!results.steps.config.valid) {
+        results.success = false;
+        results.errors.push(...results.steps.config.errors);
+      }
+
+      // Step 3: Operations Compliance
+      this.logger.info('[ValidationOrchestrator] Step 3/6: Operations Compliance');
+      results.steps.operations = await this.validateOperations();
+      if (!results.steps.operations.valid) {
+        results.success = false;
+        results.errors.push(...results.steps.operations.errors);
+      }
+
+      // Step 4: Cookbook Tests
+      this.logger.info('[ValidationOrchestrator] Step 4/6: Cookbook Tests');
+      results.steps.cookbooks = await this.runCookbookTests();
+      results.totalTests += results.steps.cookbooks.total || 0;
+      results.passedTests += results.steps.cookbooks.passed || 0;
+      results.failedTests += results.steps.cookbooks.failed || 0;
+      if (!results.steps.cookbooks.success) {
+        results.success = false;
+        results.errors.push(...(results.steps.cookbooks.errors || []));
+      }
+
+      // Step 5: Service Readiness
+      this.logger.info('[ValidationOrchestrator] Step 5/6: Service Readiness');
+      results.steps.readiness = await this.validateReadiness();
+      if (!results.steps.readiness.valid) {
+        results.success = false;
+        results.errors.push(...results.steps.readiness.errors);
+      }
+
+      // Step 6: Connector Integration
+      this.logger.info('[ValidationOrchestrator] Step 6/6: Connector Integration');
+      results.steps.connectors = this.validateConnectors();
+      if (!results.steps.connectors.valid) {
+        // Non-critical - just warnings
+        results.warnings.push(...results.steps.connectors.warnings);
+      }
+
+      // Finalize and generate proof if successful
+      return await this.finalizeResults(results, startTime);
+
+    } catch (error) {
+      this.logger.error(`[ValidationOrchestrator] Validation failed: ${error.message}`);
+      results.success = false;
+      results.errors.push(`Validation error: ${error.message}`);
+      return this.finalizeResults(results, startTime);
+    }
+  }
+
+  /**
+   * Step 1: Validate service structure
+   */
+  async validateStructure() {
+    try {
+      const result = this.structureValidator.validate();
+
+      this.logger.info(`[ValidationOrchestrator] ✓ Service structure: ${result.valid ? 'PASS' : 'FAIL'}`);
+      return result;
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [`Structure validation failed: ${error.message}`]
+      };
+    }
+  }
+
+  /**
+   * Step 2: Validate config files
+   */
+  async validateConfig() {
+    const errors = [];
+
+    try {
+      // Validate config.json
+      const configFile = path.join(this.configPath, 'config.json');
+      if (!fs.existsSync(configFile)) {
+        errors.push('config.json not found');
+      } else {
+        const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+        if (!config.service?.name) errors.push('config.json missing service.name');
+        if (!config.service?.version) errors.push('config.json missing service.version');
+      }
+
+      // Validate operations.json
+      const operationsFile = path.join(this.configPath, 'operations.json');
+      if (!fs.existsSync(operationsFile)) {
+        errors.push('operations.json not found');
+      } else {
+        const operations = JSON.parse(fs.readFileSync(operationsFile, 'utf8'));
+        if (!operations.operations || Object.keys(operations.operations).length === 0) {
+          errors.push('operations.json has no operations defined');
+        }
+      }
+
+      this.logger.info(`[ValidationOrchestrator] ✓ Config files: ${errors.length === 0 ? 'PASS' : 'FAIL'}`);
+      return {
+        valid: errors.length === 0,
+        errors: errors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [`Config validation failed: ${error.message}`]
+      };
+    }
+  }
+
+  /**
+   * Step 3: Validate operations compliance
+   */
+  async validateOperations() {
+    try {
+      const operationsFile = path.join(this.configPath, 'operations.json');
+      const operations = JSON.parse(fs.readFileSync(operationsFile, 'utf8'));
+      const errors = [];
+
+      // Validate each operation
+      for (const [opName, opDef] of Object.entries(operations.operations || {})) {
+        if (!opDef.endpoint) {
+          errors.push(`Operation ${opName}: missing endpoint`);
+        } else if (!opDef.endpoint.startsWith('/')) {
+          errors.push(`Operation ${opName}: endpoint must start with /`);
+        }
+
+        if (!opDef.method) {
+          errors.push(`Operation ${opName}: missing method`);
+        } else if (!['GET', 'POST', 'PUT', 'DELETE', 'PATCH'].includes(opDef.method)) {
+          errors.push(`Operation ${opName}: invalid HTTP method`);
+        }
+
+        if (!opDef.input) {
+          errors.push(`Operation ${opName}: missing input schema`);
+        }
+        if (!opDef.output) {
+          errors.push(`Operation ${opName}: missing output schema`);
+        }
+      }
+
+      this.logger.info(`[ValidationOrchestrator] ✓ Operations compliance: ${errors.length === 0 ? 'PASS' : 'FAIL'}`);
+      return {
+        valid: errors.length === 0,
+        errors: errors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [`Operations validation failed: ${error.message}`]
+      };
+    }
+  }
+
+  /**
+   * Step 4: Run cookbook tests
+   */
+  async runCookbookTests() {
+    try {
+      const cookbooksPath = path.join(this.serviceRoot, 'tests', 'cookbooks');
+
+      if (!fs.existsSync(cookbooksPath)) {
+        this.logger.warn('[ValidationOrchestrator] No cookbook tests found (tests/cookbooks/ missing)');
+        return {
+          success: true,
+          total: 0,
+          passed: 0,
+          failed: 0,
+          warnings: ['No cookbook tests found']
+        };
+      }
+
+      const result = await this.cookbookRunner.runCookbooks(cookbooksPath);
+
+      this.logger.info(`[ValidationOrchestrator] ✓ Cookbook tests: ${result.passed}/${result.total} passed`);
+      return {
+        success: result.failed === 0,
+        total: result.total,
+        passed: result.passed,
+        failed: result.failed,
+        errors: result.failed > 0 ? [`${result.failed} cookbook test(s) failed`] : []
+      };
+    } catch (error) {
+      return {
+        success: false,
+        total: 0,
+        passed: 0,
+        failed: 0,
+        errors: [`Cookbook tests failed: ${error.message}`]
+      };
+    }
+  }
+
+  /**
+   * Step 5: Validate service readiness
+   */
+  async validateReadiness() {
+    try {
+      // Load operations.json
+      const operationsFile = path.join(this.configPath, 'operations.json');
+      const operations = JSON.parse(fs.readFileSync(operationsFile, 'utf8'));
+
+      const result = await this.readinessValidator.validateReadiness({
+        serviceRoot: this.serviceRoot,
+        serviceName: this.serviceName,
+        operations: operations.operations
+      });
+
+      this.logger.info(`[ValidationOrchestrator] ✓ Service readiness: ${result.ready ? 'PASS' : 'FAIL'}`);
+      return {
+        valid: result.ready,
+        errors: result.ready ? [] : result.errors || ['Service not ready']
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [`Readiness validation failed: ${error.message}`]
+      };
+    }
+  }
+
+  /**
+   * Step 6: Validate connector integration
+   */
+  validateConnectors() {
+    try {
+      // This is validated implicitly through cookbook tests
+      // which test ServiceWrapper + all connectors
+
+      this.logger.info('[ValidationOrchestrator] ✓ Connector integration: PASS (via cookbook tests)');
+      return {
+        valid: true,
+        warnings: []
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        warnings: [`Connector validation warning: ${error.message}`]
+      };
+    }
+  }
+
+  /**
+   * Finalize validation results and generate proof if successful
+   */
+  async finalizeResults(results, startTime) {
+    const duration = Date.now() - startTime;
+    results.durationMs = duration;
+
+    if (results.success) {
+      try {
+        // Generate validation proof
+        const fingerprint = await this.calculateFingerprint();
+        const proof = {
+          serviceName: this.serviceName,
+          serviceVersion: this.serviceVersion,
+          fingerprint: fingerprint,
+          validator: '@onlineapps/conn-orch-validator',
+          validatorVersion: require('../package.json').version,
+          validatedAt: new Date().toISOString(),
+          testsRun: results.totalTests,
+          testsPassed: results.passedTests,
+          testsFailed: results.failedTests,
+          durationMs: duration,
+          steps: {
+            structure: results.steps.structure?.valid || false,
+            config: results.steps.config?.valid || false,
+            operations: results.steps.operations?.valid || false,
+            cookbooks: results.steps.cookbooks?.success || false,
+            readiness: results.steps.readiness?.valid || false,
+            connectors: results.steps.connectors?.valid || false
+          }
+        };
+
+        // Encode proof using ValidationProofCodec
+        const encodedProof = ValidationProofCodec.encode(proof);
+
+        // Save proof to conn-runtime/
+        await this.saveProof(encodedProof);
+
+        results.proof = encodedProof;
+        results.fingerprint = fingerprint;
+
+        this.logger.info(`[ValidationOrchestrator] ✅ Validation PASSED (${duration}ms)`);
+        this.logger.info(`[ValidationOrchestrator] Proof saved to: ${this.proofPath}`);
+      } catch (error) {
+        this.logger.error(`[ValidationOrchestrator] Failed to generate proof: ${error.message}`);
+        results.success = false;
+        results.errors.push(`Proof generation failed: ${error.message}`);
+      }
+    } else {
+      this.logger.error(`[ValidationOrchestrator] ❌ Validation FAILED (${duration}ms)`);
+      this.logger.error(`[ValidationOrchestrator] Errors: ${results.errors.join(', ')}`);
+    }
+
+    return results;
+  }
+
+  /**
+   * Save validation proof to conn-runtime/validation-proof.json
+   */
+  async saveProof(proof) {
+    try {
+      // Ensure conn-runtime/ directory exists
+      if (!fs.existsSync(this.runtimePath)) {
+        fs.mkdirSync(this.runtimePath, { recursive: true });
+
+        // Create .gitkeep
+        const gitkeepPath = path.join(this.runtimePath, '.gitkeep');
+        fs.writeFileSync(gitkeepPath, '# Runtime data generated by connectors\n');
+      }
+
+      // Save proof
+      fs.writeFileSync(this.proofPath, JSON.stringify(proof, null, 2));
+
+      this.logger.info(`[ValidationOrchestrator] Proof saved: ${this.proofPath}`);
+    } catch (error) {
+      throw new Error(`Failed to save proof: ${error.message}`);
+    }
+  }
+}
+
+module.exports = ValidationOrchestrator;