@onlineapps/conn-orch-validator 2.0.0

package/src/validators/ServiceStructureValidator.js

@@ -0,0 +1,487 @@
+/**
+ * Service Structure Validator
+ *
+ * Validates that a business service has correct directory structure,
+ * configuration files, and follows OA Drive standards.
+ *
+ * Used by test helpers to provide clear error messages when something is wrong.
+ *
+ * @module validators/ServiceStructureValidator
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+class ServiceStructureValidator {
+  constructor(serviceRoot) {
+    this.serviceRoot = serviceRoot;
+    this.errors = [];
+    this.warnings = [];
+    this.info = [];
+  }
+
+  /**
+   * Validate complete service structure
+   *
+   * @returns {Object} Validation result
+   */
+  validate() {
+    this.errors = [];
+    this.warnings = [];
+    this.info = [];
+
+    this.info.push(`Validating service structure: ${this.serviceRoot}`);
+
+    // 1. Validate directory structure
+    this.validateDirectoryStructure();
+
+    // 2. Validate configuration files
+    this.validateConfigurationFiles();
+
+    // 3. Validate package.json
+    this.validatePackageJson();
+
+    // 4. Validate source code structure
+    this.validateSourceStructure();
+
+    // 5. Validate test structure
+    this.validateTestStructure();
+
+    const valid = this.errors.length === 0;
+
+    return {
+      valid,
+      errors: this.errors,
+      warnings: this.warnings,
+      info: this.info
+    };
+  }
+
+  /**
+   * Validate directory structure exists
+   */
+  validateDirectoryStructure() {
+    const requiredDirs = [
+      { path: 'conn-config', description: 'Configuration directory' },
+      { path: 'src', description: 'Source code directory' },
+      { path: 'tests', description: 'Tests directory' }
+    ];
+
+    const recommendedDirs = [
+      { path: 'tests/unit', description: 'Unit tests' },
+      { path: 'tests/integration', description: 'Integration tests' },
+      { path: 'tests/cookbooks', description: 'Cookbook tests' }
+    ];
+
+    for (const dir of requiredDirs) {
+      const fullPath = path.join(this.serviceRoot, dir.path);
+      if (!fs.existsSync(fullPath)) {
+        this.errors.push({
+          type: 'MISSING_DIRECTORY',
+          path: dir.path,
+          message: `Required directory missing: ${dir.path}`,
+          description: dir.description,
+          fix: `Create directory: mkdir -p ${dir.path}`
+        });
+      } else {
+        this.info.push(`✓ Found ${dir.description}: ${dir.path}`);
+      }
+    }
+
+    for (const dir of recommendedDirs) {
+      const fullPath = path.join(this.serviceRoot, dir.path);
+      if (!fs.existsSync(fullPath)) {
+        this.warnings.push({
+          type: 'MISSING_RECOMMENDED_DIRECTORY',
+          path: dir.path,
+          message: `Recommended directory missing: ${dir.path}`,
+          description: dir.description,
+          fix: `Create directory: mkdir -p ${dir.path}`
+        });
+      }
+    }
+  }
+
+  /**
+   * Validate configuration files
+   */
+  validateConfigurationFiles() {
+    // 1. Validate conn-config/config.json
+    const configPath = path.join(this.serviceRoot, 'conn-config/config.json');
+    if (!fs.existsSync(configPath)) {
+      this.errors.push({
+        type: 'MISSING_CONFIG',
+        path: 'conn-config/config.json',
+        message: 'Service configuration missing: conn-config/config.json',
+        fix: 'Create config.json with service metadata. See: /docs/standards/SERVICE_TEMPLATE.md'
+      });
+    } else {
+      try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        this.validateConfigStructure(config);
+        this.info.push('✓ Found valid config.json');
+      } catch (error) {
+        this.errors.push({
+          type: 'INVALID_CONFIG',
+          path: 'conn-config/config.json',
+          message: `Invalid JSON in config.json: ${error.message}`,
+          fix: 'Fix JSON syntax errors in config.json'
+        });
+      }
+    }
+
+    // 2. Validate conn-config/operations.json
+    const operationsPath = path.join(this.serviceRoot, 'conn-config/operations.json');
+    if (!fs.existsSync(operationsPath)) {
+      this.errors.push({
+        type: 'MISSING_OPERATIONS',
+        path: 'conn-config/operations.json',
+        message: 'Operations specification missing: conn-config/operations.json',
+        fix: 'Create operations.json. See: /docs/standards/OPERATIONS.md'
+      });
+    } else {
+      try {
+        const operations = JSON.parse(fs.readFileSync(operationsPath, 'utf-8'));
+        this.validateOperationsStructure(operations);
+        this.info.push('✓ Found valid operations.json');
+      } catch (error) {
+        this.errors.push({
+          type: 'INVALID_OPERATIONS',
+          path: 'conn-config/operations.json',
+          message: `Invalid JSON in operations.json: ${error.message}`,
+          fix: 'Fix JSON syntax errors in operations.json'
+        });
+      }
+    }
+  }
+
+  /**
+   * Validate config.json structure
+   */
+  validateConfigStructure(config) {
+    // Required fields
+    const requiredFields = [
+      'service.name',
+      'service.version',
+      'service.port'
+    ];
+
+    for (const field of requiredFields) {
+      const parts = field.split('.');
+      let value = config;
+      for (const part of parts) {
+        value = value?.[part];
+      }
+
+      if (!value) {
+        this.errors.push({
+          type: 'MISSING_CONFIG_FIELD',
+          path: 'conn-config/config.json',
+          field: field,
+          message: `Required field missing in config.json: ${field}`,
+          fix: `Add "${field}" to config.json`
+        });
+      }
+    }
+
+    // Validate service name format
+    if (config.service?.name) {
+      if (!/^[a-z][a-z0-9-]*$/.test(config.service.name)) {
+        this.warnings.push({
+          type: 'INVALID_SERVICE_NAME',
+          path: 'conn-config/config.json',
+          field: 'service.name',
+          value: config.service.name,
+          message: `Service name should be lowercase kebab-case: ${config.service.name}`,
+          fix: 'Use lowercase letters, numbers, and hyphens only (e.g., "my-service")'
+        });
+      }
+    }
+
+    // Validate version format
+    if (config.service?.version) {
+      if (!/^\d+\.\d+\.\d+$/.test(config.service.version)) {
+        this.warnings.push({
+          type: 'INVALID_VERSION',
+          path: 'conn-config/config.json',
+          field: 'service.version',
+          value: config.service.version,
+          message: `Version should follow semantic versioning: ${config.service.version}`,
+          fix: 'Use format: MAJOR.MINOR.PATCH (e.g., "1.0.0")'
+        });
+      }
+    }
+  }
+
+  /**
+   * Validate operations.json structure
+   */
+  validateOperationsStructure(operations) {
+    if (!operations.operations) {
+      this.errors.push({
+        type: 'INVALID_OPERATIONS_STRUCTURE',
+        path: 'conn-config/operations.json',
+        message: 'operations.json must have "operations" key',
+        fix: 'Wrap operations in {"operations": {...}}. See: /docs/standards/OPERATIONS.md'
+      });
+      return;
+    }
+
+    const ops = operations.operations;
+    if (typeof ops !== 'object' || Array.isArray(ops)) {
+      this.errors.push({
+        type: 'INVALID_OPERATIONS_TYPE',
+        path: 'conn-config/operations.json',
+        message: 'operations must be an object',
+        fix: 'operations should be key-value pairs: {"operation-name": {...}}'
+      });
+      return;
+    }
+
+    if (Object.keys(ops).length === 0) {
+      this.warnings.push({
+        type: 'NO_OPERATIONS',
+        path: 'conn-config/operations.json',
+        message: 'No operations defined',
+        fix: 'Add at least one operation to operations.json'
+      });
+      return;
+    }
+
+    // Validate each operation
+    for (const [operationName, operationSpec] of Object.entries(ops)) {
+      this.validateOperation(operationName, operationSpec);
+    }
+  }
+
+  /**
+   * Validate single operation structure
+   */
+  validateOperation(name, spec) {
+    const requiredFields = ['endpoint', 'method'];
+
+    for (const field of requiredFields) {
+      if (!spec[field]) {
+        this.errors.push({
+          type: 'MISSING_OPERATION_FIELD',
+          path: 'conn-config/operations.json',
+          operation: name,
+          field: field,
+          message: `Operation "${name}" missing required field: ${field}`,
+          fix: `Add "${field}" to operation "${name}"`
+        });
+      }
+    }
+
+    // Validate endpoint format
+    if (spec.endpoint && !spec.endpoint.startsWith('/')) {
+      this.errors.push({
+        type: 'INVALID_ENDPOINT',
+        path: 'conn-config/operations.json',
+        operation: name,
+        field: 'endpoint',
+        value: spec.endpoint,
+        message: `Endpoint must start with /: ${spec.endpoint}`,
+        fix: `Change endpoint to: /${spec.endpoint}`
+      });
+    }
+
+    // Validate HTTP method
+    const validMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
+    if (spec.method && !validMethods.includes(spec.method)) {
+      this.errors.push({
+        type: 'INVALID_HTTP_METHOD',
+        path: 'conn-config/operations.json',
+        operation: name,
+        field: 'method',
+        value: spec.method,
+        message: `Invalid HTTP method: ${spec.method}`,
+        fix: `Use one of: ${validMethods.join(', ')}`
+      });
+    }
+  }
+
+  /**
+   * Validate package.json
+   */
+  validatePackageJson() {
+    const packagePath = path.join(this.serviceRoot, 'package.json');
+    if (!fs.existsSync(packagePath)) {
+      this.errors.push({
+        type: 'MISSING_PACKAGE_JSON',
+        path: 'package.json',
+        message: 'package.json missing',
+        fix: 'Create package.json: npm init'
+      });
+      return;
+    }
+
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+
+      // Check for required scripts
+      const recommendedScripts = [
+        { name: 'test', description: 'Run tests' },
+        { name: 'test:unit', description: 'Run unit tests' },
+        { name: 'test:integration', description: 'Run integration tests' },
+        { name: 'test:cookbooks', description: 'Run pre-validation cookbook tests' }
+      ];
+
+      for (const script of recommendedScripts) {
+        if (!pkg.scripts?.[script.name]) {
+          this.warnings.push({
+            type: 'MISSING_NPM_SCRIPT',
+            path: 'package.json',
+            script: script.name,
+            message: `Recommended npm script missing: ${script.name}`,
+            description: script.description,
+            fix: `Add to package.json scripts: "${script.name}": "..."`
+          });
+        }
+      }
+
+      // Check for @onlineapps dependencies
+      const requiredDeps = [
+        '@onlineapps/service-wrapper',
+        '@onlineapps/conn-orch-validator'
+      ];
+
+      for (const dep of requiredDeps) {
+        const hasDep = pkg.dependencies?.[dep] || pkg.devDependencies?.[dep];
+        if (!hasDep) {
+          this.warnings.push({
+            type: 'MISSING_DEPENDENCY',
+            path: 'package.json',
+            dependency: dep,
+            message: `Recommended dependency missing: ${dep}`,
+            fix: `Install: npm install ${dep}`
+          });
+        }
+      }
+
+      this.info.push('✓ Found valid package.json');
+    } catch (error) {
+      this.errors.push({
+        type: 'INVALID_PACKAGE_JSON',
+        path: 'package.json',
+        message: `Invalid JSON in package.json: ${error.message}`,
+        fix: 'Fix JSON syntax errors in package.json'
+      });
+    }
+  }
+
+  /**
+   * Validate source code structure
+   */
+  validateSourceStructure() {
+    const appPath = path.join(this.serviceRoot, 'src/app.js');
+    if (!fs.existsSync(appPath)) {
+      this.errors.push({
+        type: 'MISSING_APP',
+        path: 'src/app.js',
+        message: 'Express application missing: src/app.js',
+        fix: 'Create src/app.js with Express app. See: /docs/standards/SERVICE_TEMPLATE.md'
+      });
+    } else {
+      this.info.push('✓ Found src/app.js');
+    }
+
+    const indexPath = path.join(this.serviceRoot, 'index.js');
+    if (!fs.existsSync(indexPath)) {
+      this.warnings.push({
+        type: 'MISSING_INDEX',
+        path: 'index.js',
+        message: 'Entry point missing: index.js',
+        fix: 'Create index.js as service entry point'
+      });
+    }
+  }
+
+  /**
+   * Validate test structure
+   */
+  validateTestStructure() {
+    const cookbooksPath = path.join(this.serviceRoot, 'tests/cookbooks');
+    if (fs.existsSync(cookbooksPath)) {
+      const cookbookFiles = fs.readdirSync(cookbooksPath).filter(f => f.endsWith('.json'));
+      if (cookbookFiles.length === 0) {
+        this.warnings.push({
+          type: 'NO_COOKBOOK_TESTS',
+          path: 'tests/cookbooks',
+          message: 'No cookbook tests found in tests/cookbooks/',
+          fix: 'Create cookbook tests for pre-validation. See: /docs/standards/TESTING.md'
+        });
+      } else {
+        this.info.push(`✓ Found ${cookbookFiles.length} cookbook test(s)`);
+      }
+    }
+  }
+
+  /**
+   * Format validation result as readable message
+   */
+  static formatResult(result) {
+    const lines = [];
+
+    lines.push('');
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('  SERVICE STRUCTURE VALIDATION');
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+
+    if (result.errors.length === 0 && result.warnings.length === 0) {
+      lines.push('✅ ALL CHECKS PASSED');
+      lines.push('');
+      for (const info of result.info) {
+        lines.push(`   ${info}`);
+      }
+    } else {
+      // Errors
+      if (result.errors.length > 0) {
+        lines.push(`❌ ERRORS (${result.errors.length}):`);
+        lines.push('');
+        for (const error of result.errors) {
+          lines.push(`   ✗ ${error.message}`);
+          lines.push(`     Type: ${error.type}`);
+          if (error.path) lines.push(`     File: ${error.path}`);
+          if (error.field) lines.push(`     Field: ${error.field}`);
+          if (error.value) lines.push(`     Value: ${error.value}`);
+          lines.push(`     Fix: ${error.fix}`);
+          lines.push('');
+        }
+      }
+
+      // Warnings
+      if (result.warnings.length > 0) {
+        lines.push(`⚠️  WARNINGS (${result.warnings.length}):`);
+        lines.push('');
+        for (const warning of result.warnings) {
+          lines.push(`   ⚠ ${warning.message}`);
+          if (warning.fix) {
+            lines.push(`     Suggestion: ${warning.fix}`);
+          }
+          lines.push('');
+        }
+      }
+
+      // Info
+      if (result.info.length > 0) {
+        lines.push('ℹ️  INFO:');
+        lines.push('');
+        for (const info of result.info) {
+          lines.push(`   ${info}`);
+        }
+        lines.push('');
+      }
+    }
+
+    lines.push('═══════════════════════════════════════════════════════════════');
+    lines.push('');
+
+    return lines.join('\n');
+  }
+}
+
+module.exports = { ServiceStructureValidator };

package/src/validators/ValidationProofGenerator.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const { ValidationProofCodec } = require('@onlineapps/service-validator-core');
+
+/**
+ * ValidationProofGenerator - Generates validation proof from test results
+ *
+ * This is a THIN WRAPPER for use in testing workflows.
+ * All encoding logic is delegated to ValidationProofCodec.
+ *
+ * Responsibility: Bridge between test results and proof generation
+ * - Accept test results in test framework format
+ * - Transform to ValidationProofSchema format
+ * - Delegate encoding to ValidationProofCodec
+ */
+class ValidationProofGenerator {
+  constructor(options = {}) {
+    this.serviceName = options.serviceName;
+    this.serviceVersion = options.serviceVersion;
+    this.validatorName = options.validatorName || '@onlineapps/conn-orch-validator';
+    this.validatorVersion = options.validatorVersion || '1.0.0';
+  }
+
+  /**
+   * Generate validation proof from test results
+   *
+   * @param {Object} testResults - Results from test execution
+   * @param {Object} dependencies - Service dependencies with versions
+   * @returns {Object} Validation proof with metadata
+   */
+  generateProof(testResults, dependencies = {}) {
+    // Transform test results to ValidationProofSchema format
+    const validationData = {
+      serviceName: this.serviceName,
+      version: this.serviceVersion,
+      validator: this.validatorName,
+      validatorVersion: this.validatorVersion,
+      validatedAt: new Date().toISOString(),
+      durationMs: testResults.duration || 0,
+      testsRun: testResults.total || 0,
+      testsPassed: testResults.passed || 0,
+      testsFailed: testResults.failed || 0,
+      dependencies: dependencies || {}
+    };
+
+    // Delegate encoding to centralized codec
+    // This ensures Generator and Verifier use EXACTLY the same algorithm
+    return ValidationProofCodec.encode(validationData);
+  }
+
+  /**
+   * Extract test results summary
+   */
+  extractTestSummary(testResults) {
+    return {
+      total: testResults.total || 0,
+      passed: testResults.passed || 0,
+      failed: testResults.failed || 0,
+      duration: testResults.duration || 0,
+      coverage: testResults.coverage || 0
+    };
+  }
+
+  /**
+   * Create validation error
+   */
+  createValidationError(code, message, details = {}) {
+    return {
+      error: {
+        code,
+        message,
+        details,
+        timestamp: new Date().toISOString()
+      }
+    };
+  }
+}
+
+module.exports = ValidationProofGenerator;

package/test-mq-flow.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Simple test script to verify MQ message flow
+ * Usage: node test-mq-flow.js
+ */
+
+const amqp = require('amqplib');
+
+async function sendTestMessage() {
+  const rabbitUrl = 'amqp://guest:guest@localhost:33023';
+  const queueName = 'hello-service.workflow';
+
+  try {
+    // Connect to RabbitMQ
+    const connection = await amqp.connect(rabbitUrl);
+    const channel = await connection.createChannel();
+
+    // Ensure queue exists
+    await channel.assertQueue(queueName, { durable: true });
+
+    // Create test message with cookbook
+    const testMessage = {
+      workflow_id: `test-${Date.now()}`,
+      cookbook: {
+        name: 'test-workflow',
+        version: '1.0.0',
+        steps: [
+          {
+            id: 'goodDay',  // ID se použije jako operation name
+            type: 'task',
+            service: 'hello-service',
+            input: {
+              name: 'E2E Test'
+            }
+          }
+        ]
+      },
+      current_step: 'step1',
+      step_index: 0,
+      context: {}
+    };
+
+    console.log('Sending test message:', JSON.stringify(testMessage, null, 2));
+
+    // Send message
+    channel.sendToQueue(
+      queueName,
+      Buffer.from(JSON.stringify(testMessage)),
+      { persistent: true }
+    );
+
+    console.log(`Message sent to queue: ${queueName}`);
+
+    // Wait a bit to ensure message is sent
+    await new Promise(resolve => setTimeout(resolve, 1000));
+
+    // Clean up
+    await channel.close();
+    await connection.close();
+
+    console.log('Test completed successfully');
+
+  } catch (error) {
+    console.error('Test failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run the test
+sendTestMessage();