@umituz/react-native-auth 2.7.3 → 2.7.6

package/src/infrastructure/services/AuthService.ts

@@ -6,162 +6,133 @@
 import type { Auth } from "firebase/auth";
 import type { IAuthService, SignUpParams, SignInParams } from "../../application/ports/IAuthService";
 import type { IAuthProvider } from "../../application/ports/IAuthProvider";
+import { FirebaseAuthProvider } from "../providers/FirebaseAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
 import { DEFAULT_AUTH_CONFIG } from "../../domain/value-objects/AuthConfig";
-import { AuthCoreService } from "./AuthCoreService";
-import { GuestModeService, type IStorageProvider } from "./GuestModeService";
+import { AuthRepository } from "../repositories/AuthRepository";
+import { GuestModeService } from "./GuestModeService";
 import { authEventService } from "./AuthEventService";
-import { initializeAuthPackage, getAuthPackage } from "./AuthPackage";
-import {
-  trackPackageError,
-  addPackageBreadcrumb,
-} from "@umituz/react-native-sentry";
+import { authTracker } from "../utils/auth-tracker.util";
+import type { IStorageProvider } from "./AuthPackage";
 
 export class AuthService implements IAuthService {
-  private coreService: AuthCoreService;
+  private repository!: AuthRepository;
   private guestModeService: GuestModeService;
   private storageProvider?: IStorageProvider;
   private initialized: boolean = false;
+  private config: AuthConfig;
 
   constructor(config: Partial<AuthConfig> = {}, storageProvider?: IStorageProvider) {
-    const authConfig = {
+    this.config = {
       ...DEFAULT_AUTH_CONFIG,
       ...config,
-      password: {
-        ...DEFAULT_AUTH_CONFIG.password,
-        ...config.password,
-      },
+      password: { ...DEFAULT_AUTH_CONFIG.password, ...config.password },
     };
+    // Initialize with a dummy provider effectively, or null?
+    // AuthRepository needs a provider. We can't init it without one.
+    // We'll initialize it properly in initialize()
+    // For now we can cast null or strict init check.
+    // Better: Allow repository to be nullable or initialize with a dummy/proxy.
+    // To satisfy strict TS, let's delay repository creation or create a NotInitializedProvider.
+    // But since initialize() sets it up, we can use a ! or optional.
 
-    this.coreService = new AuthCoreService(authConfig);
     this.guestModeService = new GuestModeService();
     this.storageProvider = storageProvider;
+
+    // We can't instantiate AuthRepository yet if we don't have provider.
+    // So we'll have to keep it optional or allow late init.
+  }
+
+  private get repositoryInstance(): AuthRepository {
+    if (!this.initialized) throw new Error("AuthService not initialized");
+    return this.repository;
   }
 
   async initialize(providerOrAuth: IAuthProvider | Auth): Promise<void> {
-    if (this.initialized) {
-      return;
+    if (this.initialized) return;
+
+    let provider: IAuthProvider;
+
+    // Check if it's a Firebase Auth instance (has currentUser property)
+    if ("currentUser" in providerOrAuth) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument
+      const firebaseProvider = new FirebaseAuthProvider(providerOrAuth as any);
+      await firebaseProvider.initialize();
+      provider = firebaseProvider as unknown as IAuthProvider;
+    } else {
+      provider = providerOrAuth;
+      await provider.initialize();
     }
 
-    // Initialize core service
-    await this.coreService.initialize(providerOrAuth);
+    this.repository = new AuthRepository(provider, this.config);
 
-    // Initialize guest mode if storage provider is available
     if (this.storageProvider) {
       await this.guestModeService.load(this.storageProvider);
     }
-
     this.initialized = true;
   }
 
   isInitialized(): boolean {
-    return this.initialized && this.coreService.isInitialized();
+    return this.initialized;
   }
 
   async signUp(params: SignUpParams): Promise<AuthUser> {
-    addPackageBreadcrumb("auth", "Sign up started", {
-      email: params.email,
-    });
-
+    authTracker.logOperationStarted("Sign up", { email: params.email });
     try {
-      const user = await this.coreService.signUp(params);
-
-      // Clear guest mode when user signs up
-      if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
-        await this.guestModeService.clear(this.storageProvider);
-      }
-
-      addPackageBreadcrumb("auth", "Sign up successful", {
-        userId: user.uid,
-      });
-
+      const user = await this.repositoryInstance.signUp(params);
+      await this.clearGuestModeIfNeeded();
+      authTracker.logOperationSuccess("Sign up", { userId: user.uid });
       authEventService.emitUserAuthenticated(user.uid);
       return user;
     } catch (error) {
-      trackPackageError(
-        error instanceof Error ? error : new Error("Sign up failed"),
-        {
-          packageName: "auth",
-          operation: "sign-up",
-          email: params.email,
-        }
-      );
+      authTracker.logOperationError("sign-up", error, { email: params.email });
       throw error;
     }
   }
 
   async signIn(params: SignInParams): Promise<AuthUser> {
-    addPackageBreadcrumb("auth", "Sign in started", {
-      email: params.email,
-    });
-
+    authTracker.logOperationStarted("Sign in", { email: params.email });
     try {
-      const user = await this.coreService.signIn(params);
-
-      // Clear guest mode when user signs in
-      if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
-        await this.guestModeService.clear(this.storageProvider);
-      }
-
-      addPackageBreadcrumb("auth", "Sign in successful", {
-        userId: user.uid,
-      });
-
+      const user = await this.repositoryInstance.signIn(params);
+      await this.clearGuestModeIfNeeded();
+      authTracker.logOperationSuccess("Sign in", { userId: user.uid });
       authEventService.emitUserAuthenticated(user.uid);
       return user;
     } catch (error) {
-      trackPackageError(
-        error instanceof Error ? error : new Error("Sign in failed"),
-        {
-          packageName: "auth",
-          operation: "sign-in",
-          email: params.email,
-        }
-      );
+      authTracker.logOperationError("sign-in", error, { email: params.email });
       throw error;
     }
   }
 
   async signOut(): Promise<void> {
-    addPackageBreadcrumb("auth", "Sign out started");
-
+    authTracker.logOperationStarted("Sign out");
     try {
-      await this.coreService.signOut();
-
-      // Clear guest mode if signing out explicitly
-      if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
-        await this.guestModeService.clear(this.storageProvider);
-      }
-
-      addPackageBreadcrumb("auth", "Sign out successful");
+      await this.repositoryInstance.signOut();
+      await this.clearGuestModeIfNeeded();
+      authTracker.logOperationSuccess("Sign out");
     } catch (error) {
-      trackPackageError(
-        error instanceof Error ? error : new Error("Sign out failed"),
-        {
-          packageName: "auth",
-          operation: "sign-out",
-        }
-      );
+      authTracker.logOperationError("sign-out", error);
       throw error;
     }
   }
 
+  private async clearGuestModeIfNeeded(): Promise<void> {
+    if (this.guestModeService.getIsGuestMode() && this.storageProvider) {
+      await this.guestModeService.clear(this.storageProvider);
+    }
+  }
+
   async setGuestMode(): Promise<void> {
     if (!this.storageProvider) {
       throw new Error("Storage provider is required for guest mode");
     }
-
-    // No provider needed for guest mode enablement
-    
     await this.guestModeService.enable(this.storageProvider);
   }
 
   getCurrentUser(): AuthUser | null {
-    if (this.guestModeService.getIsGuestMode()) {
-      return null;
-    }
-    return this.coreService.getCurrentUser();
+    if (!this.initialized) return null;
+    return this.guestModeService.getIsGuestMode() ? null : this.repositoryInstance.getCurrentUser();
   }
 
   getIsGuestMode(): boolean {
@@ -170,55 +141,32 @@ export class AuthService implements IAuthService {
 
   onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {
     const wrappedCallback = this.guestModeService.wrapAuthStateCallback(callback);
-    return this.coreService.onAuthStateChange(wrappedCallback);
-  }
-
-  getConfig(): AuthConfig {
-    return this.coreService.getConfig();
-  }
-
-  getCoreService(): AuthCoreService {
-    return this.coreService;
+    return this.repositoryInstance.onAuthStateChange(wrappedCallback);
   }
 
-  getGuestModeService(): GuestModeService {
-    return this.guestModeService;
-  }
+  getConfig(): AuthConfig { return this.config; }
+  getGuestModeService(): GuestModeService { return this.guestModeService; }
+  getRepository(): AuthRepository { return this.repositoryInstance; }
 }
 
-// Singleton instance
 let authServiceInstance: AuthService | null = null;
 
-/**
- * Initialize auth service with provider or Firebase Auth instance
- */
 export async function initializeAuthService(
   providerOrAuth: IAuthProvider | Auth,
   config?: Partial<AuthConfig>,
   storageProvider?: IStorageProvider
 ): Promise<AuthService> {
   if (!authServiceInstance) {
-    // Initialize package if not already done
-    const packageConfig = getAuthPackage()?.getConfig();
     authServiceInstance = new AuthService(config, storageProvider);
   }
   await authServiceInstance.initialize(providerOrAuth);
   return authServiceInstance;
 }
 
-/**
- * Get auth service instance
- */
 export function getAuthService(): AuthService | null {
-  if (!authServiceInstance || !authServiceInstance.isInitialized()) {
-    return null;
-  }
-  return authServiceInstance;
+  return (authServiceInstance && authServiceInstance.isInitialized()) ? authServiceInstance : null;
 }
 
-/**
- * Reset auth service (useful for testing)
- */
 export function resetAuthService(): void {
   authServiceInstance = null;
 }

package/src/infrastructure/services/GuestModeService.ts

@@ -6,12 +6,7 @@
 import type { IAuthProvider } from "../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 import { emitGuestModeEnabled } from "../utils/AuthEventEmitter";
-
-export interface IStorageProvider {
-  get(key: string): Promise<string | null>;
-  set(key: string, value: string): Promise<void>;
-  remove(key: string): Promise<void>;
-}
+import type { IStorageProvider } from "./AuthPackage";
 
 export class GuestModeService {
   private isGuestMode: boolean = false;

package/src/infrastructure/utils/AuthValidation.ts

@@ -8,7 +8,7 @@ import { getAuthPackage } from "../services/AuthPackage";
 
 export interface ValidationResult {
   isValid: boolean;
-  error?: string;
+  error?: string; // This should be a localization key
 }
 
 export interface PasswordStrengthResult extends ValidationResult {
@@ -58,12 +58,12 @@ function getValidationConfig(): ValidationConfig {
  */
 export function validateEmail(email: string): ValidationResult {
   if (!email || email.trim() === "") {
-    return { isValid: false, error: "Email is required" };
+    return { isValid: false, error: "auth.validation.emailRequired" };
   }
 
   const config = getValidationConfig();
   if (!config.emailRegex.test(email.trim())) {
-    return { isValid: false, error: "Please enter a valid email address" };
+    return { isValid: false, error: "auth.validation.invalidEmail" };
   }
 
   return { isValid: true };
@@ -75,7 +75,7 @@ export function validateEmail(email: string): ValidationResult {
  */
 export function validatePasswordForLogin(password: string): ValidationResult {
   if (!password || password.length === 0) {
-    return { isValid: false, error: "Password is required" };
+    return { isValid: false, error: "auth.validation.passwordRequired" };
   }
 
   return { isValid: true };
@@ -102,7 +102,7 @@ export function validatePasswordForRegister(
   if (!password || password.length === 0) {
     return {
       isValid: false,
-      error: "Password is required",
+      error: "auth.validation.passwordRequired",
       requirements,
     };
   }
@@ -110,7 +110,7 @@ export function validatePasswordForRegister(
   if (!requirements.hasMinLength) {
     return {
       isValid: false,
-      error: `Password must be at least ${config.minLength} characters`,
+      error: "auth.validation.passwordTooShort",
       requirements,
     };
   }
@@ -118,7 +118,7 @@ export function validatePasswordForRegister(
   if (config.requireUppercase && !validationConfig.uppercaseRegex.test(password)) {
     return {
       isValid: false,
-      error: "Password must contain at least one uppercase letter",
+      error: "auth.validation.passwordRequireUppercase",
       requirements,
     };
   }
@@ -126,7 +126,7 @@ export function validatePasswordForRegister(
   if (config.requireLowercase && !validationConfig.lowercaseRegex.test(password)) {
     return {
       isValid: false,
-      error: "Password must contain at least one lowercase letter",
+      error: "auth.validation.passwordRequireLowercase",
       requirements,
     };
   }
@@ -134,7 +134,7 @@ export function validatePasswordForRegister(
   if (config.requireNumber && !validationConfig.numberRegex.test(password)) {
     return {
       isValid: false,
-      error: "Password must contain at least one number",
+      error: "auth.validation.passwordRequireNumber",
       requirements,
     };
   }
@@ -142,7 +142,7 @@ export function validatePasswordForRegister(
   if (config.requireSpecialChar && !validationConfig.specialCharRegex.test(password)) {
     return {
       isValid: false,
-      error: "Password must contain at least one special character",
+      error: "auth.validation.passwordRequireSpecialChar",
       requirements,
     };
   }
@@ -158,11 +158,11 @@ export function validatePasswordConfirmation(
   confirmPassword: string
 ): ValidationResult {
   if (!confirmPassword) {
-    return { isValid: false, error: "Please confirm your password" };
+    return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
   }
 
   if (password !== confirmPassword) {
-    return { isValid: false, error: "Passwords do not match" };
+    return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
   }
 
   return { isValid: true };
@@ -176,7 +176,7 @@ export function validateDisplayName(
   minLength?: number
 ): ValidationResult {
   if (!displayName || displayName.trim() === "") {
-    return { isValid: false, error: "Name is required" };
+    return { isValid: false, error: "auth.validation.nameRequired" };
   }
 
   const config = getValidationConfig();
@@ -185,10 +185,11 @@ export function validateDisplayName(
   if (displayName.trim().length < actualMinLength) {
     return {
       isValid: false,
-      error: `Name must be at least ${actualMinLength} characters`,
+      error: "auth.validation.nameTooShort",
     };
   }
 
   return { isValid: true };
 }
 
+

package/src/infrastructure/utils/auth-tracker.util.ts

@@ -0,0 +1,28 @@
+import {
+    trackPackageError as sentryTrack,
+    addPackageBreadcrumb as sentryBreadcrumb
+} from "@umituz/react-native-sentry";
+
+export const authTracker = {
+    logOperationStarted: (operation: string, data?: Record<string, unknown>) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call
+        (sentryBreadcrumb as any)("auth", `${operation} started`, data);
+    },
+
+    logOperationSuccess: (operation: string, data?: Record<string, unknown>) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call
+        (sentryBreadcrumb as any)("auth", `${operation} successful`, data);
+    },
+
+    logOperationError: (operation: string, error: unknown, metadata?: Record<string, unknown>) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call
+        (sentryTrack as any)(
+            error instanceof Error ? error : new Error(`${operation} failed`),
+            {
+                packageName: "auth",
+                operation,
+                ...metadata,
+            }
+        );
+    }
+};

package/src/presentation/components/AccountActions.tsx

@@ -5,16 +5,16 @@
  */
 
 import React from "react";
-import { View, Text, TouchableOpacity, StyleSheet, Alert } from "react-native";
-import { useAppDesignTokens } from "@umituz/react-native-design-system";
+import { View, TouchableOpacity, StyleSheet, Alert } from "react-native";
+import { useAppDesignTokens, AtomicIcon, AtomicText } from "@umituz/react-native-design-system";
 
 export interface AccountActionsConfig {
-    logoutText?: string;
-    deleteAccountText?: string;
-    logoutConfirmTitle?: string;
-    logoutConfirmMessage?: string;
-    deleteConfirmTitle?: string;
-    deleteConfirmMessage?: string;
+    logoutText: string;
+    deleteAccountText: string;
+    logoutConfirmTitle: string;
+    logoutConfirmMessage: string;
+    deleteConfirmTitle: string;
+    deleteConfirmMessage: string;
     onLogout: () => Promise<void>;
     onDeleteAccount: () => Promise<void>;
 }
@@ -26,13 +26,12 @@ export interface AccountActionsProps {
 export const AccountActions: React.FC<AccountActionsProps> = ({ config }) => {
     const tokens = useAppDesignTokens();
     const {
-        logoutText = "Log Out",
-        deleteAccountText = "Delete Account",
-        logoutConfirmTitle = "Log Out?",
-        logoutConfirmMessage = "Are you sure you want to log out?",
-        deleteConfirmTitle = "Delete Account?",
-        deleteConfirmMessage =
-        "This will permanently delete your account and all data. This action cannot be undone.",
+        logoutText,
+        deleteAccountText,
+        logoutConfirmTitle,
+        logoutConfirmMessage,
+        deleteConfirmTitle,
+        deleteConfirmMessage,
         onLogout,
         onDeleteAccount,
     } = config;
@@ -43,12 +42,14 @@ export const AccountActions: React.FC<AccountActionsProps> = ({ config }) => {
             {
                 text: logoutText,
                 style: "destructive",
-                onPress: async () => {
-                    try {
-                        await onLogout();
-                    } catch (error) {
-                        // Silent error handling
-                    }
+                onPress: () => {
+                    void (async () => {
+                        try {
+                            await onLogout();
+                        } catch (error) {
+                            // Silent error handling
+                        }
+                    })();
                 },
             },
         ]);
@@ -60,12 +61,14 @@ export const AccountActions: React.FC<AccountActionsProps> = ({ config }) => {
             {
                 text: deleteAccountText,
                 style: "destructive",
-                onPress: async () => {
-                    try {
-                        await onDeleteAccount();
-                    } catch (error) {
-                        // Silent error handling
-                    }
+                onPress: () => {
+                    void (async () => {
+                        try {
+                            await onDeleteAccount();
+                        } catch (error) {
+                            // Silent error handling
+                        }
+                    })();
                 },
             },
         ]);
@@ -79,15 +82,11 @@ export const AccountActions: React.FC<AccountActionsProps> = ({ config }) => {
                 onPress={handleLogout}
                 activeOpacity={0.7}
             >
-                <Text style={[styles.actionIcon, { color: tokens.colors.error }]}>
-                    ⎋
-                </Text>
-                <Text style={[styles.actionText, { color: tokens.colors.error }]}>
+                <AtomicIcon name="logout" size="md" color="error" />
+                <AtomicText style={[styles.actionText, { color: tokens.colors.error }]}>
                     {logoutText}
-                </Text>
-                <Text style={[styles.chevron, { color: tokens.colors.textTertiary }]}>
-                    ›
-                </Text>
+                </AtomicText>
+                <AtomicIcon name="chevron-right" size="sm" color="secondary" />
             </TouchableOpacity>
 
             {/* Delete Account */}
@@ -96,15 +95,11 @@ export const AccountActions: React.FC<AccountActionsProps> = ({ config }) => {
                 onPress={handleDeleteAccount}
                 activeOpacity={0.7}
             >
-                <Text style={[styles.actionIcon, { color: tokens.colors.error }]}>
-                    🗑
-                </Text>
-                <Text style={[styles.actionText, { color: tokens.colors.error }]}>
+                <AtomicIcon name="trash-2" size="md" color="error" />
+                <AtomicText style={[styles.actionText, { color: tokens.colors.error }]}>
                     {deleteAccountText}
-                </Text>
-                <Text style={[styles.chevron, { color: tokens.colors.textTertiary }]}>
-                    ›
-                </Text>
+                </AtomicText>
+                <AtomicIcon name="chevron-right" size="sm" color="secondary" />
             </TouchableOpacity>
         </View>
     );
@@ -123,16 +118,9 @@ const styles = StyleSheet.create({
         borderWidth: 1,
         gap: 12,
     },
-    actionIcon: {
-        fontSize: 20,
-    },
     actionText: {
         flex: 1,
         fontSize: 16,
         fontWeight: "500",
     },
-    chevron: {
-        fontSize: 24,
-        fontWeight: "400",
-    },
 });

package/src/presentation/components/AuthBottomSheet.tsx

@@ -45,7 +45,7 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
 }) => {
   const tokens = useAppDesignTokens();
   const { t } = useLocalization();
-  const modalRef = useRef<any>(null);
+  const modalRef = useRef<BottomSheetModal>(null);
 
   const [googleLoading, setGoogleLoading] = useState(false);
   const [appleLoading, setAppleLoading] = useState(false);
@@ -138,7 +138,7 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
           style={styles.closeButton}
           onPress={handleClose}
           hitSlop={{ top: 10, bottom: 10, left: 10, right: 10 }}
-          accessibilityLabel={t("common.close") || "Close"}
+          accessibilityLabel={t("common.close")}
           accessibilityRole="button"
         >
           <AtomicIcon name="close" size="md" color="secondary" />
@@ -169,8 +169,8 @@ export const AuthBottomSheet: React.FC<AuthBottomSheetProps> = ({
           {socialProviders.length > 0 && (
             <SocialLoginButtons
               enabledProviders={socialProviders}
-              onGooglePress={handleGoogleSignIn}
-              onApplePress={handleAppleSignIn}
+              onGooglePress={() => { void handleGoogleSignIn(); }}
+              onApplePress={() => { void handleAppleSignIn(); }}
               googleLoading={googleLoading}
               appleLoading={appleLoading}
             />

package/src/presentation/components/AuthDivider.tsx

@@ -21,7 +21,6 @@ export const AuthDivider: React.FC = () => {
         ]}
       />
       <AtomicText
-        type="caption"
         style={{
           color: tokens.colors.textSecondary,
           marginHorizontal: tokens.spacing.sm,

package/src/presentation/components/AuthGradientBackground.tsx

@@ -13,7 +13,7 @@ export const AuthGradientBackground: React.FC = () => {
 
   return (
     <LinearGradient
-      colors={[tokens.colors.primary, tokens.colors.secondary]}
+      colors={[tokens.colors.primary, tokens.colors.surfaceSecondary]}
       start={{ x: 0, y: 0 }}
       end={{ x: 1, y: 1 }}
       style={StyleSheet.absoluteFill}