document-extraction-service/src/services/CustomExtractionCallbackValidator.js

A service for handling document extraction and processing

const ChunkData = require('../models/ChunkData');

class CustomExtractionCallbackValidator {
  constructor() {
    // Make instance immutable
    Object.freeze(this);
  }

  /**
   * Handle callback data
   * @param {Object} chunksData - Callback data
   * @returns {Object} Validated and processed chunks
   */
  async handleCallback(chunksData) {
    try {
      if (!chunksData || typeof chunksData !== 'object') {
        throw new Error('Invalid callback data format');
      }

      // Validate required fields first
      const requiredFields = ['docId', 'traceId', 'chunkData', 'lastBatch', 'strategiesBatchId'];
      for (const field of requiredFields) {
        if (!(field in chunksData)) {
          throw new Error(`Missing required field: ${field}`);
        }
      }

      // Validate chunk data structure
      ChunkData.validateResponse(chunksData);

      // Process and validate each chunk
      const processedChunks = await Promise.all(
        chunksData.chunkData.map(async chunk => {
          try {
            ChunkData.validateChunk(chunk);
            
            // Handle async processing if available
            if (chunk.processAsync && typeof chunk.processAsync === 'function') {
              await chunk.processAsync();
            }
            return chunk;
          } catch (error) {
            throw new Error(`Invalid chunk format: ${error.message}`);
          }
        })
      );

      return {
        success: true,
        docId: chunksData.docId,
        traceId: chunksData.traceId,
        lastBatch: chunksData.lastBatch,
        strategiesBatchId: chunksData.strategiesBatchId,
        chunks: processedChunks,
        metadata: {
          processedAt: new Date().toISOString(),
          chunksCount: processedChunks.length
        }
      };
    } catch (error) {
      return {
        success: false,
        error: error.message,
        docId: chunksData?.docId,
        traceId: chunksData?.traceId,
        lastBatch: chunksData?.lastBatch,
        strategiesBatchId: chunksData?.strategiesBatchId
      };
    }
  }

  static validateCallback(callbackData) {
    if (!callbackData) {
      throw new Error('Callback data is required');
    }

    const requiredFields = ['docId', 'traceId', 'chunkData', 'lastBatch', 'strategiesBatchId'];
    for (const field of requiredFields) {
      if (!(field in callbackData)) {
        throw new Error(`Missing required field: ${field}`);
      }
    }

    if (!Array.isArray(callbackData.chunkData)) {
      throw new Error('chunkData must be an array');
    }

    return true;
  }

  static validateChunk(chunk) {
    if (!chunk || typeof chunk !== 'object') {
      throw new Error('Invalid chunk format');
    }
    return true;
  }
}

// Make class immutable
Object.freeze(CustomExtractionCallbackValidator.prototype);
module.exports = CustomExtractionCallbackValidator;