@umituz/react-native-auth 4.2.15 → 4.2.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "4.2.15",
+  "version": "4.2.17",
   "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/AuthValidation.ts

@@ -34,7 +34,8 @@ export function validateEmail(
 }
 
 export function validatePasswordForLogin(password: string): ValidationResult {
-  if (!password || password.trim().length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
+  // Don't trim passwords - whitespace may be intentional
+  if (!password || password.length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
   return { isValid: true };
 }
 
@@ -42,7 +43,8 @@ export function validatePasswordForRegister(
   password: string,
   config: PasswordConfig,
 ): PasswordStrengthResult {
-  if (!password || password.trim().length === 0) {
+  // Don't trim passwords - whitespace may be intentional
+  if (!password || password.length === 0) {
     return { isValid: false, error: "auth.validation.passwordRequired", requirements: { hasMinLength: false } };
   }
 
@@ -56,7 +58,8 @@ export function validatePasswordForRegister(
 }
 
 export function validatePasswordConfirmation(password: string, confirm: string): ValidationResult {
-  if (!confirm || confirm.trim().length === 0) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
+  // Don't trim passwords - whitespace may be intentional
+  if (!confirm || confirm.length === 0) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
   if (password !== confirm) return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
   return { isValid: true };
 }

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/infrastructure/utils/validation/sanitization.ts

@@ -14,31 +14,39 @@ export const SECURITY_LIMITS = {
 export type SecurityLimitKey = keyof typeof SECURITY_LIMITS;
 
 export const sanitizeWhitespace = (input: string): string => {
+  if (!input) return '';
   return input.trim().replace(/\s+/g, ' ');
 };
 
 export const sanitizeEmail = (email: string): string => {
+  if (!email) return '';
   const trimmed = email.trim().toLowerCase();
   return trimmed.substring(0, SECURITY_LIMITS.EMAIL_MAX_LENGTH);
 };
 
 export const sanitizePassword = (password: string): string => {
-  return password.trim().substring(0, SECURITY_LIMITS.PASSWORD_MAX_LENGTH);
+  // Don't trim passwords - leading/trailing whitespace may be intentional
+  // Only enforce max length for security
+  if (!password) return '';
+  return password.substring(0, SECURITY_LIMITS.PASSWORD_MAX_LENGTH);
 };
 
 export const sanitizeName = (name: string): string => {
+  if (!name) return '';
   const trimmed = sanitizeWhitespace(name);
   const noTags = trimmed.replace(/<[^>]*>/g, '');
   return noTags.substring(0, SECURITY_LIMITS.NAME_MAX_LENGTH);
 };
 
 export const sanitizeText = (text: string): string => {
+  if (!text) return '';
   const trimmed = sanitizeWhitespace(text);
   const noTags = trimmed.replace(/<[^>]*>/g, '');
   return noTags.substring(0, SECURITY_LIMITS.GENERAL_TEXT_MAX_LENGTH);
 };
 
 export const containsDangerousChars = (input: string): boolean => {
+  if (!input) return false;
   const dangerousPatterns = [
     /<script/i,
     /javascript:/i,
@@ -54,6 +62,7 @@ export const isWithinLengthLimit = (
   maxLength: number,
   minLength = 0
 ): boolean => {
+  if (!input) return minLength === 0;
   const length = input.trim().length;
   return length >= minLength && length <= maxLength;
 };

package/src/presentation/components/LoginForm.tsx

@@ -68,7 +68,7 @@ export const LoginForm: React.FC<LoginFormProps> = ({
       <AtomicButton
         variant="primary"
         onPress={() => { void handleSignIn(); }}
-        disabled={loading || !email.trim() || !password.trim()}
+        disabled={loading || !email.trim() || !password}
         fullWidth
         style={styles.signInButton}
       >

package/src/presentation/components/RegisterForm.tsx

@@ -128,7 +128,7 @@ export const RegisterForm: React.FC<RegisterFormProps> = ({
       <AtomicButton
         variant="primary"
         onPress={() => { void handleSignUp(); }}
-        disabled={loading || !email.trim() || !password.trim() || !confirmPassword.trim()}
+        disabled={loading || !email.trim() || !password || !confirmPassword}
         fullWidth
         style={styles.signUpButton}
       >

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/screens/PasswordPromptScreen.tsx

@@ -49,7 +49,8 @@ export const PasswordPromptScreen: React.FC<PasswordPromptScreenProps> = ({
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[PasswordPromptScreen] handleConfirm called, password length:", password.length);
     }
-    if (!password.trim()) {
+    // Don't trim password - whitespace may be intentional
+    if (!password) {
       setError('Password is required');
       return;
     }

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/presentation/stores/initializeAuthListener.ts

@@ -34,14 +34,16 @@ export function initializeAuthListener(
   if (!startInitialization()) {
     // Either already initializing or initialized - handle accordingly
     if (isListenerInitialized()) {
-      return handleExistingInitialization()!;
+      const unsubscribe = handleExistingInitialization();
+      return unsubscribe || handleInitializationInProgress();
     }
     return handleInitializationInProgress();
   }
 
   // If already initialized, increment ref count and return unsubscribe
   if (isListenerInitialized()) {
-    return handleExistingInitialization()!;
+    const unsubscribe = handleExistingInitialization();
+    return unsubscribe || (() => {});
   }
 
   const auth = getFirebaseAuth();

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>;
 }