@oxyhq/services 5.9.1 → 5.9.3

package/src/utils/hookUtils.ts

@@ -0,0 +1,397 @@
+/**
+ * React hook utilities for common patterns and state management
+ */
+
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+
+/**
+ * Hook for managing async operations with loading, error, and data states
+ */
+export function useAsync<T>(
+  asyncFn: () => Promise<T>,
+  deps: any[] = []
+) {
+  const [data, setData] = useState<T | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const execute = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    
+    try {
+      const result = await asyncFn();
+      setData(result);
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      setError(error);
+      throw error;
+    } finally {
+      setLoading(false);
+    }
+  }, deps);
+
+  return { data, loading, error, execute };
+}
+
+/**
+ * Hook for managing async operations that execute on mount
+ */
+export function useAsyncEffect<T>(
+  asyncFn: () => Promise<T>,
+  deps: any[] = []
+) {
+  const [data, setData] = useState<T | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let mounted = true;
+    
+    const execute = async () => {
+      try {
+        const result = await asyncFn();
+        if (mounted) {
+          setData(result);
+          setLoading(false);
+        }
+      } catch (err) {
+        if (mounted) {
+          const error = err instanceof Error ? err : new Error(String(err));
+          setError(error);
+          setLoading(false);
+        }
+      }
+    };
+
+    execute();
+
+    return () => {
+      mounted = false;
+    };
+  }, deps);
+
+  return { data, loading, error };
+}
+
+/**
+ * Hook for debounced values
+ */
+export function useDebounce<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState<T>(value);
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+
+  return debouncedValue;
+}
+
+/**
+ * Hook for throttled values
+ */
+export function useThrottle<T>(value: T, delay: number): T {
+  const [throttledValue, setThrottledValue] = useState<T>(value);
+  const lastRun = useRef(Date.now());
+
+  useEffect(() => {
+    const handler = setTimeout(() => {
+      if (Date.now() - lastRun.current >= delay) {
+        setThrottledValue(value);
+        lastRun.current = Date.now();
+      }
+    }, delay - (Date.now() - lastRun.current));
+
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+
+  return throttledValue;
+}
+
+/**
+ * Hook for previous value
+ */
+export function usePrevious<T>(value: T): T | undefined {
+  const ref = useRef<T>();
+  
+  useEffect(() => {
+    ref.current = value;
+  });
+  
+  return ref.current;
+}
+
+/**
+ * Hook for boolean state with toggle
+ */
+export function useToggle(initialValue: boolean = false) {
+  const [value, setValue] = useState(initialValue);
+  
+  const toggle = useCallback(() => setValue(v => !v), []);
+  const setTrue = useCallback(() => setValue(true), []);
+  const setFalse = useCallback(() => setValue(false), []);
+  
+  return { value, toggle, setTrue, setFalse, setValue };
+}
+
+/**
+ * Hook for counter state
+ */
+export function useCounter(initialValue: number = 0) {
+  const [count, setCount] = useState(initialValue);
+  
+  const increment = useCallback(() => setCount(c => c + 1), []);
+  const decrement = useCallback(() => setCount(c => c - 1), []);
+  const reset = useCallback(() => setCount(initialValue), [initialValue]);
+  const setValue = useCallback((value: number) => setCount(value), []);
+  
+  return { count, increment, decrement, reset, setValue };
+}
+
+/**
+ * Hook for local storage
+ */
+export function useLocalStorage<T>(key: string, initialValue: T) {
+  const [storedValue, setStoredValue] = useState<T>(() => {
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      console.error(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+
+  const setValue = useCallback((value: T | ((val: T) => T)) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+      window.localStorage.setItem(key, JSON.stringify(valueToStore));
+    } catch (error) {
+      console.error(`Error setting localStorage key "${key}":`, error);
+    }
+  }, [key, storedValue]);
+
+  return [storedValue, setValue] as const;
+}
+
+/**
+ * Hook for session storage
+ */
+export function useSessionStorage<T>(key: string, initialValue: T) {
+  const [storedValue, setStoredValue] = useState<T>(() => {
+    try {
+      const item = window.sessionStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      console.error(`Error reading sessionStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+
+  const setValue = useCallback((value: T | ((val: T) => T)) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+      window.sessionStorage.setItem(key, JSON.stringify(valueToStore));
+    } catch (error) {
+      console.error(`Error setting sessionStorage key "${key}":`, error);
+    }
+  }, [key, storedValue]);
+
+  return [storedValue, setValue] as const;
+}
+
+/**
+ * Hook for window size
+ */
+export function useWindowSize() {
+  const [windowSize, setWindowSize] = useState({
+    width: window.innerWidth,
+    height: window.innerHeight,
+  });
+
+  useEffect(() => {
+    const handleResize = () => {
+      setWindowSize({
+        width: window.innerWidth,
+        height: window.innerHeight,
+      });
+    };
+
+    window.addEventListener('resize', handleResize);
+    return () => window.removeEventListener('resize', handleResize);
+  }, []);
+
+  return windowSize;
+}
+
+/**
+ * Hook for scroll position
+ */
+export function useScrollPosition() {
+  const [scrollPosition, setScrollPosition] = useState(0);
+
+  useEffect(() => {
+    const handleScroll = () => {
+      setScrollPosition(window.pageYOffset);
+    };
+
+    window.addEventListener('scroll', handleScroll);
+    return () => window.removeEventListener('scroll', handleScroll);
+  }, []);
+
+  return scrollPosition;
+}
+
+/**
+ * Hook for online/offline status
+ */
+export function useOnlineStatus() {
+  const [isOnline, setIsOnline] = useState(navigator.onLine);
+
+  useEffect(() => {
+    const handleOnline = () => setIsOnline(true);
+    const handleOffline = () => setIsOnline(false);
+
+    window.addEventListener('online', handleOnline);
+    window.addEventListener('offline', handleOffline);
+
+    return () => {
+      window.removeEventListener('online', handleOnline);
+      window.removeEventListener('offline', handleOffline);
+    };
+  }, []);
+
+  return isOnline;
+}
+
+/**
+ * Hook for media queries
+ */
+export function useMediaQuery(query: string): boolean {
+  const [matches, setMatches] = useState(false);
+
+  useEffect(() => {
+    const media = window.matchMedia(query);
+    if (media.matches !== matches) {
+      setMatches(media.matches);
+    }
+
+    const listener = () => setMatches(media.matches);
+    media.addEventListener('change', listener);
+    
+    return () => media.removeEventListener('change', listener);
+  }, [matches, query]);
+
+  return matches;
+}
+
+/**
+ * Hook for keyboard events
+ */
+export function useKeyPress(targetKey: string): boolean {
+  const [keyPressed, setKeyPressed] = useState(false);
+
+  useEffect(() => {
+    const downHandler = ({ key }: KeyboardEvent) => {
+      if (key === targetKey) {
+        setKeyPressed(true);
+      }
+    };
+
+    const upHandler = ({ key }: KeyboardEvent) => {
+      if (key === targetKey) {
+        setKeyPressed(false);
+      }
+    };
+
+    window.addEventListener('keydown', downHandler);
+    window.addEventListener('keyup', upHandler);
+
+    return () => {
+      window.removeEventListener('keydown', downHandler);
+      window.removeEventListener('keyup', upHandler);
+    };
+  }, [targetKey]);
+
+  return keyPressed;
+}
+
+/**
+ * Hook for click outside detection
+ */
+export function useClickOutside(ref: React.RefObject<HTMLElement>, handler: () => void) {
+  useEffect(() => {
+    const listener = (event: MouseEvent | TouchEvent) => {
+      if (!ref.current || ref.current.contains(event.target as Node)) {
+        return;
+      }
+      handler();
+    };
+
+    document.addEventListener('mousedown', listener);
+    document.addEventListener('touchstart', listener);
+
+    return () => {
+      document.removeEventListener('mousedown', listener);
+      document.removeEventListener('touchstart', listener);
+    };
+  }, [ref, handler]);
+}
+
+/**
+ * Hook for form validation
+ */
+export function useFormValidation<T extends Record<string, any>>(
+  initialValues: T,
+  validationSchema: (values: T) => Partial<Record<keyof T, string>>
+) {
+  const [values, setValues] = useState<T>(initialValues);
+  const [errors, setErrors] = useState<Partial<Record<keyof T, string>>>({});
+  const [touched, setTouched] = useState<Partial<Record<keyof T, boolean>>>({});
+
+  const validate = useCallback((valuesToValidate: T) => {
+    return validationSchema(valuesToValidate);
+  }, [validationSchema]);
+
+  const setValue = useCallback((field: keyof T, value: any) => {
+    setValues(prev => ({ ...prev, [field]: value }));
+    if (touched[field]) {
+      const newErrors = validate({ ...values, [field]: value });
+      setErrors(prev => ({ ...prev, [field]: newErrors[field] }));
+    }
+  }, [values, touched, validate]);
+
+  const setTouchedField = useCallback((field: keyof T) => {
+    setTouched(prev => ({ ...prev, [field]: true }));
+    const newErrors = validate(values);
+    setErrors(prev => ({ ...prev, [field]: newErrors[field] }));
+  }, [values, validate]);
+
+  const isValid = useMemo(() => {
+    const validationErrors = validate(values);
+    return Object.keys(validationErrors).length === 0;
+  }, [values, validate]);
+
+  return {
+    values,
+    errors,
+    touched,
+    isValid,
+    setValue,
+    setTouchedField,
+    setValues,
+    setErrors,
+    setTouched
+  };
+} 

package/src/utils/loggerUtils.ts

@@ -0,0 +1,153 @@
+/**
+ * Centralized logging utilities for consistent logging across the application
+ */
+
+export enum LogLevel {
+  DEBUG = 0,
+  INFO = 1,
+  WARN = 2,
+  ERROR = 3,
+  NONE = 4
+}
+
+export interface LogContext {
+  component?: string;
+  method?: string;
+  userId?: string;
+  sessionId?: string;
+  requestId?: string;
+  [key: string]: any;
+}
+
+class Logger {
+  private level: LogLevel = LogLevel.INFO;
+  private isDevelopment: boolean = process.env.NODE_ENV === 'development';
+
+  setLevel(level: LogLevel): void {
+    this.level = level;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    return level >= this.level;
+  }
+
+  private formatMessage(level: string, message: string, context?: LogContext): string {
+    const timestamp = new Date().toISOString();
+    const contextStr = context ? ` [${Object.entries(context).map(([k, v]) => `${k}:${v}`).join(', ')}]` : '';
+    return `[${timestamp}] ${level}${contextStr}: ${message}`;
+  }
+
+  debug(message: string, context?: LogContext, ...args: any[]): void {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      const formattedMessage = this.formatMessage('DEBUG', message, context);
+      if (this.isDevelopment) {
+        console.log(formattedMessage, ...args);
+      }
+    }
+  }
+
+  info(message: string, context?: LogContext, ...args: any[]): void {
+    if (this.shouldLog(LogLevel.INFO)) {
+      const formattedMessage = this.formatMessage('INFO', message, context);
+      console.log(formattedMessage, ...args);
+    }
+  }
+
+  warn(message: string, context?: LogContext, ...args: any[]): void {
+    if (this.shouldLog(LogLevel.WARN)) {
+      const formattedMessage = this.formatMessage('WARN', message, context);
+      console.warn(formattedMessage, ...args);
+    }
+  }
+
+  error(message: string, error?: any, context?: LogContext, ...args: any[]): void {
+    if (this.shouldLog(LogLevel.ERROR)) {
+      const formattedMessage = this.formatMessage('ERROR', message, context);
+      if (error) {
+        console.error(formattedMessage, error, ...args);
+      } else {
+        console.error(formattedMessage, ...args);
+      }
+    }
+  }
+
+  // Specialized logging methods for common patterns
+  auth(message: string, context?: LogContext, ...args: any[]): void {
+    this.info(`🔐 ${message}`, { ...context, category: 'auth' }, ...args);
+  }
+
+  api(message: string, context?: LogContext, ...args: any[]): void {
+    this.info(`🌐 ${message}`, { ...context, category: 'api' }, ...args);
+  }
+
+  session(message: string, context?: LogContext, ...args: any[]): void {
+    this.info(`📱 ${message}`, { ...context, category: 'session' }, ...args);
+  }
+
+  user(message: string, context?: LogContext, ...args: any[]): void {
+    this.info(`👤 ${message}`, { ...context, category: 'user' }, ...args);
+  }
+
+  device(message: string, context?: LogContext, ...args: any[]): void {
+    this.info(`📱 ${message}`, { ...context, category: 'device' }, ...args);
+  }
+
+  payment(message: string, context?: LogContext, ...args: any[]): void {
+    this.info(`💳 ${message}`, { ...context, category: 'payment' }, ...args);
+  }
+
+  // Performance logging
+  performance(operation: string, duration: number, context?: LogContext): void {
+    const level = duration > 1000 ? LogLevel.WARN : LogLevel.INFO;
+    const message = `⏱️ ${operation} completed in ${duration}ms`;
+    if (level === LogLevel.WARN) {
+      this.warn(message, { ...context, category: 'performance', duration });
+    } else {
+      this.info(message, { ...context, category: 'performance', duration });
+    }
+  }
+
+  // Error logging with stack trace
+  errorWithStack(message: string, error: Error, context?: LogContext): void {
+    this.error(message, error, { ...context, stack: error.stack });
+  }
+
+  // Group related log messages
+  group(label: string, fn: () => void): void {
+    if (this.isDevelopment && this.shouldLog(LogLevel.DEBUG)) {
+      console.group(label);
+      fn();
+      console.groupEnd();
+    } else {
+      fn();
+    }
+  }
+}
+
+// Create singleton instance
+export const logger = new Logger();
+
+// Convenience functions for common logging patterns
+export const logAuth = (message: string, context?: LogContext, ...args: any[]) => 
+  logger.auth(message, context, ...args);
+
+export const logApi = (message: string, context?: LogContext, ...args: any[]) => 
+  logger.api(message, context, ...args);
+
+export const logSession = (message: string, context?: LogContext, ...args: any[]) => 
+  logger.session(message, context, ...args);
+
+export const logUser = (message: string, context?: LogContext, ...args: any[]) => 
+  logger.user(message, context, ...args);
+
+export const logDevice = (message: string, context?: LogContext, ...args: any[]) => 
+  logger.device(message, context, ...args);
+
+export const logPayment = (message: string, context?: LogContext, ...args: any[]) => 
+  logger.payment(message, context, ...args);
+
+export const logError = (message: string, error?: any, context?: LogContext, ...args: any[]) => 
+  logger.error(message, error, context, ...args);
+
+export const logPerformance = (operation: string, duration: number, context?: LogContext) => 
+  logger.performance(operation, duration, context); 

package/src/utils/validationUtils.ts

@@ -0,0 +1,158 @@
+/**
+ * Validation utilities for common data validation patterns
+ */
+
+/**
+ * Email validation regex
+ */
+export const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+/**
+ * Username validation regex (alphanumeric, underscore, dash, 3-30 chars)
+ */
+export const USERNAME_REGEX = /^[a-zA-Z0-9_-]{3,30}$/;
+
+/**
+ * Password validation regex (at least 8 chars, 1 uppercase, 1 lowercase, 1 number)
+ */
+export const PASSWORD_REGEX = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d@$!%*?&]{8,}$/;
+
+/**
+ * Validate email format
+ */
+export function isValidEmail(email: string): boolean {
+  return EMAIL_REGEX.test(email);
+}
+
+/**
+ * Validate username format
+ */
+export function isValidUsername(username: string): boolean {
+  return USERNAME_REGEX.test(username);
+}
+
+/**
+ * Validate password strength
+ */
+export function isValidPassword(password: string): boolean {
+  return PASSWORD_REGEX.test(password);
+}
+
+/**
+ * Validate required string
+ */
+export function isRequiredString(value: any): boolean {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+/**
+ * Validate required number
+ */
+export function isRequiredNumber(value: any): boolean {
+  return typeof value === 'number' && !isNaN(value);
+}
+
+/**
+ * Validate required boolean
+ */
+export function isRequiredBoolean(value: any): boolean {
+  return typeof value === 'boolean';
+}
+
+/**
+ * Validate array
+ */
+export function isValidArray(value: any): boolean {
+  return Array.isArray(value);
+}
+
+/**
+ * Validate object
+ */
+export function isValidObject(value: any): boolean {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Validate UUID format
+ */
+export function isValidUUID(uuid: string): boolean {
+  const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return UUID_REGEX.test(uuid);
+}
+
+/**
+ * Validate URL format
+ */
+export function isValidURL(url: string): boolean {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate date string
+ */
+export function isValidDate(dateString: string): boolean {
+  const date = new Date(dateString);
+  return !isNaN(date.getTime());
+}
+
+/**
+ * Validate file size (in bytes)
+ */
+export function isValidFileSize(size: number, maxSize: number): boolean {
+  return size > 0 && size <= maxSize;
+}
+
+/**
+ * Validate file type
+ */
+export function isValidFileType(filename: string, allowedTypes: string[]): boolean {
+  const extension = filename.split('.').pop()?.toLowerCase();
+  return extension ? allowedTypes.includes(extension) : false;
+}
+
+/**
+ * Sanitize string input
+ */
+export function sanitizeString(input: string): string {
+  return input.trim().replace(/[<>]/g, '');
+}
+
+/**
+ * Sanitize HTML input
+ */
+export function sanitizeHTML(input: string): string {
+  return input
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#x27;');
+}
+
+/**
+ * Validate and sanitize user input
+ */
+export function validateAndSanitizeUserInput(input: any, type: 'string' | 'email' | 'username'): string | null {
+  if (typeof input !== 'string') {
+    return null;
+  }
+
+  const sanitized = sanitizeString(input);
+  
+  switch (type) {
+    case 'email':
+      return isValidEmail(sanitized) ? sanitized : null;
+    case 'username':
+      return isValidUsername(sanitized) ? sanitized : null;
+    case 'string':
+      return isRequiredString(sanitized) ? sanitized : null;
+    default:
+      return null;
+  }
+} 

package/lib/commonjs/models/secureSession.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=secureSession.js.map

package/lib/commonjs/models/secureSession.js.map

@@ -1 +0,0 @@
-{"version":3,"names":[],"sourceRoot":"../../../src","sources":["models/secureSession.ts"],"mappings":"","ignoreList":[]}