@umituz/react-native-firebase 2.6.1 → 2.6.3

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;
+  }
+}