@umituz/react-native-firebase 2.6.1 → 2.6.2

package/src/application/auth/use-cases/SignOutUseCase_part_ab

@@ -0,0 +1,138 @@
+        error: {
+          code: 'auth/not-signed-in',
+          message: 'No user is currently signed in',
+        },
+      };
+    }
+
+    // Additional checks can be added here
+    // For example: check for unsaved changes, active operations, etc.
+
+    return { success: true };
+  }
+
+  /**
+   * Sign out with confirmation
+   * Shows confirmation dialog before signing out
+   */
+  async signOutWithConfirmation(): Promise<SignOutUseCaseResult> {
+    const confirmed = await this.confirmSignOut();
+
+    if (!confirmed) {
+      return {
+        success: false,
+        error: {
+          code: 'auth/sign-out-cancelled',
+          message: 'Sign out was cancelled',
+        },
+        wasSignedIn: this.isSignedIn(),
+      };
+    }
+
+    return this.execute();
+  }
+
+  /**
+   * Sign out and navigate
+   * Signs out and navigates to sign in screen
+   */
+  async signOutAndNavigate(): Promise<SignOutUseCaseResult> {
+    return this.execute({
+      clearLocalData: true,
+      navigateToSignIn: true,
+    });
+  }
+
+  /**
+   * Force sign out
+   * Signs out even if there are errors
+   */
+  async forceSignOut(): Promise<void> {
+    try {
+      await this.execute({
+        clearLocalData: true,
+      });
+    } catch (error) {
+      // Ignore errors during force sign out
+      if (__DEV__) {
+        console.error('[SignOutUseCase] Force sign out error:', error);
+      }
+    }
+
+    // Ensure local data is cleared
+    await this.clearLocalData();
+  }
+
+  /**
+   * Get sign out statistics
+   */
+  getSignOutStats(): {
+    readonly isSignedIn: boolean;
+    readonly isAnonymous: boolean;
+    readonly hasUserId: boolean;
+  } {
+    return {
+      isSignedIn: this.isSignedIn(),
+      isAnonymous: this.isAnonymous(),
+      hasUserId: this.getCurrentUserId() !== null,
+    };
+  }
+
+  /**
+   * Create sign out options
+   */
+  createOptions(options: Partial<SignOutOptions> = {}): SignOutOptions {
+    return {
+      clearLocalData: false,
+      navigateToSignIn: false,
+      showConfirmation: false,
+      ...options,
+    };
+  }
+
+  /**
+   * Quick sign out helper
+   */
+  async quickSignOut(): Promise<SignOutUseCaseResult> {
+    return this.execute();
+  }
+
+  /**
+   * Check if confirmation should be shown
+   */
+  shouldShowConfirmation(): boolean {
+    // Default: show confirmation for authenticated users
+    return this.isSignedIn() && !this.isAnonymous();
+  }
+
+  /**
+   * Get user-friendly sign out message
+   */
+  getSignOutMessage(): string {
+    if (!this.isSignedIn()) {
+      return 'You are not signed in';
+    }
+
+    if (this.isAnonymous()) {
+      return 'Sign out from guest session?';
+    }
+
+    return 'Are you sure you want to sign out?';
+  }
+}
+
+/**
+ * Factory function to create sign out use case
+ */
+export function createSignOutUseCase(authPort: IAuthPort): SignOutUseCase {
+  return new SignOutUseCase(authPort);
+}
+
+/**
+ * Factory function to create sign out use case with default auth port
+ */
+export async function createDefaultSignOutUseCase(): Promise<SignOutUseCase> {
+  const { createAuthPort } = await import('../ports/AuthPort');
+  const authPort = createAuthPort();
+  return createSignOutUseCase(authPort);
+}

package/src/domains/account-deletion/domain/services/UserValidationHelpers.ts.bak

@@ -0,0 +1,181 @@
+/**
+ * User Validation Helpers
+ * Single Responsibility: Provide helper methods for user validation
+ *
+ * Helper methods separated from main UserValidationService.
+ * Provides utility functions for user state checking.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { User } from 'firebase/auth';
+import type { UserValidationService } from './UserValidationService';
+
+/**
+ * Check if user email matches pattern
+ */
+export function isValidEmailFormat(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+/**
+ * Get password strength indicator
+ */
+export function getPasswordStrength(password: string): 'weak' | 'medium' | 'strong' {
+  if (password.length < 6) {
+    return 'weak';
+  }
+
+  if (password.length < 8) {
+    return 'medium';
+  }
+
+  // Check for variety
+  const hasLower = /[a-z]/.test(password);
+  const hasUpper = /[A-Z]/.test(password);
+  const hasNumber = /[0-9]/.test(password);
+  const hasSpecial = /[^a-zA-Z0-9]/.test(password);
+
+  const varietyScore = [hasLower, hasUpper, hasNumber, hasSpecial].filter(Boolean).length;
+
+  if (varietyScore >= 3) {
+    return 'strong';
+  }
+
+  return 'medium';
+}
+
+/**
+ * Check if account is locked
+ */
+export function isAccountLocked(errorCode?: string): boolean {
+  return errorCode === 'auth/too-many-requests' || errorCode === 'auth/user-disabled';
+}
+
+/**
+ * Get user-friendly error message
+ */
+export function getAuthErrorMessage(errorCode: string): string {
+  const errorMessages: Record<string, string> = {
+    'auth/invalid-credentials': 'Invalid email or password',
+    'auth/user-not-found': 'No account found with this email',
+    'auth/wrong-password': 'Incorrect password',
+    'auth/unverified-email': 'Please verify your email first',
+    'auth/user-disabled': 'This account has been disabled',
+    'auth/too-many-requests': 'Too many attempts. Please try again later',
+    'auth/invalid-email': 'Invalid email address',
+  };
+
+  return errorMessages[errorCode] || 'Authentication failed. Please try again.';
+}
+
+/**
+ * Check if user session is valid
+ */
+export function isSessionValid(user: User, maxAgeMs: number = 30 * 60 * 1000): boolean {
+  if (!user.metadata.lastSignInTime) {
+    return false;
+  }
+
+  const lastSignIn = new Date(user.metadata.lastSignInTime).getTime();
+  const timeSinceSignIn = Date.now() - lastSignIn;
+
+  return timeSinceSignIn <= maxAgeMs;
+}
+
+/**
+ * Check if user needs to refresh session
+ */
+export function needsSessionRefresh(user: User, maxAgeMs: number = 30 * 60 * 1000): boolean {
+  return !isSessionValid(user, maxAgeMs);
+}
+
+/**
+ * Get user display name
+ */
+export function getUserDisplayName(user: User): string {
+  if (user.displayName) {
+    return user.displayName;
+  }
+
+  if (user.email) {
+    return user.email.split('@')[0];
+  }
+
+  return 'User';
+}
+
+/**
+ * Get user initials for avatar
+ */
+export function getUserInitials(user: User): string {
+  if (user.displayName) {
+    const names = user.displayName.split(' ');
+    if (names.length >= 2) {
+      return (names[0][0] + names[names.length - 1][0]).toUpperCase();
+    }
+    return names[0][0].toUpperCase();
+  }
+
+  if (user.email) {
+    return user.email[0].toUpperCase();
+  }
+
+  return 'U';
+}
+
+/**
+ * Check if user profile is complete
+ */
+export function isProfileComplete(user: User): boolean {
+  return !!(
+    user.email &&
+    user.displayName &&
+    user.emailVerified &&
+    user.metadata.lastSignInTime
+  );
+}
+
+/**
+ * Get profile completion percentage
+ */
+export function getProfileCompletionPercentage(user: User): number {
+  let completion = 0;
+
+  if (user.email) completion += 25;
+  if (user.displayName) completion += 25;
+  if (user.emailVerified) completion += 25;
+  if (user.metadata.lastSignInTime) completion += 25;
+
+  return completion;
+}
+
+/**
+ * Check if user can perform sensitive operation
+ */
+export function canPerformSensitiveOperation(user: User, maxSessionAgeMs: number = 5 * 60 * 1000): boolean {
+  return isSessionValid(user, maxSessionAgeMs);
+}
+
+/**
+ * Get user account age in days
+ */
+export function getAccountAgeDays(user: User): number | null {
+  if (!user.metadata.creationTime) {
+    return null;
+  }
+
+  const creationTime = new Date(user.metadata.creationTime).getTime();
+  const ageMs = Date.now() - creationTime;
+
+  return Math.floor(ageMs / (24 * 60 * 60 * 1000));
+}
+
+/**
+ * Check if account is old enough for operation
+ */
+export function isAccountOldEnough(user: User, minDays: number = 1): boolean {
+  const ageDays = getAccountAgeDays(user);
+  return ageDays !== null && ageDays >= minDays;
+}

package/src/domains/account-deletion/domain/services/UserValidationHelpers_part_aa

@@ -0,0 +1,150 @@
+/**
+ * User Validation Helpers
+ * Single Responsibility: Provide helper methods for user validation
+ *
+ * Helper methods separated from main UserValidationService.
+ * Provides utility functions for user state checking.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { User } from 'firebase/auth';
+import type { UserValidationService } from './UserValidationService';
+
+/**
+ * Check if user email matches pattern
+ */
+export function isValidEmailFormat(email: string): boolean {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+/**
+ * Get password strength indicator
+ */
+export function getPasswordStrength(password: string): 'weak' | 'medium' | 'strong' {
+  if (password.length < 6) {
+    return 'weak';
+  }
+
+  if (password.length < 8) {
+    return 'medium';
+  }
+
+  // Check for variety
+  const hasLower = /[a-z]/.test(password);
+  const hasUpper = /[A-Z]/.test(password);
+  const hasNumber = /[0-9]/.test(password);
+  const hasSpecial = /[^a-zA-Z0-9]/.test(password);
+
+  const varietyScore = [hasLower, hasUpper, hasNumber, hasSpecial].filter(Boolean).length;
+
+  if (varietyScore >= 3) {
+    return 'strong';
+  }
+
+  return 'medium';
+}
+
+/**
+ * Check if account is locked
+ */
+export function isAccountLocked(errorCode?: string): boolean {
+  return errorCode === 'auth/too-many-requests' || errorCode === 'auth/user-disabled';
+}
+
+/**
+ * Get user-friendly error message
+ */
+export function getAuthErrorMessage(errorCode: string): string {
+  const errorMessages: Record<string, string> = {
+    'auth/invalid-credentials': 'Invalid email or password',
+    'auth/user-not-found': 'No account found with this email',
+    'auth/wrong-password': 'Incorrect password',
+    'auth/unverified-email': 'Please verify your email first',
+    'auth/user-disabled': 'This account has been disabled',
+    'auth/too-many-requests': 'Too many attempts. Please try again later',
+    'auth/invalid-email': 'Invalid email address',
+  };
+
+  return errorMessages[errorCode] || 'Authentication failed. Please try again.';
+}
+
+/**
+ * Check if user session is valid
+ */
+export function isSessionValid(user: User, maxAgeMs: number = 30 * 60 * 1000): boolean {
+  if (!user.metadata.lastSignInTime) {
+    return false;
+  }
+
+  const lastSignIn = new Date(user.metadata.lastSignInTime).getTime();
+  const timeSinceSignIn = Date.now() - lastSignIn;
+
+  return timeSinceSignIn <= maxAgeMs;
+}
+
+/**
+ * Check if user needs to refresh session
+ */
+export function needsSessionRefresh(user: User, maxAgeMs: number = 30 * 60 * 1000): boolean {
+  return !isSessionValid(user, maxAgeMs);
+}
+
+/**
+ * Get user display name
+ */
+export function getUserDisplayName(user: User): string {
+  if (user.displayName) {
+    return user.displayName;
+  }
+
+  if (user.email) {
+    return user.email.split('@')[0];
+  }
+
+  return 'User';
+}
+
+/**
+ * Get user initials for avatar
+ */
+export function getUserInitials(user: User): string {
+  if (user.displayName) {
+    const names = user.displayName.split(' ');
+    if (names.length >= 2) {
+      return (names[0][0] + names[names.length - 1][0]).toUpperCase();
+    }
+    return names[0][0].toUpperCase();
+  }
+
+  if (user.email) {
+    return user.email[0].toUpperCase();
+  }
+
+  return 'U';
+}
+
+/**
+ * Check if user profile is complete
+ */
+export function isProfileComplete(user: User): boolean {
+  return !!(
+    user.email &&
+    user.displayName &&
+    user.emailVerified &&
+    user.metadata.lastSignInTime
+  );
+}
+
+/**
+ * Get profile completion percentage
+ */
+export function getProfileCompletionPercentage(user: User): number {
+  let completion = 0;
+
+  if (user.email) completion += 25;
+  if (user.displayName) completion += 25;
+  if (user.emailVerified) completion += 25;
+  if (user.metadata.lastSignInTime) completion += 25;
+

package/src/domains/account-deletion/domain/services/UserValidationHelpers_part_ab

@@ -0,0 +1,31 @@
+  return completion;
+}
+
+/**
+ * Check if user can perform sensitive operation
+ */
+export function canPerformSensitiveOperation(user: User, maxSessionAgeMs: number = 5 * 60 * 1000): boolean {
+  return isSessionValid(user, maxSessionAgeMs);
+}
+
+/**
+ * Get user account age in days
+ */
+export function getAccountAgeDays(user: User): number | null {
+  if (!user.metadata.creationTime) {
+    return null;
+  }
+
+  const creationTime = new Date(user.metadata.creationTime).getTime();
+  const ageMs = Date.now() - creationTime;
+
+  return Math.floor(ageMs / (24 * 60 * 60 * 1000));
+}
+
+/**
+ * Check if account is old enough for operation
+ */
+export function isAccountOldEnough(user: User, minDays: number = 1): boolean {
+  const ageDays = getAccountAgeDays(user);
+  return ageDays !== null && ageDays >= minDays;
+}

package/src/domains/account-deletion/domain/services/{UserValidationService.ts → UserValidationService.ts.bak}

@@ -1,5 +1,5 @@
 /**
- * User Validation Service
+ * User Validation Service (Main)
  * Single Responsibility: Validate user state for account operations
  *
  * Domain service that encapsulates user validation logic.
@@ -12,15 +12,6 @@ import type { Auth, User } from 'firebase/auth';
 import type { Result } from '../../../../shared/domain/utils';
 import { successResult, failureResultFrom } from '../../../../shared/domain/utils';
 
-/**
- * User validation result
- */
-export interface UserValidationResult {
-  readonly valid: boolean;
-  readonly error?: { code: string; message: string };
-  readonly userId?: string;
-}
-
 /**
  * User validation service
  * Provides user validation functionality for account operations

package/src/domains/account-deletion/domain/services/UserValidationService_part_aa

@@ -0,0 +1,150 @@
+/**
+ * User Validation Service (Main)
+ * Single Responsibility: Validate user state for account operations
+ *
+ * Domain service that encapsulates user validation logic.
+ * Moves business logic from infrastructure to domain layer.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { Auth, User } from 'firebase/auth';
+import type { Result } from '../../../../shared/domain/utils';
+import { successResult, failureResultFrom } from '../../../../shared/domain/utils';
+
+/**
+ * User validation service
+ * Provides user validation functionality for account operations
+ */
+export class UserValidationService {
+  /**
+   * Validate user is ready for deletion
+   * Checks user exists, not anonymous, and has required provider
+   */
+  validateForDeletion(user: User | null): Result<{ userId: string; provider: string }> {
+    if (!user) {
+      return failureResultFrom('auth/not-ready', 'No authenticated user');
+    }
+
+    if (user.isAnonymous) {
+      return failureResultFrom('auth/anonymous', 'Cannot delete anonymous account');
+    }
+
+    const provider = this.getUserAuthProvider(user);
+    if (!provider) {
+      return failureResultFrom('auth/unsupported', 'Unsupported auth provider');
+    }
+
+    return successResult({
+      userId: user.uid,
+      provider,
+    });
+  }
+
+  /**
+   * Validate user hasn't changed during operation
+   * Critical for preventing race conditions
+   */
+  validateUserUnchanged(auth: Auth | null, originalUserId: string): Result<void> {
+    if (!auth) {
+      return failureResultFrom('auth/not-ready', 'Auth not initialized');
+    }
+
+    const currentUserId = auth.currentUser?.uid;
+
+    if (!currentUserId) {
+      return failureResultFrom('auth/user-signed-out', 'User signed out during operation');
+    }
+
+    if (currentUserId !== originalUserId) {
+      return failureResultFrom('auth/user-changed', 'User changed during operation');
+    }
+
+    return successResult();
+  }
+
+  /**
+   * Validate user credentials are present
+   */
+  validateCredentials(
+    user: User,
+    options: {
+      password?: string;
+      googleIdToken?: string;
+    }
+  ): Result<void> {
+    const provider = this.getUserAuthProvider(user);
+
+    if (provider === 'password' && !options.password) {
+      return failureResultFrom('auth/password-required', 'Password required for reauthentication');
+    }
+
+    if (provider === 'google.com' && !options.googleIdToken) {
+      return failureResultFrom('auth/google-token-required', 'Google ID token required for reauthentication');
+    }
+
+    return successResult();
+  }
+
+  /**
+   * Get user's auth provider
+   * Returns provider ID or null if unknown
+   */
+  getUserAuthProvider(user: User): string | null {
+    if (!user.providerData || user.providerData.length === 0) {
+      return null;
+    }
+
+    // Check all providers
+    for (const userInfo of user.providerData) {
+      if (userInfo.providerId) {
+        return userInfo.providerId;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if user has specific provider
+   */
+  hasProvider(user: User, providerId: string): boolean {
+    if (!user.providerData || user.providerData.length === 0) {
+      return false;
+    }
+
+    return user.providerData.some(
+      userInfo => userInfo.providerId === providerId
+    );
+  }
+
+  /**
+   * Check if user is email/password user
+   */
+  isEmailPasswordUser(user: User): boolean {
+    return this.hasProvider(user, 'password');
+  }
+
+  /**
+   * Check if user is Google user
+   */
+  isGoogleUser(user: User): boolean {
+    return this.hasProvider(user, 'google.com');
+  }
+
+  /**
+   * Check if user is Apple user
+   */
+  isAppleUser(user: User): boolean {
+    return this.hasProvider(user, 'apple.com');
+  }
+
+  /**
+   * Check if user requires reauthentication
+   * Based on provider and operation type
+   */
+  requiresReauthentication(user: User, operation: 'delete' | 'update'): boolean {
+    // Email/password users always need recent auth
+    if (this.isEmailPasswordUser(user)) {
+      return true;
+    }