@umituz/react-native-auth 3.4.32 → 3.4.34

package/src/infrastructure/utils/validation/BaseValidators.ts

@@ -0,0 +1,35 @@
+import { ValidationResult } from './types';
+
+/**
+ * Validate required field (not null, undefined, or empty string)
+ */
+export const validateRequired = (
+  value: any,
+  fieldName: string = "Field",
+  errorKey?: string
+): ValidationResult => {
+  const isValid = value !== undefined && value !== null && (typeof value === 'string' ? value.trim() !== "" : true);
+  
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `${fieldName} is required`)
+  };
+};
+
+/**
+ * Validate pattern (regex)
+ */
+export const validatePattern = (
+  value: string,
+  pattern: RegExp,
+  fieldName: string = "Field",
+  errorKey?: string
+): ValidationResult => {
+  if (!value) return { isValid: true }; // Use validateRequired for mandatory check
+
+  const isValid = pattern.test(value);
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `${fieldName} format is invalid`)
+  };
+};

package/src/infrastructure/utils/validation/CollectionValidators.ts

@@ -0,0 +1,56 @@
+import { ValidationResult } from './types';
+
+/**
+ * Custom enum validation
+ * Generic validator for enum-like values with custom options
+ */
+export const validateEnum = (
+  value: string,
+  validOptions: readonly string[],
+  fieldName: string = "Field",
+  errorKey?: string
+): ValidationResult => {
+  if (!value || value.trim() === "") {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  const isValid = validOptions.includes(value.toLowerCase());
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `Please select a valid ${fieldName.toLowerCase()}`)
+  };
+};
+
+/**
+ * Tags validation
+ * Generic validator for array of strings with constraints
+ */
+export const validateTags = (
+  tags: string[],
+  maxTags: number = 10,
+  maxTagLength: number = 20,
+  errorKey?: string
+): ValidationResult => {
+  if (!Array.isArray(tags)) {
+    return { isValid: false, error: errorKey || "Tags must be an array" };
+  }
+
+  if (tags.length > maxTags) {
+    return { isValid: false, error: errorKey || `Maximum ${maxTags} tags allowed` };
+  }
+
+  for (const tag of tags) {
+    if (typeof tag !== "string" || tag.trim().length === 0) {
+      return { isValid: false, error: errorKey || "All tags must be non-empty strings" };
+    }
+
+    if (tag.trim().length > maxTagLength) {
+      return {
+        isValid: false,
+        error: errorKey || `Each tag must be at most ${maxTagLength} characters`,
+      };
+    }
+  }
+
+  return { isValid: true };
+};

package/src/infrastructure/utils/validation/DateValidators.ts

@@ -0,0 +1,63 @@
+import { ValidationResult } from './types';
+
+/**
+ * Validate date of birth
+ */
+export const validateDateOfBirth = (
+  date: Date,
+  minAge: number = 13,
+  errorKey?: string
+): ValidationResult => {
+  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
+    return { isValid: false, error: "Please enter a valid date" };
+  }
+
+  const today = new Date();
+  let age = today.getFullYear() - date.getFullYear();
+  const m = today.getMonth() - date.getMonth();
+  if (m < 0 || (m === 0 && today.getDate() < date.getDate())) {
+    age--;
+  }
+
+  if (age < minAge) {
+    return { isValid: false, error: errorKey || `You must be at least ${minAge} years old` };
+  }
+
+  if (age > 120) {
+    return { isValid: false, error: "Please enter a valid date of birth" };
+  }
+
+  return { isValid: true };
+};
+
+/**
+ * Date range validation
+ * Validates date is within a specific range
+ */
+export const validateDateRange = (
+  date: Date,
+  minDate?: Date,
+  maxDate?: Date,
+  fieldName: string = "Date",
+  errorKey?: string
+): ValidationResult => {
+  if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
+    return { isValid: false, error: errorKey || `Please enter a valid ${fieldName.toLowerCase()}` };
+  }
+
+  if (minDate && date < minDate) {
+    return {
+      isValid: false,
+      error: errorKey || `${fieldName} cannot be before ${minDate.toLocaleDateString()}`,
+    };
+  }
+
+  if (maxDate && date > maxDate) {
+    return {
+      isValid: false,
+      error: errorKey || `${fieldName} cannot be after ${maxDate.toLocaleDateString()}`,
+    };
+  }
+
+  return { isValid: true };
+};

package/src/infrastructure/utils/validation/FormValidators.ts

@@ -0,0 +1,22 @@
+import { ValidationResult } from './types';
+
+/**
+ * Batch validation helper
+ * Validates multiple fields and returns all errors in a record
+ */
+export const batchValidate = (
+  validations: Array<{ field: string; validator: () => ValidationResult }>,
+): { isValid: boolean; errors: Record<string, string> } => {
+  const errors: Record<string, string> = {};
+  let isValid = true;
+
+  validations.forEach(({ field, validator }) => {
+    const result = validator();
+    if (!result.isValid && result.error) {
+      errors[field] = result.error;
+      isValid = false;
+    }
+  });
+
+  return { isValid, errors };
+};

package/src/infrastructure/utils/validation/NumberValidators.ts

@@ -0,0 +1,55 @@
+import { ValidationResult } from './types';
+
+/**
+ * Validate numeric range
+ */
+export const validateNumberRange = (
+  value: number,
+  min: number,
+  max: number,
+  fieldName: string = "Number",
+  errorKey?: string
+): ValidationResult => {
+  const isValid = value >= min && value <= max;
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `${fieldName} must be between ${min} and ${max}`)
+  };
+};
+
+/**
+ * Validate positive number
+ */
+export const validatePositiveNumber = (
+  value: number,
+  fieldName: string = "Number",
+  errorKey?: string
+): ValidationResult => {
+  const isValid = value > 0;
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `${fieldName} must be a positive number`)
+  };
+};
+
+/**
+ * Validate age based on birth date
+ */
+export const validateAge = (
+  birthDate: Date,
+  minAge: number,
+  errorKey?: string
+): ValidationResult => {
+  const today = new Date();
+  let age = today.getFullYear() - birthDate.getFullYear();
+  const m = today.getMonth() - birthDate.getMonth();
+  if (m < 0 || (m === 0 && today.getDate() < birthDate.getDate())) {
+    age--;
+  }
+
+  const isValid = age >= minAge;
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `You must be at least ${minAge} years old`)
+  };
+};

package/src/infrastructure/utils/validation/StringValidators.ts

@@ -0,0 +1,55 @@
+import { ValidationResult } from './types';
+
+/**
+ * Validate min length of a string
+ */
+export const validateMinLength = (
+  value: string,
+  minLength: number,
+  fieldName: string = "Field",
+  errorKey?: string
+): ValidationResult => {
+  if (!value) return { isValid: false, error: `${fieldName} is required` };
+  
+  const isValid = value.trim().length >= minLength;
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `${fieldName} must be at least ${minLength} characters`)
+  };
+};
+
+/**
+ * Validate max length of a string
+ */
+export const validateMaxLength = (
+  value: string,
+  maxLength: number,
+  fieldName: string = "Field",
+  errorKey?: string
+): ValidationResult => {
+  if (!value) return { isValid: true };
+  
+  const isValid = value.trim().length <= maxLength;
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || `${fieldName} must be at most ${maxLength} characters`)
+  };
+};
+
+/**
+ * Validate phone number (E.164 format)
+ */
+export const validatePhone = (
+  phone: string,
+  errorKey?: string
+): ValidationResult => {
+  if (!phone) return { isValid: true };
+  
+  const phoneRegex = /^\+[1-9]\d{1,14}$/;
+  const isValid = phoneRegex.test(phone);
+  
+  return {
+    isValid,
+    error: isValid ? undefined : (errorKey || "Please enter a valid phone number")
+  };
+};

package/src/infrastructure/utils/validation/sanitization.ts

@@ -0,0 +1,98 @@
+/**
+ * Sanitization Utilities
+ * Secure input cleaning for user data
+ */
+
+/**
+ * Security constants for input validation
+ */
+export const SECURITY_LIMITS = {
+  EMAIL_MAX_LENGTH: 254, // RFC 5321
+  PASSWORD_MIN_LENGTH: 6,
+  PASSWORD_MAX_LENGTH: 128,
+  NAME_MAX_LENGTH: 100,
+  GENERAL_TEXT_MAX_LENGTH: 500,
+} as const;
+
+/**
+ * Trim and normalize whitespace
+ */
+export const sanitizeWhitespace = (input: string): string => {
+  return input.trim().replace(/\s+/g, ' ');
+};
+
+/**
+ * Sanitize email address
+ * - Trim whitespace
+ * - Convert to lowercase
+ * - Limit length
+ */
+export const sanitizeEmail = (email: string): string => {
+  const trimmed = email.trim().toLowerCase();
+  return trimmed.substring(0, SECURITY_LIMITS.EMAIL_MAX_LENGTH);
+};
+
+/**
+ * Sanitize password
+ * - Only trim (preserve case and special chars)
+ * - Limit length to prevent DoS
+ */
+export const sanitizePassword = (password: string): string => {
+  // Don't trim password to preserve intentional spaces
+  // Only limit length
+  return password.substring(0, SECURITY_LIMITS.PASSWORD_MAX_LENGTH);
+};
+
+/**
+ * Sanitize display name
+ * - Trim whitespace
+ * - Normalize multiple spaces
+ * - Remove potential XSS characters
+ * - Limit length
+ */
+export const sanitizeName = (name: string): string => {
+  const trimmed = sanitizeWhitespace(name);
+  // Remove HTML tags and script content
+  const noTags = trimmed.replace(/<[^>]*>/g, '');
+  return noTags.substring(0, SECURITY_LIMITS.NAME_MAX_LENGTH);
+};
+
+/**
+ * Sanitize general text input
+ * - Trim whitespace
+ * - Remove HTML/script tags
+ * - Limit length
+ */
+export const sanitizeText = (text: string): string => {
+  const trimmed = sanitizeWhitespace(text);
+  const noTags = trimmed.replace(/<[^>]*>/g, '');
+  return noTags.substring(0, SECURITY_LIMITS.GENERAL_TEXT_MAX_LENGTH);
+};
+
+/**
+ * Check if string contains potentially dangerous characters
+ */
+export const containsDangerousChars = (input: string): boolean => {
+  // Check for common XSS patterns
+  const dangerousPatterns = [
+    /<script/i,
+    /javascript:/i,
+    /on\w+\s*=/i, // onclick, onload, etc.
+    /<iframe/i,
+    /eval\(/i,
+  ];
+
+  return dangerousPatterns.some(pattern => pattern.test(input));
+};
+
+/**
+ * Validate string length is within bounds
+ */
+export const isWithinLengthLimit = (
+  input: string,
+  maxLength: number,
+  minLength = 0
+): boolean => {
+  const length = input.trim().length;
+  return length >= minLength && length <= maxLength;
+};

package/src/infrastructure/utils/validation/types.ts

@@ -0,0 +1,15 @@
+/**
+ * Validation Result Interface
+ * Represents the outcome of a validation operation
+ */
+export interface ValidationResult {
+  /**
+   * Whether the validation passed
+   */
+  isValid: boolean;
+
+  /**
+   * Error message or translation key if validation failed
+   */
+  error?: string;
+}