bowling-analysis-system/src/pipeline/PipelineConfig.js

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

/**
 * @module pipeline/PipelineConfig
 * @description Pipeline configuration handler for video processing
 */

const fs = require('fs');
const path = require('path');
const { merge } = require('lodash');

const { defaultLogger } = require('../utils/logger');
const { getPipelineTemplate } = require('../core/utils/PatternDetectionConfig');
const env = require('../config/env');

  /**
 * Default pipeline configuration
 * @type {Object}
 */
const DEFAULT_CONFIG = {
  template: 'FULL_ANALYSIS',
  outputFormat: 'json',
  processorOptions: {},
  monitoring: {
    enablePerformanceTracking: true,
    detailedMetrics: true
  }
};

  /**
   * Load pipeline configuration from a file
 * @param {string} configPath - Path to configuration file
 * @returns {Object|null} - Loaded configuration or null if loading failed
 */
function loadConfigFromFile(configPath) {
  try {
    if (!fs.existsSync(configPath)) {
      logger.warn(`Pipeline configuration file not found: ${configPath}`);
      return null;
    }

    const configData = fs.readFileSync(configPath, 'utf8');
    return JSON.parse(configData);
    } catch (error) {
    logger.error(`Failed to load pipeline configuration: ${error.message}`);
    return null;
    }
  }

  /**
 * Build a pipeline configuration with overrides
 * @param {Object} options - Configuration options and overrides
 * @returns {Object} - Complete pipeline configuration
 */
function buildPipelineConfig(options = {}) {
  // Start with default configuration
  const config = { ...DEFAULT_CONFIG };

  // Load configuration from environment
  if (env.pipeline && typeof env.pipeline === 'object') {
    merge(config, env.pipeline);
  }

  // Load configuration from default config file
  const defaultConfigPath = path.join(process.cwd(), 'src', 'config', 'pipeline-config.json');
  const fileConfig = loadConfigFromFile(defaultConfigPath);
  if (fileConfig) {
    merge(config, fileConfig);
    }

  // Apply any custom config file specified in options
  if (options.configFile) {
    const customFileConfig = loadConfigFromFile(options.configFile);
    if (customFileConfig) {
      merge(config, customFileConfig);
    }
  }

  // Apply direct options (highest priority)
  merge(config, options);

  // Set up template
  if (config.template) {
    const template = getPipelineTemplate(config.template);
    if (template) {
      config.stages = template.stages;
    } else {
      logger.warn(`Unknown pipeline template: ${config.template}, using default stages`);
    }
  }

  // Validate configuration
  validatePipelineConfig(config);

  return config;
  }

  /**
 * Validate pipeline configuration
 * @param {Object} config - Pipeline configuration
 * @returns {boolean} - Whether configuration is valid
 */
function validatePipelineConfig(config) {
  let isValid = true;

  // Validate required properties
  if (!config.stages || !Array.isArray(config.stages)) {
    logger.error('Pipeline configuration missing stages array');
    isValid = false;
  }

  // Validate stages
  if (config.stages) {
    config.stages.forEach((stage, index) => {
      if (!stage.type) {
        logger.error(`Stage at index ${index} is missing type property`);
        isValid = false;
      }
    });
  }

  return isValid;
  }

  /**
 * Get processor configuration for a stage
 * @param {Object} stage - Pipeline stage
 * @param {Object} pipelineConfig - Overall pipeline configuration
 * @returns {Object} - Processor configuration
 */
function getProcessorConfig(stage, pipelineConfig) {
  // Start with empty config
  const config = {};

  // Add processor options from pipeline config if available
  if (pipelineConfig.processorOptions && pipelineConfig.processorOptions[stage.type]) {
    merge(config, pipelineConfig.processorOptions[stage.type]);
  }

  // Add processor options from stage config if available
  if (stage.config) {
    merge(config, stage.config);
  }

  return config;
}

module.exports = {
  buildPipelineConfig,
  validatePipelineConfig,
  getProcessorConfig,
  DEFAULT_CONFIG
};