@umituz/react-native-firebase 2.6.1 → 2.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.6.1",
+  "version": "2.6.2",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/application/auth/ports/AuthPort_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Auth Port
+ * Single Responsibility: Define authentication contract
+ *
+ * Port interface for authentication operations.
+ * Defines the contract that infrastructure must implement.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { User, Auth } from 'firebase/auth';
+import type { Result } from '../../../shared/domain/utils';
+
+/**
+ * Email credentials
+ */
+export interface EmailCredentials {
+  readonly email: string;
+  readonly password: string;
+}
+
+/**
+ * Sign in result
+ */
+export interface SignInResult {
+  readonly user: User;
+  readonly isNewUser: boolean;
+}
+
+/**
+ * Sign up result
+ */
+export interface SignUpResult {
+  readonly user: User;
+  readonly userId: string;
+}
+
+/**
+ * Auth port interface
+ * Defines contract for authentication operations
+ */
+export interface IAuthPort {
+  /**
+   * Sign in with email and password
+   */
+  signInWithEmail(credentials: EmailCredentials): Promise<Result<SignInResult>>;
+
+  /**
+   * Sign up with email and password
+   */
+  signUpWithEmail(credentials: EmailCredentials): Promise<Result<SignUpResult>>;
+
+  /**
+   * Sign out current user
+   */
+  signOut(): Promise<Result<void>>;
+
+  /**
+   * Get current authenticated user
+   */
+  getCurrentUser(): User | null;
+
+  /**
+   * Get current user ID
+   */
+  getCurrentUserId(): string | null;
+
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated(): boolean;
+
+  /**
+   * Check if user is anonymous
+   */
+  isAnonymous(): boolean;
+
+  /**
+   * Delete user account
+   */
+  deleteAccount(): Promise<Result<void>>;
+
+  /**
+   * Update user password
+   */
+  updatePassword(newPassword: string): Promise<Result<void>>;
+
+  /**
+   * Send password reset email
+   */
+  sendPasswordResetEmail(email: string): Promise<Result<void>>;
+
+  /**
+   * Get auth instance
+   */
+  getAuth(): Auth | null;
+}
+
+/**
+ * Auth port options
+ */
+export interface AuthPortOptions {
+  /** Auto-initialize auth on first access */
+  autoInitialize?: boolean;
+  /** Enable detailed logging */
+  enableLogging?: boolean;
+}
+
+/**
+ * Auth port configuration
+ */
+export interface AuthPortConfig {
+  readonly port: IAuthPort;
+  readonly options: AuthPortOptions;
+}
+
+/**
+ * Create auth port configuration
+ */
+export function createAuthPortConfig(
+  port: IAuthPort,
+  options: AuthPortOptions = {}
+): AuthPortConfig {
+  return {
+    port,
+    options: {
+      autoInitialize: true,
+      enableLogging: __DEV__,
+      ...options,
+    },
+  };
+}
+
+/**
+ * Auth port factory
+ * Creates auth port instances
+ */
+export interface IAuthPortFactory {
+  createPort(options?: AuthPortOptions): IAuthPort;
+}
+
+/**
+ * Default auth port factory
+ * Implements factory pattern for auth ports
+ */
+export class AuthPortFactory implements IAuthPortFactory {
+  createPort(options?: AuthPortOptions): IAuthPort {
+    // Import and create actual implementation
+    const { FirebaseAuthPort } = require('../implementations/FirebaseAuthPort');
+    return new FirebaseAuthPort(options);

package/src/application/auth/ports/AuthPort_part_ab

@@ -0,0 +1,14 @@
+  }
+}
+
+/**
+ * Default auth port factory instance
+ */
+export const authPortFactory = new AuthPortFactory();
+
+/**
+ * Create auth port with default factory
+ */
+export function createAuthPort(options?: AuthPortOptions): IAuthPort {
+  return authPortFactory.createPort(options);
+}

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

@@ -0,0 +1,150 @@
+/**
+ * Sign In Use Case
+ * Single Responsibility: Handle user sign in operations
+ *
+ * Application use case for user authentication.
+ * Coordinates domain services and infrastructure.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { User } from 'firebase/auth';
+import type { Result } from '../../../shared/domain/utils';
+import type { IAuthPort, EmailCredentials, SignInResult } from '../ports/AuthPort';
+
+/**
+ * Sign in use case result
+ */
+export interface SignInUseCaseResult extends Result<SignInResult> {
+  readonly requiresVerification?: boolean;
+}
+
+/**
+ * Sign in use case options
+ */
+export interface SignInOptions {
+  /** Email credentials */
+  readonly email: string;
+  /** Password */
+  readonly password: string;
+  /** Remember user */
+  readonly rememberMe?: boolean;
+}
+
+/**
+ * Sign in use case
+ * Handles user sign in with validation and error handling
+ */
+export class SignInUseCase {
+  private readonly authPort: IAuthPort;
+
+  constructor(authPort: IAuthPort) {
+    this.authPort = authPort;
+  }
+
+  /**
+   * Execute sign in use case
+   * Validates credentials and signs in user
+   */
+  async execute(options: SignInOptions): Promise<SignInUseCaseResult> {
+    // Validate credentials
+    const validation = this.validateCredentials(options);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: {
+          code: 'auth/invalid-credentials',
+          message: validation.error,
+        },
+      };
+    }
+
+    // Create credentials object
+    const credentials: EmailCredentials = {
+      email: options.email,
+      password: options.password,
+    };
+
+    // Sign in with credentials
+    const result = await this.authPort.signInWithEmail(credentials);
+
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        requiresVerification: this.requiresVerification(result.error?.code),
+      };
+    }
+
+    return {
+      success: true,
+      data: result.data,
+    };
+  }
+
+  /**
+   * Validate email and password
+   */
+  private validateCredentials(options: SignInOptions): { valid: boolean; error?: string } {
+    const { email, password } = options;
+
+    // Validate email
+    if (!email || typeof email !== 'string' || email.trim() === '') {
+      return { valid: false, error: 'Email is required' };
+    }
+
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(email)) {
+      return { valid: false, error: 'Invalid email format' };
+    }
+
+    // Validate password
+    if (!password || typeof password !== 'string' || password.trim() === '') {
+      return { valid: false, error: 'Password is required' };
+    }
+
+    if (password.length < 6) {
+      return { valid: false, error: 'Password must be at least 6 characters' };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Check if error requires email verification
+   */
+  private requiresVerification(errorCode?: string): boolean {
+    return errorCode === 'auth/unverified-email' || errorCode === 'auth/email-not-verified';
+  }
+
+  /**
+   * Check if user is already signed in
+   */
+  isSignedIn(): boolean {
+    return this.authPort.isAuthenticated();
+  }
+
+  /**
+   * Get current user
+   */
+  getCurrentUser(): User | null {
+    return this.authPort.getCurrentUser();
+  }
+
+  /**
+   * Sign out current user
+   */
+  async signOut(): Promise<Result<void>> {
+    return this.authPort.signOut();
+  }
+
+  /**
+   * Check if credentials match current user
+   */
+  async credentialsMatchCurrentUser(email: string): Promise<boolean> {
+    const currentUser = this.getCurrentUser();
+    if (!currentUser || !currentUser.email) {
+      return false;
+    }
+
+    return currentUser.email.toLowerCase() === email.toLowerCase();

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

@@ -0,0 +1,103 @@
+  }
+
+  /**
+   * Validate email format
+   */
+  isValidEmail(email: string): boolean {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
+  /**
+   * Validate password strength
+   */
+  isStrongPassword(password: string): boolean {
+    // Basic password strength check
+    return password.length >= 8;
+  }
+
+  /**
+   * Get password strength indicator
+   */
+  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
+   */
+  isAccountLocked(errorCode?: string): boolean {
+    return errorCode === 'auth/too-many-requests' || errorCode === 'auth/user-disabled';
+  }
+
+  /**
+   * Get user-friendly error message
+   */
+  getErrorMessage(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] || 'Sign in failed. Please try again.';
+  }
+
+  /**
+   * Create sign in options from email and password
+   */
+  createOptions(email: string, password: string, rememberMe: boolean = false): SignInOptions {
+    return {
+      email,
+      password,
+      rememberMe,
+    };
+  }
+
+  /**
+   * Quick sign in helper
+   */
+  async quickSignIn(email: string, password: string): Promise<SignInUseCaseResult> {
+    return this.execute(this.createOptions(email, password));
+  }
+}
+
+/**
+ * Factory function to create sign in use case
+ */
+export function createSignInUseCase(authPort: IAuthPort): SignInUseCase {
+  return new SignInUseCase(authPort);
+}
+
+/**
+ * Factory function to create sign in use case with default auth port
+ */
+export async function createDefaultSignInUseCase(): Promise<SignInUseCase> {
+  const { createAuthPort } = await import('../ports/AuthPort');
+  const authPort = createAuthPort();
+  return createSignInUseCase(authPort);
+}

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

@@ -0,0 +1,150 @@
+/**
+ * Sign Out Use Case
+ * Single Responsibility: Handle user sign out operations
+ *
+ * Application use case for user sign out.
+ * Ensures proper cleanup and state management.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { User } from 'firebase/auth';
+import type { Result } from '../../../shared/domain/utils';
+import type { IAuthPort } from '../ports/AuthPort';
+
+/**
+ * Sign out use case result
+ */
+export interface SignOutUseCaseResult extends Result<void> {
+  readonly wasSignedIn: boolean;
+}
+
+/**
+ * Sign out use case options
+ */
+export interface SignOutOptions {
+  /** Clear local data */
+  readonly clearLocalData?: boolean;
+  /** Navigate to sign in screen */
+  readonly navigateToSignIn?: boolean;
+  /** Show confirmation dialog */
+  readonly showConfirmation?: boolean;
+}
+
+/**
+ * Sign out use case
+ * Handles user sign out with proper cleanup
+ */
+export class SignOutUseCase {
+  private readonly authPort: IAuthPort;
+
+  constructor(authPort: IAuthPort) {
+    this.authPort = authPort;
+  }
+
+  /**
+   * Execute sign out use case
+   * Signs out user and performs cleanup
+   */
+  async execute(options: SignOutOptions = {}): Promise<SignOutUseCaseResult> {
+    const wasSignedIn = this.authPort.isAuthenticated();
+
+    // Check if user is signed in
+    if (!wasSignedIn) {
+      return {
+        success: true,
+        wasSignedIn: false,
+      };
+    }
+
+    // Sign out from auth
+    const result = await this.authPort.signOut();
+
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        wasSignedIn,
+      };
+    }
+
+    // Perform cleanup
+    await this.performCleanup(options);
+
+    return {
+      success: true,
+      wasSignedIn,
+    };
+  }
+
+  /**
+   * Perform cleanup after sign out
+   */
+  private async performCleanup(options: SignOutOptions): Promise<void> {
+    // Clear local data if requested
+    if (options.clearLocalData) {
+      await this.clearLocalData();
+    }
+
+    // Additional cleanup can be added here
+    // For example: clear cache, reset state, etc.
+  }
+
+  /**
+   * Clear local data
+   * Override in subclass for custom cleanup
+   */
+  protected async clearLocalData(): Promise<void> {
+    // Default implementation does nothing
+    // Subclass can override for custom cleanup
+    if (__DEV__) {
+      console.log('[SignOutUseCase] Clearing local data');
+    }
+  }
+
+  /**
+   * Check if user is signed in
+   */
+  isSignedIn(): boolean {
+    return this.authPort.isAuthenticated();
+  }
+
+  /**
+   * Get current user
+   */
+  getCurrentUser(): User | null {
+    return this.authPort.getCurrentUser();
+  }
+
+  /**
+   * Get current user ID
+   */
+  getCurrentUserId(): string | null {
+    return this.authPort.getCurrentUserId();
+  }
+
+  /**
+   * Check if user is anonymous
+   */
+  isAnonymous(): boolean {
+    return this.authPort.isAnonymous();
+  }
+
+  /**
+   * Confirm sign out
+   * Useful for showing confirmation dialog
+   */
+  async confirmSignOut(): Promise<boolean> {
+    // Default implementation always returns true
+    // Override in subclass to show confirmation dialog
+    return true;
+  }
+
+  /**
+   * Validate can sign out
+   * Check if sign out is allowed
+   */
+  async canSignOut(): Promise<Result<void>> {
+    if (!this.isSignedIn()) {
+      return {
+        success: false,