@umituz/react-native-auth 3.6.60 → 3.6.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.60",
+  "version": "3.6.62",
   "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/application/ports/IAuthRepository.ts

@@ -1,10 +1,10 @@
 
 import type { AuthUser } from "../../domain/entities/AuthUser";
-import type { SignUpParams, SignInParams } from "../ports/IAuthService";
+import type { AuthCredentials, SignUpCredentials } from "./IAuthProvider";
 
 export interface IAuthRepository {
-    signUp(params: SignUpParams): Promise<AuthUser>;
-    signIn(params: SignInParams): Promise<AuthUser>;
+    signUp(params: SignUpCredentials): Promise<AuthUser>;
+    signIn(params: AuthCredentials): Promise<AuthUser>;
     signOut(): Promise<void>;
     getCurrentUser(): AuthUser | null;
     onAuthStateChange(callback: (user: AuthUser | null) => void): () => void;

package/src/index.ts

@@ -39,14 +39,11 @@ export {
 } from './domain/value-objects/AuthConfig';
 
 export type { UserProfile, UpdateProfileParams } from './domain/entities/UserProfile';
-export { migrateUserData, configureMigration } from './domain/utils/migration';
-export type { MigrationConfig } from './domain/utils/migration';
 
 // =============================================================================
 // APPLICATION LAYER
 // =============================================================================
 
-export type { IAuthService, SignUpParams, SignInParams } from './application/ports/IAuthService';
 export type {
   IAuthProvider,
   AuthCredentials,
@@ -70,17 +67,6 @@ export {
   createStorageProvider,
   StorageProviderAdapter,
 } from './infrastructure/adapters/StorageProviderAdapter';
-export {
-  ensureUserDocument,
-  markUserDeleted,
-  configureUserDocumentService,
-} from './infrastructure/services/UserDocumentService';
-export type {
-  UserDocumentConfig,
-  UserDocumentExtras,
-  UserDocumentUser,
-} from './infrastructure/services/UserDocumentService';
-
 export {
   initializeAuth,
   isAuthInitialized,
@@ -171,22 +157,24 @@ export { RegisterScreen } from './presentation/screens/RegisterScreen';
 export type { RegisterScreenProps } from './presentation/screens/RegisterScreen';
 
 export { AccountScreen } from './presentation/screens/AccountScreen';
-export type { AccountScreenProps } from './presentation/screens/AccountScreen';
+export type { AccountScreenProps, AccountScreenConfig } from './presentation/screens/AccountScreen';
 
 export { EditProfileScreen } from './presentation/screens/EditProfileScreen';
 export type { EditProfileScreenProps } from './presentation/screens/EditProfileScreen';
 
-export { ChangePasswordScreen } from './presentation/screens/change-password';
-export type { ChangePasswordScreenProps } from './presentation/screens/change-password';
-
 export { AuthNavigator } from './presentation/navigation/AuthNavigator';
 export type { AuthStackParamList } from './presentation/navigation/AuthNavigator';
 
+export { AuthBottomSheet } from './presentation/components/AuthBottomSheet';
+export { ProfileSection } from './presentation/components/ProfileSection';
+export type { ProfileSectionProps, ProfileSectionConfig } from './presentation/components/ProfileSection';
+
 // =============================================================================
 // STORES
 // =============================================================================
 
 export { useAuthStore } from './presentation/stores/authStore';
+export { useAuthModalStore } from './presentation/stores/authModalStore';
 export {
   initializeAuthListener,
   resetAuthListener,
@@ -194,6 +182,7 @@ export {
 } from './presentation/stores/initializeAuthListener';
 export type { AuthState, AuthActions, UserType } from './types/auth-store.types';
 export type { AuthListenerOptions } from './types/auth-store.types';
+export * from './presentation/stores/auth.selectors';
 
 // =============================================================================
 // UTILITIES

package/src/infrastructure/providers/FirebaseAuthProvider.ts

@@ -164,10 +164,14 @@ export class FirebaseAuthProvider implements IAuthProvider {
   }
 
   getCurrentUser(): AuthUser | null {
-    if (!this.auth?.currentUser) {
+    if (!this.auth) {
+      return null;
+    }
+    const currentUser = this.auth.currentUser;
+    if (!currentUser) {
       return null;
     }
-    return mapToAuthUser(this.auth.currentUser);
+    return mapToAuthUser(currentUser);
   }
 
   onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {

package/src/infrastructure/repositories/AuthRepository.ts

@@ -7,7 +7,7 @@
 import type { IAuthRepository } from "../../application/ports/IAuthRepository";
 import type { IAuthProvider } from "../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
-import type { SignUpParams, SignInParams } from "../../application/ports/IAuthService";
+import type { AuthCredentials, SignUpCredentials } from "../../application/ports/IAuthProvider";
 import {
     AuthValidationError,
     AuthWeakPasswordError,
@@ -31,7 +31,7 @@ export class AuthRepository implements IAuthRepository {
         this.config = config;
     }
 
-    async signUp(params: SignUpParams): Promise<AuthUser> {
+    async signUp(params: SignUpCredentials): Promise<AuthUser> {
         const email = sanitizeEmail(params.email);
         const password = sanitizePassword(params.password);
         const displayName = params.displayName ? sanitizeName(params.displayName) : undefined;
@@ -64,7 +64,7 @@ export class AuthRepository implements IAuthRepository {
         return this.provider.signUp({ email, password, displayName });
     }
 
-    async signIn(params: SignInParams): Promise<AuthUser> {
+    async signIn(params: AuthCredentials): Promise<AuthUser> {
         const email = sanitizeEmail(params.email);
         const password = sanitizePassword(params.password);
 

package/src/infrastructure/services/AuthEventService.ts

@@ -70,6 +70,10 @@ export class AuthEventService {
       const index = eventListeners.indexOf(listener);
       if (index > -1) {
         eventListeners.splice(index, 1);
+        // Clean up empty arrays to prevent memory leaks
+        if (eventListeners.length === 0) {
+          this.listeners.delete(event);
+        }
       }
     };
   }

package/src/infrastructure/services/AuthService.ts

@@ -4,7 +4,7 @@
  */
 
 import type { Auth } from "firebase/auth";
-import type { IAuthService, SignUpParams, SignInParams } from "../../application/ports/IAuthService";
+import type { AuthCredentials, SignUpCredentials } from "../../application/ports/IAuthProvider";
 import type { IAuthProvider } from "../../application/ports/IAuthProvider";
 import { FirebaseAuthProvider } from "../providers/FirebaseAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
@@ -13,10 +13,9 @@ import { sanitizeAuthConfig } from "../../domain/value-objects/AuthConfig";
 import { AuthRepository } from "../repositories/AuthRepository";
 import { AnonymousModeService } from "./AnonymousModeService";
 import { authEventService } from "./AuthEventService";
-import { authTracker } from "../utils/auth-tracker.util";
 import type { IStorageProvider } from "../types/Storage.types";
 
-export class AuthService implements IAuthService {
+export class AuthService {
   private repository!: AuthRepository;
   private anonymousModeService: AnonymousModeService;
   private storageProvider?: IStorageProvider;
@@ -62,44 +61,23 @@ export class AuthService implements IAuthService {
     return this.initialized;
   }
 
-  async signUp(params: SignUpParams): Promise<AuthUser> {
-    authTracker.logOperationStarted("Sign up", { email: params.email });
-    try {
-      const user = await this.repositoryInstance.signUp(params);
-      await this.clearAnonymousModeIfNeeded();
-      authTracker.logOperationSuccess("Sign up", { userId: user.uid });
-      authEventService.emitUserAuthenticated(user.uid);
-      return user;
-    } catch (error) {
-      authTracker.logOperationError("Sign up", error, { email: params.email });
-      throw error;
-    }
+  async signUp(params: SignUpCredentials): Promise<AuthUser> {
+    const user = await this.repositoryInstance.signUp(params);
+    await this.clearAnonymousModeIfNeeded();
+    authEventService.emitUserAuthenticated(user.uid);
+    return user;
   }
 
-  async signIn(params: SignInParams): Promise<AuthUser> {
-    authTracker.logOperationStarted("Sign in", { email: params.email });
-    try {
-      const user = await this.repositoryInstance.signIn(params);
-      await this.clearAnonymousModeIfNeeded();
-      authTracker.logOperationSuccess("Sign in", { userId: user.uid });
-      authEventService.emitUserAuthenticated(user.uid);
-      return user;
-    } catch (error) {
-      authTracker.logOperationError("Sign in", error, { email: params.email });
-      throw error;
-    }
+  async signIn(params: AuthCredentials): Promise<AuthUser> {
+    const user = await this.repositoryInstance.signIn(params);
+    await this.clearAnonymousModeIfNeeded();
+    authEventService.emitUserAuthenticated(user.uid);
+    return user;
   }
 
   async signOut(): Promise<void> {
-    authTracker.logOperationStarted("Sign out");
-    try {
-      await this.repositoryInstance.signOut();
-      await this.clearAnonymousModeIfNeeded();
-      authTracker.logOperationSuccess("Sign out");
-    } catch (error) {
-      authTracker.logOperationError("Sign out", error);
-      throw error;
-    }
+    await this.repositoryInstance.signOut();
+    await this.clearAnonymousModeIfNeeded();
   }
 
   private async clearAnonymousModeIfNeeded(): Promise<void> {

package/src/infrastructure/services/initializeAuth.ts

@@ -6,9 +6,6 @@
 import type { Auth, User } from "firebase/auth";
 import { getFirebaseAuth } from "@umituz/react-native-firebase";
 import { initializeAuthService } from "./AuthService";
-import { configureUserDocumentService } from "./UserDocumentService";
-import type { UserDocumentExtras } from "./UserDocumentService";
-import { collectDeviceExtras } from "@umituz/react-native-design-system";
 import { initializeAuthListener } from "../../presentation/stores/initializeAuthListener";
 import { createAuthStateHandler } from "../utils/authStateHandler";
 import type { ConversionState } from "../utils/authConversionDetector";
@@ -16,9 +13,6 @@ import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
 import type { IStorageProvider } from "../types/Storage.types";
 
 export interface InitializeAuthOptions {
-  userCollection?: string;
-  extraFields?: Record<string, unknown>;
-  collectExtras?: () => Promise<UserDocumentExtras>;
   storageProvider?: IStorageProvider;
   autoAnonymousSignIn?: boolean;
   onUserConverted?: (anonymousId: string, authenticatedId: string) => void | Promise<void>;
@@ -58,9 +52,6 @@ async function doInitializeAuth(
 ): Promise<{ success: boolean; auth: Auth | null }> {
 
   const {
-    userCollection = "users",
-    extraFields,
-    collectExtras,
     storageProvider,
     autoAnonymousSignIn = true,
     onUserConverted,
@@ -71,12 +62,6 @@ async function doInitializeAuth(
   const auth = getFirebaseAuth();
   if (!auth) return { success: false, auth: null };
 
-  configureUserDocumentService({
-    collectionName: userCollection,
-    extraFields,
-    collectExtras: collectExtras || collectDeviceExtras,
-  });
-
   let authServiceInitFailed = false;
   try {
     await initializeAuthService(auth, authConfig, storageProvider);

package/src/infrastructure/utils/AuthValidation.ts

@@ -1,7 +1,10 @@
 import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
-import type { ValidationResult } from "./validation/types";
 
-export type { ValidationResult };
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
 export interface PasswordStrengthResult extends ValidationResult { requirements: PasswordRequirements; }
 export interface PasswordRequirements {
   hasMinLength: boolean;

package/src/infrastructure/utils/UserMapper.ts

@@ -32,14 +32,17 @@ export function extractProvider(user: FirebaseUserLike): AuthProviderType {
     return "unknown";
   }
 
-  const googleProvider = providerData.find((p) => p?.providerId === "google.com");
-  if (googleProvider) return "google.com";
+  // Filter out null providers and find the first valid one
+  const validProviders = providerData.filter((p): p is ProviderData => p != null);
 
-  const appleProvider = providerData.find((p) => p?.providerId === "apple.com");
-  if (appleProvider) return "apple.com";
+  const googleProvider = validProviders.find((p) => p.providerId === "google.com");
+  if (googleProvider && googleProvider.providerId) return "google.com";
 
-  const passwordProvider = providerData.find((p) => p?.providerId === "password");
-  if (passwordProvider) return "password";
+  const appleProvider = validProviders.find((p) => p.providerId === "apple.com");
+  if (appleProvider && appleProvider.providerId) return "apple.com";
+
+  const passwordProvider = validProviders.find((p) => p.providerId === "password");
+  if (passwordProvider && passwordProvider.providerId) return "password";
 
   return "unknown";
 }

package/src/infrastructure/utils/authStateHandler.ts

@@ -4,7 +4,6 @@
  */
 
 import type { User } from "firebase/auth";
-import { ensureUserDocument } from "../services/UserDocumentService";
 import { detectConversion, type ConversionState } from "./authConversionDetector";
 
 export interface AuthStateHandlerOptions {
@@ -43,12 +42,6 @@ export function createAuthStateHandler(
       }
     }
 
-    const extras = conversion.isConversion && state.current.previousUserId
-      ? { previousAnonymousUserId: state.current.previousUserId }
-      : undefined;
-
-    await ensureUserDocument(user, extras);
-
     state.current = {
       previousUserId: currentUserId,
       wasAnonymous: isCurrentlyAnonymous,

package/src/infrastructure/utils/validation/sanitization.ts

@@ -1,141 +1,54 @@
 /**
  * Sanitization Utilities
  * Secure input cleaning for user data
- *
- * @module Sanitization
- * @description Provides input sanitization functions to prevent XSS attacks,
- * injection attacks, and ensure data integrity. All user inputs should be
- * sanitized before storage or processing.
- *
- * Security Limits:
- * These constants define maximum lengths for various input fields to prevent
- * DoS attacks and ensure database integrity. They are based on industry standards:
- *
- * - EMAIL_MAX_LENGTH: 254 (RFC 5321 - maximum email address length)
- * - PASSWORD_MAX_LENGTH: 128 (NIST recommendations)
- * - NAME_MAX_LENGTH: 100 (Reasonable limit for display names)
- * - GENERAL_TEXT_MAX_LENGTH: 500 (Prevents abuse of text fields)
- *
- * @note These limits are currently hardcoded for security. If you need to
- * customize them for your application, you can:
- * 1. Create your own sanitization functions with custom limits
- * 2. Use the helper functions like `isWithinLengthLimit()` for validation
- * 3. Submit a PR to make these limits configurable via AuthConfig
  */
 
-/**
- * Security constants for input validation
- *
- * @constant
- * @type {readonly [key: string]: number}
- *
- * @property {number} EMAIL_MAX_LENGTH - Maximum email length per RFC 5321
- * @property {number} PASSWORD_MIN_LENGTH - Minimum password length (configurable via AuthConfig)
- * @property {number} PASSWORD_MAX_LENGTH - Maximum password length to prevent DoS
- * @property {number} NAME_MAX_LENGTH - Maximum display name length
- * @property {number} GENERAL_TEXT_MAX_LENGTH - Maximum general text input length
- */
 export const SECURITY_LIMITS = {
-  EMAIL_MAX_LENGTH: 254, // RFC 5321
+  EMAIL_MAX_LENGTH: 254,
   PASSWORD_MIN_LENGTH: 6,
   PASSWORD_MAX_LENGTH: 128,
   NAME_MAX_LENGTH: 100,
   GENERAL_TEXT_MAX_LENGTH: 500,
 } as const;
 
-/**
- * Type for security limit keys
- */
 export type SecurityLimitKey = keyof typeof SECURITY_LIMITS;
 
-/**
- * Get a specific security limit value
- * @param key - The security limit key
- * @returns The security limit value
- * @example
- * ```ts
- * const maxEmailLength = getSecurityLimit('EMAIL_MAX_LENGTH'); // 254
- * ```
- */
-export function getSecurityLimit(key: SecurityLimitKey): number {
-  return SECURITY_LIMITS[key];
-}
-
-/**
- * Trim and normalize whitespace
- */
 export const sanitizeWhitespace = (input: string): string => {
   return input.trim().replace(/\s+/g, ' ');
 };
 
-/**
- * Sanitize email address
- * - Trim whitespace
- * - Convert to lowercase
- * - Limit length
- */
 export const sanitizeEmail = (email: string): string => {
   const trimmed = email.trim().toLowerCase();
   return trimmed.substring(0, SECURITY_LIMITS.EMAIL_MAX_LENGTH);
 };
 
-/**
- * Sanitize password
- * - Trim leading/trailing whitespace to prevent login issues
- * - Preserve case and special chars
- * - Limit length to prevent DoS
- */
 export const sanitizePassword = (password: string): string => {
-  // Trim leading/trailing spaces to prevent authentication issues
-  // Internal spaces are preserved for special use cases
   return password.trim().substring(0, SECURITY_LIMITS.PASSWORD_MAX_LENGTH);
 };
 
-/**
- * Sanitize display name
- * - Trim whitespace
- * - Normalize multiple spaces
- * - Remove potential XSS characters
- * - Limit length
- */
 export const sanitizeName = (name: string): string => {
   const trimmed = sanitizeWhitespace(name);
-  // Remove HTML tags and script content
   const noTags = trimmed.replace(/<[^>]*>/g, '');
   return noTags.substring(0, SECURITY_LIMITS.NAME_MAX_LENGTH);
 };
 
-/**
- * Sanitize general text input
- * - Trim whitespace
- * - Remove HTML/script tags
- * - Limit length
- */
 export const sanitizeText = (text: string): string => {
   const trimmed = sanitizeWhitespace(text);
   const noTags = trimmed.replace(/<[^>]*>/g, '');
   return noTags.substring(0, SECURITY_LIMITS.GENERAL_TEXT_MAX_LENGTH);
 };
 
-/**
- * Check if string contains potentially dangerous characters
- */
 export const containsDangerousChars = (input: string): boolean => {
-  // Check for common XSS patterns
   const dangerousPatterns = [
     /<script/i,
     /javascript:/i,
-    /on\w+\s*=/i, // onclick, onload, etc.
+    /on\w+\s*=/i,
     /<iframe/i,
     /eval\(/i,
   ];
-
   return dangerousPatterns.some(pattern => pattern.test(input));
 };
 
-/**
- * Validate string length is within bounds
- */
 export const isWithinLengthLimit = (
   input: string,
   maxLength: number,

package/src/init/createAuthInitModule.ts

@@ -8,23 +8,12 @@ import { initializeAuth } from '../infrastructure/services/initializeAuth';
 import type { InitializeAuthOptions } from '../infrastructure/services/initializeAuth';
 
 export interface AuthInitModuleConfig {
-  /**
-   * Firestore collection name for user documents
-   * @default "users"
-   */
-  userCollection?: string;
-
   /**
    * Whether to auto sign-in as anonymous user
    * @default true
    */
   autoAnonymousSignIn?: boolean;
 
-  /**
-   * Function to collect device extras for user document
-   */
-  collectExtras?: InitializeAuthOptions['collectExtras'];
-
   /**
    * Storage provider for auth persistence
    */
@@ -80,9 +69,7 @@ export function createAuthInitModule(
   config: AuthInitModuleConfig = {}
 ): InitModule {
   const {
-    userCollection = 'users',
     autoAnonymousSignIn = true,
-    collectExtras,
     storageProvider,
     onRestorePurchases,
     onUserConverted,
@@ -97,9 +84,7 @@ export function createAuthInitModule(
     init: async () => {
       try {
         await initializeAuth({
-          userCollection,
           autoAnonymousSignIn,
-          collectExtras,
           storageProvider,
           onUserConverted: async (anonymousId: string, authenticatedId: string) => {
             if (__DEV__) {

package/src/presentation/hooks/mutations/useAuthMutations.ts

@@ -5,12 +5,12 @@
 
 import { useMutation } from "@umituz/react-native-design-system";
 import { getAuthService } from "../../../infrastructure/services/AuthService";
-import type { SignUpParams, SignInParams } from "../../../application/ports/IAuthService";
+import type { AuthCredentials, SignUpCredentials } from "../../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../../domain/entities/AuthUser";
 
 export const useSignUpMutation = () => {
     return useMutation({
-        mutationFn: async (params: SignUpParams): Promise<AuthUser> => {
+        mutationFn: async (params: SignUpCredentials): Promise<AuthUser> => {
             const service = getAuthService();
             if (!service) throw new Error("Auth Service not initialized");
             return service.signUp(params);
@@ -20,7 +20,7 @@ export const useSignUpMutation = () => {
 
 export const useSignInMutation = () => {
     return useMutation({
-        mutationFn: async (params: SignInParams): Promise<AuthUser> => {
+        mutationFn: async (params: AuthCredentials): Promise<AuthUser> => {
             const service = getAuthService();
             if (!service) throw new Error("Auth Service not initialized");
             return service.signIn(params);

package/src/presentation/hooks/useAuthBottomSheet.ts

@@ -103,6 +103,8 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
       });
     }
 
+    let timeoutId: NodeJS.Timeout | undefined;
+
     if ((justAuthenticated || justConvertedFromAnonymous) && isVisible && !isAnonymous) {
       if (__DEV__) {
         console.log("[useAuthBottomSheet] Auto-closing due to successful authentication transition", {
@@ -116,7 +118,7 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
       // Notify auth success
       onAuthSuccess?.();
       // Execute callback with delay to ensure auth state has propagated
-      setTimeout(() => {
+      timeoutId = setTimeout(() => {
         if (__DEV__) {
           console.log("[useAuthBottomSheet] Executing pending callback after auth");
         }
@@ -127,6 +129,13 @@ export function useAuthBottomSheet(params: UseAuthBottomSheetParams = {}) {
     prevIsAuthenticatedRef.current = isAuthenticated;
     prevIsVisibleRef.current = isVisible;
     prevIsAnonymousRef.current = isAnonymous;
+
+    // Cleanup timeout on unmount or dependency change
+    return () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    };
   }, [isAuthenticated, isVisible, isAnonymous, executePendingCallback, hideAuthModal, onAuthSuccess]);
 
   const handleNavigateToRegister = useCallback(() => {