@umituz/react-native-firebase 2.6.3 → 2.6.4

package/src/shared/infrastructure/base/ErrorHandler_part_aa

@@ -1,150 +0,0 @@
-/**
- * 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

@@ -1,39 +0,0 @@
-      '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.ts.bak

@@ -1,220 +0,0 @@
-/**
- * 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,
-      };
-    }
-
-    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/base/ServiceBase_part_aa

@@ -1,150 +0,0 @@
-/**
- * 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

@@ -1,70 +0,0 @@
-    }
-
-    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);
-  }
-}