@umituz/react-native-firebase 1.13.140 → 1.13.141

package/src/auth/presentation/hooks/shared/hook-utils.util.ts

@@ -0,0 +1,222 @@
+/**
+ * Shared Hook Utilities
+ * Common utilities and patterns for React hooks
+ * Reduces code duplication across presentation hooks
+ */
+
+import { useState, useCallback, useRef, useEffect } from 'react';
+import { onAuthStateChanged, type Auth, type User } from 'firebase/auth';
+
+/**
+ * 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 cleanup callbacks
+ */
+export function useCleanup(
+  cleanupFn: () => void,
+  deps: React.DependencyList = []
+): void {
+  useEffect(() => {
+    return () => {
+      cleanupFn();
+    };
+  }, deps);
+}
+
+/**
+ * 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,
+  };
+}
+
+/**
+ * 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 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];
+}
+
+/**
+ * Create an auth state handler
+ */
+export function createAuthStateHandler(
+  setState: (user: User | null) => void,
+  setLoading: (loading: boolean) => void,
+  setError: (error: Error | null) => void
+): (user: User | null) => void {
+  return (user: User | null) => {
+    try {
+      setState(user);
+      setError(null);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error('Auth state update failed');
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  };
+}
+
+/**
+ * Hook for managing auth listener lifecycle
+ */
+export function useAuthListener(
+  auth: Auth | null,
+  onAuthStateChange: (user: User | null) => void
+): void {
+  const unsubscribeRef = useRef<(() => void) | null>(null);
+
+  useEffect(() => {
+    // Cleanup previous listener
+    if (unsubscribeRef.current) {
+      unsubscribeRef.current();
+      unsubscribeRef.current = null;
+    }
+
+    if (!auth) {
+      onAuthStateChange(null);
+      return;
+    }
+
+    unsubscribeRef.current = onAuthStateChanged(auth, onAuthStateChange);
+
+    return () => {
+      if (unsubscribeRef.current) {
+        unsubscribeRef.current();
+        unsubscribeRef.current = null;
+      }
+    };
+  }, [auth, onAuthStateChange]);
+}

package/src/auth/presentation/hooks/useSocialAuth.ts

@@ -48,11 +48,20 @@ export function useSocialAuth(config?: SocialAuthConfig): UseSocialAuthResult {
   }, [googleConfig]);
 
   useEffect(() => {
+    let cancelled = false;
+
     const checkApple = async () => {
       const available = await appleAuthService.isAvailable();
-      setAppleAvailable(available && (config?.apple?.enabled ?? false));
+      if (!cancelled) {
+        setAppleAvailable(available && (config?.apple?.enabled ?? false));
+      }
     };
+
     checkApple();
+
+    return () => {
+      cancelled = true;
+    };
   }, [config?.apple?.enabled]);
 
   const signInWithGoogleToken = useCallback(

package/src/domain/utils/async-executor.util.ts

@@ -0,0 +1,176 @@
+/**
+ * Async Operation Executor Utility
+ * Centralized async operation execution with error handling
+ * Eliminates code duplication across services
+ */
+
+import type { Result, FailureResult } from './result.util';
+import { failureResultFromError, successResult } from './result.util';
+
+/**
+ * Error converter function type
+ * Converts unknown errors to ErrorInfo
+ */
+export type ErrorConverter = (error: unknown) => { code: string; message: string };
+
+/**
+ * Default error converter for auth operations
+ */
+export function authErrorConverter(error: unknown): { code: string; message: string } {
+  if (error instanceof Error) {
+    return {
+      code: (error as { code?: string }).code ?? 'auth/failed',
+      message: error.message,
+    };
+  }
+  return {
+    code: 'auth/failed',
+    message: typeof error === 'string' ? error : 'Authentication failed',
+  };
+}
+
+/**
+ * Default error converter for operations
+ */
+export function defaultErrorConverter(
+  error: unknown,
+  defaultCode = 'operation/failed'
+): { code: string; message: string } {
+  if (error instanceof Error) {
+    return {
+      code: (error as { code?: string }).code ?? defaultCode,
+      message: error.message,
+    };
+  }
+  return {
+    code: defaultCode,
+    message: typeof error === 'string' ? error : 'Operation failed',
+  };
+}
+
+/**
+ * Execute async operation with error handling
+ * Returns Result type with success/failure
+ */
+export async function executeOperation<T>(
+  operation: () => Promise<T>,
+  errorConverter?: ErrorConverter
+): Promise<Result<T>> {
+  try {
+    const data = await operation();
+    return successResult(data);
+  } catch (error) {
+    const converter = errorConverter ?? defaultErrorConverter;
+    return { success: false, error: converter(error) };
+  }
+}
+
+/**
+ * Execute async operation with error handling and default code
+ */
+export async function executeOperationWithCode<T>(
+  operation: () => Promise<T>,
+  defaultErrorCode = 'operation/failed'
+): Promise<Result<T>> {
+  return executeOperation(operation, (error) => defaultErrorConverter(error, defaultErrorCode));
+}
+
+/**
+ * Execute async void operation
+ * Useful for operations that don't return data
+ */
+export async function executeVoidOperation(
+  operation: () => Promise<void>,
+  errorConverter?: ErrorConverter
+): Promise<Result<void>> {
+  return executeOperation(operation, errorConverter) as Promise<Result<void>>;
+}
+
+/**
+ * Execute async operation with auth error handling
+ */
+export async function executeAuthOperation<T>(
+  operation: () => Promise<T>
+): Promise<Result<T>> {
+  return executeOperation(operation, authErrorConverter);
+}
+
+/**
+ * Execute multiple operations in parallel
+ * Returns success only if all operations succeed
+ */
+export async function executeAll<T>(
+  ...operations: (() => Promise<Result<T>>)[]
+): Promise<Result<T[]>> {
+  try {
+    const results = await Promise.all(operations.map((op) => op()));
+    const failures = results.filter((r) => !r.success);
+    if (failures.length > 0) {
+      return failures[0] as FailureResult;
+    }
+    const data = results.map((r) => (r as { success: true; data: T }).data);
+    return successResult(data);
+  } catch (error) {
+    return failureResultFromError(error);
+  }
+}
+
+/**
+ * Execute operations in sequence, stopping at first failure
+ */
+export async function executeSequence<T>(
+  ...operations: (() => Promise<Result<T>>)[]
+): Promise<Result<void>> {
+  for (const operation of operations) {
+    const result = await operation();
+    if (!result.success) {
+      return result as Result<void>;
+    }
+  }
+  return successResult();
+}
+
+/**
+ * Execute operation with retry
+ */
+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) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs * (i + 1)));
+      }
+    }
+  }
+  return failureResultFromError(lastError);
+}
+
+/**
+ * Execute operation with timeout
+ */
+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/domain/utils/credential.util.ts

@@ -0,0 +1,102 @@
+/**
+ * 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 '../../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/domain/utils/index.ts

@@ -0,0 +1,101 @@
+/**
+ * Domain Utils
+ * Centralized utilities for domain operations
+ */
+
+// Result types
+export {
+  successResult,
+  failureResult,
+  failureResultFrom,
+  failureResultFromError,
+  isSuccess,
+  isFailure,
+  getDataOrDefault,
+  mapResult,
+  chainResults,
+  type Result,
+  type SuccessResult,
+  type FailureResult,
+  type ErrorInfo,
+} from './result.util';
+
+// Async operation execution
+export {
+  executeOperation,
+  executeOperationWithCode,
+  executeVoidOperation,
+  executeAuthOperation,
+  executeAll,
+  executeSequence,
+  executeWithRetry,
+  executeWithTimeout,
+  authErrorConverter,
+  defaultErrorConverter,
+  type ErrorConverter,
+} from './async-executor.util';
+
+// Service configuration
+export {
+  ConfigurableService,
+  createConfigurableService,
+  type ConfigState,
+  type IConfigurableService,
+} from './service-config.util';
+
+// Credential utilities
+export {
+  generateGoogleCredential,
+  generateAppleCredential,
+  isAppleSignInAvailable,
+  performAppleSignIn,
+  isValidEmailPassword,
+  type EmailPasswordCredential,
+  type CredentialGenerator,
+} from './credential.util';
+
+// Error handling
+export {
+  toErrorInfo,
+  toAuthErrorInfo,
+  hasErrorCode,
+  isCancelledError,
+  isQuotaErrorInfo,
+  isNetworkError,
+  isAuthError,
+  isQuotaError,
+  isRetryableError,
+  getQuotaErrorMessage,
+  getRetryableErrorMessage,
+  type ErrorInfo as ErrorHandlerErrorInfo,
+} from './error-handler.util';
+
+// Type guards
+export {
+  hasCodeProperty,
+  hasMessageProperty,
+  hasCodeAndMessageProperties,
+} from './type-guards.util';
+
+// Validation
+export {
+  isValidString,
+  isEmptyString,
+  isValidFirebaseApiKey,
+  isValidFirebaseAuthDomain,
+  isValidFirebaseProjectId,
+  isValidUrl,
+  isValidHttpsUrl,
+  isValidEmail,
+  isDefined,
+  isNonEmptyArray,
+  isInRange,
+  isPositive,
+  isNonNegative,
+} from './validation.util';
+
+// ID generation
+export {
+  generateUniqueId,
+  generateShortId,
+} from './id-generator.util';