@umituz/react-native-auth 4.2.16 → 4.2.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "4.2.16",
+  "version": "4.2.18",
   "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/AnonymousModeService.ts

@@ -21,6 +21,8 @@ export class AnonymousModeService {
       this.isAnonymousMode = value === "true";
       return this.isAnonymousMode;
     } catch {
+      // On error, reset to false to maintain consistency
+      this.isAnonymousMode = false;
       return false;
     }
   }
@@ -40,14 +42,24 @@ export class AnonymousModeService {
       this.isAnonymousMode = false;
       return true;
     } catch {
-      this.isAnonymousMode = false;
+      // Don't update memory state if storage operation failed
+      // This maintains consistency between storage and memory
       return false;
     }
   }
 
   async enable(storageProvider: IStorageProvider): Promise<void> {
+    // Save to storage first, then update memory to maintain consistency
+    const previousState = this.isAnonymousMode;
     this.isAnonymousMode = true;
-    await this.save(storageProvider);
+    const saveSuccess = await this.save(storageProvider);
+
+    if (!saveSuccess) {
+      // Rollback on failure
+      this.isAnonymousMode = previousState;
+      throw new Error('Failed to save anonymous mode state');
+    }
+
     emitAnonymousModeEnabled();
   }
 

package/src/infrastructure/services/AuthService.ts

@@ -16,6 +16,7 @@ export class AuthService {
   private anonymousModeService: AnonymousModeService;
   private storageProvider?: IStorageProvider;
   private initialized: boolean = false;
+  private initializationPromise: Promise<void> | null = null;
   private config: AuthConfig;
 
   constructor(config: Partial<AuthConfig> = {}, storageProvider?: IStorageProvider) {
@@ -30,14 +31,28 @@ export class AuthService {
   }
 
   async initialize(): Promise<void> {
+    // Return existing promise if initialization is in progress
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+
     if (this.initialized) return;
 
-    this.repository = new AuthRepository(this.config);
+    // Create and store initialization promise to prevent concurrent initialization
+    this.initializationPromise = (async () => {
+      this.repository = new AuthRepository(this.config);
+
+      if (this.storageProvider) {
+        await this.anonymousModeService.load(this.storageProvider);
+      }
+      this.initialized = true;
+    })();
 
-    if (this.storageProvider) {
-      await this.anonymousModeService.load(this.storageProvider);
+    try {
+      await this.initializationPromise;
+    } finally {
+      this.initializationPromise = null;
     }
-    this.initialized = true;
   }
 
   isInitialized(): boolean {
@@ -65,7 +80,12 @@ export class AuthService {
 
   private async clearAnonymousModeIfNeeded(): Promise<void> {
     if (this.anonymousModeService.getIsAnonymousMode() && this.storageProvider) {
-      await this.anonymousModeService.clear(this.storageProvider);
+      const success = await this.anonymousModeService.clear(this.storageProvider);
+      if (!success) {
+        console.warn('[AuthService] Failed to clear anonymous mode from storage');
+        // Force clear in memory to maintain consistency
+        this.anonymousModeService.setAnonymousMode(false);
+      }
     }
   }
 

package/src/infrastructure/utils/authStateHandler.ts

@@ -45,13 +45,26 @@ export function createAuthStateHandler(
       ? { previousAnonymousUserId: state.current.previousUserId }
       : undefined;
 
-    await ensureUserDocument(user, extras);
+    try {
+      await ensureUserDocument(user, extras);
+    } catch (error) {
+      console.error('[AuthStateHandler] Failed to ensure user document:', error);
+      // Continue execution - don't let user document creation failure block auth flow
+    }
 
     state.current = {
       previousUserId: currentUserId,
       wasAnonymous: isCurrentlyAnonymous,
     };
 
-    await onAuthStateChange?.(user);
+    // Call user callback with error handling
+    if (onAuthStateChange) {
+      try {
+        await onAuthStateChange(user);
+      } catch (error) {
+        console.error('[AuthStateHandler] User callback error:', error);
+        // Don't propagate user callback errors
+      }
+    }
   };
 }

package/src/infrastructure/utils/listener/authStateHandler.ts

@@ -18,7 +18,7 @@ export function handleAuthStateChange(
   store: Store,
   auth: Auth,
   autoAnonymousSignIn: boolean,
-  onAuthStateChange?: (user: User | null) => void
+  onAuthStateChange?: (user: User | null) => void | Promise<void>
 ): void {
   try {
     if (!user && autoAnonymousSignIn) {
@@ -37,7 +37,20 @@ export function handleAuthStateChange(
       store.setIsAnonymous(false);
     }
 
-    onAuthStateChange?.(user);
+    // Call user callback with proper error handling for async callbacks
+    if (onAuthStateChange) {
+      try {
+        const result = onAuthStateChange(user);
+        // If callback returns a promise, catch rejections
+        if (result && typeof result.then === 'function') {
+          result.catch((error) => {
+            console.error("[AuthListener] User callback promise rejected:", error);
+          });
+        }
+      } catch (error) {
+        console.error("[AuthListener] User callback error:", error);
+      }
+    }
   } catch (error) {
     console.error("[AuthListener] Error handling auth state change:", error);
     // Ensure we don't leave the app in a bad state

package/src/infrastructure/utils/listener/listenerState.util.ts

@@ -95,7 +95,11 @@ export function incrementRefCount(): number {
  * Uses cleanupInProgress flag to prevent concurrent cleanup attempts
  */
 export function decrementRefCount(): { shouldCleanup: boolean; count: number } {
-  state.refCount--;
+  // Prevent refCount from going negative
+  if (state.refCount > 0) {
+    state.refCount--;
+  }
+
   const shouldCleanup =
     state.refCount <= 0 &&
     state.unsubscribe !== null &&
@@ -132,7 +136,11 @@ export function completeAnonymousSignIn(): void {
  */
 export function resetListenerState(): void {
   if (state.unsubscribe) {
-    state.unsubscribe();
+    try {
+      state.unsubscribe();
+    } catch (error) {
+      console.error('[ListenerState] Error during unsubscribe:', error);
+    }
   }
   state.initialized = false;
   state.refCount = 0;

package/src/infrastructure/utils/listener/setupListener.ts

@@ -19,7 +19,7 @@ export function setupAuthListener(
   auth: Auth,
   store: Store,
   autoAnonymousSignIn: boolean,
-  onAuthStateChange?: (user: User | null) => void
+  onAuthStateChange?: (user: User | null) => void | Promise<void>
 ): void {
   const service = getAuthService();
 
@@ -58,6 +58,6 @@ export function setupAuthListener(
     store.setLoading(false);
     store.setInitialized(true);
     store.setError("Failed to initialize authentication listener");
-    throw error;
+    // Don't re-throw - app state is already cleaned up and consistent
   }
 }

package/src/presentation/hooks/useLoginForm.ts

@@ -106,7 +106,7 @@ export function useLoginForm(config?: UseLoginFormConfig): UseLoginFormResult {
       const localizationKey = getAuthErrorLocalizationKey(err);
       setLocalError(getErrorMessage(localizationKey));
     }
-  }, [fields, signIn, translations, getErrorMessage, clearErrors, updateField]);
+  }, [fields, signIn, translations, getErrorMessage, clearErrors]);
 
   const handleContinueAnonymously = useCallback(async () => {
     try {

package/src/presentation/stores/authModalStore.ts

@@ -61,7 +61,8 @@ export const useAuthModalStore = createStore<AuthModalState, AuthModalActions>({
     },
 
     hideAuthModal: () => {
-      set({ isVisible: false });
+      // Clear pending callback to prevent memory leaks
+      set({ isVisible: false, pendingCallback: null });
     },
 
     setMode: (mode: AuthModalMode) => {
@@ -71,7 +72,18 @@ export const useAuthModalStore = createStore<AuthModalState, AuthModalActions>({
     executePendingCallback: () => {
       const state = get();
       if (state.pendingCallback) {
-        void state.pendingCallback();
+        // Wrap in try-catch to handle promise rejections
+        try {
+          const result = state.pendingCallback();
+          // If it's a promise, catch rejections
+          if (result && typeof result.then === 'function') {
+            result.catch((error) => {
+              console.error('[AuthModalStore] Pending callback error:', error);
+            });
+          }
+        } catch (error) {
+          console.error('[AuthModalStore] Pending callback error:', error);
+        }
         set({ pendingCallback: null });
       }
     },

package/src/presentation/stores/authStore.ts

@@ -48,7 +48,13 @@ export const useAuthStore = createStore<AuthState, AuthActions>({
         initialized: state.initialized ?? false,
       };
     }
-    return { ...initialAuthState, ...state };
+    // Only restore persisted fields (isAnonymous, initialized)
+    // Never restore runtime state (user, firebaseUser, loading, error)
+    return {
+      ...initialAuthState,
+      isAnonymous: state.isAnonymous ?? false,
+      initialized: state.initialized ?? false,
+    };
   },
   actions: (set, get) => ({
     setFirebaseUser: (firebaseUser) => {

package/src/types/auth-store.types.ts

@@ -65,6 +65,6 @@ export const initialAuthState: AuthState = {
 export interface AuthListenerOptions {
   /** Enable auto anonymous sign-in when no user is logged in */
   autoAnonymousSignIn?: boolean;
-  /** Callback when auth state changes */
-  onAuthStateChange?: (user: User | null) => void;
+  /** Callback when auth state changes (can be async) */
+  onAuthStateChange?: (user: User | null) => void | Promise<void>;
 }