bowling-analysis-system/src/processors/ValidatorProcessor.js

A comprehensive system for analyzing bowling techniques using video processing and metrics calculation

/**
 * Validator Processor
 * 
 * Validates input data against schemas
 * @module processors/ValidatorProcessor
 */

const { BaseProcessor } = require('../core/BaseProcessor');

/**
 * @class ValidatorProcessor
 * @description Processor for validating data against schemas
 * @extends BaseProcessor
 */
class ValidatorProcessor extends BaseProcessor {
  /**
   * Create a new validator processor
   * @param {Object} config - Processor configuration
   */
  constructor(config = {}) {
    if (!config.validationEngine) {
      throw new Error('ValidationEngine is required for ValidatorProcessor');
    }
    
    super('validator', config);
    this.schemas = new Map();
    this.validationEngine = config.validationEngine;
  }

  /**
   * Register a validation schema
   * @param {string} name - Schema name
   * @param {Object|Function} schema - Validation schema or function
   * @returns {ValidatorProcessor} Processor instance for chaining
   */
  registerSchema(name, schema) {
    this.schemas.set(name, schema);
    return this;
  }

  /**
   * Process input by validating it
   * @param {*} input - Input data to validate
   * @param {Object} context - Processing context
   * @returns {Promise<Object>} Validated data
   * @protected
   */
  async _process(input, context) {
    const schemaName = this.config.schema || 'default';
    const schema = this.schemas.get(schemaName);
    
    if (!schema) {
      throw new Error(`Validation schema not found: ${schemaName}`);
    }
    
    try {
      // Execute validation
      if (typeof schema === 'function') {
        // Schema is a validation function
        const result = await schema(input, context);
        
        if (result !== true) {
          throw new Error(result || 'Validation failed');
        }
      } else {
        // Schema is a validation object - use validation engine
        const validationResult = await this.validationEngine.validate(input, schema);
        
        if (!validationResult.valid) {
          throw new Error(validationResult.errors.join(', '));
        }
      }
      
      return input;
    } catch (error) {
      throw new Error(`Validation error: ${error.message}`);
    }
  }
}

module.exports = ValidatorProcessor;