react-native-healthkit-bridge/src/utils/ValidationUtils.ts

A comprehensive React Native bridge for Apple HealthKit with TypeScript support, advanced authorization, and flexible data queries

import { HEALTHKIT_CONFIG } from '../config/healthkit.config';

export class HealthKitValidator {
  static validateIdentifier(identifier: string): boolean {
    if (!identifier || typeof identifier !== 'string') {
      return false;
    }
    
    if (identifier.length > HEALTHKIT_CONFIG.VALIDATION.MAX_IDENTIFIER_LENGTH) {
      return false;
    }
    
    if (!/^[a-zA-Z0-9_]+$/.test(identifier)) {
      return false;
    }
    
    return true;
  }
  
  static validateDateRange(start: Date, end: Date): boolean {
    if (!start || !end || !(start instanceof Date) || !(end instanceof Date)) {
      return false;
    }
    
    if (start >= end) {
      return false;
    }
    
    const range = end.getTime() - start.getTime();
    
    if (range < HEALTHKIT_CONFIG.VALIDATION.MIN_DATE_RANGE) {
      return false;
    }
    
    if (range > HEALTHKIT_CONFIG.VALIDATION.MAX_DATE_RANGE) {
      return false;
    }
    
    return true;
  }
  
  static validateDays(days: number): boolean {
    if (!Number.isInteger(days) || days < HEALTHKIT_CONFIG.VALIDATION.MIN_DAYS || days > HEALTHKIT_CONFIG.VALIDATION.MAX_DAYS) {
      return false;
    }
    
    return true;
  }
  
  static validateUnit(unit: string): boolean {
    if (!unit || typeof unit !== 'string') {
      return false;
    }
    
    // Unidades válidas do HealthKit
    const validUnits = [
      'count',
      'm',
      'km',
      'mi',
      'yd',
      'ft',
      'kcal',
      'kJ',
      'count/min',
      'bpm',
      'kg',
      'lb',
      'g',
      'oz',
      'mmHg',
      'mg/dL',
      'mmol/L',
      '%',
      'C',
      'F',
      'L',
      'mL',
      'gal',
      'qt',
      'pt',
      'cup',
      'tbsp',
      'tsp',
      'in',
      'cm',
      'mm',
      'min'
    ];
    
    return validUnits.includes(unit);
  }
  
  static validateIdentifiers(identifiers: string[]): boolean {
    if (!Array.isArray(identifiers) || identifiers.length === 0) {
      return false;
    }
    
    if (identifiers.length > HEALTHKIT_CONFIG.VALIDATION.MAX_BATCH_SIZE) {
      return false;
    }
    
    return identifiers.every(identifier => this.validateIdentifier(identifier));
  }
  
  static validateQueryOptions(options: any): boolean {
    if (!options || typeof options !== 'object') {
      return false;
    }
    
    if (options.startDate && !(options.startDate instanceof Date)) {
      return false;
    }
    
    if (options.endDate && !(options.endDate instanceof Date)) {
      return false;
    }
    
    if (options.days && !this.validateDays(options.days)) {
      return false;
    }
    
    if (options.limit && (!Number.isInteger(options.limit) || options.limit <= 0)) {
      return false;
    }
    
    if (options.ascending !== undefined && typeof options.ascending !== 'boolean') {
      return false;
    }
    
    return true;
  }
  
  static validateAuthorizationRequest(identifiers: string[]): boolean {
    return this.validateIdentifiers(identifiers);
  }
  
  static getValidationErrors(validationResults: { [key: string]: boolean }): string[] {
    const errors: string[] = [];
    
    Object.entries(validationResults).forEach(([field, isValid]) => {
      if (!isValid) {
        errors.push(`Campo '${field}' é inválido`);
      }
    });
    
    return errors;
  }
  
  static sanitizeIdentifier(identifier: string): string {
    return identifier.trim().replace(/[^a-zA-Z0-9_]/g, '');
  }
  
  static sanitizeUnit(unit: string): string {
    return unit.trim().toLowerCase();
  }
}