@oxyhq/services 5.27.0 → 6.0.1

package/src/utils/__tests__/validationUtils.test.ts

@@ -1,236 +0,0 @@
-import {
-  isRequiredString,
-  isRequiredNumber,
-  isRequiredBoolean,
-  isValidArray,
-  isValidObject,
-  isValidEmail,
-  isValidUsername,
-  isValidPassword,
-  isValidUUID,
-  isValidDate,
-  isValidFileSize,
-  isValidFileType,
-  sanitizeString,
-  sanitizeHTML,
-  validateAndSanitizeUserInput
-} from '../validationUtils';
-
-describe('Validation Utils', () => {
-  describe('isRequiredString', () => {
-    it('should return true for valid non-empty strings', () => {
-      expect(isRequiredString('hello')).toBe(true);
-      expect(isRequiredString('  hello  ')).toBe(true); // trims whitespace
-    });
-
-    it('should return false for invalid or empty strings', () => {
-      expect(isRequiredString('')).toBe(false);
-      expect(isRequiredString('   ')).toBe(false); // only whitespace
-      expect(isRequiredString(null)).toBe(false);
-      expect(isRequiredString(undefined)).toBe(false);
-      expect(isRequiredString(123)).toBe(false);
-    });
-  });
-
-  describe('isRequiredNumber', () => {
-    it('should return true for valid numbers', () => {
-      expect(isRequiredNumber(123)).toBe(true);
-      expect(isRequiredNumber(0)).toBe(true);
-      expect(isRequiredNumber(-456)).toBe(true);
-      expect(isRequiredNumber(3.14)).toBe(true);
-    });
-
-    it('should return false for invalid numbers', () => {
-      expect(isRequiredNumber(Number.NaN)).toBe(false);
-      expect(isRequiredNumber('123')).toBe(false);
-      expect(isRequiredNumber(null)).toBe(false);
-      expect(isRequiredNumber(undefined)).toBe(false);
-    });
-  });
-
-  describe('isRequiredBoolean', () => {
-    it('should return true for boolean values', () => {
-      expect(isRequiredBoolean(true)).toBe(true);
-      expect(isRequiredBoolean(false)).toBe(true);
-    });
-
-    it('should return false for non-boolean values', () => {
-      expect(isRequiredBoolean('true')).toBe(false);
-      expect(isRequiredBoolean(1)).toBe(false);
-      expect(isRequiredBoolean(0)).toBe(false);
-      expect(isRequiredBoolean(null)).toBe(false);
-      expect(isRequiredBoolean(undefined)).toBe(false);
-    });
-  });
-
-  describe('isValidArray', () => {
-    it('should return true for arrays', () => {
-      expect(isValidArray([])).toBe(true);
-      expect(isValidArray([1, 2, 3])).toBe(true);
-      expect(isValidArray(['a', 'b'])).toBe(true);
-    });
-
-    it('should return false for non-arrays', () => {
-      expect(isValidArray({})).toBe(false);
-      expect(isValidArray('[]')).toBe(false);
-      expect(isValidArray(null)).toBe(false);
-      expect(isValidArray(undefined)).toBe(false);
-    });
-  });
-
-  describe('isValidObject', () => {
-    it('should return true for plain objects', () => {
-      expect(isValidObject({})).toBe(true);
-      expect(isValidObject({ key: 'value' })).toBe(true);
-    });
-
-    it('should return false for non-objects', () => {
-      expect(isValidObject([])).toBe(false);
-      expect(isValidObject(null)).toBe(false);
-      expect(isValidObject(undefined)).toBe(false);
-      expect(isValidObject('object')).toBe(false);
-      expect(isValidObject(123)).toBe(false);
-    });
-  });
-
-  describe('isValidEmail', () => {
-    it('should return true for valid email addresses', () => {
-      expect(isValidEmail('test@example.com')).toBe(true);
-      expect(isValidEmail('user.name+tag@domain.co.uk')).toBe(true);
-      expect(isValidEmail('simple@test.io')).toBe(true);
-    });
-
-    it('should return false for invalid email addresses', () => {
-      expect(isValidEmail('invalid-email')).toBe(false);
-      expect(isValidEmail('test@')).toBe(false);
-      expect(isValidEmail('@domain.com')).toBe(false);
-      expect(isValidEmail('test.domain.com')).toBe(false);
-      expect(isValidEmail('')).toBe(false);
-    });
-  });
-
-  describe('isValidUsername', () => {
-    it('should return true for valid usernames', () => {
-      expect(isValidUsername('user123')).toBe(true);
-      expect(isValidUsername('test_user')).toBe(true);
-      expect(isValidUsername('john-doe')).toBe(true);
-    });
-
-    it('should return false for invalid usernames', () => {
-      expect(isValidUsername('')).toBe(false);
-      expect(isValidUsername('a')).toBe(false); // too short
-      expect(isValidUsername('ab')).toBe(false); // too short
-      expect(isValidUsername('user@domain')).toBe(false); // invalid characters
-      expect(isValidUsername('user with spaces')).toBe(false); // spaces
-    });
-  });
-
-  describe('isValidPassword', () => {
-    it('should return true for valid passwords', () => {
-      expect(isValidPassword('password123')).toBe(true);
-      expect(isValidPassword('mySecurePass')).toBe(true);
-      expect(isValidPassword('12345678')).toBe(true);
-    });
-
-    it('should return false for invalid passwords', () => {
-      expect(isValidPassword('')).toBe(false);
-      expect(isValidPassword('short')).toBe(false); // too short
-      expect(isValidPassword('1234567')).toBe(false); // too short
-    });
-  });
-
-  describe('isValidUUID', () => {
-    it('should return true for valid UUIDs', () => {
-      expect(isValidUUID('123e4567-e89b-12d3-a456-426614174000')).toBe(true);
-      expect(isValidUUID('550e8400-e29b-41d4-a716-446655440000')).toBe(true);
-    });
-
-    it('should return false for invalid UUIDs', () => {
-      expect(isValidUUID('invalid-uuid')).toBe(false);
-      expect(isValidUUID('123-456-789')).toBe(false);
-      expect(isValidUUID('')).toBe(false);
-    });
-  });
-
-  describe('isValidDate', () => {
-    it('should return true for valid date strings', () => {
-      expect(isValidDate('2024-01-01')).toBe(true);
-      expect(isValidDate('2024-12-31T23:59:59.999Z')).toBe(true);
-      expect(isValidDate('January 1, 2024')).toBe(true);
-    });
-
-    it('should return false for invalid date strings', () => {
-      expect(isValidDate('invalid-date')).toBe(false);
-      expect(isValidDate('2024-13-01')).toBe(false); // invalid month
-      expect(isValidDate('')).toBe(false);
-    });
-  });
-
-  describe('isValidFileSize', () => {
-    const maxSize = 1024 * 1024; // 1MB
-
-    it('should return true for valid file sizes', () => {
-      expect(isValidFileSize(1024, maxSize)).toBe(true);
-      expect(isValidFileSize(maxSize, maxSize)).toBe(true);
-      expect(isValidFileSize(1, maxSize)).toBe(true);
-    });
-
-    it('should return false for invalid file sizes', () => {
-      expect(isValidFileSize(0, maxSize)).toBe(false);
-      expect(isValidFileSize(-1, maxSize)).toBe(false);
-      expect(isValidFileSize(maxSize + 1, maxSize)).toBe(false);
-    });
-  });
-
-  describe('isValidFileType', () => {
-    const allowedTypes = ['jpg', 'png', 'gif', 'pdf'];
-
-    it('should return true for allowed file types', () => {
-      expect(isValidFileType('image.jpg', allowedTypes)).toBe(true);
-      expect(isValidFileType('document.PDF', allowedTypes)).toBe(true); // case insensitive
-      expect(isValidFileType('photo.png', allowedTypes)).toBe(true);
-    });
-
-    it('should return false for disallowed file types', () => {
-      expect(isValidFileType('script.js', allowedTypes)).toBe(false);
-      expect(isValidFileType('data.txt', allowedTypes)).toBe(false);
-      expect(isValidFileType('noextension', allowedTypes)).toBe(false);
-    });
-  });
-
-  describe('sanitizeString', () => {
-    it('should trim whitespace and remove dangerous characters', () => {
-      expect(sanitizeString('  hello  ')).toBe('hello');
-      expect(sanitizeString('hello<script>alert("xss")</script>world')).toBe('helloalert("xss")world');
-      expect(sanitizeString('normal text')).toBe('normal text');
-    });
-  });
-
-  describe('sanitizeHTML', () => {
-    it('should escape HTML characters', () => {
-      expect(sanitizeHTML('<script>alert("xss")</script>')).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;');
-      expect(sanitizeHTML('Hello & Goodbye')).toBe('Hello &amp; Goodbye');
-      expect(sanitizeHTML("It's a test")).toBe('It&#x27;s a test');
-    });
-  });
-
-  describe('validateAndSanitizeUserInput', () => {
-    it('should validate and sanitize email input', () => {
-      expect(validateAndSanitizeUserInput('  test@example.com  ', 'email')).toBe('test@example.com');
-      expect(validateAndSanitizeUserInput('invalid-email', 'email')).toBeNull();
-      expect(validateAndSanitizeUserInput(123, 'email')).toBeNull();
-    });
-
-    it('should validate and sanitize username input', () => {
-      expect(validateAndSanitizeUserInput('  testuser  ', 'username')).toBe('testuser');
-      expect(validateAndSanitizeUserInput('ab', 'username')).toBeNull(); // too short
-      expect(validateAndSanitizeUserInput(123, 'username')).toBeNull();
-    });
-
-    it('should validate and sanitize string input', () => {
-      expect(validateAndSanitizeUserInput('  hello world  ', 'string')).toBe('hello world');
-      expect(validateAndSanitizeUserInput('', 'string')).toBeNull();
-      expect(validateAndSanitizeUserInput(123, 'string')).toBeNull();
-    });
-  });
-});

package/src/utils/apiUtils.ts

@@ -1,88 +0,0 @@
-/**
- * Utility functions for common API patterns
- */
-
-/**
- * Build URL search parameters from an object
- * @param params Object with parameter key-value pairs
- * @returns URLSearchParams instance
- */
-export function buildSearchParams(params: Record<string, any>): URLSearchParams {
-  const searchParams = new URLSearchParams();
-  
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== undefined && value !== null) {
-      searchParams.append(key, value.toString());
-    }
-  }
-  
-  return searchParams;
-}
-
-/**
- * Build URL with search parameters
- * @param baseUrl Base URL
- * @param params Object with parameter key-value pairs
- * @returns Complete URL with search parameters
- */
-export function buildUrl(baseUrl: string, params?: Record<string, any>): string {
-  if (!params) return baseUrl;
-  
-  const searchParams = buildSearchParams(params);
-  const queryString = searchParams.toString();
-  
-  return queryString ? `${baseUrl}?${queryString}` : baseUrl;
-}
-
-/**
- * Common pagination parameters
- */
-export interface PaginationParams {
-  limit?: number;
-  offset?: number;
-}
-
-/**
- * Build pagination search parameters
- * @param params Pagination parameters
- * @returns URLSearchParams with pagination
- */
-export function buildPaginationParams(params: PaginationParams): URLSearchParams {
-  return buildSearchParams(params);
-}
-
-/**
- * Common API response wrapper
- */
-export interface ApiResponse<T = any> {
-  data: T;
-  message?: string;
-  success?: boolean;
-}
-
-/**
- * Common error response wrapper
- */
-export interface ErrorResponse {
-  message: string;
-  code: string;
-  status: number;
-  details?: any;
-}
-
-/**
- * Safe JSON parsing with error handling
- * @param data Data to parse
- * @param fallback Fallback value if parsing fails
- * @returns Parsed data or fallback
- */
-export function safeJsonParse<T>(data: any, fallback: T): T {
-  if (typeof data === 'string') {
-    try {
-      return JSON.parse(data);
-    } catch {
-      return fallback;
-    }
-  }
-  return data as T;
-} 

package/src/utils/asyncUtils.ts

@@ -1,252 +0,0 @@
-/**
- * Async utilities for common asynchronous patterns and error handling
- */
-
-import { TTLCache, registerCacheForCleanup } from './cache';
-import { logger } from './loggerUtils';
-
-/**
- * Wrapper for async operations with automatic error handling
- * Returns null on error instead of throwing
- */
-export async function withErrorHandling<T>(
-  operation: () => Promise<T>,
-  errorHandler?: (error: any) => void,
-  context?: string
-): Promise<T | null> {
-  try {
-    return await operation();
-  } catch (error) {
-    if (errorHandler) {
-      errorHandler(error);
-    } else {
-      logger.error(`Error in ${context || 'operation'}`, error instanceof Error ? error : new Error(String(error)), {
-        component: 'asyncUtils',
-        method: 'withErrorHandling',
-      });
-    }
-    return null;
-  }
-}
-
-/**
- * Execute multiple async operations in parallel with error handling
- */
-export async function parallelWithErrorHandling<T>(
-  operations: (() => Promise<T>)[],
-  errorHandler?: (error: any, index: number) => void
-): Promise<(T | null)[]> {
-  const results = await Promise.allSettled(
-    operations.map((op, index) => 
-      withErrorHandling(op, error => errorHandler?.(error, index))
-    )
-  );
-  
-  return results.map(result => 
-    result.status === 'fulfilled' ? result.value : null
-  );
-}
-
-/**
- * Retry an async operation with exponential backoff
- * 
- * By default, does not retry on 4xx errors (client errors).
- * Use shouldRetry callback to customize retry behavior.
- */
-export async function retryAsync<T>(
-  operation: () => Promise<T>,
-  maxRetries = 3,
-  baseDelay = 1000,
-  shouldRetry?: (error: any) => boolean
-): Promise<T> {
-  let lastError: any;
-  
-  // Default shouldRetry: don't retry on 4xx errors
-  const defaultShouldRetry = (error: any): boolean => {
-    // Don't retry on 4xx errors (client errors)
-    if (error?.response?.status >= 400 && error?.response?.status < 500) {
-      return false;
-    }
-    return true;
-  };
-  
-  const retryCheck = shouldRetry || defaultShouldRetry;
-  
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error;
-      
-      if (attempt === maxRetries) {
-        break;
-      }
-      
-      if (!retryCheck(error)) {
-        break;
-      }
-      
-      // Calculate delay with exponential backoff and jitter
-      const delay = baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
-      await new Promise(resolve => setTimeout(resolve, delay));
-    }
-  }
-  
-  throw lastError;
-}
-
-/**
- * Debounce async function calls
- */
-export function debounceAsync<T extends (...args: any[]) => Promise<any>>(
-  func: T,
-  delay: number
-): (...args: Parameters<T>) => Promise<ReturnType<T>> {
-  let timeoutId: ReturnType<typeof setTimeout>;
-  const lastPromise: Promise<ReturnType<T>> | null = null;
-  
-  return (...args: Parameters<T>): Promise<ReturnType<T>> => {
-    return new Promise((resolve, reject) => {
-      clearTimeout(timeoutId);
-      
-      timeoutId = setTimeout(async () => {
-        try {
-          const result = await func(...args);
-          resolve(result);
-        } catch (error) {
-          reject(error);
-        }
-      }, delay);
-    });
-  };
-}
-
-/**
- * Throttle async function calls
- */
-export function throttleAsync<T extends (...args: any[]) => Promise<any>>(
-  func: T,
-  limit: number,
-  interval: number
-): (...args: Parameters<T>) => Promise<ReturnType<T>> {
-  let inThrottle = false;
-  let lastPromise: Promise<ReturnType<T>> | null = null;
-  
-  return (...args: Parameters<T>): Promise<ReturnType<T>> => {
-    if (inThrottle) {
-      return lastPromise!;
-    }
-    
-    inThrottle = true;
-    lastPromise = func(...args);
-    
-    setTimeout(() => {
-      inThrottle = false;
-    }, interval);
-    
-    return lastPromise;
-  };
-}
-
-/**
- * Execute async operations sequentially with progress tracking
- */
-export async function sequentialWithProgress<T>(
-  operations: (() => Promise<T>)[],
-  onProgress?: (completed: number, total: number) => void
-): Promise<T[]> {
-  const results: T[] = [];
-  
-  for (let i = 0; i < operations.length; i++) {
-    const result = await operations[i]();
-    results.push(result);
-    onProgress?.(i + 1, operations.length);
-  }
-  
-  return results;
-}
-
-/**
- * Batch async operations
- */
-export async function batchAsync<T>(
-  items: T[],
-  batchSize: number,
-  processor: (batch: T[]) => Promise<void>
-): Promise<void> {
-  for (let i = 0; i < items.length; i += batchSize) {
-    const batch = items.slice(i, i + batchSize);
-    await processor(batch);
-  }
-}
-
-/**
- * Create a cancellable async operation
- */
-export function createCancellableAsync<T>(
-  operation: (signal: AbortSignal) => Promise<T>
-): { execute: () => Promise<T>; cancel: () => void } {
-  let abortController: AbortController | null = null;
-  
-  return {
-    execute: async () => {
-      abortController = new AbortController();
-      return await operation(abortController.signal);
-    },
-    cancel: () => {
-      abortController?.abort();
-    }
-  };
-}
-
-/**
- * Timeout wrapper for async operations
- */
-export async function withTimeout<T>(
-  operation: Promise<T>,
-  timeoutMs: number,
-  timeoutMessage?: string
-): Promise<T> {
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    setTimeout(() => {
-      reject(new Error(timeoutMessage || `Operation timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-  });
-  
-  return Promise.race([operation, timeoutPromise]);
-}
-
-/**
- * Execute async operation with loading state
- */
-export async function withLoadingState<T>(
-  operation: () => Promise<T>,
-  setLoading: (loading: boolean) => void
-): Promise<T> {
-  setLoading(true);
-  try {
-    return await operation();
-  } finally {
-    setLoading(false);
-  }
-}
-
-/**
- * Create a promise that resolves after a delay
- */
-export const delay = (ms: number): Promise<void> => 
-  new Promise(resolve => setTimeout(resolve, ms));
-
-/**
- * Execute async operation with retry on specific errors
- */
-export async function retryOnError<T>(
-  operation: () => Promise<T>,
-  retryableErrors: (string | number)[],
-  maxRetries = 3
-): Promise<T> {
-  return retryAsync(operation, maxRetries, 1000, (error) => {
-    const errorCode = error?.code || error?.status || error?.message;
-    return retryableErrors.includes(errorCode);
-  });
-}