@umituz/react-native-auth 3.4.22 → 3.4.23

package/src/infrastructure/utils/AuthValidation.ts

@@ -1,38 +1,17 @@
-/**
- * Auth Validation Utilities
- * Single Responsibility: Email and password validation for authentication
- */
-
 import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
 import { getAuthPackage } from "../services/AuthPackage";
 
-export interface ValidationResult {
-  isValid: boolean;
-  error?: string; // This should be a localization key
-}
-
-export interface PasswordStrengthResult extends ValidationResult {
-  requirements: PasswordRequirements;
-}
-
+export interface ValidationResult { isValid: boolean; error?: string; }
+export interface PasswordStrengthResult extends ValidationResult { requirements: PasswordRequirements; }
 export interface PasswordRequirements {
-  hasMinLength: boolean;
-  hasUppercase: boolean;
-  hasLowercase: boolean;
-  hasNumber: boolean;
-  hasSpecialChar: boolean;
+  hasMinLength: boolean; hasUppercase: boolean; hasLowercase: boolean; hasNumber: boolean; hasSpecialChar: boolean;
 }
-
 export interface ValidationConfig {
-  emailRegex: RegExp;
-  uppercaseRegex: RegExp;
-  lowercaseRegex: RegExp;
-  numberRegex: RegExp;
-  specialCharRegex: RegExp;
-  displayNameMinLength: number;
+  emailRegex: RegExp; uppercaseRegex: RegExp; lowercaseRegex: RegExp;
+  numberRegex: RegExp; specialCharRegex: RegExp; displayNameMinLength: number;
 }
 
-const DEFAULT_VALIDATION_CONFIG: ValidationConfig = {
+const DEFAULT_VAL_CONFIG: ValidationConfig = {
   emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
   uppercaseRegex: /[A-Z]/,
   lowercaseRegex: /[a-z]/,
@@ -41,155 +20,57 @@ const DEFAULT_VALIDATION_CONFIG: ValidationConfig = {
   displayNameMinLength: 2,
 };
 
-function getValidationConfig(): ValidationConfig {
-  const packageConfig = getAuthPackage()?.getConfig();
+function getValConfig(): ValidationConfig {
+  const p = getAuthPackage()?.getConfig();
   return {
-    emailRegex: packageConfig?.validation.emailRegex || DEFAULT_VALIDATION_CONFIG.emailRegex,
-    uppercaseRegex: DEFAULT_VALIDATION_CONFIG.uppercaseRegex,
-    lowercaseRegex: DEFAULT_VALIDATION_CONFIG.lowercaseRegex,
-    numberRegex: DEFAULT_VALIDATION_CONFIG.numberRegex,
-    specialCharRegex: DEFAULT_VALIDATION_CONFIG.specialCharRegex,
-    displayNameMinLength: DEFAULT_VALIDATION_CONFIG.displayNameMinLength,
+    emailRegex: p?.validation.emailRegex || DEFAULT_VAL_CONFIG.emailRegex,
+    uppercaseRegex: DEFAULT_VAL_CONFIG.uppercaseRegex,
+    lowercaseRegex: DEFAULT_VAL_CONFIG.lowercaseRegex,
+    numberRegex: DEFAULT_VAL_CONFIG.numberRegex,
+    specialCharRegex: DEFAULT_VAL_CONFIG.specialCharRegex,
+    displayNameMinLength: DEFAULT_VAL_CONFIG.displayNameMinLength,
   };
 }
 
-/**
- * Validate email format
- */
 export function validateEmail(email: string): ValidationResult {
-  if (!email || email.trim() === "") {
-    return { isValid: false, error: "auth.validation.emailRequired" };
-  }
-
-  const config = getValidationConfig();
-  if (!config.emailRegex.test(email.trim())) {
-    return { isValid: false, error: "auth.validation.invalidEmail" };
-  }
-
+  if (!email || email.trim() === "") return { isValid: false, error: "auth.validation.emailRequired" };
+  if (!getValConfig().emailRegex.test(email.trim())) return { isValid: false, error: "auth.validation.invalidEmail" };
   return { isValid: true };
 }
 
-/**
- * Validate password for login - only checks if password is provided
- * No strength requirements for login (existing users may have old passwords)
- */
 export function validatePasswordForLogin(password: string): ValidationResult {
-  if (!password || password.length === 0) {
-    return { isValid: false, error: "auth.validation.passwordRequired" };
-  }
-
+  if (!password || password.length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
   return { isValid: true };
 }
 
-/**
- * Validate password strength for registration
- * Returns detailed requirements for UI feedback
- */
-export function validatePasswordForRegister(
-  password: string,
-  config: PasswordConfig
-): PasswordStrengthResult {
-  const validationConfig = getValidationConfig();
-  const requirements: PasswordRequirements = {
+export function validatePasswordForRegister(password: string, config: PasswordConfig): PasswordStrengthResult {
+  const v = getValConfig();
+  const req: PasswordRequirements = {
     hasMinLength: password.length >= config.minLength,
-    hasUppercase: !config.requireUppercase || validationConfig.uppercaseRegex.test(password),
-    hasLowercase: !config.requireLowercase || validationConfig.lowercaseRegex.test(password),
-    hasNumber: !config.requireNumber || validationConfig.numberRegex.test(password),
-    hasSpecialChar:
-      !config.requireSpecialChar || validationConfig.specialCharRegex.test(password),
+    hasUppercase: !config.requireUppercase || v.uppercaseRegex.test(password),
+    hasLowercase: !config.requireLowercase || v.lowercaseRegex.test(password),
+    hasNumber: !config.requireNumber || v.numberRegex.test(password),
+    hasSpecialChar: !config.requireSpecialChar || v.specialCharRegex.test(password),
   };
 
-  if (!password || password.length === 0) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequired",
-      requirements,
-    };
-  }
-
-  if (!requirements.hasMinLength) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordTooShort",
-      requirements,
-    };
-  }
-
-  if (config.requireUppercase && !validationConfig.uppercaseRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireUppercase",
-      requirements,
-    };
-  }
+  if (!password) return { isValid: false, error: "auth.validation.passwordRequired", requirements: req };
+  if (!req.hasMinLength) return { isValid: false, error: "auth.validation.passwordTooShort", requirements: req };
+  if (config.requireUppercase && !req.hasUppercase) return { isValid: false, error: "auth.validation.passwordRequireUppercase", requirements: req };
+  if (config.requireLowercase && !req.hasLowercase) return { isValid: false, error: "auth.validation.passwordRequireLowercase", requirements: req };
+  if (config.requireNumber && !req.hasNumber) return { isValid: false, error: "auth.validation.passwordRequireNumber", requirements: req };
+  if (config.requireSpecialChar && !req.hasSpecialChar) return { isValid: false, error: "auth.validation.passwordRequireSpecialChar", requirements: req };
 
-  if (config.requireLowercase && !validationConfig.lowercaseRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireLowercase",
-      requirements,
-    };
-  }
-
-  if (config.requireNumber && !validationConfig.numberRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireNumber",
-      requirements,
-    };
-  }
-
-  if (config.requireSpecialChar && !validationConfig.specialCharRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireSpecialChar",
-      requirements,
-    };
-  }
-
-  return { isValid: true, requirements };
+  return { isValid: true, requirements: req };
 }
 
-/**
- * Validate password confirmation
- */
-export function validatePasswordConfirmation(
-  password: string,
-  confirmPassword: string
-): ValidationResult {
-  if (!confirmPassword) {
-    return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
-  }
-
-  if (password !== confirmPassword) {
-    return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
-  }
-
+export function validatePasswordConfirmation(password: string, confirm: string): ValidationResult {
+  if (!confirm) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
+  if (password !== confirm) return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
   return { isValid: true };
 }
 
-/**
- * Validate display name
- */
-export function validateDisplayName(
-  displayName: string,
-  minLength?: number
-): ValidationResult {
-  if (!displayName || displayName.trim() === "") {
-    return { isValid: false, error: "auth.validation.nameRequired" };
-  }
-
-  const config = getValidationConfig();
-  const actualMinLength = minLength ?? config.displayNameMinLength;
-
-  if (displayName.trim().length < actualMinLength) {
-    return {
-      isValid: false,
-      error: "auth.validation.nameTooShort",
-    };
-  }
-
+export function validateDisplayName(name: string, minLength?: number): ValidationResult {
+  if (!name || name.trim() === "") return { isValid: false, error: "auth.validation.nameRequired" };
+  if (name.trim().length < (minLength ?? getValConfig().displayNameMinLength)) return { isValid: false, error: "auth.validation.nameTooShort" };
   return { isValid: true };
 }
-
-

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

@@ -1,247 +0,0 @@
-/**
- * AuthCoreService Tests
- */
-
-import { AuthCoreService } from '../../../src/infrastructure/services/AuthCoreService';
-import { DEFAULT_AUTH_CONFIG } from '../../../src/domain/value-objects/AuthConfig';
-import type { IAuthProvider } from '../../../src/application/ports/IAuthProvider';
-import type { AuthUser } from '../../../src/domain/entities/AuthUser';
-
-describe('AuthCoreService', () => {
-  let authCoreService: AuthCoreService;
-  let mockProvider: jest.Mocked<IAuthProvider>;
-
-  beforeEach(() => {
-    mockProvider = {
-      initialize: jest.fn(),
-      isInitialized: jest.fn().mockReturnValue(true),
-      signIn: jest.fn(),
-      signUp: jest.fn(),
-      signOut: jest.fn(),
-      getCurrentUser: jest.fn(),
-      onAuthStateChange: jest.fn().mockReturnValue(jest.fn()),
-    };
-
-    authCoreService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
-  });
-
-  describe('constructor', () => {
-    it('should initialize with provided config', () => {
-      const customConfig = {
-        ...DEFAULT_AUTH_CONFIG,
-        password: {
-          ...DEFAULT_AUTH_CONFIG.password,
-          minLength: 12,
-        },
-      };
-
-      const service = new AuthCoreService(customConfig);
-      expect(service.getConfig()).toEqual(customConfig);
-    });
-  });
-
-  describe('initialize', () => {
-    it('should initialize with IAuthProvider', async () => {
-      await authCoreService.initialize(mockProvider);
-      expect(mockProvider.initialize).toHaveBeenCalled();
-    });
-
-    it('should initialize with Firebase Auth instance', async () => {
-      const mockFirebaseAuth = {
-        currentUser: null,
-      } as any;
-
-      await expect(authCoreService.initialize(mockFirebaseAuth)).rejects.toThrow();
-    });
-
-    it('should throw error when no provider provided', async () => {
-      await expect(authCoreService.initialize(null as any)).rejects.toThrow(
-        'Auth provider or Firebase Auth instance is required'
-      );
-    });
-  });
-
-  describe('isInitialized', () => {
-    it('should return false when not initialized', () => {
-      expect(authCoreService.isInitialized()).toBe(false);
-    });
-
-    it('should return true when initialized', async () => {
-      await authCoreService.initialize(mockProvider);
-      expect(authCoreService.isInitialized()).toBe(true);
-    });
-  });
-
-  describe('signUp', () => {
-    const mockUser: AuthUser = {
-      uid: 'test-uid',
-      email: 'test@example.com',
-      displayName: 'Test User',
-      isAnonymous: false,
-      emailVerified: false,
-      photoURL: null,
-    };
-
-    beforeEach(async () => {
-      await authCoreService.initialize(mockProvider);
-    });
-
-    it('should sign up successfully with valid credentials', async () => {
-      mockProvider.signUp.mockResolvedValue(mockUser);
-
-      const result = await authCoreService.signUp({
-        email: 'test@example.com',
-        password: 'password123',
-        displayName: 'Test User',
-      });
-
-      expect(result).toEqual(mockUser);
-      expect(mockProvider.signUp).toHaveBeenCalledWith({
-        email: 'test@example.com',
-        password: 'password123',
-        displayName: 'Test User',
-      });
-    });
-
-    it('should sign up without display name', async () => {
-      mockProvider.signUp.mockResolvedValue(mockUser);
-
-      await authCoreService.signUp({
-        email: 'test@example.com',
-        password: 'password123',
-      });
-
-      expect(mockProvider.signUp).toHaveBeenCalledWith({
-        email: 'test@example.com',
-        password: 'password123',
-        displayName: undefined,
-      });
-    });
-
-    it('should throw error when not initialized', async () => {
-      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
-      
-      await expect(uninitializedService.signUp({
-        email: 'test@example.com',
-        password: 'password123',
-      })).rejects.toThrow('Auth service is not initialized');
-    });
-  });
-
-  describe('signIn', () => {
-    const mockUser: AuthUser = {
-      uid: 'test-uid',
-      email: 'test@example.com',
-      displayName: 'Test User',
-      isAnonymous: false,
-      emailVerified: false,
-      photoURL: null,
-    };
-
-    beforeEach(async () => {
-      await authCoreService.initialize(mockProvider);
-    });
-
-    it('should sign in successfully with valid credentials', async () => {
-      mockProvider.signIn.mockResolvedValue(mockUser);
-
-      const result = await authCoreService.signIn({
-        email: 'test@example.com',
-        password: 'password123',
-      });
-
-      expect(result).toEqual(mockUser);
-      expect(mockProvider.signIn).toHaveBeenCalledWith({
-        email: 'test@example.com',
-        password: 'password123',
-      });
-    });
-
-    it('should throw error when not initialized', async () => {
-      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
-      
-      await expect(uninitializedService.signIn({
-        email: 'test@example.com',
-        password: 'password123',
-      })).rejects.toThrow('Auth service is not initialized');
-    });
-  });
-
-  describe('signOut', () => {
-    beforeEach(async () => {
-      await authCoreService.initialize(mockProvider);
-    });
-
-    it('should sign out successfully', async () => {
-      await authCoreService.signOut();
-      expect(mockProvider.signOut).toHaveBeenCalled();
-    });
-
-    it('should handle sign out when not initialized', async () => {
-      const uninitializedService = new AuthCoreService(DEFAULT_AUTH_CONFIG);
-      
-      await expect(uninitializedService.signOut()).resolves.not.toThrow();
-    });
-  });
-
-  describe('getCurrentUser', () => {
-    const mockUser: AuthUser = {
-      uid: 'test-uid',
-      email: 'test@example.com',
-      displayName: 'Test User',
-      isAnonymous: false,
-      emailVerified: false,
-      photoURL: null,
-    };
-
-    it('should return null when not initialized', () => {
-      const result = authCoreService.getCurrentUser();
-      expect(result).toBeNull();
-    });
-
-    it('should return current user when initialized', async () => {
-      mockProvider.getCurrentUser.mockReturnValue(mockUser);
-      await authCoreService.initialize(mockProvider);
-
-      const result = authCoreService.getCurrentUser();
-      expect(result).toEqual(mockUser);
-    });
-
-    it('should return null when no current user', async () => {
-      mockProvider.getCurrentUser.mockReturnValue(null);
-      await authCoreService.initialize(mockProvider);
-
-      const result = authCoreService.getCurrentUser();
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('onAuthStateChange', () => {
-    it('should return cleanup function when not initialized', () => {
-      const callback = jest.fn();
-      const cleanup = authCoreService.onAuthStateChange(callback);
-      
-      expect(callback).toHaveBeenCalledWith(null);
-      expect(typeof cleanup).toBe('function');
-    });
-
-    it('should subscribe to auth state changes when initialized', async () => {
-      const callback = jest.fn();
-      const mockCleanup = jest.fn();
-      mockProvider.onAuthStateChange.mockReturnValue(mockCleanup);
-      
-      await authCoreService.initialize(mockProvider);
-      const cleanup = authCoreService.onAuthStateChange(callback);
-
-      expect(mockProvider.onAuthStateChange).toHaveBeenCalledWith(callback);
-      expect(cleanup).toBe(mockCleanup);
-    });
-  });
-
-  describe('getConfig', () => {
-    it('should return the current config', () => {
-      const config = authCoreService.getConfig();
-      expect(config).toEqual(DEFAULT_AUTH_CONFIG);
-    });
-  });
-});