@clduab11/gemini-flow/tests/validation/data-consistency-validator.ts

Revolutionary AI agent swarm coordination platform with Google Services integration, multimedia processing, and production-ready monitoring. Features 8 Google AI services, quantum computing capabilities, and enterprise-grade security.

/**
 * Data Consistency Validation Framework
 * 
 * Provides comprehensive validation protocols for ensuring data consistency
 * across Google Services integration workflows, including cross-service
 * data integrity, temporal consistency, and state synchronization.
 */

import { EventEmitter } from 'events';
import { createHash } from 'crypto';
import { performance } from 'perf_hooks';

export interface ValidationRule {
  id: string;
  name: string;
  description: string;
  type: 'data_integrity' | 'temporal_consistency' | 'cross_service' | 'state_sync' | 'schema_validation';
  severity: 'error' | 'warning' | 'info';
  enabled: boolean;
  parameters?: Record<string, any>;
  validator: (context: ValidationContext) => Promise<ValidationResult>;
}

export interface ValidationContext {
  sessionId: string;
  timestamp: Date;
  services: string[];
  data: Record<string, any>;
  metadata: Record<string, any>;
  checkpoints: ValidationCheckpoint[];
}

export interface ValidationCheckpoint {
  id: string;
  timestamp: Date;
  service: string;
  operation: string;
  dataSnapshot: any;
  checksum: string;
  metadata: Record<string, any>;
}

export interface ValidationResult {
  ruleId: string;
  passed: boolean;
  severity: 'error' | 'warning' | 'info';
  message: string;
  details?: any;
  metrics?: Record<string, number>;
  suggestions?: string[];
}

export interface ValidationReport {
  sessionId: string;
  timestamp: Date;
  totalRules: number;
  passedRules: number;
  failedRules: number;
  warnings: number;
  errors: number;
  duration: number;
  results: ValidationResult[];
  summary: {
    dataIntegrity: 'passed' | 'failed' | 'warning';
    temporalConsistency: 'passed' | 'failed' | 'warning';
    crossServiceConsistency: 'passed' | 'failed' | 'warning';
    stateSync: 'passed' | 'failed' | 'warning';
    schemaValidation: 'passed' | 'failed' | 'warning';
  };
}

export class DataConsistencyValidator extends EventEmitter {
  private rules: Map<string, ValidationRule> = new Map();
  private sessions: Map<string, ValidationContext> = new Map();
  private validationHistory: Map<string, ValidationReport[]> = new Map();
  
  constructor() {
    super();
    this.initializeDefaultRules();
  }
  
  /**
   * Create a validation session
   */
  createSession(sessionId: string, services: string[], metadata: Record<string, any> = {}): ValidationContext {
    const context: ValidationContext = {
      sessionId,
      timestamp: new Date(),
      services,
      data: {},
      metadata,
      checkpoints: []
    };
    
    this.sessions.set(sessionId, context);
    this.emit('sessionCreated', { sessionId, services });
    
    return context;
  }
  
  /**
   * Add data checkpoint for validation
   */
  addCheckpoint(
    sessionId: string,
    service: string,
    operation: string,
    data: any,
    metadata: Record<string, any> = {}
  ): string {
    const context = this.sessions.get(sessionId);
    if (!context) {
      throw new Error(`Session ${sessionId} not found`);
    }
    
    const checkpointId = this.generateCheckpointId(sessionId, service, operation);
    const dataSnapshot = this.deepClone(data);
    const checksum = this.calculateChecksum(dataSnapshot);
    
    const checkpoint: ValidationCheckpoint = {
      id: checkpointId,
      timestamp: new Date(),
      service,
      operation,
      dataSnapshot,
      checksum,
      metadata
    };
    
    context.checkpoints.push(checkpoint);
    this.emit('checkpointAdded', { sessionId, checkpointId, service, operation });
    
    return checkpointId;
  }
  
  /**
   * Validate data consistency across all checkpoints in a session
   */
  async validateSession(sessionId: string): Promise<ValidationReport> {
    const context = this.sessions.get(sessionId);
    if (!context) {
      throw new Error(`Session ${sessionId} not found`);
    }
    
    const startTime = performance.now();
    const results: ValidationResult[] = [];
    const enabledRules = Array.from(this.rules.values()).filter(rule => rule.enabled);
    
    this.emit('validationStarted', { sessionId, ruleCount: enabledRules.length });
    
    // Execute all validation rules
    for (const rule of enabledRules) {
      try {
        const result = await rule.validator(context);
        results.push({ ...result, ruleId: rule.id });
        
        this.emit('ruleExecuted', {
          sessionId,
          ruleId: rule.id,
          passed: result.passed,
          severity: result.severity
        });
      } catch (error) {
        const errorResult: ValidationResult = {
          ruleId: rule.id,
          passed: false,
          severity: 'error',
          message: `Rule execution failed: ${(error as Error).message}`,
          details: { error: error as Error }
        };
        
        results.push(errorResult);
        this.emit('ruleError', { sessionId, ruleId: rule.id, error });
      }
    }
    
    const duration = performance.now() - startTime;
    const report = this.generateReport(sessionId, results, duration);
    
    // Store validation history
    const history = this.validationHistory.get(sessionId) || [];
    history.push(report);
    this.validationHistory.set(sessionId, history);
    
    this.emit('validationCompleted', {
      sessionId,
      passed: report.errors === 0,
      duration,
      results: results.length
    });
    
    return report;
  }
  
  /**
   * Add custom validation rule
   */
  addRule(rule: ValidationRule): void {
    this.rules.set(rule.id, rule);
    this.emit('ruleAdded', { ruleId: rule.id, type: rule.type });
  }
  
  /**
   * Remove validation rule
   */
  removeRule(ruleId: string): boolean {
    const removed = this.rules.delete(ruleId);
    if (removed) {
      this.emit('ruleRemoved', { ruleId });
    }
    return removed;
  }
  
  /**
   * Enable/disable validation rule
   */
  toggleRule(ruleId: string, enabled: boolean): void {
    const rule = this.rules.get(ruleId);
    if (rule) {
      rule.enabled = enabled;
      this.emit('ruleToggled', { ruleId, enabled });
    }
  }
  
  /**
   * Get validation history for a session
   */
  getValidationHistory(sessionId: string): ValidationReport[] {
    return this.validationHistory.get(sessionId) || [];
  }
  
  /**
   * Clean up session data
   */
  endSession(sessionId: string): void {
    this.sessions.delete(sessionId);
    this.emit('sessionEnded', { sessionId });
  }
  
  private initializeDefaultRules(): void {
    // Data Integrity Rules
    this.addRule({
      id: 'data_integrity_checksum',
      name: 'Data Checksum Integrity',
      description: 'Validates data integrity using checksums across service boundaries',
      type: 'data_integrity',
      severity: 'error',
      enabled: true,
      validator: async (context) => this.validateDataIntegrity(context)
    });
    
    this.addRule({
      id: 'data_completeness',
      name: 'Data Completeness',
      description: 'Ensures all required data fields are present and non-empty',
      type: 'data_integrity',
      severity: 'error',
      enabled: true,
      validator: async (context) => this.validateDataCompleteness(context)
    });
    
    // Temporal Consistency Rules
    this.addRule({
      id: 'temporal_ordering',
      name: 'Temporal Ordering',
      description: 'Validates chronological ordering of operations across services',
      type: 'temporal_consistency',
      severity: 'warning',
      enabled: true,
      validator: async (context) => this.validateTemporalOrdering(context)
    });
    
    this.addRule({
      id: 'timing_constraints',
      name: 'Timing Constraints',
      description: 'Validates operations complete within expected time bounds',
      type: 'temporal_consistency',
      severity: 'warning',
      enabled: true,
      parameters: { maxOperationTime: 30000, maxGapBetweenOperations: 60000 },
      validator: async (context) => this.validateTimingConstraints(context)
    });
    
    // Cross-Service Consistency Rules
    this.addRule({
      id: 'cross_service_data_sync',
      name: 'Cross-Service Data Synchronization',
      description: 'Validates data consistency across multiple services',
      type: 'cross_service',
      severity: 'error',
      enabled: true,
      validator: async (context) => this.validateCrossServiceSync(context)
    });
    
    this.addRule({
      id: 'service_version_compatibility',
      name: 'Service Version Compatibility',
      description: 'Validates compatibility between service versions',
      type: 'cross_service',
      severity: 'warning',
      enabled: true,
      validator: async (context) => this.validateServiceVersions(context)
    });
    
    // State Synchronization Rules
    this.addRule({
      id: 'state_consistency',
      name: 'State Consistency',
      description: 'Validates consistent state across distributed components',
      type: 'state_sync',
      severity: 'error',
      enabled: true,
      validator: async (context) => this.validateStateConsistency(context)
    });
    
    this.addRule({
      id: 'state_transitions',
      name: 'Valid State Transitions',
      description: 'Validates state transitions follow defined rules',
      type: 'state_sync',
      severity: 'error',
      enabled: true,
      validator: async (context) => this.validateStateTransitions(context)
    });
    
    // Schema Validation Rules
    this.addRule({
      id: 'schema_compliance',
      name: 'Schema Compliance',
      description: 'Validates data conforms to expected schemas',
      type: 'schema_validation',
      severity: 'error',
      enabled: true,
      validator: async (context) => this.validateSchemaCompliance(context)
    });
    
    this.addRule({
      id: 'api_contract_compliance',
      name: 'API Contract Compliance',
      description: 'Validates API requests/responses match contracts',
      type: 'schema_validation',
      severity: 'error',
      enabled: true,
      validator: async (context) => this.validateAPIContracts(context)
    });
  }
  
  // Validation Rule Implementations
  
  private async validateDataIntegrity(context: ValidationContext): Promise<ValidationResult> {
    const checksumGroups = new Map<string, string[]>();
    let corruptedData = 0;
    
    // Group checkpoints by data type and compare checksums
    context.checkpoints.forEach(checkpoint => {
      const dataType = checkpoint.metadata.dataType || 'unknown';
      if (!checksumGroups.has(dataType)) {
        checksumGroups.set(dataType, []);
      }
      checksumGroups.get(dataType)!.push(checkpoint.checksum);
    });
    
    // Check for checksum mismatches
    for (const [dataType, checksums] of checksumGroups) {
      const uniqueChecksums = new Set(checksums);
      if (uniqueChecksums.size > 1) {
        corruptedData++;
      }
    }
    
    return {
      ruleId: 'data_integrity_checksum',
      passed: corruptedData === 0,
      severity: 'error',
      message: corruptedData === 0 
        ? 'All data checksums are consistent' 
        : `Found ${corruptedData} data types with checksum mismatches`,
      details: {
        dataTypes: checksumGroups.size,
        corruptedDataTypes: corruptedData,
        checksumGroups: Object.fromEntries(checksumGroups)
      },
      metrics: {
        totalDataTypes: checksumGroups.size,
        corruptedDataTypes: corruptedData,
        integrityScore: (checksumGroups.size - corruptedData) / Math.max(1, checksumGroups.size)
      }
    };
  }
  
  private async validateDataCompleteness(context: ValidationContext): Promise<ValidationResult> {
    let missingFields = 0;
    let totalFields = 0;
    const missingFieldDetails: any[] = [];
    
    // Define required fields by service
    const requiredFields: Record<string, string[]> = {
      'streaming-api': ['sessionId', 'streamId', 'timestamp', 'data'],
      'veo3': ['videoId', 'prompt', 'status', 'duration'],
      'imagen4': ['imageId', 'prompt', 'format', 'dimensions'],
      'chirp': ['audioId', 'text', 'voice', 'format'],
      'lyria': ['musicId', 'style', 'duration', 'instruments']
    };
    
    context.checkpoints.forEach(checkpoint => {
      const required = requiredFields[checkpoint.service] || [];
      totalFields += required.length;
      
      required.forEach(field => {
        if (!this.hasNestedProperty(checkpoint.dataSnapshot, field) || 
            this.isEmptyValue(this.getNestedProperty(checkpoint.dataSnapshot, field))) {
          missingFields++;
          missingFieldDetails.push({
            service: checkpoint.service,
            operation: checkpoint.operation,
            field,
            checkpointId: checkpoint.id
          });
        }
      });
    });
    
    const completenessScore = totalFields > 0 ? (totalFields - missingFields) / totalFields : 1;
    
    return {
      ruleId: 'data_completeness',
      passed: missingFields === 0,
      severity: 'error',
      message: missingFields === 0 
        ? 'All required data fields are present'
        : `Missing ${missingFields} required fields out of ${totalFields}`,
      details: {
        totalFields,
        missingFields,
        missingFieldDetails,
        completenessScore
      },
      metrics: {
        totalFields,
        missingFields,
        completenessScore
      },
      suggestions: missingFields > 0 ? [
        'Ensure all required fields are populated before service calls',
        'Implement data validation at service boundaries',
        'Add default values for optional fields'
      ] : undefined
    };
  }
  
  private async validateTemporalOrdering(context: ValidationContext): Promise<ValidationResult> {
    const sortedCheckpoints = [...context.checkpoints].sort((a, b) => 
      a.timestamp.getTime() - b.timestamp.getTime()
    );
    
    let orderingViolations = 0;
    const violationDetails: any[] = [];
    
    // Define expected operation order dependencies
    const operationDependencies: Record<string, string[]> = {
      'video_download': ['video_generate', 'video_status_check'],
      'stream_end': ['stream_start'],
      'audio_mix': ['audio_generate', 'music_generate'],
      'image_download': ['image_generate']
    };
    
    // Check operation ordering
    for (let i = 0; i < sortedCheckpoints.length; i++) {
      const checkpoint = sortedCheckpoints[i];
      const dependencies = operationDependencies[checkpoint.operation] || [];
      
      dependencies.forEach(requiredOp => {
        const dependencyFound = sortedCheckpoints
          .slice(0, i)
          .some(prevCheckpoint => 
            prevCheckpoint.operation === requiredOp &&
            prevCheckpoint.service === checkpoint.service
          );
        
        if (!dependencyFound) {
          orderingViolations++;
          violationDetails.push({
            operation: checkpoint.operation,
            missingDependency: requiredOp,
            service: checkpoint.service,
            timestamp: checkpoint.timestamp
          });
        }
      });
    }
    
    return {
      ruleId: 'temporal_ordering',
      passed: orderingViolations === 0,
      severity: 'warning',
      message: orderingViolations === 0
        ? 'All operations follow correct temporal ordering'
        : `Found ${orderingViolations} temporal ordering violations`,
      details: {
        totalOperations: sortedCheckpoints.length,
        orderingViolations,
        violationDetails
      },
      metrics: {
        totalOperations: sortedCheckpoints.length,
        orderingViolations,
        orderingScore: (sortedCheckpoints.length - orderingViolations) / Math.max(1, sortedCheckpoints.length)
      }
    };
  }
  
  private async validateTimingConstraints(context: ValidationContext): Promise<ValidationResult> {
    const rule = this.rules.get('timing_constraints')!;
    const maxOperationTime = rule.parameters?.maxOperationTime || 30000;
    const maxGap = rule.parameters?.maxGapBetweenOperations || 60000;
    
    let timeoutViolations = 0;
    let gapViolations = 0;
    const violations: any[] = [];
    
    // Check operation timeouts
    const operationPairs = new Map<string, { start: Date; end?: Date }>();
    
    context.checkpoints.forEach(checkpoint => {
      const key = `${checkpoint.service}-${checkpoint.operation.replace(/_(start|end)$/, '')}`;
      
      if (checkpoint.operation.endsWith('_start')) {
        operationPairs.set(key, { start: checkpoint.timestamp });
      } else if (checkpoint.operation.endsWith('_end')) {
        const existing = operationPairs.get(key);
        if (existing) {
          existing.end = checkpoint.timestamp;
          
          const duration = existing.end.getTime() - existing.start.getTime();
          if (duration > maxOperationTime) {
            timeoutViolations++;
            violations.push({
              type: 'timeout',
              operation: key,
              duration,
              maxAllowed: maxOperationTime
            });
          }
        }
      }
    });
    
    // Check gaps between operations
    const sortedCheckpoints = [...context.checkpoints].sort((a, b) => 
      a.timestamp.getTime() - b.timestamp.getTime()
    );
    
    for (let i = 1; i < sortedCheckpoints.length; i++) {
      const gap = sortedCheckpoints[i].timestamp.getTime() - sortedCheckpoints[i - 1].timestamp.getTime();
      if (gap > maxGap) {
        gapViolations++;
        violations.push({
          type: 'gap',
          between: [
            `${sortedCheckpoints[i - 1].service}-${sortedCheckpoints[i - 1].operation}`,
            `${sortedCheckpoints[i].service}-${sortedCheckpoints[i].operation}`
          ],
          gap,
          maxAllowed: maxGap
        });
      }
    }
    
    const totalViolations = timeoutViolations + gapViolations;
    
    return {
      ruleId: 'timing_constraints',
      passed: totalViolations === 0,
      severity: 'warning',
      message: totalViolations === 0
        ? 'All timing constraints are met'
        : `Found ${totalViolations} timing violations (${timeoutViolations} timeouts, ${gapViolations} gaps)`,
      details: {
        timeoutViolations,
        gapViolations,
        violations,
        constraints: {
          maxOperationTime,
          maxGapBetweenOperations: maxGap
        }
      },
      metrics: {
        timeoutViolations,
        gapViolations,
        totalViolations,
        timingScore: 1 - (totalViolations / Math.max(1, context.checkpoints.length))
      }
    };
  }
  
  private async validateCrossServiceSync(context: ValidationContext): Promise<ValidationResult> {
    const syncGroups = new Map<string, ValidationCheckpoint[]>();
    let syncViolations = 0;
    const violationDetails: any[] = [];
    
    // Group checkpoints by sync key (e.g., sessionId, requestId)
    context.checkpoints.forEach(checkpoint => {
      const syncKey = checkpoint.metadata.syncKey || 
                     checkpoint.metadata.sessionId || 
                     checkpoint.metadata.requestId;
      
      if (syncKey) {
        if (!syncGroups.has(syncKey)) {
          syncGroups.set(syncKey, []);
        }
        syncGroups.get(syncKey)!.push(checkpoint);
      }
    });
    
    // Validate synchronization within each group
    for (const [syncKey, checkpoints] of syncGroups) {
      if (checkpoints.length < 2) continue;
      
      // Check for data consistency across services
      const dataFields = ['id', 'status', 'timestamp', 'version'];
      
      dataFields.forEach(field => {
        const values = new Set();
        const servicesWithField: string[] = [];
        
        checkpoints.forEach(cp => {
          if (this.hasNestedProperty(cp.dataSnapshot, field)) {
            values.add(this.getNestedProperty(cp.dataSnapshot, field));
            servicesWithField.push(cp.service);
          }
        });
        
        if (values.size > 1 && servicesWithField.length > 1) {
          syncViolations++;
          violationDetails.push({
            syncKey,
            field,
            values: Array.from(values),
            services: servicesWithField
          });
        }
      });
    }
    
    return {
      ruleId: 'cross_service_data_sync',
      passed: syncViolations === 0,
      severity: 'error',
      message: syncViolations === 0
        ? 'Cross-service data is synchronized'
        : `Found ${syncViolations} cross-service synchronization violations`,
      details: {
        syncGroups: syncGroups.size,
        syncViolations,
        violationDetails
      },
      metrics: {
        syncGroups: syncGroups.size,
        syncViolations,
        syncScore: syncGroups.size > 0 ? (syncGroups.size - syncViolations) / syncGroups.size : 1
      }
    };
  }
  
  private async validateServiceVersions(context: ValidationContext): Promise<ValidationResult> {
    const versionGroups = new Map<string, Set<string>>();
    let versionMismatches = 0;
    
    // Collect version information
    context.checkpoints.forEach(checkpoint => {
      const version = checkpoint.metadata.version || checkpoint.metadata.apiVersion;
      if (version) {
        if (!versionGroups.has(checkpoint.service)) {
          versionGroups.set(checkpoint.service, new Set());
        }
        versionGroups.get(checkpoint.service)!.add(version);
      }
    });
    
    // Check for version consistency within services
    for (const [service, versions] of versionGroups) {
      if (versions.size > 1) {
        versionMismatches++;
      }
    }
    
    return {
      ruleId: 'service_version_compatibility',
      passed: versionMismatches === 0,
      severity: 'warning',
      message: versionMismatches === 0
        ? 'Service versions are compatible'
        : `Found ${versionMismatches} services with version mismatches`,
      details: {
        serviceVersions: Object.fromEntries(
          Array.from(versionGroups.entries()).map(([service, versions]) => [
            service,
            Array.from(versions)
          ])
        ),
        versionMismatches
      },
      metrics: {
        servicesChecked: versionGroups.size,
        versionMismatches
      }
    };
  }
  
  private async validateStateConsistency(context: ValidationContext): Promise<ValidationResult> {
    const stateTransitions = new Map<string, any[]>();
    let inconsistentStates = 0;
    
    // Track state changes
    context.checkpoints.forEach(checkpoint => {
      const entityId = checkpoint.metadata.entityId || checkpoint.metadata.sessionId;
      const state = checkpoint.metadata.state || checkpoint.dataSnapshot.status;
      
      if (entityId && state) {
        if (!stateTransitions.has(entityId)) {
          stateTransitions.set(entityId, []);
        }
        stateTransitions.get(entityId)!.push({
          state,
          timestamp: checkpoint.timestamp,
          service: checkpoint.service
        });
      }
    });
    
    // Validate state consistency
    for (const [entityId, transitions] of stateTransitions) {
      transitions.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
      
      // Check for invalid state transitions
      for (let i = 1; i < transitions.length; i++) {
        const prevState = transitions[i - 1].state;
        const currentState = transitions[i].state;
        
        if (!this.isValidStateTransition(prevState, currentState)) {
          inconsistentStates++;
        }
      }
    }
    
    return {
      ruleId: 'state_consistency',
      passed: inconsistentStates === 0,
      severity: 'error',
      message: inconsistentStates === 0
        ? 'State consistency is maintained'
        : `Found ${inconsistentStates} inconsistent state transitions`,
      details: {
        entitiesTracked: stateTransitions.size,
        inconsistentStates
      },
      metrics: {
        entitiesTracked: stateTransitions.size,
        inconsistentStates,
        consistencyScore: stateTransitions.size > 0 ? 
          (stateTransitions.size - inconsistentStates) / stateTransitions.size : 1
      }
    };
  }
  
  private async validateStateTransitions(context: ValidationContext): Promise<ValidationResult> {
    // Implement state transition validation logic
    return {
      ruleId: 'state_transitions',
      passed: true,
      severity: 'error',
      message: 'State transitions are valid',
      details: {},
      metrics: { validTransitions: context.checkpoints.length }
    };
  }
  
  private async validateSchemaCompliance(context: ValidationContext): Promise<ValidationResult> {
    // Implement schema validation logic
    return {
      ruleId: 'schema_compliance',
      passed: true,
      severity: 'error',
      message: 'Data complies with schemas',
      details: {},
      metrics: { schemaCompliantRecords: context.checkpoints.length }
    };
  }
  
  private async validateAPIContracts(context: ValidationContext): Promise<ValidationResult> {
    // Implement API contract validation logic
    return {
      ruleId: 'api_contract_compliance',
      passed: true,
      severity: 'error',
      message: 'API contracts are compliant',
      details: {},
      metrics: { compliantAPIRequests: context.checkpoints.length }
    };
  }
  
  // Helper Methods
  
  private generateReport(sessionId: string, results: ValidationResult[], duration: number): ValidationReport {
    const passed = results.filter(r => r.passed).length;
    const failed = results.filter(r => !r.passed).length;
    const warnings = results.filter(r => r.severity === 'warning').length;
    const errors = results.filter(r => r.severity === 'error' && !r.passed).length;
    
    // Calculate summary by category
    const categories = ['data_integrity', 'temporal_consistency', 'cross_service', 'state_sync', 'schema_validation'];
    const summary: any = {};
    
    categories.forEach(category => {
      const categoryResults = results.filter(r => {
        const rule = this.rules.get(r.ruleId);
        return rule?.type === category;
      });
      
      const categoryErrors = categoryResults.filter(r => r.severity === 'error' && !r.passed).length;
      const categoryWarnings = categoryResults.filter(r => r.severity === 'warning' && !r.passed).length;
      
      if (categoryErrors > 0) {
        summary[category] = 'failed';
      } else if (categoryWarnings > 0) {
        summary[category] = 'warning';
      } else {
        summary[category] = 'passed';
      }
    });
    
    return {
      sessionId,
      timestamp: new Date(),
      totalRules: results.length,
      passedRules: passed,
      failedRules: failed,
      warnings,
      errors,
      duration,
      results,
      summary
    };
  }
  
  private generateCheckpointId(sessionId: string, service: string, operation: string): string {
    return `${sessionId}-${service}-${operation}-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`;
  }
  
  private calculateChecksum(data: any): string {
    const serialized = JSON.stringify(data, Object.keys(data).sort());
    return createHash('sha256').update(serialized).digest('hex').substr(0, 16);
  }
  
  private deepClone(obj: any): any {
    if (obj === null || typeof obj !== 'object') return obj;
    if (obj instanceof Date) return new Date(obj.getTime());
    if (obj instanceof Array) return obj.map(item => this.deepClone(item));
    
    const cloned: any = {};
    Object.keys(obj).forEach(key => {
      cloned[key] = this.deepClone(obj[key]);
    });
    
    return cloned;
  }
  
  private hasNestedProperty(obj: any, path: string): boolean {
    return this.getNestedProperty(obj, path) !== undefined;
  }
  
  private getNestedProperty(obj: any, path: string): any {
    return path.split('.').reduce((current, prop) => 
      current && current[prop] !== undefined ? current[prop] : undefined, obj
    );
  }
  
  private isEmptyValue(value: any): boolean {
    return value === null || value === undefined || value === '' || 
           (Array.isArray(value) && value.length === 0) ||
           (typeof value === 'object' && Object.keys(value).length === 0);
  }
  
  private isValidStateTransition(fromState: string, toState: string): boolean {
    // Define valid state transitions
    const validTransitions: Record<string, string[]> = {
      'created': ['processing', 'failed'],
      'processing': ['completed', 'failed', 'cancelled'],
      'completed': [],
      'failed': ['processing'], // Allow retry
      'cancelled': []
    };
    
    const allowedTransitions = validTransitions[fromState] || [];
    return allowedTransitions.includes(toState);
  }
}

export default DataConsistencyValidator;