@umituz/react-native-firebase 1.13.148 → 1.13.150

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.148",
+  "version": "1.13.150",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/auth/infrastructure/services/apple-auth.service.ts

@@ -75,10 +75,18 @@ export class AppleAuthService {
       });
 
       const userCredential = await signInWithCredential(auth, credential);
+
+      // Check if user is new by comparing metadata timestamps
+      // Convert to timestamps for reliable comparison (string comparison can be unreliable)
+      const creationTime = userCredential.user.metadata.creationTime;
+      const lastSignInTime = userCredential.user.metadata.lastSignInTime;
+      const isNewUser = creationTime && lastSignInTime
+        ? new Date(creationTime).getTime() === new Date(lastSignInTime).getTime()
+        : false;
+
       return {
         userCredential,
-        isNewUser: userCredential.user.metadata.creationTime ===
-          userCredential.user.metadata.lastSignInTime
+        isNewUser
       };
     });
 

package/src/auth/infrastructure/services/google-auth.service.ts

@@ -46,10 +46,18 @@ export class GoogleAuthService extends ConfigurableService<GoogleAuthConfig> {
     const result = await executeAuthOperation(async () => {
       const credential = GoogleAuthProvider.credential(idToken);
       const userCredential = await signInWithCredential(auth, credential);
+
+      // Check if user is new by comparing metadata timestamps
+      // Convert to timestamps for reliable comparison (string comparison can be unreliable)
+      const creationTime = userCredential.user.metadata.creationTime;
+      const lastSignInTime = userCredential.user.metadata.lastSignInTime;
+      const isNewUser = creationTime && lastSignInTime
+        ? new Date(creationTime).getTime() === new Date(lastSignInTime).getTime()
+        : false;
+
       return {
         userCredential,
-        isNewUser: userCredential.user.metadata.creationTime ===
-          userCredential.user.metadata.lastSignInTime
+        isNewUser
       };
     });
     return this.convertToGoogleAuthResult(result);

package/src/auth/infrastructure/services/reauthentication.service.ts

@@ -99,7 +99,11 @@ export async function getAppleReauthCredential(): Promise<ReauthCredentialResult
     };
   } catch (error: unknown) {
     const err = error instanceof Error ? error : new Error(String(error));
-    const code = isCancelledError({ code: '', message: err.message }) ? "auth/cancelled" : "auth/failed";
+    const errorInfo = {
+      code: (err as { code?: string }).code ?? '',
+      message: err.message
+    };
+    const code = isCancelledError(errorInfo) ? "auth/cancelled" : "auth/failed";
     return {
       success: false,
       error: { code, message: err.message }

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

@@ -0,0 +1,60 @@
+/**
+ * Auth-Specific Hooks
+ * React hooks for Firebase Auth state management
+ */
+
+import { useRef, useEffect, useCallback } from 'react';
+import { onAuthStateChanged, type Auth, type User } from 'firebase/auth';
+
+/**
+ * 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/shared/hook-utils.util.ts

@@ -1,222 +1,20 @@
 /**
  * Shared Hook Utilities
- * Common utilities and patterns for React hooks
- * Reduces code duplication across presentation hooks
+ * Re-exports all hook utilities for backward compatibility
+ * @deprecated Import from specific files instead
  */
 
-import { useState, useCallback, useRef, useEffect } from 'react';
-import { onAuthStateChanged, type Auth, type User } from 'firebase/auth';
+// State Management Hooks
+export type { HookState, HookStateActions } from './state-hooks.util';
+export { useHookState, useAsyncOperation } from './state-hooks.util';
 
-/**
- * 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);
+// Safe State Hooks
+export {
+  useIsMounted,
+  useSafeState,
+  useDebouncedValue,
+  useCleanup,
+} from './safe-state-hooks.util';
 
-    return () => {
-      if (unsubscribeRef.current) {
-        unsubscribeRef.current();
-        unsubscribeRef.current = null;
-      }
-    };
-  }, [auth, onAuthStateChange]);
-}
+// Auth Hooks
+export { createAuthStateHandler, useAuthListener } from './auth-hooks.util';

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

@@ -0,0 +1,76 @@
+/**
+ * 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/auth/presentation/hooks/shared/state-hooks.util.ts

@@ -0,0 +1,97 @@
+/**
+ * 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,
+  };
+}