@umituz/react-native-firebase 2.4.30 → 2.4.33

package/src/domains/auth/presentation/hooks/shared/safe-state-hooks.util.ts

@@ -1,76 +0,0 @@
-/**
- * Safe State Hooks
- * React hooks for safe state management and mounted state tracking
- */
-
-import { useState, useCallback, useRef, useEffect } from 'react';
-
-/**
- * Hook for tracking mounted state
- */
-export function useIsMounted(): () => boolean {
-  const isMountedRef = useRef<boolean>(true);
-
-  useEffect(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-
-  return useCallback(() => isMountedRef.current, []);
-}
-
-/**
- * Hook for safe state updates (only if mounted)
- */
-export function useSafeState<T>(
-  initialValue: T
-): [T, (value: T | ((prev: T) => T)) => void] {
-  const isMounted = useIsMounted();
-  const [state, setState] = useState<T>(initialValue);
-
-  const setSafeState = useCallback(
-    (value: T | ((prev: T) => T)) => {
-      if (isMounted()) {
-        setState(value);
-      }
-    },
-    [isMounted]
-  );
-
-  return [state, setSafeState];
-}
-
-/**
- * Hook for debounced value updates
- */
-export function useDebouncedValue<T>(value: T, delayMs: number): T {
-  const [debouncedValue, setDebouncedValue] = useState<T>(value);
-
-  useEffect(() => {
-    const handler = setTimeout(() => {
-      setDebouncedValue(value);
-    }, delayMs);
-
-    return () => {
-      clearTimeout(handler);
-    };
-  }, [value, delayMs]);
-
-  return debouncedValue;
-}
-
-/**
- * Hook for managing cleanup callbacks
- */
-export function useCleanup(
-  cleanupFn: () => void,
-  deps: React.DependencyList = []
-): void {
-  useEffect(() => {
-    return () => {
-      cleanupFn();
-    };
-  }, deps);
-}

package/src/domains/auth/presentation/hooks/shared/state-hooks.util.ts

@@ -1,97 +0,0 @@
-/**
- * State Management Hooks
- * React hooks for managing component state with loading and error handling
- */
-
-import { useState, useCallback, useRef } from 'react';
-
-/**
- * Hook state management result
- */
-export interface HookState<T> {
-  value: T;
-  loading: boolean;
-  error: Error | null;
-}
-
-/**
- * Hook state actions
- */
-export interface HookStateActions<T> {
-  setValue: (value: T) => void;
-  setLoading: (loading: boolean) => void;
-  setError: (error: Error | null) => void;
-  clearError: () => void;
-  reset: () => void;
-}
-
-/**
- * Create a stateful hook with loading and error handling
- */
-export function useHookState<T>(
-  initialValue: T
-): [HookState<T>, HookStateActions<T>] {
-  const [value, setValue] = useState<T>(initialValue);
-  const [loading, setLoading] = useState<boolean>(false);
-  const [error, setError] = useState<Error | null>(null);
-
-  const clearError = useCallback(() => {
-    setError(null);
-  }, []);
-
-  const reset = useCallback(() => {
-    setValue(initialValue);
-    setLoading(false);
-    setError(null);
-  }, [initialValue]);
-
-  const state: HookState<T> = { value, loading, error };
-  const actions: HookStateActions<T> = {
-    setValue,
-    setLoading,
-    setError,
-    clearError,
-    reset,
-  };
-
-  return [state, actions];
-}
-
-/**
- * Hook for managing async operation state
- */
-export function useAsyncOperation<T = void>() {
-  const [loading, setLoading] = useState<boolean>(false);
-  const [error, setError] = useState<Error | null>(null);
-  const operationRef = useRef<Promise<T> | null>(null);
-
-  const execute = useCallback(async (operation: () => Promise<T>): Promise<T> => {
-    setLoading(true);
-    setError(null);
-
-    try {
-      const promise = operation();
-      operationRef.current = promise;
-      const result = await promise;
-      return result;
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      setError(error);
-      throw error;
-    } finally {
-      setLoading(false);
-      operationRef.current = null;
-    }
-  }, []);
-
-  const clearError = useCallback(() => {
-    setError(null);
-  }, []);
-
-  return {
-    loading,
-    error,
-    execute,
-    clearError,
-  };
-}

package/src/shared/domain/utils/credential.util.ts

@@ -1,102 +0,0 @@
-/**
- * Credential Utility
- * Centralized credential generation for authentication providers
- * Eliminates code duplication across auth services
- */
-
-import {
-  GoogleAuthProvider,
-  OAuthProvider,
-  type AuthCredential,
-} from 'firebase/auth';
-import * as AppleAuthentication from 'expo-apple-authentication';
-import { Platform } from 'react-native';
-import { generateNonce, hashNonce } from '../../../domains/auth/infrastructure/services/crypto.util';
-
-/**
- * Generate Google credential from ID token
- */
-export function generateGoogleCredential(idToken: string): AuthCredential {
-  return GoogleAuthProvider.credential(idToken);
-}
-
-/**
- * Generate Apple credential from identity token and nonce
- */
-export function generateAppleCredential(
-  identityToken: string,
-  rawNonce: string
-): AuthCredential {
-  const provider = new OAuthProvider('apple.com');
-  return provider.credential({
-    idToken: identityToken,
-    rawNonce,
-  });
-}
-
-/**
- * Check if Apple Sign-In is available
- */
-export async function isAppleSignInAvailable(): Promise<boolean> {
-  if (Platform.OS !== 'ios') {
-    return false;
-  }
-  try {
-    return await AppleAuthentication.isAvailableAsync();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Perform Apple Sign-In with default scopes
- */
-export async function performAppleSignIn(): Promise<{
-  identityToken: string | null;
-  nonce: string;
-  rawNonce: string;
-}> {
-  const rawNonce = await generateNonce();
-  const hashedNonce = await hashNonce(rawNonce);
-
-  const result = await AppleAuthentication.signInAsync({
-    requestedScopes: [
-      AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
-      AppleAuthentication.AppleAuthenticationScope.EMAIL,
-    ],
-    nonce: hashedNonce,
-  });
-
-  return {
-    identityToken: result.identityToken,
-    nonce: hashedNonce,
-    rawNonce,
-  };
-}
-
-/**
- * Email/Password credential interface
- */
-export interface EmailPasswordCredential {
-  email: string;
-  password: string;
-}
-
-/**
- * Validate email/password credential
- */
-export function isValidEmailPassword(credential: EmailPasswordCredential): boolean {
-  return (
-    typeof credential.email === 'string' &&
-    credential.email.length > 0 &&
-    typeof credential.password === 'string' &&
-    credential.password.length > 0
-  );
-}
-
-/**
- * Custom credential generator interface
- */
-export interface CredentialGenerator {
-  generate(): AuthCredential | Promise<AuthCredential>;
-}

package/src/shared/domain/utils/executors/advanced-executors.util.ts

@@ -1,59 +0,0 @@
-/**
- * Advanced Async Executors
- * Retry and timeout support for async operations
- */
-
-import type { Result } from '../result/result-types';
-import { failureResultFromError, successResult } from '../result/result-creators';
-import { executeOperation } from './basic-executors.util';
-
-/**
- * Execute operation with retry
- * @param operation - Operation to execute
- * @param maxRetries - Maximum number of retries (default: 3)
- * @param delayMs - Base delay between retries in milliseconds (default: 1000)
- */
-export async function executeWithRetry<T>(
-  operation: () => Promise<T>,
-  maxRetries = 3,
-  delayMs = 1000
-): Promise<Result<T>> {
-  let lastError: unknown;
-  for (let i = 0; i <= maxRetries; i++) {
-    try {
-      const data = await operation();
-      return successResult(data);
-    } catch (error) {
-      lastError = error;
-      if (i < maxRetries) {
-        // Exponential backoff: delay * (attempt + 1)
-        await new Promise((resolve) => setTimeout(() => resolve(undefined), delayMs * (i + 1)));
-      }
-    }
-  }
-  return failureResultFromError(lastError);
-}
-
-/**
- * Execute operation with timeout
- * @param operation - Operation to execute
- * @param timeoutMs - Timeout in milliseconds
- */
-export async function executeWithTimeout<T>(
-  operation: () => Promise<T>,
-  timeoutMs: number
-): Promise<Result<T>> {
-  return Promise.race([
-    executeOperation(operation),
-    new Promise<Result<T>>((resolve) =>
-      setTimeout(
-        () =>
-          resolve({
-            success: false,
-            error: { code: 'timeout', message: `Operation timed out after ${timeoutMs}ms` },
-          }),
-        timeoutMs
-      )
-    ),
-  ]);
-}

package/src/shared/domain/utils/executors/batch-executors.util.ts

@@ -1,42 +0,0 @@
-import type { Result } from '../result/result-types';
-import { failureResultFromError, successResult } from '../result/result-creators';
-import { isSuccess, isFailure } from '../result/result-helpers';
-
-export async function executeAll<T>(
-  ...operations: (() => Promise<Result<T>>)[]
-): Promise<Result<T[]>> {
-  try {
-    const results = await Promise.all(operations.map((op) => op()));
-
-    // FIX: Use isFailure() type guard instead of manual check
-    for (const result of results) {
-      if (isFailure(result)) {
-        return result;
-      }
-    }
-
-    const data: T[] = [];
-    for (const result of results) {
-      if (isSuccess(result) && result.data !== undefined) {
-        data.push(result.data);
-      }
-    }
-
-    return successResult(data);
-  } catch (error) {
-    return failureResultFromError(error);
-  }
-}
-
-export async function executeSequence<T>(
-  ...operations: (() => Promise<Result<T>>)[]
-): Promise<Result<void>> {
-  for (const operation of operations) {
-    const result = await operation();
-    // FIX: Use isFailure() type guard instead of manual check
-    if (isFailure(result)) {
-      return { success: false, error: result.error };
-    }
-  }
-  return successResult();
-}

package/src/shared/domain/utils/validators/composite.validator.ts

@@ -1,24 +0,0 @@
-/**
- * Composite Validators
- * Higher-order validators for combining multiple validation rules
- */
-
-/**
- * Create a validator that combines multiple validators (AND logic)
- * All validators must pass
- */
-export function combineValidators(
-  ...validators: ((value: string) => boolean)[]
-): (value: string) => boolean {
-  return (value: string) => validators.every((validator) => validator(value));
-}
-
-/**
- * Create a validator that checks if value matches one of validators (OR logic)
- * At least one validator must pass
- */
-export function anyValidator(
-  ...validators: ((value: string) => boolean)[]
-): (value: string) => boolean {
-  return (value: string) => validators.some((validator) => validator(value));
-}

package/src/shared/domain/utils/validators/generic.validator.ts

@@ -1,59 +0,0 @@
-/**
- * Generic Validators
- * Generic validation utilities for arrays, numbers, and objects
- */
-
-/**
- * Check if array is not empty
- */
-export function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]] {
-  return Array.isArray(value) && value.length > 0;
-}
-
-/**
- * Check if number is in range
- */
-export function isInRange(value: number, min: number, max: number): boolean {
-  return typeof value === 'number' && value >= min && value <= max;
-}
-
-/**
- * Check if number is positive
- */
-export function isPositive(value: number): boolean {
-  return typeof value === 'number' && value > 0;
-}
-
-/**
- * Check if number is non-negative
- */
-export function isNonNegative(value: number): boolean {
-  return typeof value === 'number' && value >= 0;
-}
-
-/**
- * Validate object has required properties
- */
-export function hasRequiredProperties<T extends Record<string, unknown>>(
-  obj: unknown,
-  requiredProps: (keyof T)[]
-): obj is T {
-  if (typeof obj !== 'object' || obj === null) {
-    return false;
-  }
-  return requiredProps.every((prop) => prop in obj);
-}
-
-/**
- * Validate all items in array match predicate
- */
-export function allMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
-  return Array.isArray(items) && items.every(predicate);
-}
-
-/**
- * Validate at least one item in array matches predicate
- */
-export function anyMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
-  return Array.isArray(items) && items.some(predicate);
-}

package/src/shared/domain/utils/validators/url.validator.ts

@@ -1,36 +0,0 @@
-/**
- * URL Validators
- * Validation utilities for URLs
- */
-
-import { isValidString } from './string.validator';
-
-/**
- * Validate URL format
- */
-export function isValidUrl(url: string): boolean {
-  if (!isValidString(url)) {
-    return false;
-  }
-  try {
-    new URL(url);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Validate HTTPS URL
- */
-export function isValidHttpsUrl(url: string): boolean {
-  if (!isValidString(url)) {
-    return false;
-  }
-  try {
-    const urlObj = new URL(url);
-    return (urlObj as any).protocol === 'https:';
-  } catch {
-    return false;
-  }
-}

package/src/shared/domain/utils/validators/user-input.validator.ts

@@ -1,54 +0,0 @@
-/**
- * User Input Validators
- * Validation utilities for user input (email, password, username, phone)
- */
-
-import { isValidString } from './string.validator';
-
-/**
- * Validate email format
- */
-export function isValidEmail(email: string): boolean {
-  if (!isValidString(email)) {
-    return false;
-  }
-  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailPattern.test(email);
-}
-
-/**
- * Validate password strength
- * At least 8 characters, containing uppercase, lowercase, and number
- */
-export function isStrongPassword(password: string): boolean {
-  if (!isValidString(password) || password.length < 8) {
-    return false;
-  }
-  const hasUpperCase = /[A-Z]/.test(password);
-  const hasLowerCase = /[a-z]/.test(password);
-  const hasNumber = /[0-9]/.test(password);
-  return hasUpperCase && hasLowerCase && hasNumber;
-}
-
-/**
- * Validate username format
- * Alphanumeric, underscores, and hyphens, 3-20 characters
- */
-export function isValidUsername(username: string): boolean {
-  if (!isValidString(username)) {
-    return false;
-  }
-  const pattern = /^[a-zA-Z0-9_-]{3,20}$/;
-  return pattern.test(username);
-}
-
-/**
- * Validate phone number format (basic check)
- */
-export function isValidPhoneNumber(phone: string): boolean {
-  if (!isValidString(phone)) {
-    return false;
-  }
-  const cleaned = phone.replace(/\s+/g, '').replace(/[-+()]/g, '');
-  return /^[0-9]{10,15}$/.test(cleaned);
-}

package/src/shared/domain/utils/validators/validation.util.ts

@@ -1,63 +0,0 @@
-/**
- * Generic Validation Utilities
- * Provides reusable validation patterns to eliminate duplication
- */
-
-/**
- * Generic validation utility that throws error if validation fails
- * Eliminates duplicate validate-or-throw patterns across the codebase
- *
- * @param value - Value to validate
- * @param validator - Validation function that returns true if valid
- * @param errorMessage - Error message to throw if validation fails
- * @param ErrorClass - Error class to instantiate (defaults to Error)
- * @throws {ErrorClass} When validation fails
- *
- * @example
- * ```typescript
- * validateOrThrow(
- *   cursor,
- *   isValidCursor,
- *   ERROR_MESSAGES.FIRESTORE.INVALID_CURSOR,
- *   CursorValidationError
- * );
- * ```
- */
-export function validateOrThrow<T>(
-  value: T,
-  validator: (value: T) => boolean,
-  errorMessage: string,
-  ErrorClass: new (message: string) => Error = Error
-): void {
-  if (!validator(value)) {
-    throw new ErrorClass(errorMessage);
-  }
-}
-
-/**
- * Validate multiple values, throw on first failure
- * Useful for validating multiple preconditions before an operation
- *
- * @param validations - Array of validation configurations
- * @throws {Error} When any validation fails
- *
- * @example
- * ```typescript
- * validateAllOrThrow([
- *   { value: email, validator: isValidEmail, errorMessage: 'Invalid email' },
- *   { value: password, validator: isValidPassword, errorMessage: 'Invalid password' },
- * ]);
- * ```
- */
-export function validateAllOrThrow<T = unknown>(
-  validations: Array<{
-    value: T;
-    validator: (value: T) => boolean;
-    errorMessage: string;
-    ErrorClass?: new (message: string) => Error;
-  }>
-): void {
-  for (const { value, validator, errorMessage, ErrorClass = Error } of validations) {
-    validateOrThrow(value, validator, errorMessage, ErrorClass);
-  }
-}

package/src/shared/infrastructure/config/validators/FirebaseConfigValidator.ts

@@ -1,89 +0,0 @@
-/**
- * Firebase Configuration Validator
- *
- * Single Responsibility: Validates Firebase configuration
- * Uses centralized validation utilities from validation.util.ts
- */
-
-import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
-import { FirebaseConfigurationError } from '../../../domain/errors/FirebaseError';
-import { isValidString } from '../../../domain/utils/validators/string.validator';
-import { isValidFirebaseApiKey, isValidFirebaseProjectId, isValidFirebaseAuthDomain } from '../../../domain/utils/validators/firebase.validator';
-
-/**
- * Validation rule interface
- */
-interface ValidationRule {
-  validate(config: FirebaseConfig): void;
-}
-
-/**
- * Required field validation rule using centralized validation
- */
-class RequiredFieldRule implements ValidationRule {
-  constructor(
-    private fieldName: string,
-    private getter: (config: FirebaseConfig) => string | undefined,
-    private customValidator?: (value: string) => boolean
-  ) {}
-
-  validate(config: FirebaseConfig): void {
-    const value = this.getter(config);
-
-    if (!isValidString(value)) {
-      throw new FirebaseConfigurationError(
-        `Firebase ${this.fieldName} is required and must be a non-empty string`
-      );
-    }
-
-    if (this.customValidator && !this.customValidator(value)) {
-      throw new FirebaseConfigurationError(
-        `Firebase ${this.fieldName} format is invalid`
-      );
-    }
-  }
-}
-
-/**
- * Placeholder validation rule
- */
-class PlaceholderRule implements ValidationRule {
-  constructor(
-    private fieldName: string,
-    private getter: (config: FirebaseConfig) => string | undefined,
-    private placeholder: string
-  ) {}
-
-  validate(config: FirebaseConfig): void {
-    const value = this.getter(config);
-
-    if (value && value.includes(this.placeholder)) {
-      throw new FirebaseConfigurationError(
-        `Please replace placeholder values with actual Firebase credentials for ${this.fieldName}`
-      );
-    }
-  }
-}
-
-/**
- * Firebase Configuration Validator
- */
-export class FirebaseConfigValidator {
-  private static rules: ValidationRule[] = [
-    new RequiredFieldRule('API Key', config => config.apiKey, isValidFirebaseApiKey),
-    new RequiredFieldRule('Auth Domain', config => config.authDomain, isValidFirebaseAuthDomain),
-    new RequiredFieldRule('Project ID', config => config.projectId, isValidFirebaseProjectId),
-    new PlaceholderRule('API Key', config => config.apiKey, 'your_firebase_api_key'),
-    new PlaceholderRule('Project ID', config => config.projectId, 'your-project-id'),
-  ];
-
-  /**
-   * Validate Firebase configuration
-   * @throws {FirebaseConfigurationError} If configuration is invalid
-   */
-  static validate(config: FirebaseConfig): void {
-    for (const rule of this.rules) {
-      rule.validate(config);
-    }
-  }
-}