@umituz/react-native-firebase 2.6.1 → 2.6.2

package/src/shared/infrastructure/base/ErrorHandler_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Error Handler Base Class
+ * Single Responsibility: Centralized error handling and conversion
+ *
+ * Eliminates try-catch duplication across 9+ files.
+ * Provides standardized error-to-ErrorInfo conversion.
+ * Integrates with existing Result pattern.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { ErrorInfo } from '../../domain/utils';
+import { toErrorInfo, successResult, type Result } from '../../domain/utils';
+import { isCancelledError, isQuotaError, isRetryableError } from '../../domain/utils/error-handlers/error-checkers';
+import { ERROR_MESSAGES } from '../../domain/utils/error-handlers/error-messages';
+
+/**
+ * Error handler options
+ */
+export interface ErrorHandlerOptions {
+  /** Default error code if none can be extracted */
+  defaultErrorCode?: string;
+  /** Custom error message mapper */
+  errorMapper?: (error: unknown) => string | null;
+  /** Enable detailed logging in development */
+  enableDevLogging?: boolean;
+}
+
+/**
+ * Base class for error handling
+ * Provides centralized error conversion and handling
+ */
+export class ErrorHandler {
+  private readonly options: ErrorHandlerOptions;
+
+  constructor(options: ErrorHandlerOptions = {}) {
+    this.options = {
+      defaultErrorCode: 'unknown/error',
+      enableDevLogging: __DEV__,
+      ...options,
+    };
+  }
+
+  /**
+   * Wrap an async operation with standardized error handling
+   * Eliminates try-catch duplication across services
+   */
+  async handleAsync<T>(
+    operation: () => Promise<T>,
+    errorCode: string = this.options.defaultErrorCode || 'unknown/error'
+  ): Promise<Result<T>> {
+    try {
+      const result = await operation();
+      return successResult(result);
+    } catch (error) {
+      if (this.options.enableDevLogging) {
+        console.error(`[ErrorHandler] Operation failed: ${errorCode}`, error);
+      }
+      return { success: false, error: toErrorInfo(error, errorCode) };
+    }
+  }
+
+  /**
+   * Wrap a synchronous operation with standardized error handling
+   */
+  handle<T>(
+    operation: () => T,
+    errorCode: string = this.options.defaultErrorCode || 'unknown/error'
+  ): Result<T> {
+    try {
+      const result = operation();
+      return successResult(result);
+    } catch (error) {
+      if (this.options.enableDevLogging) {
+        console.error(`[ErrorHandler] Operation failed: ${errorCode}`, error);
+      }
+      return { success: false, error: toErrorInfo(error, errorCode) };
+    }
+  }
+
+  /**
+   * Convert error to ErrorInfo with optional custom code
+   */
+  toErrorInfo(error: unknown, code?: string): ErrorInfo {
+    // Try custom error mapper first
+    if (this.options.errorMapper) {
+      const customMessage = this.options.errorMapper(error);
+      if (customMessage) {
+        return {
+          code: code || this.options.defaultErrorCode || 'unknown/error',
+          message: customMessage,
+        };
+      }
+    }
+
+    // Use standard conversion
+    return toErrorInfo(error, code || this.options.defaultErrorCode);
+  }
+
+  /**
+   * Check if error is a cancelled operation
+   */
+  isCancelledError(error: unknown): boolean {
+    return isCancelledError(error);
+  }
+
+  /**
+   * Check if error is a quota error
+   */
+  isQuotaError(error: unknown): boolean {
+    return isQuotaError(error);
+  }
+
+  /**
+   * Check if error is retryable
+   */
+  isRetryableError(error: unknown): boolean {
+    return isRetryableError(error);
+  }
+
+  /**
+   * Get user-friendly error message
+   * Maps error codes to user-friendly messages
+   */
+  getUserMessage(error: ErrorInfo): string {
+    // Check if it's a known error category
+    if (error.code.startsWith('auth/')) {
+      return this.getAuthUserMessage(error.code);
+    }
+    if (error.code.startsWith('firestore/')) {
+      return this.getFirestoreUserMessage(error.code);
+    }
+    if (error.code.startsWith('storage/')) {
+      return ERROR_MESSAGES.STORAGE.GENERIC_ERROR;
+    }
+
+    return error.message || ERROR_MESSAGES.GENERAL.UNKNOWN;
+  }
+
+  /**
+   * Get user-friendly auth error message
+   */
+  private getAuthUserMessage(code: string): string {
+    // Map common auth error codes to user-friendly messages
+    const authMessages: Record<string, string> = {
+      'auth/user-not-found': ERROR_MESSAGES.AUTH.USER_NOT_FOUND,
+      'auth/wrong-password': ERROR_MESSAGES.AUTH.INVALID_CREDENTIALS,
+      'auth/email-already-in-use': ERROR_MESSAGES.AUTH.EMAIL_ALREADY_IN_USE,
+      'auth/invalid-email': ERROR_MESSAGES.AUTH.INVALID_EMAIL,
+      'auth/weak-password': ERROR_MESSAGES.AUTH.WEAK_PASSWORD,

package/src/shared/infrastructure/base/ErrorHandler_part_ab

@@ -0,0 +1,39 @@
+      'auth/too-many-requests': ERROR_MESSAGES.AUTH.TOO_MANY_REQUESTS,
+      'auth/user-disabled': ERROR_MESSAGES.AUTH.USER_DISABLED,
+    };
+
+    return authMessages[code] || ERROR_MESSAGES.AUTH.GENERIC_ERROR;
+  }
+
+  /**
+   * Get user-friendly firestore error message
+   */
+  private getFirestoreUserMessage(code: string): string {
+    const firestoreMessages: Record<string, string> = {
+      'firestore/permission-denied': ERROR_MESSAGES.FIRESTORE.PERMISSION_DENIED,
+      'firestore/not-found': ERROR_MESSAGES.FIRESTORE.NOT_FOUND,
+      'firestore/unavailable': ERROR_MESSAGES.FIRESTORE.UNAVAILABLE,
+    };
+
+    return firestoreMessages[code] || ERROR_MESSAGES.FIRESTORE.GENERIC_ERROR;
+  }
+
+  /**
+   * Create a failure result from error code
+   */
+  failureFrom(code: string, message?: string): Result {
+    return {
+      success: false,
+      error: {
+        code,
+        message: message || ERROR_MESSAGES.GENERAL.UNKNOWN,
+      },
+    };
+  }
+}
+
+/**
+ * Default error handler instance
+ * Can be used across the application
+ */
+export const defaultErrorHandler = new ErrorHandler();

package/src/shared/infrastructure/base/ServiceBase_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Service Base Class
+ * Single Responsibility: Provide common service functionality
+ *
+ * Base class for all services to eliminate duplication.
+ * Integrates error handling and initialization.
+ * Reduces service boilerplate by ~50%.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { Result } from '../../domain/utils';
+import { ErrorHandler, type ErrorHandlerOptions } from './ErrorHandler';
+import { successResult } from '../../domain/utils';
+import type { ErrorInfo } from '../../domain/utils';
+
+/**
+ * Service state
+ */
+interface ServiceState {
+  isInitialized: boolean;
+  initializationError: string | null;
+}
+
+/**
+ * Service base options
+ */
+export interface ServiceBaseOptions extends ErrorHandlerOptions {
+  /** Service name for logging and error messages */
+  serviceName: string;
+  /** Auto-initialize on first access */
+  autoInitialize?: boolean;
+}
+
+/**
+ * Base class for all services
+ * Provides common initialization, error handling, and state management
+ *
+ * Usage:
+ * ```typescript
+ * class MyService extends ServiceBase {
+ *   constructor() {
+ *     super({ serviceName: 'MyService' });
+ *   }
+ *
+ *   async myMethod() {
+ *     return this.handleAsync(async () => {
+ *       // Your logic here
+ *       return result;
+ *     }, 'my-method/failed');
+ *   }
+ * }
+ * ```
+ */
+export abstract class ServiceBase {
+  protected readonly errorHandler: ErrorHandler;
+  protected readonly serviceName: string;
+  protected readonly autoInitialize: boolean;
+  protected state: ServiceState;
+  private initInProgress = false;
+
+  constructor(options: ServiceBaseOptions) {
+    this.serviceName = options.serviceName;
+    this.autoInitialize = options.autoInitialize ?? false;
+    this.errorHandler = new ErrorHandler({
+      ...options,
+      defaultErrorCode: `${this.serviceName.toLowerCase()}/error`,
+    });
+    this.state = {
+      isInitialized: false,
+      initializationError: null,
+    };
+  }
+
+  /**
+   * Initialize the service
+   * Override this method to provide custom initialization logic
+   */
+  protected async initialize(): Promise<Result<void>> {
+    // Override in subclasses
+    this.state.isInitialized = true;
+    return successResult();
+  }
+
+  /**
+   * Ensure service is initialized before operation
+   * Automatically initializes if autoInitialize is enabled
+   */
+  protected async ensureInitialized(): Promise<Result<void>> {
+    if (this.state.isInitialized) {
+      return successResult();
+    }
+
+    if (this.state.initializationError) {
+      return {
+        success: false,
+        error: {
+          code: `${this.serviceName.toLowerCase()}/initialization-failed`,
+          message: this.state.initializationError,
+        },
+      };
+    }
+
+    if (this.initInProgress) {
+      return {
+        success: false,
+        error: {
+          code: `${this.serviceName.toLowerCase()}/initialization-in-progress`,
+          message: 'Service initialization is in progress',
+        },
+      };
+    }
+
+    if (!this.autoInitialize) {
+      return {
+        success: false,
+        error: {
+          code: `${this.serviceName.toLowerCase()}/not-initialized`,
+          message: 'Service is not initialized. Call initialize() first.',
+        },
+      };
+    }
+
+    this.initInProgress = true;
+    try {
+      const result = await this.initialize();
+      if (!result.success) {
+        this.state.initializationError = result.error?.message || 'Initialization failed';
+        return result;
+      }
+      this.state.isInitialized = true;
+      return successResult();
+    } finally {
+      this.initInProgress = false;
+    }
+  }
+
+  /**
+   * Wrap async operation with error handling and initialization check
+   */
+  protected async execute<T>(
+    operation: () => Promise<T>,
+    errorCode?: string
+  ): Promise<Result<T>> {
+    const initResult = await this.ensureInitialized();
+    if (!initResult.success) {
+      return {
+        success: false,
+        error: initResult.error,
+      };

package/src/shared/infrastructure/base/ServiceBase_part_ab

@@ -0,0 +1,70 @@
+    }
+
+    return this.errorHandler.handleAsync(operation, errorCode);
+  }
+
+  /**
+   * Wrap sync operation with error handling
+   */
+  protected executeSync<T>(operation: () => T, errorCode?: string): Result<T> {
+    return this.errorHandler.handle(operation, errorCode);
+  }
+
+  /**
+   * Check if service is initialized
+   */
+  isInitialized(): boolean {
+    return this.state.isInitialized;
+  }
+
+  /**
+   * Get initialization error if any
+   */
+  getInitializationError(): string | null {
+    return this.state.initializationError;
+  }
+
+  /**
+   * Reset service state
+   * Override to add custom cleanup logic
+   */
+  reset(): void {
+    this.state = {
+      isInitialized: false,
+      initializationError: null,
+    };
+    this.initInProgress = false;
+  }
+
+  /**
+   * Get service name
+   */
+  getServiceName(): string {
+    return this.serviceName;
+  }
+
+  /**
+   * Log in development mode
+   */
+  protected log(message: string, ...args: unknown[]): void {
+    if (__DEV__) {
+      console.log(`[${this.serviceName}] ${message}`, ...args);
+    }
+  }
+
+  /**
+   * Log error in development mode
+   */
+  protected logError(message: string, error?: unknown): void {
+    if (__DEV__) {
+      console.error(`[${this.serviceName}] ${message}`, error);
+    }
+  }
+
+  /**
+   * Create a failure result
+   */
+  protected failure(code: string, message?: string): Result {
+    return this.errorHandler.failureFrom(code, message);
+  }
+}

package/src/shared/infrastructure/config/base/ServiceClientSingleton_part_aa

@@ -0,0 +1,150 @@
+/**
+ * Service Client Singleton Base Class
+ *
+ * Provides a generic singleton pattern for Firebase service clients.
+ * Eliminates code duplication across FirebaseClient, FirestoreClient, FirebaseAuthClient.
+ *
+ * Features:
+ * - Generic singleton pattern
+ * - Initialization state management
+ * - Error handling and tracking
+ * - Automatic cleanup
+ *
+ * @template TInstance - The service instance type (e.g., Firestore, Auth)
+ * @template TConfig - The configuration type (optional)
+ */
+
+interface ServiceClientState<TInstance> {
+  instance: TInstance | null;
+  initializationError: string | null;
+  isInitialized: boolean;
+}
+
+interface ServiceClientOptions<TInstance, TConfig = unknown> {
+  serviceName: string;
+  initializer?: (config?: TConfig) => TInstance | null;
+  autoInitializer?: () => TInstance | null;
+}
+
+/**
+ * Generic service client singleton base class
+ * Provides common initialization, state management, and error handling
+ */
+export class ServiceClientSingleton<TInstance, TConfig = unknown> {
+  protected state: ServiceClientState<TInstance>;
+  private readonly options: ServiceClientOptions<TInstance, TConfig>;
+  private initInProgress = false;
+
+  constructor(options: ServiceClientOptions<TInstance, TConfig>) {
+    this.options = options;
+    this.state = {
+      instance: null,
+      initializationError: null,
+      isInitialized: false,
+    };
+  }
+
+  /**
+   * Initialize the service with optional configuration
+   */
+  initialize(config?: TConfig): TInstance | null {
+    if (this.state.isInitialized && this.state.instance) {
+      return this.state.instance;
+    }
+
+    if (this.state.initializationError) {
+      return null;
+    }
+
+    // Prevent concurrent initialization attempts
+    if (this.initInProgress) {
+      return null;
+    }
+
+    this.initInProgress = true;
+    try {
+      const instance = this.options.initializer ? this.options.initializer(config) : null;
+      if (instance) {
+        this.state.instance = instance;
+        this.state.isInitialized = true;
+      }
+      return instance;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : `Failed to initialize ${this.options.serviceName}`;
+      this.state.initializationError = errorMessage;
+      return null;
+    } finally {
+      this.initInProgress = false;
+    }
+  }
+
+  /**
+   * Get the service instance, auto-initializing if needed
+   */
+  getInstance(autoInit: boolean = false): TInstance | null {
+    if (this.state.instance) {
+      return this.state.instance;
+    }
+
+    if (this.state.initializationError) {
+      return null;
+    }
+
+    // Prevent concurrent auto-initialization attempts
+    if (this.initInProgress) {
+      return null;
+    }
+
+    if (autoInit && this.options.autoInitializer) {
+      this.initInProgress = true;
+      try {
+        const instance = this.options.autoInitializer();
+        if (instance) {
+          this.state.instance = instance;
+          this.state.isInitialized = true;
+        }
+        return instance;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : `Failed to initialize ${this.options.serviceName}`;
+        this.state.initializationError = errorMessage;
+      } finally {
+        this.initInProgress = false;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Check if the service is initialized
+   */
+  isInitialized(): boolean {
+    return this.state.isInitialized;
+  }
+
+  /**
+   * Get the initialization error if any
+   */
+  getInitializationError(): string | null {
+    return this.state.initializationError;
+  }
+
+  /**
+   * Reset the service state
+   */
+  reset(): void {
+    this.state.instance = null;
+    this.state.initializationError = null;
+    this.state.isInitialized = false;
+    this.initInProgress = false;
+  }
+
+  /**
+   * Get the current instance without initialization
+   */
+  protected getCurrentInstance(): TInstance | null {
+    return this.state.instance;
+  }
+
+  /**
+   * Set initialization error

package/src/shared/infrastructure/config/base/ServiceClientSingleton_part_ab

@@ -0,0 +1,5 @@
+   */
+  protected setError(error: string): void {
+    this.state.initializationError = error;
+  }
+}