@umituz/react-native-auth 1.12.0 → 2.0.2

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

@@ -0,0 +1,194 @@
+/**
+ * GuestModeService Tests
+ */
+
+import { GuestModeService } from '../../../src/infrastructure/services/GuestModeService';
+import type { IStorageProvider } from '../../../src/infrastructure/services/GuestModeService';
+
+describe('GuestModeService', () => {
+  let guestModeService: GuestModeService;
+  let mockStorageProvider: jest.Mocked<IStorageProvider>;
+
+  beforeEach(() => {
+    mockStorageProvider = {
+      get: jest.fn(),
+      set: jest.fn(),
+      remove: jest.fn(),
+    };
+
+    guestModeService = new GuestModeService('@test_guest_mode');
+  });
+
+  describe('constructor', () => {
+    it('should use default storage key when none provided', () => {
+      const service = new GuestModeService();
+      expect(service.getIsGuestMode()).toBe(false);
+    });
+
+    it('should use custom storage key when provided', () => {
+      const service = new GuestModeService('@custom_key');
+      expect(service.getIsGuestMode()).toBe(false);
+    });
+  });
+
+  describe('load', () => {
+    it('should load false when storage returns null', async () => {
+      mockStorageProvider.get.mockResolvedValue(null);
+      
+      const result = await guestModeService.load(mockStorageProvider);
+      
+      expect(result).toBe(false);
+      expect(mockStorageProvider.get).toHaveBeenCalledWith('@test_guest_mode');
+    });
+
+    it('should load false when storage returns "false"', async () => {
+      mockStorageProvider.get.mockResolvedValue('false');
+      
+      const result = await guestModeService.load(mockStorageProvider);
+      
+      expect(result).toBe(false);
+    });
+
+    it('should load true when storage returns "true"', async () => {
+      mockStorageProvider.get.mockResolvedValue('true');
+      
+      const result = await guestModeService.load(mockStorageProvider);
+      
+      expect(result).toBe(true);
+      expect(guestModeService.getIsGuestMode()).toBe(true);
+    });
+
+    it('should handle storage errors gracefully', async () => {
+      mockStorageProvider.get.mockRejectedValue(new Error('Storage error'));
+      
+      const result = await guestModeService.load(mockStorageProvider);
+      
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('save', () => {
+    it('should save true to storage when guest mode is enabled', async () => {
+      guestModeService.setGuestMode(true);
+      
+      await guestModeService.save(mockStorageProvider);
+      
+      expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_guest_mode', 'true');
+    });
+
+    it('should remove from storage when guest mode is disabled', async () => {
+      guestModeService.setGuestMode(false);
+      
+      await guestModeService.save(mockStorageProvider);
+      
+      expect(mockStorageProvider.remove).toHaveBeenCalledWith('@test_guest_mode');
+    });
+
+    it('should handle storage errors gracefully', async () => {
+      guestModeService.setGuestMode(true);
+      mockStorageProvider.set.mockRejectedValue(new Error('Storage error'));
+      
+      await expect(guestModeService.save(mockStorageProvider)).resolves.not.toThrow();
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear guest mode and remove from storage', async () => {
+      guestModeService.setGuestMode(true);
+      
+      await guestModeService.clear(mockStorageProvider);
+      
+      expect(guestModeService.getIsGuestMode()).toBe(false);
+      expect(mockStorageProvider.remove).toHaveBeenCalledWith('@test_guest_mode');
+    });
+
+    it('should handle storage errors gracefully', async () => {
+      mockStorageProvider.remove.mockRejectedValue(new Error('Storage error'));
+      
+      await expect(guestModeService.clear(mockStorageProvider)).resolves.not.toThrow();
+      expect(guestModeService.getIsGuestMode()).toBe(false);
+    });
+  });
+
+  describe('enable', () => {
+    let mockAuthProvider: any;
+
+    beforeEach(() => {
+      mockAuthProvider = {
+        getCurrentUser: jest.fn(),
+        signOut: jest.fn(),
+      };
+    });
+
+    it('should enable guest mode without provider', async () => {
+      await guestModeService.enable(mockStorageProvider);
+      
+      expect(guestModeService.getIsGuestMode()).toBe(true);
+      expect(mockStorageProvider.set).toHaveBeenCalledWith('@test_guest_mode', 'true');
+    });
+
+    it('should sign out provider if user is logged in', async () => {
+      mockAuthProvider.getCurrentUser.mockReturnValue({ uid: 'test-user' });
+      mockAuthProvider.signOut.mockResolvedValue(undefined);
+      
+      await guestModeService.enable(mockStorageProvider, mockAuthProvider);
+      
+      expect(mockAuthProvider.signOut).toHaveBeenCalled();
+      expect(guestModeService.getIsGuestMode()).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(guestModeService.enable(mockStorageProvider, mockAuthProvider)).resolves.not.toThrow();
+      expect(guestModeService.getIsGuestMode()).toBe(true);
+    });
+  });
+
+  describe('wrapAuthStateCallback', () => {
+    it('should call callback with user when not in guest mode', () => {
+      const callback = jest.fn();
+      const wrappedCallback = guestModeService.wrapAuthStateCallback(callback);
+      const mockUser = { uid: 'test-user' };
+      
+      wrappedCallback(mockUser);
+      
+      expect(callback).toHaveBeenCalledWith(mockUser);
+    });
+
+    it('should call callback with null when in guest mode', () => {
+      guestModeService.setGuestMode(true);
+      const callback = jest.fn();
+      const wrappedCallback = guestModeService.wrapAuthStateCallback(callback);
+      const mockUser = { uid: 'test-user' };
+      
+      wrappedCallback(mockUser);
+      
+      expect(callback).toHaveBeenCalledWith(null);
+    });
+
+    it('should call callback with null when user is null', () => {
+      const callback = jest.fn();
+      const wrappedCallback = guestModeService.wrapAuthStateCallback(callback);
+      
+      wrappedCallback(null);
+      
+      expect(callback).toHaveBeenCalledWith(null);
+    });
+  });
+
+  describe('getIsGuestMode and setGuestMode', () => {
+    it('should return initial guest mode state', () => {
+      expect(guestModeService.getIsGuestMode()).toBe(false);
+    });
+
+    it('should set and get guest mode state', () => {
+      guestModeService.setGuestMode(true);
+      expect(guestModeService.getIsGuestMode()).toBe(true);
+      
+      guestModeService.setGuestMode(false);
+      expect(guestModeService.getIsGuestMode()).toBe(false);
+    });
+  });
+});

package/src/__tests__/utils/AuthValidation.test.ts

@@ -0,0 +1,270 @@
+/**
+ * AuthValidation Tests
+ */
+
+import {
+  validateEmail,
+  validatePasswordForLogin,
+  validatePasswordForRegister,
+  validatePasswordConfirmation,
+  validateDisplayName,
+} from '../../../src/infrastructure/utils/AuthValidation';
+import { DEFAULT_PASSWORD_CONFIG } from '../../../src/domain/value-objects/AuthConfig';
+import { initializeAuthPackage } from '../../../src/infrastructure/services/AuthPackage';
+
+describe('AuthValidation', () => {
+  beforeEach(() => {
+    // Reset package config before each test
+    initializeAuthPackage();
+  });
+
+  describe('validateEmail', () => {
+    it('should reject empty email', () => {
+      const result = validateEmail('');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Email is required');
+    });
+
+    it('should reject whitespace-only email', () => {
+      const result = validateEmail('   ');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Email is required');
+    });
+
+    it('should reject invalid email format', () => {
+      const result = validateEmail('invalid-email');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Please enter a valid email address');
+    });
+
+    it('should accept valid email format', () => {
+      const result = validateEmail('test@example.com');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should accept valid email with subdomain', () => {
+      const result = validateEmail('test@mail.example.com');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should trim whitespace', () => {
+      const result = validateEmail('  test@example.com  ');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('validatePasswordForLogin', () => {
+    it('should reject empty password', () => {
+      const result = validatePasswordForLogin('');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Password is required');
+    });
+
+    it('should accept any non-empty password', () => {
+      const result = validatePasswordForLogin('any');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should accept password with spaces', () => {
+      const result = validatePasswordForLogin('  password  ');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('validatePasswordForRegister', () => {
+    const config = DEFAULT_PASSWORD_CONFIG;
+
+    it('should reject empty password', () => {
+      const result = validatePasswordForRegister('', config);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Password is required');
+      expect(result.requirements.hasMinLength).toBe(false);
+    });
+
+    it('should reject password that is too short', () => {
+      const result = validatePasswordForRegister('123', config);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe(`Password must be at least ${config.minLength} characters`);
+      expect(result.requirements.hasMinLength).toBe(false);
+    });
+
+    it('should accept password that meets minimum length', () => {
+      const result = validatePasswordForRegister('12345678', config);
+      expect(result.requirements.hasMinLength).toBe(true);
+    });
+
+    it('should validate uppercase requirement', () => {
+      const configWithUppercase = {
+        ...config,
+        requireUppercase: true,
+      };
+
+      const result = validatePasswordForRegister('password', configWithUppercase);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Password must contain at least one uppercase letter');
+      expect(result.requirements.hasUppercase).toBe(false);
+
+      const validResult = validatePasswordForRegister('Password', configWithUppercase);
+      expect(validResult.requirements.hasUppercase).toBe(true);
+    });
+
+    it('should validate lowercase requirement', () => {
+      const configWithLowercase = {
+        ...config,
+        requireLowercase: true,
+      };
+
+      const result = validatePasswordForRegister('PASSWORD', configWithLowercase);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Password must contain at least one lowercase letter');
+      expect(result.requirements.hasLowercase).toBe(false);
+
+      const validResult = validatePasswordForRegister('Password', configWithLowercase);
+      expect(validResult.requirements.hasLowercase).toBe(true);
+    });
+
+    it('should validate number requirement', () => {
+      const configWithNumber = {
+        ...config,
+        requireNumber: true,
+      };
+
+      const result = validatePasswordForRegister('Password', configWithNumber);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Password must contain at least one number');
+      expect(result.requirements.hasNumber).toBe(false);
+
+      const validResult = validatePasswordForRegister('Password1', configWithNumber);
+      expect(validResult.requirements.hasNumber).toBe(true);
+    });
+
+    it('should validate special character requirement', () => {
+      const configWithSpecial = {
+        ...config,
+        requireSpecialChar: true,
+      };
+
+      const result = validatePasswordForRegister('Password1', configWithSpecial);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Password must contain at least one special character');
+      expect(result.requirements.hasSpecialChar).toBe(false);
+
+      const validResult = validatePasswordForRegister('Password1!', configWithSpecial);
+      expect(validResult.requirements.hasSpecialChar).toBe(true);
+    });
+
+    it('should accept password that meets all requirements', () => {
+      const strictConfig = {
+        ...config,
+        requireUppercase: true,
+        requireLowercase: true,
+        requireNumber: true,
+        requireSpecialChar: true,
+      };
+
+      const result = validatePasswordForRegister('Password1!', strictConfig);
+      expect(result.isValid).toBe(true);
+      expect(result.requirements).toEqual({
+        hasMinLength: true,
+        hasUppercase: true,
+        hasLowercase: true,
+        hasNumber: true,
+        hasSpecialChar: true,
+      });
+    });
+
+    it('should skip requirements when disabled', () => {
+      const lenientConfig = {
+        ...config,
+        requireUppercase: false,
+        requireLowercase: false,
+        requireNumber: false,
+        requireSpecialChar: false,
+      };
+
+      const result = validatePasswordForRegister('password', lenientConfig);
+      expect(result.requirements).toEqual({
+        hasMinLength: true,
+        hasUppercase: true, // Should be true when requirement is disabled
+        hasLowercase: true, // Should be true when requirement is disabled
+        hasNumber: true, // Should be true when requirement is disabled
+        hasSpecialChar: true, // Should be true when requirement is disabled
+      });
+    });
+  });
+
+  describe('validatePasswordConfirmation', () => {
+    it('should reject empty confirmation', () => {
+      const result = validatePasswordConfirmation('password', '');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Please confirm your password');
+    });
+
+    it('should reject mismatched passwords', () => {
+      const result = validatePasswordConfirmation('password', 'different');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Passwords do not match');
+    });
+
+    it('should accept matching passwords', () => {
+      const result = validatePasswordConfirmation('password', 'password');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should handle empty passwords that match', () => {
+      const result = validatePasswordConfirmation('', '');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('validateDisplayName', () => {
+    it('should reject empty name', () => {
+      const result = validateDisplayName('');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name is required');
+    });
+
+    it('should reject whitespace-only name', () => {
+      const result = validateDisplayName('   ');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name is required');
+    });
+
+    it('should reject name that is too short', () => {
+      const result = validateDisplayName('A');
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name must be at least 2 characters');
+    });
+
+    it('should accept name that meets minimum length', () => {
+      const result = validateDisplayName('Al');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should use custom minimum length', () => {
+      const result = validateDisplayName('Al', 3);
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Name must be at least 3 characters');
+    });
+
+    it('should trim whitespace', () => {
+      const result = validateDisplayName('  John Doe  ');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should accept name with special characters', () => {
+      const result = validateDisplayName('John-O\'Connor');
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+});

package/src/infrastructure/adapters/StorageProviderAdapter.ts

@@ -0,0 +1,73 @@
+/**
+ * Storage Provider Adapter
+ * Adapts external storage implementations to our IStorageProvider interface
+ */
+
+import type { IStorageProvider } from "../services/GuestModeService";
+
+export class StorageProviderAdapter implements IStorageProvider {
+  private storage: any;
+
+  constructor(storage: any) {
+    this.storage = storage;
+  }
+
+  async get(key: string): Promise<string | null> {
+    try {
+      if (this.storage.getString) {
+        // @umituz/react-native-storage format
+        const result = await this.storage.getString(key, null);
+        return result?.value ?? null;
+      } else if (this.storage.getItem) {
+        // AsyncStorage format
+        return await this.storage.getItem(key);
+      } else {
+        throw new Error("Unsupported storage implementation");
+      }
+    } catch {
+      return null;
+    }
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    try {
+      if (this.storage.setString) {
+        // @umituz/react-native-storage format
+        await this.storage.setString(key, value);
+      } else if (this.storage.setItem) {
+        // AsyncStorage format
+        await this.storage.setItem(key, value);
+      } else {
+        throw new Error("Unsupported storage implementation");
+      }
+    } catch (error) {
+      if (__DEV__) {
+        console.warn("[StorageProviderAdapter] Failed to set value:", error);
+      }
+      throw error;
+    }
+  }
+
+  async remove(key: string): Promise<void> {
+    try {
+      if (this.storage.removeItem) {
+        // Both AsyncStorage and @umituz/react-native-storage support removeItem
+        await this.storage.removeItem(key);
+      } else {
+        throw new Error("Unsupported storage implementation");
+      }
+    } catch (error) {
+      if (__DEV__) {
+        console.warn("[StorageProviderAdapter] Failed to remove value:", error);
+      }
+      throw error;
+    }
+  }
+}
+
+/**
+ * Create storage provider from various storage implementations
+ */
+export function createStorageProvider(storage: any): IStorageProvider {
+  return new StorageProviderAdapter(storage);
+}

package/src/infrastructure/adapters/UIProviderAdapter.ts

@@ -0,0 +1,39 @@
+/**
+ * UI Provider Adapter
+ * Adapts external UI implementations to our IUIProvider interface
+ */
+
+import type { IUIProvider } from "../services/AuthPackage";
+
+export class UIProviderAdapter implements IUIProvider {
+  private theme: any;
+  private localization: any;
+
+  constructor(theme?: any, localization?: any) {
+    this.theme = theme;
+    this.localization = localization;
+  }
+
+  getTheme(): any {
+    return this.theme;
+  }
+
+  getLocalization(): any {
+    return this.localization;
+  }
+
+  updateTheme(theme: any): void {
+    this.theme = theme;
+  }
+
+  updateLocalization(localization: any): void {
+    this.localization = localization;
+  }
+}
+
+/**
+ * Create UI provider from theme and localization implementations
+ */
+export function createUIProvider(theme?: any, localization?: any): IUIProvider {
+  return new UIProviderAdapter(theme, localization);
+}

package/src/infrastructure/providers/FirebaseAuthProvider.ts

@@ -55,7 +55,11 @@ export class FirebaseAuthProvider implements IAuthProvider {
         credentials.email.trim(),
         credentials.password
       );
-      return mapToAuthUser(userCredential.user) as AuthUser;
+      const user = mapToAuthUser(userCredential.user);
+      if (!user) {
+        throw new Error("Failed to sign in");
+      }
+      return user;
     } catch (error: unknown) {
       throw mapFirebaseAuthError(error);
     }
@@ -83,7 +87,11 @@ export class FirebaseAuthProvider implements IAuthProvider {
         }
       }
 
-      return mapToAuthUser(userCredential.user) as AuthUser;
+      const user = mapToAuthUser(userCredential.user);
+      if (!user) {
+        throw new Error("Failed to create user account");
+      }
+      return user;
     } catch (error: unknown) {
       throw mapFirebaseAuthError(error);
     }