@umituz/react-native-firebase 1.13.149 → 1.13.150

package/src/domain/utils/validators/firebase.validator.ts

@@ -0,0 +1,45 @@
+/**
+ * Firebase-Specific Validators
+ * Validation utilities for Firebase configuration
+ */
+
+import { isValidString } from './string.validator';
+
+/**
+ * Validate Firebase API key format
+ * Firebase API keys typically start with "AIza" followed by 35 characters
+ */
+export function isValidFirebaseApiKey(apiKey: string): boolean {
+  if (!isValidString(apiKey)) {
+    return false;
+  }
+  const apiKeyPattern = /^AIza[0-9A-Za-z_-]{35}$/;
+  return apiKeyPattern.test(apiKey.trim());
+}
+
+/**
+ * Validate Firebase authDomain format
+ * Expected format: "projectId.firebaseapp.com" or "projectId.web.app"
+ */
+export function isValidFirebaseAuthDomain(authDomain: string): boolean {
+  if (!isValidString(authDomain)) {
+    return false;
+  }
+  const trimmed = authDomain.trim();
+  return (
+    trimmed.includes('.firebaseapp.com') ||
+    trimmed.includes('.web.app')
+  );
+}
+
+/**
+ * Validate Firebase projectId format
+ * Project IDs must be 6-30 characters, lowercase, alphanumeric, and may contain hyphens
+ */
+export function isValidFirebaseProjectId(projectId: string): boolean {
+  if (!isValidString(projectId)) {
+    return false;
+  }
+  const pattern = /^[a-z0-9][a-z0-9-]{4,28}[a-z0-9]$/;
+  return pattern.test(projectId.trim());
+}

package/src/domain/utils/validators/generic.validator.ts

@@ -0,0 +1,59 @@
+/**
+ * Generic Validators
+ * Generic validation utilities for arrays, numbers, and objects
+ */
+
+/**
+ * Check if array is not empty
+ */
+export function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]] {
+  return Array.isArray(value) && value.length > 0;
+}
+
+/**
+ * Check if number is in range
+ */
+export function isInRange(value: number, min: number, max: number): boolean {
+  return typeof value === 'number' && value >= min && value <= max;
+}
+
+/**
+ * Check if number is positive
+ */
+export function isPositive(value: number): boolean {
+  return typeof value === 'number' && value > 0;
+}
+
+/**
+ * Check if number is non-negative
+ */
+export function isNonNegative(value: number): boolean {
+  return typeof value === 'number' && value >= 0;
+}
+
+/**
+ * Validate object has required properties
+ */
+export function hasRequiredProperties<T extends Record<string, unknown>>(
+  obj: unknown,
+  requiredProps: (keyof T)[]
+): obj is T {
+  if (typeof obj !== 'object' || obj === null) {
+    return false;
+  }
+  return requiredProps.every((prop) => prop in obj);
+}
+
+/**
+ * Validate all items in array match predicate
+ */
+export function allMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
+  return Array.isArray(items) && items.every(predicate);
+}
+
+/**
+ * Validate at least one item in array matches predicate
+ */
+export function anyMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
+  return Array.isArray(items) && items.some(predicate);
+}

package/src/domain/utils/validators/string.validator.ts

@@ -0,0 +1,25 @@
+/**
+ * String Validators
+ * Basic string validation utilities
+ */
+
+/**
+ * Check if a string is a valid non-empty value
+ */
+export function isValidString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+/**
+ * Check if a string is empty or whitespace only
+ */
+export function isEmptyString(value: unknown): boolean {
+  return typeof value === 'string' && value.trim().length === 0;
+}
+
+/**
+ * Check if value is defined (not null or undefined)
+ */
+export function isDefined<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined;
+}

package/src/domain/utils/validators/url.validator.ts

@@ -0,0 +1,36 @@
+/**
+ * URL Validators
+ * Validation utilities for URLs
+ */
+
+import { isValidString } from './string.validator';
+
+/**
+ * Validate URL format
+ */
+export function isValidUrl(url: string): boolean {
+  if (!isValidString(url)) {
+    return false;
+  }
+  try {
+    new URL(url.trim());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate HTTPS URL
+ */
+export function isValidHttpsUrl(url: string): boolean {
+  if (!isValidString(url)) {
+    return false;
+  }
+  try {
+    const urlObj = new URL(url.trim());
+    return urlObj.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}

package/src/domain/utils/validators/user-input.validator.ts

@@ -0,0 +1,54 @@
+/**
+ * User Input Validators
+ * Validation utilities for user input (email, password, username, phone)
+ */
+
+import { isValidString } from './string.validator';
+
+/**
+ * Validate email format
+ */
+export function isValidEmail(email: string): boolean {
+  if (!isValidString(email)) {
+    return false;
+  }
+  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailPattern.test(email.trim());
+}
+
+/**
+ * Validate password strength
+ * At least 8 characters, containing uppercase, lowercase, and number
+ */
+export function isStrongPassword(password: string): boolean {
+  if (!isValidString(password) || password.length < 8) {
+    return false;
+  }
+  const hasUpperCase = /[A-Z]/.test(password);
+  const hasLowerCase = /[a-z]/.test(password);
+  const hasNumber = /[0-9]/.test(password);
+  return hasUpperCase && hasLowerCase && hasNumber;
+}
+
+/**
+ * Validate username format
+ * Alphanumeric, underscores, and hyphens, 3-20 characters
+ */
+export function isValidUsername(username: string): boolean {
+  if (!isValidString(username)) {
+    return false;
+  }
+  const pattern = /^[a-zA-Z0-9_-]{3,20}$/;
+  return pattern.test(username);
+}
+
+/**
+ * Validate phone number format (basic check)
+ */
+export function isValidPhoneNumber(phone: string): boolean {
+  if (!isValidString(phone)) {
+    return false;
+  }
+  const cleaned = phone.replace(/\s+/g, '').replace(/[-+()]/g, '');
+  return /^[0-9]{10,15}$/.test(cleaned);
+}

package/src/firestore/infrastructure/middleware/QuotaTrackingMiddleware.ts

@@ -43,8 +43,11 @@ export class QuotaTrackingMiddleware {
 
     /**
      * Track read operation
+     * @param _collection - Collection name (reserved for future per-collection tracking)
+     * @param count - Number of documents read
+     * @param cached - Whether result was from cache
      */
-    trackRead(collection: string, count: number = 1, cached: boolean = false): void {
+    trackRead(_collection: string, count: number = 1, cached: boolean = false): void {
         if (!cached) {
             this.readCount += count;
         }
@@ -52,15 +55,19 @@ export class QuotaTrackingMiddleware {
 
     /**
      * Track write operation
+     * @param _collection - Collection name (reserved for future per-collection tracking)
+     * @param count - Number of documents written
      */
-    trackWrite(collection: string, count: number = 1): void {
+    trackWrite(_collection: string, count: number = 1): void {
         this.writeCount += count;
     }
 
     /**
      * Track delete operation
+     * @param _collection - Collection name (reserved for future per-collection tracking)
+     * @param count - Number of documents deleted
      */
-    trackDelete(collection: string, count: number = 1): void {
+    trackDelete(_collection: string, count: number = 1): void {
         this.deleteCount += count;
     }
 

package/src/firestore/utils/deduplication/timer-manager.util.ts

@@ -31,8 +31,8 @@ export class TimerManager {
         this.options.onCleanup();
       } catch (error) {
         // Silently handle cleanup errors to prevent timer from causing issues
-        // Log error in development for debugging
-        if (process.env.NODE_ENV === 'development') {
+        // Log error in development for debugging (use __DEV__ for React Native)
+        if (__DEV__) {
           console.error('TimerManager cleanup error:', error);
         }
       }

package/src/firestore/utils/pagination.helper.ts

@@ -33,7 +33,9 @@ export class PaginationHelper<T> {
   ): PaginatedResult<T> {
     const hasMore = items.length > pageLimit;
     const resultItems = hasMore ? items.slice(0, pageLimit) : items;
-    const lastItem = resultItems[resultItems.length - 1];
+
+    // Safe access: check array is not empty before accessing last item
+    const lastItem = resultItems.length > 0 ? resultItems[resultItems.length - 1] : undefined;
     const nextCursor = hasMore && lastItem
       ? getCursor(lastItem)
       : null;

package/src/infrastructure/config/FirebaseClient.ts

@@ -6,192 +6,31 @@
  *
  * IMPORTANT: This package does NOT read from .env files.
  * Configuration must be provided by the application.
- */
-
-import type { FirebaseConfig } from '../../domain/value-objects/FirebaseConfig';
-import type { IFirebaseClient } from '../../application/ports/IFirebaseClient';
-import type { FirebaseApp } from './initializers/FirebaseAppInitializer';
-import { FirebaseClientState } from './state/FirebaseClientState';
-import { FirebaseInitializationOrchestrator } from './orchestrators/FirebaseInitializationOrchestrator';
-import { loadFirebaseConfig } from './FirebaseConfigLoader';
-
-export type { FirebaseApp };
-
-/**
- * Auth initializer callback type
- */
-export type AuthInitializer = () => Promise<void> | ((() => (any | null) | null));
-
-/**
- * Service initialization options
- */
-export interface ServiceInitializationOptions {
-  authInitializer?: AuthInitializer;
-}
-
-/**
- * Service initialization result interface
- */
-export interface ServiceInitializationResult {
-  app: FirebaseApp | null;
-  auth: boolean | null;
-  authError?: string;
-}
-
-/**
- * Firebase Client Singleton
- * Orchestrates Firebase initialization using specialized initializers
- */
-class FirebaseClientSingleton implements IFirebaseClient {
-  private static instance: FirebaseClientSingleton | null = null;
-  private state: FirebaseClientState;
-  private lastError: string | null = null;
-
-  private constructor() {
-    this.state = new FirebaseClientState();
-  }
-
-  static getInstance(): FirebaseClientSingleton {
-    if (!FirebaseClientSingleton.instance) {
-      FirebaseClientSingleton.instance = new FirebaseClientSingleton();
-    }
-    return FirebaseClientSingleton.instance;
-  }
-
-  initialize(config: FirebaseConfig): FirebaseApp | null {
-    try {
-      const result = FirebaseInitializationOrchestrator.initialize(config);
-      // Sync state with orchestrator result
-      this.state.setInstance(result);
-      this.lastError = null;
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      this.lastError = errorMessage;
-      this.state.setInitializationError(errorMessage);
-      return null;
-    }
-  }
-
-  getApp(): FirebaseApp | null {
-    // Check local state first
-    const localApp = this.state.getApp();
-    if (localApp) return localApp;
-
-    // Try to get from orchestrator
-    const result = FirebaseInitializationOrchestrator.autoInitialize();
-    if (result) {
-      this.state.setInstance(result);
-    }
-    return result;
-  }
-
-  isInitialized(): boolean {
-    // Check both local state and orchestrator for consistency
-    if (this.state.isInitialized()) return true;
-
-    // Check if Firebase has any apps initialized
-    return FirebaseInitializationOrchestrator.autoInitialize() !== null;
-  }
-
-  getInitializationError(): string | null {
-    // Check local state first
-    const localError = this.state.getInitializationError();
-    if (localError) return localError;
-    // Return last error
-    return this.lastError;
-  }
-
-  reset(): void {
-    // Reset local state
-    this.state.reset();
-    this.lastError = null;
-    // Note: We don't reset Firebase apps as they might be in use
-  }
-}
-
-export const firebaseClient = FirebaseClientSingleton.getInstance();
-
-/**
- * Initialize Firebase client with configuration
- */
-export function initializeFirebase(config: FirebaseConfig): FirebaseApp | null {
-  return firebaseClient.initialize(config);
-}
-
-/**
- * Get Firebase app instance
- * Auto-initializes from Constants/environment if not already initialized
- */
-export function getFirebaseApp(): FirebaseApp | null {
-  return firebaseClient.getApp();
-}
-
-/**
- * Auto-initialize Firebase from Constants/environment
- */
-export function autoInitializeFirebase(): FirebaseApp | null {
-  const config = loadFirebaseConfig();
-  if (config) {
-    return initializeFirebase(config);
-  }
-  return null;
-}
-
-/**
- * Initialize all Firebase services (App and Auth)
- * This is the main entry point for applications
- */
-export async function initializeAllFirebaseServices(
-  config?: FirebaseConfig,
-  options?: ServiceInitializationOptions
-): Promise<ServiceInitializationResult> {
-  const app = config ? initializeFirebase(config) : autoInitializeFirebase();
-
-  if (!app) {
-    return {
-      app: null,
-      auth: null,
-    };
-  }
-
-  // Initialize Auth if provided
-  let authSuccess = null;
-  let authError: string | undefined;
-
-  if (options?.authInitializer) {
-    try {
-      await options.authInitializer();
-      authSuccess = true;
-    } catch (error) {
-      authError = error instanceof Error ? error.message : 'Auth initialization failed';
-    }
-  }
-
-  return {
-    app,
-    auth: authSuccess,
-    authError,
-  };
-}
-
-/**
- * Check if Firebase client is initialized
- */
-export function isFirebaseInitialized(): boolean {
-  return firebaseClient.isInitialized();
-}
-
-/**
- * Get initialization error if any
- */
-export function getFirebaseInitializationError(): string | null {
-  return firebaseClient.getInitializationError();
-}
-
-/**
- * Reset Firebase client instance
- */
-export function resetFirebaseClient(): void {
-  firebaseClient.reset();
-}
+ *
+ * @deprecated Import from specific files instead:
+ * - FirebaseClientSingleton from './clients/FirebaseClientSingleton'
+ * - Initialization functions from './services/FirebaseInitializationService'
+ */
+
+export type { FirebaseApp } from './initializers/FirebaseAppInitializer';
+
+// Export singleton for backward compatibility
+export { FirebaseClientSingleton } from './clients/FirebaseClientSingleton';
+export const firebaseClient = require('./clients/FirebaseClientSingleton').FirebaseClientSingleton.getInstance();
+
+// Re-export types and functions
+export type {
+  AuthInitializer,
+  ServiceInitializationOptions,
+  ServiceInitializationResult,
+} from './services/FirebaseInitializationService';
+
+export {
+  initializeFirebase,
+  getFirebaseApp,
+  autoInitializeFirebase,
+  initializeAllFirebaseServices,
+  isFirebaseInitialized,
+  getFirebaseInitializationError,
+  resetFirebaseClient,
+} from './services/FirebaseInitializationService';

package/src/infrastructure/config/clients/FirebaseClientSingleton.ts

@@ -0,0 +1,82 @@
+/**
+ * Firebase Client Singleton
+ * Core singleton implementation for Firebase client
+ */
+
+import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
+import type { IFirebaseClient } from '../../../application/ports/IFirebaseClient';
+import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
+import { FirebaseClientState } from '../state/FirebaseClientState';
+import { FirebaseInitializationOrchestrator } from '../orchestrators/FirebaseInitializationOrchestrator';
+
+/**
+ * Firebase Client Singleton
+ * Orchestrates Firebase initialization using specialized initializers
+ */
+export class FirebaseClientSingleton implements IFirebaseClient {
+  private static instance: FirebaseClientSingleton | null = null;
+  private state: FirebaseClientState;
+  private lastError: string | null = null;
+
+  private constructor() {
+    this.state = new FirebaseClientState();
+  }
+
+  static getInstance(): FirebaseClientSingleton {
+    if (!FirebaseClientSingleton.instance) {
+      FirebaseClientSingleton.instance = new FirebaseClientSingleton();
+    }
+    return FirebaseClientSingleton.instance;
+  }
+
+  initialize(config: FirebaseConfig): FirebaseApp | null {
+    try {
+      const result = FirebaseInitializationOrchestrator.initialize(config);
+      // Sync state with orchestrator result
+      this.state.setInstance(result);
+      this.lastError = null;
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      this.lastError = errorMessage;
+      this.state.setInitializationError(errorMessage);
+      return null;
+    }
+  }
+
+  getApp(): FirebaseApp | null {
+    // Check local state first
+    const localApp = this.state.getApp();
+    if (localApp) return localApp;
+
+    // Try to get from orchestrator
+    const result = FirebaseInitializationOrchestrator.autoInitialize();
+    if (result) {
+      this.state.setInstance(result);
+    }
+    return result;
+  }
+
+  isInitialized(): boolean {
+    // Check both local state and orchestrator for consistency
+    if (this.state.isInitialized()) return true;
+
+    // Check if Firebase has any apps initialized
+    return FirebaseInitializationOrchestrator.autoInitialize() !== null;
+  }
+
+  getInitializationError(): string | null {
+    // Check local state first
+    const localError = this.state.getInitializationError();
+    if (localError) return localError;
+    // Return last error
+    return this.lastError;
+  }
+
+  reset(): void {
+    // Reset local state
+    this.state.reset();
+    this.lastError = null;
+    // Note: We don't reset Firebase apps as they might be in use
+  }
+}

package/src/infrastructure/config/services/FirebaseInitializationService.ts

@@ -0,0 +1,115 @@
+/**
+ * Firebase Initialization Service
+ * Service layer for Firebase initialization with auth support
+ */
+
+import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
+import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
+import { FirebaseClientSingleton } from '../clients/FirebaseClientSingleton';
+import { loadFirebaseConfig } from '../FirebaseConfigLoader';
+
+/**
+ * Auth initializer callback type
+ * Returns a Promise that resolves when auth initialization is complete
+ */
+export type AuthInitializer = () => Promise<void>;
+
+/**
+ * Service initialization options
+ */
+export interface ServiceInitializationOptions {
+  authInitializer?: AuthInitializer;
+}
+
+/**
+ * Service initialization result interface
+ */
+export interface ServiceInitializationResult {
+  app: FirebaseApp | null;
+  auth: boolean | null;
+  authError?: string;
+}
+
+/**
+ * Initialize Firebase client with configuration
+ */
+export function initializeFirebase(config: FirebaseConfig): FirebaseApp | null {
+  return FirebaseClientSingleton.getInstance().initialize(config);
+}
+
+/**
+ * Get Firebase app instance
+ * Auto-initializes from Constants/environment if not already initialized
+ */
+export function getFirebaseApp(): FirebaseApp | null {
+  return FirebaseClientSingleton.getInstance().getApp();
+}
+
+/**
+ * Auto-initialize Firebase from Constants/environment
+ */
+export function autoInitializeFirebase(): FirebaseApp | null {
+  const config = loadFirebaseConfig();
+  if (config) {
+    return initializeFirebase(config);
+  }
+  return null;
+}
+
+/**
+ * Initialize all Firebase services (App and Auth)
+ * This is the main entry point for applications
+ */
+export async function initializeAllFirebaseServices(
+  config?: FirebaseConfig,
+  options?: ServiceInitializationOptions
+): Promise<ServiceInitializationResult> {
+  const app = config ? initializeFirebase(config) : autoInitializeFirebase();
+
+  if (!app) {
+    return {
+      app: null,
+      auth: null,
+    };
+  }
+
+  // Initialize Auth if provided
+  let authSuccess = null;
+  let authError: string | undefined;
+
+  if (options?.authInitializer) {
+    try {
+      await options.authInitializer();
+      authSuccess = true;
+    } catch (error) {
+      authError = error instanceof Error ? error.message : 'Auth initialization failed';
+    }
+  }
+
+  return {
+    app,
+    auth: authSuccess,
+    authError,
+  };
+}
+
+/**
+ * Check if Firebase client is initialized
+ */
+export function isFirebaseInitialized(): boolean {
+  return FirebaseClientSingleton.getInstance().isInitialized();
+}
+
+/**
+ * Get initialization error if any
+ */
+export function getFirebaseInitializationError(): string | null {
+  return FirebaseClientSingleton.getInstance().getInitializationError();
+}
+
+/**
+ * Reset Firebase client instance
+ */
+export function resetFirebaseClient(): void {
+  FirebaseClientSingleton.getInstance().reset();
+}