@umituz/react-native-auth 3.2.11 → 3.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.2.11",
+  "version": "3.2.12",
   "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/__tests__/services/AnonymousModeService.test.ts

@@ -0,0 +1,197 @@
+/**
+ * AnonymousModeService Tests
+ */
+
+import { AnonymousModeService } from '../../infrastructure/services/AnonymousModeService';
+import type { IStorageProvider } from '../../infrastructure/services/AuthPackage';
+
+describe('AnonymousModeService', () => {
+  let anonymousModeService: AnonymousModeService;
+  let mockStorageProvider: jest.Mocked<IStorageProvider>;
+
+  beforeEach(() => {
+    mockStorageProvider = {
+      get: jest.fn(),
+      set: jest.fn(),
+      remove: jest.fn(),
+    };
+
+    anonymousModeService = new AnonymousModeService('@test_anonymous_mode');
+  });
+
+  describe('constructor', () => {
+    it('should use default storage key when none provided', () => {
+      const service = new AnonymousModeService();
+      expect(service.getIsAnonymousMode()).toBe(false);
+    });
+
+    it('should use custom storage key when provided', () => {
+      const service = new AnonymousModeService('@custom_key');
+      expect(service.getIsAnonymousMode()).toBe(false);
+    });
+  });
+
+  describe('load', () => {
+    it('should load false when storage returns null', async () => {
+      mockStorageProvider.get.mockResolvedValue(null);
+
+      const result = await anonymousModeService.load(mockStorageProvider);
+
+      expect(result).toBe(false);
+      expect(mockStorageProvider.get).toHaveBeenCalledWith('@test_anonymous_mode');
+    });
+
+    it('should load false when storage returns "false"', async () => {
+      mockStorageProvider.get.mockResolvedValue('false');
+
+      const result = await anonymousModeService.load(mockStorageProvider);
+
+      expect(result).toBe(false);
+    });
+
+    it('should load true when storage returns "true"', async () => {
+      mockStorageProvider.get.mockResolvedValue('true');
+
+      const result = await anonymousModeService.load(mockStorageProvider);
+
+      expect(result).toBe(true);
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
+    });
+
+    it('should handle storage errors gracefully', async () => {
+      mockStorageProvider.get.mockRejectedValue(new Error('Storage error'));
+
+      const result = await anonymousModeService.load(mockStorageProvider);
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('save', () => {
+    it('should save true to storage when anonymous mode is enabled', async () => {
+      anonymousModeService.setAnonymousMode(true);
+
+      await anonymousModeService.save(mockStorageProvider);
+
+      expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_anonymous_mode', 'true');
+    });
+
+    it('should save false to storage when anonymous mode is disabled', async () => {
+      anonymousModeService.setAnonymousMode(false);
+
+      await anonymousModeService.save(mockStorageProvider);
+
+      expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_anonymous_mode', 'false');
+    });
+
+    it('should handle storage errors gracefully', async () => {
+      anonymousModeService.setAnonymousMode(true);
+      mockStorageProvider.set.mockRejectedValue(new Error('Storage error'));
+
+      await expect(anonymousModeService.save(mockStorageProvider)).resolves.not.toThrow();
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear anonymous mode and remove from storage', async () => {
+      anonymousModeService.setAnonymousMode(true);
+
+      await anonymousModeService.clear(mockStorageProvider);
+
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
+      expect(mockStorageProvider.remove).toHaveBeenCalledWith('@test_anonymous_mode');
+    });
+
+    it('should handle storage errors gracefully', async () => {
+      mockStorageProvider.remove.mockRejectedValue(new Error('Storage error'));
+
+      await expect(anonymousModeService.clear(mockStorageProvider)).resolves.not.toThrow();
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
+    });
+  });
+
+  describe('enable', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let mockAuthProvider: any;
+
+    beforeEach(() => {
+      mockAuthProvider = {
+        getCurrentUser: jest.fn(),
+        signOut: jest.fn(),
+      };
+    });
+
+    it('should enable anonymous mode without provider', async () => {
+      await anonymousModeService.enable(mockStorageProvider);
+
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
+      expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_anonymous_mode', 'true');
+    });
+
+    it('should sign out provider if user is logged in', async () => {
+      mockAuthProvider.getCurrentUser.mockReturnValue({ uid: 'test-user' });
+      mockAuthProvider.signOut.mockResolvedValue(undefined);
+
+      await anonymousModeService.enable(mockStorageProvider, mockAuthProvider);
+
+      expect(mockAuthProvider.signOut).toHaveBeenCalled();
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
+    });
+
+    it('should ignore sign out errors', async () => {
+      mockAuthProvider.getCurrentUser.mockReturnValue({ uid: 'test-user' });
+      mockAuthProvider.signOut.mockRejectedValue(new Error('Sign out error'));
+
+      await expect(anonymousModeService.enable(mockStorageProvider, mockAuthProvider)).resolves.not.toThrow();
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
+    });
+  });
+
+  describe('wrapAuthStateCallback', () => {
+    it('should call callback with user when not in anonymous mode', () => {
+      const callback = jest.fn();
+      const wrappedCallback = anonymousModeService.wrapAuthStateCallback(callback);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const mockUser = { uid: 'test-user' } as any;
+
+      wrappedCallback(mockUser);
+
+      expect(callback).toHaveBeenCalledWith(mockUser);
+    });
+
+    it('should call callback with null when in anonymous mode', () => {
+      anonymousModeService.setAnonymousMode(true);
+      const callback = jest.fn();
+      const wrappedCallback = anonymousModeService.wrapAuthStateCallback(callback);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const mockUser = { uid: 'test-user' } as any;
+
+      wrappedCallback(mockUser);
+
+      expect(callback).toHaveBeenCalledWith(null);
+    });
+
+    it('should call callback with null when user is null', () => {
+      const callback = jest.fn();
+      const wrappedCallback = anonymousModeService.wrapAuthStateCallback(callback);
+
+      wrappedCallback(null);
+
+      expect(callback).toHaveBeenCalledWith(null);
+    });
+  });
+
+  describe('getIsAnonymousMode and setAnonymousMode', () => {
+    it('should return initial anonymous mode state', () => {
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
+    });
+
+    it('should set and get anonymous mode state', () => {
+      anonymousModeService.setAnonymousMode(true);
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(true);
+
+      anonymousModeService.setAnonymousMode(false);
+      expect(anonymousModeService.getIsAnonymousMode()).toBe(false);
+    });
+  });
+});

package/src/__tests__/services/AuthPackage.test.ts

@@ -48,11 +48,11 @@ describe('AuthPackage', () => {
     it('should merge custom config with defaults', () => {
       const customConfig = {
         storageKeys: {
-          guestMode: '@custom_guest_mode',
+          anonymousMode: '@custom_anonymous_mode',
           showRegister: 'custom_show_register',
         },
         features: {
-          guestMode: false,
+          anonymousMode: false,
           registration: false,
           passwordStrength: false,
         },
@@ -60,7 +60,7 @@ describe('AuthPackage', () => {
 
       const authPackage = new AuthPackage(customConfig);
       const config = authPackage.getConfig();
-      
+
       expect(config.storageKeys).toEqual(customConfig.storageKeys);
       expect(config.features).toEqual(customConfig.features);
       expect(config.validation).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG.validation);
@@ -117,7 +117,7 @@ describe('AuthPackage', () => {
     });
 
     it('should return feature status from config', () => {
-      expect(authPackage.isFeatureEnabled('guestMode')).toBe(true);
+      expect(authPackage.isFeatureEnabled('anonymousMode')).toBe(true);
       expect(authPackage.isFeatureEnabled('registration')).toBe(true);
       expect(authPackage.isFeatureEnabled('passwordStrength')).toBe(true);
     });
@@ -125,15 +125,15 @@ describe('AuthPackage', () => {
     it('should return custom feature status', () => {
       const customConfig = {
         features: {
-          guestMode: false,
+          anonymousMode: false,
           registration: false,
           passwordStrength: false,
         },
       };
 
       const customPackage = new AuthPackage(customConfig);
-      
-      expect(customPackage.isFeatureEnabled('guestMode')).toBe(false);
+
+      expect(customPackage.isFeatureEnabled('anonymousMode')).toBe(false);
       expect(customPackage.isFeatureEnabled('registration')).toBe(false);
       expect(customPackage.isFeatureEnabled('passwordStrength')).toBe(false);
     });
@@ -143,12 +143,12 @@ describe('AuthPackage', () => {
     it('should initialize package globally', () => {
       const customConfig = {
         storageKeys: {
-          guestMode: '@global_guest_mode',
+          anonymousMode: '@global_anonymous_mode',
         },
       };
 
       const packageInstance = initializeAuthPackage(customConfig);
-      expect(packageInstance.getConfig().storageKeys.guestMode).toBe('@global_guest_mode');
+      expect(packageInstance.getConfig().storageKeys.anonymousMode).toBe('@global_anonymous_mode');
     });
 
     it('should return existing package instance', () => {
@@ -167,11 +167,11 @@ describe('AuthPackage', () => {
     it('should not reinitialize when already initialized', () => {
       const firstInstance = initializeAuthPackage();
       const secondInstance = initializeAuthPackage({
-        storageKeys: { guestMode: '@different' },
+        storageKeys: { anonymousMode: '@different' },
       });
-      
+
       expect(firstInstance).toBe(secondInstance);
-      expect(secondInstance.getConfig().storageKeys.guestMode).toBe('@auth_guest_mode'); // Should keep original
+      expect(secondInstance.getConfig().storageKeys.anonymousMode).toBe('@auth_anonymous_mode');
     });
 
     it('should reset package instance', () => {
@@ -204,23 +204,23 @@ describe('AuthPackage', () => {
     it('should handle empty config', () => {
       const authPackage = new AuthPackage({});
       const config = authPackage.getConfig();
-      
+
       expect(config).toEqual(DEFAULT_AUTH_PACKAGE_CONFIG);
     });
 
     it('should handle partial config', () => {
       const partialConfig = {
         features: {
-          guestMode: false,
+          anonymousMode: false,
         },
       };
 
       const authPackage = new AuthPackage(partialConfig);
       const config = authPackage.getConfig();
-      
-      expect(config.features.guestMode).toBe(false);
-      expect(config.features.registration).toBe(true); // Should keep default
-      expect(config.features.passwordStrength).toBe(true); // Should keep default
+
+      expect(config.features.anonymousMode).toBe(false);
+      expect(config.features.registration).toBe(true);
+      expect(config.features.passwordStrength).toBe(true);
     });
   });
 });

package/src/application/ports/IAuthService.ts

@@ -33,14 +33,14 @@ export interface IAuthService {
   signOut(): Promise<void>;
 
   /**
-   * Set guest mode (no authentication)
+   * Set anonymous mode (no authentication)
    */
-  setGuestMode(): Promise<void>;
+  setAnonymousMode(): Promise<void>;
 
   /**
-   * Check if currently in guest mode
+   * Check if currently in anonymous mode
    */
-  getIsGuestMode(): boolean;
+  getIsAnonymousMode(): boolean;
 
   /**
    * Get current authenticated user

package/src/domain/utils/{guestNameGenerator.ts → anonymousNameGenerator.ts}

@@ -27,19 +27,19 @@ const DEFAULT_NAMES = [
     'Phoenix',
 ];
 
-export interface GuestNameConfig {
+export interface AnonymousNameConfig {
     names?: string[];
     prefixes?: string[];
     usePrefixes?: boolean;
 }
 
 /**
- * Generate a random guest name
+ * Generate a random anonymous name
  * Uses userId to ensure consistency per user
  */
-export function generateGuestName(
+export function generateAnonymousName(
     userId?: string,
-    config?: GuestNameConfig,
+    config?: AnonymousNameConfig,
 ): string {
     const names = config?.names || DEFAULT_NAMES;
     const prefixes = config?.prefixes || [];
@@ -47,7 +47,7 @@ export function generateGuestName(
 
     if (!userId) {
         const randomIndex = Math.floor(Math.random() * names.length);
-        return names[randomIndex] ?? "Guest";
+        return names[randomIndex] ?? "Anonymous";
     }
 
     // Use userId hash for consistent name per user
@@ -56,7 +56,7 @@ export function generateGuestName(
     }, 0);
 
     const nameIndex = Math.abs(hash) % names.length;
-    const name = names[nameIndex] ?? "Guest";
+    const name = names[nameIndex] ?? "Anonymous";
 
     if (usePrefixes && prefixes.length > 0) {
         const prefixIndex = Math.abs(hash >> 8) % prefixes.length;
@@ -67,13 +67,13 @@ export function generateGuestName(
 }
 
 /**
- * Get guest display name with fallback
+ * Get anonymous display name with fallback
  */
-export function getGuestDisplayName(
+export function getAnonymousDisplayName(
     userId?: string,
-    fallback = 'Guest',
-    config?: GuestNameConfig,
+    fallback = 'Anonymous',
+    config?: AnonymousNameConfig,
 ): string {
     if (!userId) return fallback;
-    return generateGuestName(userId, config);
+    return generateAnonymousName(userId, config);
 }

package/src/index.ts

@@ -146,9 +146,9 @@ export type { UseAppleAuthResult } from './presentation/hooks/useAppleAuth';
 
 export type { UserProfile, UpdateProfileParams } from './domain/entities/UserProfile';
 
-// Domain Utils - Guest Names
-export { generateGuestName, getGuestDisplayName } from './domain/utils/guestNameGenerator';
-export type { GuestNameConfig } from './domain/utils/guestNameGenerator';
+// Domain Utils - Anonymous Names
+export { generateAnonymousName, getAnonymousDisplayName } from './domain/utils/anonymousNameGenerator';
+export type { AnonymousNameConfig } from './domain/utils/anonymousNameGenerator';
 
 // =============================================================================
 // PRESENTATION LAYER - Screens & Navigation
@@ -216,7 +216,6 @@ export {
   getUserId,
   getUserType,
   getIsAuthenticated,
-  getIsGuest,
   getIsAnonymous,
 } from './presentation/stores/authStore';
 

package/src/infrastructure/services/{GuestModeService.ts → AnonymousModeService.ts}

@@ -1,26 +1,26 @@
 /**
- * Guest Mode Service
- * Handles guest mode functionality
+ * Anonymous Mode Service
+ * Handles anonymous mode functionality
  */
 
 import type { IAuthProvider } from "../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
-import { emitGuestModeEnabled } from "../utils/AuthEventEmitter";
+import { emitAnonymousModeEnabled } from "../utils/AuthEventEmitter";
 import type { IStorageProvider } from "./AuthPackage";
 
-export class GuestModeService {
-  private isGuestMode: boolean = false;
+export class AnonymousModeService {
+  private isAnonymousMode: boolean = false;
   private storageKey: string;
 
-  constructor(storageKey: string = "@auth_guest_mode") {
+  constructor(storageKey: string = "@auth_anonymous_mode") {
     this.storageKey = storageKey;
   }
 
   async load(storageProvider: IStorageProvider): Promise<boolean> {
     try {
       const value = await storageProvider.get(this.storageKey);
-      this.isGuestMode = value === "true";
-      return this.isGuestMode;
+      this.isAnonymousMode = value === "true";
+      return this.isAnonymousMode;
     } catch {
       return false;
     }
@@ -28,7 +28,7 @@ export class GuestModeService {
 
   async save(storageProvider: IStorageProvider): Promise<void> {
     try {
-      await storageProvider.set(this.storageKey, this.isGuestMode.toString());
+      await storageProvider.set(this.storageKey, this.isAnonymousMode.toString());
     } catch {
       // Silently fail storage operations
     }
@@ -40,7 +40,7 @@ export class GuestModeService {
     } catch {
       // Silently fail storage operations
     }
-    this.isGuestMode = false;
+    this.isAnonymousMode = false;
   }
 
   async enable(storageProvider: IStorageProvider, provider?: IAuthProvider): Promise<void> {
@@ -49,29 +49,29 @@ export class GuestModeService {
       try {
         await provider.signOut();
       } catch {
-        // Ignore sign out errors when switching to guest mode
+        // Ignore sign out errors when switching to anonymous mode
       }
     }
 
-    this.isGuestMode = true;
+    this.isAnonymousMode = true;
     await this.save(storageProvider);
-    emitGuestModeEnabled();
+    emitAnonymousModeEnabled();
   }
 
-  getIsGuestMode(): boolean {
-    return this.isGuestMode;
+  getIsAnonymousMode(): boolean {
+    return this.isAnonymousMode;
   }
 
-  setGuestMode(enabled: boolean): void {
-    this.isGuestMode = enabled;
+  setAnonymousMode(enabled: boolean): void {
+    this.isAnonymousMode = enabled;
   }
 
   wrapAuthStateCallback(
     callback: (user: AuthUser | null) => void
   ): (user: AuthUser | null) => void {
     return (user: AuthUser | null) => {
-      // Don't update if in guest mode
-      if (!this.isGuestMode) {
+      // Don't update if in anonymous mode
+      if (!this.isAnonymousMode) {
         callback(user);
       } else {
         callback(null);

package/src/infrastructure/services/AuthEventService.ts

@@ -38,13 +38,13 @@ export class AuthEventService {
     this.notifyListeners("user-authenticated", payload);
   }
 
-  emitGuestModeEnabled(): void {
+  emitAnonymousModeEnabled(): void {
     const payload: AuthEventPayload = {
       timestamp: Date.now(),
     };
 
-    DeviceEventEmitter.emit("guest-mode-enabled", payload);
-    this.notifyListeners("guest-mode-enabled", payload);
+    DeviceEventEmitter.emit("anonymous-mode-enabled", payload);
+    this.notifyListeners("anonymous-mode-enabled", payload);
   }
 
   emitAuthError(error: string): void {
@@ -99,13 +99,13 @@ export class AuthEventService {
 // Export singleton instance for backward compatibility
 export const authEventService = AuthEventService.getInstance();
 
-// Legacy functions for backward compatibility
+// Helper functions
 export function emitUserAuthenticated(userId: string): void {
   authEventService.emitUserAuthenticated(userId);
 }
 
-export function emitGuestModeEnabled(): void {
-  authEventService.emitGuestModeEnabled();
+export function emitAnonymousModeEnabled(): void {
+  authEventService.emitAnonymousModeEnabled();
 }
 
 export function emitAuthError(error: string): void {

package/src/infrastructure/services/AuthPackage.ts

@@ -8,7 +8,7 @@ import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
 
 export interface AuthPackageConfig {
   storageKeys: {
-    guestMode: string;
+    anonymousMode: string;
     showRegister: string;
   };
   validation: {
@@ -21,7 +21,7 @@ export interface AuthPackageConfig {
     localization?: any;
   };
   features: {
-    guestMode: boolean;
+    anonymousMode: boolean;
     registration: boolean;
     passwordStrength: boolean;
   };
@@ -29,7 +29,7 @@ export interface AuthPackageConfig {
 
 export const DEFAULT_AUTH_PACKAGE_CONFIG: AuthPackageConfig = {
   storageKeys: {
-    guestMode: "@auth_guest_mode",
+    anonymousMode: "@auth_anonymous_mode",
     showRegister: "auth_show_register",
   },
   validation: {
@@ -47,7 +47,7 @@ export const DEFAULT_AUTH_PACKAGE_CONFIG: AuthPackageConfig = {
     localization: undefined,
   },
   features: {
-    guestMode: true,
+    anonymousMode: true,
     registration: true,
     passwordStrength: true,
   },