@onlineapps/conn-orch-validator 2.0.32 → 2.0.34

package/src/ServiceValidator.js

@@ -1,399 +0,0 @@
-'use strict';
-
-const axios = require('axios');
-const Ajv = require('ajv');
-const addFormats = require('ajv-formats');
-
-/**
- * ServiceValidator - Validates service compliance with OpenAPI spec
- */
-class ServiceValidator {
-  constructor(options = {}) {
-    this.ajv = new Ajv({ allErrors: true, strict: false });
-    addFormats(this.ajv);
-    this.timeout = options.timeout || 5000;
-  }
-
-  /**
-   * Validate service against OpenAPI specification
-   */
-  async validateService(serviceUrl, openApiSpec) {
-    const results = {
-      valid: true,
-      errors: [],
-      warnings: [],
-      testedEndpoints: [],
-      coverage: 0
-    };
-
-    if (!openApiSpec.paths) {
-      results.valid = false;
-      results.errors.push('No paths defined in OpenAPI spec');
-      return results;
-    }
-
-    const totalEndpoints = this.countEndpoints(openApiSpec.paths);
-    let testedCount = 0;
-
-    // Test each endpoint
-    for (const [path, pathItem] of Object.entries(openApiSpec.paths)) {
-      for (const [method, operation] of Object.entries(pathItem)) {
-        if (method === 'parameters' || method.startsWith('x-')) continue;
-
-        const endpointResult = await this.testEndpoint(
-          serviceUrl,
-          path,
-          method,
-          operation
-        );
-
-        results.testedEndpoints.push(endpointResult);
-        if (!endpointResult.valid) {
-          results.valid = false;
-          results.errors.push(...endpointResult.errors);
-        }
-        if (endpointResult.warnings) {
-          results.warnings.push(...endpointResult.warnings);
-        }
-        testedCount++;
-      }
-    }
-
-    results.coverage = (testedCount / totalEndpoints) * 100;
-    return results;
-  }
-
-  /**
-   * Test individual endpoint
-   */
-  async testEndpoint(serviceUrl, path, method, operation) {
-    const result = {
-      path,
-      method: method.toUpperCase(),
-      operationId: operation.operationId,
-      valid: true,
-      errors: [],
-      warnings: [],
-      response: null
-    };
-
-    try {
-      // Build test request
-      const testRequest = this.buildTestRequest(path, method, operation);
-      const url = `${serviceUrl}${testRequest.path}`;
-
-      // Execute request
-      const response = await axios({
-        method: method.toUpperCase(),
-        url,
-        data: testRequest.body,
-        params: testRequest.query,
-        headers: testRequest.headers,
-        timeout: this.timeout,
-        validateStatus: () => true // Don't throw on any status
-      });
-
-      result.response = {
-        status: response.status,
-        headers: response.headers,
-        data: response.data
-      };
-
-      // Validate response
-      this.validateResponse(response, operation, result);
-
-    } catch (error) {
-      result.valid = false;
-      result.errors.push(`Failed to call endpoint: ${error.message}`);
-    }
-
-    return result;
-  }
-
-  /**
-   * Build test request from OpenAPI operation
-   */
-  buildTestRequest(path, method, operation) {
-    const request = {
-      path,
-      headers: {
-        // Validation context: ALWAYS add x-validation-request header to indicate this is a validation probe.
-        // This allows services to return deterministic responses without accessing external resources.
-        'x-validation-request': 'true'
-      },
-      query: {},
-      body: null
-    };
-
-    // Process parameters
-    if (operation.parameters) {
-      operation.parameters.forEach(param => {
-        const testValue = this.generateTestValue(param.schema);
-
-        switch (param.in) {
-          case 'path':
-            request.path = request.path.replace(`{${param.name}}`, testValue);
-            break;
-          case 'query':
-            if (!param.required && Math.random() > 0.5) break;
-            request.query[param.name] = testValue;
-            break;
-          case 'header':
-            if (!param.required && Math.random() > 0.5) break;
-            request.headers[param.name] = testValue;
-            break;
-        }
-      });
-    }
-
-    // Process request body
-    if (operation.requestBody && operation.requestBody.content) {
-      const contentType = Object.keys(operation.requestBody.content)[0];
-      const schema = operation.requestBody.content[contentType].schema;
-      request.headers['Content-Type'] = contentType;
-      request.body = this.generateTestValue(schema);
-    }
-
-    return request;
-  }
-
-  /**
-   * Generate test value based on schema
-   */
-  generateTestValue(schema) {
-    if (!schema) return null;
-
-    switch (schema.type) {
-      case 'string':
-        if (schema.enum) return schema.enum[0];
-        if (schema.format === 'email') return 'test@example.com';
-        if (schema.format === 'date') return '2024-01-01';
-        if (schema.format === 'date-time') return '2024-01-01T00:00:00Z';
-        if (schema.format === 'uuid') return '123e4567-e89b-12d3-a456-426614174000';
-        return schema.example || 'test';
-
-      case 'number':
-      case 'integer':
-        if (schema.minimum !== undefined) return schema.minimum;
-        if (schema.maximum !== undefined) return schema.maximum;
-        return schema.example || 1;
-
-      case 'boolean':
-        return schema.example !== undefined ? schema.example : true;
-
-      case 'array':
-        const itemValue = this.generateTestValue(schema.items);
-        return [itemValue];
-
-      case 'object':
-        const obj = {};
-        if (schema.properties) {
-          const entries = Object.entries(schema.properties);
-          entries.forEach(([key, prop]) => {
-            if (schema.required && schema.required.includes(key)) {
-              obj[key] = this.generateTestValue(prop);
-            } else if (Math.random() > 0.5) {
-              obj[key] = this.generateTestValue(prop);
-            }
-          });
-
-          // If schema has properties but nothing was picked (e.g., no required fields and randomness skipped),
-          // pick the first property to keep requests deterministic and non-empty.
-          if (Object.keys(obj).length === 0 && entries.length > 0) {
-            const [firstKey, firstSchema] = entries[0];
-            obj[firstKey] = this.generateTestValue(firstSchema);
-          }
-        }
-        return obj;
-
-      default:
-        return null;
-    }
-  }
-
-  /**
-   * Validate response against OpenAPI schema
-   */
-  validateResponse(response, operation, result) {
-    if (!operation.responses) {
-      result.warnings.push('No responses defined in OpenAPI spec');
-      return;
-    }
-
-    const statusCode = response.status.toString();
-    const responseSpec = operation.responses[statusCode] || operation.responses.default;
-
-    if (!responseSpec) {
-      result.valid = false;
-      result.errors.push(`Unexpected status code: ${statusCode}`);
-      return;
-    }
-
-    // Validate response body
-    if (responseSpec.content) {
-      const contentType = Object.keys(responseSpec.content)[0];
-      const schema = responseSpec.content[contentType].schema;
-
-      if (schema) {
-        const validate = this.ajv.compile(schema);
-        if (!validate(response.data)) {
-          result.valid = false;
-          result.errors.push(`Response validation failed: ${JSON.stringify(validate.errors)}`);
-        }
-      }
-    }
-
-    // Validate headers
-    if (responseSpec.headers) {
-      Object.entries(responseSpec.headers).forEach(([headerName, headerSpec]) => {
-        const headerValue = response.headers[headerName.toLowerCase()];
-        if (headerSpec.required && !headerValue) {
-          result.valid = false;
-          result.errors.push(`Required header missing: ${headerName}`);
-        }
-      });
-    }
-  }
-
-  /**
-   * Count total endpoints in paths
-   */
-  countEndpoints(paths) {
-    let count = 0;
-    Object.values(paths).forEach(pathItem => {
-      Object.keys(pathItem).forEach(method => {
-        if (method !== 'parameters' && !method.startsWith('x-')) {
-          count++;
-        }
-      });
-    });
-    return count;
-  }
-
-  /**
-   * Validate cookbook structure and operations
-   */
-  async validateCookbook(cookbook, serviceRegistry) {
-    const results = {
-      valid: true,
-      errors: [],
-      warnings: [],
-      validatedSteps: []
-    };
-
-    if (!cookbook.steps || !Array.isArray(cookbook.steps)) {
-      results.valid = false;
-      results.errors.push('Cookbook must have steps array');
-      return results;
-    }
-
-    // Validate each step
-    for (const step of cookbook.steps) {
-      const stepResult = await this.validateStep(step, serviceRegistry);
-      results.validatedSteps.push(stepResult);
-      
-      if (!stepResult.valid) {
-        results.valid = false;
-        results.errors.push(...stepResult.errors);
-      }
-      if (stepResult.warnings) {
-        results.warnings.push(...stepResult.warnings);
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Validate individual cookbook step
-   */
-  async validateStep(step, serviceRegistry) {
-    const result = {
-      stepId: step.id,
-      valid: true,
-      errors: [],
-      warnings: []
-    };
-
-    // Basic validation
-    if (!step.id) {
-      result.valid = false;
-      result.errors.push('Step must have an id');
-    }
-
-    if (!step.type) {
-      result.valid = false;
-      result.errors.push('Step must have a type');
-    }
-
-    // Type-specific validation
-    switch (step.type) {
-      case 'task':
-        if (!step.service) {
-          result.valid = false;
-          result.errors.push('Task step must have a service');
-        } else {
-          // Check if service exists
-          const service = serviceRegistry.getService(step.service);
-          if (!service) {
-            result.valid = false;
-            result.errors.push(`Service not found: ${step.service}`);
-          } else if (step.operation) {
-            // Validate operation exists in service
-            const hasOperation = this.serviceHasOperation(
-              service.openapi,
-              step.operation
-            );
-            if (!hasOperation) {
-              result.valid = false;
-              result.errors.push(`Operation not found: ${step.operation}`);
-            }
-          }
-        }
-        break;
-
-      case 'foreach':
-        if (!step.items) {
-          result.valid = false;
-          result.errors.push('Foreach step must have items');
-        }
-        if (!step.body) {
-          result.valid = false;
-          result.errors.push('Foreach step must have body');
-        }
-        break;
-
-      case 'switch':
-        if (!step.condition) {
-          result.valid = false;
-          result.errors.push('Switch step must have condition');
-        }
-        if (!step.cases || !Array.isArray(step.cases)) {
-          result.valid = false;
-          result.errors.push('Switch step must have cases array');
-        }
-        break;
-    }
-
-    return result;
-  }
-
-  /**
-   * Check if service has operation
-   */
-  serviceHasOperation(openApiSpec, operationId) {
-    if (!openApiSpec || !openApiSpec.paths) return false;
-
-    for (const pathItem of Object.values(openApiSpec.paths)) {
-      for (const operation of Object.values(pathItem)) {
-        if (operation.operationId === operationId) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-}
-
-module.exports = ServiceValidator;