@umituz/react-native-firebase 2.6.0 → 2.6.2

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/base/TypedGuard.ts

@@ -0,0 +1,131 @@
+/**
+ * Typed Guard Utilities
+ * Single Responsibility: Provide type-safe guard utilities
+ *
+ * Consolidates all type guards to eliminate duplication across 6+ files.
+ * Provides type-safe checking without using 'as' assertions.
+ * Optimized for performance with minimal type assertions.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+/**
+ * Type guard for non-null objects
+ * Inline function for better performance
+ */
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+/**
+ * Type guard for objects with a 'code' property of type string
+ * Commonly used for Firebase errors and other error objects
+ * Optimized: Reduced type assertions by using 'in' operator check first
+ */
+export function hasCodeProperty(error: unknown): error is { code: string } {
+  return isObject(error) && 'code' in error && typeof error.code === 'string';
+}
+
+/**
+ * Type guard for objects with a 'message' property of type string
+ * Commonly used for Error objects
+ * Optimized: Reduced type assertions by using 'in' operator check first
+ */
+export function hasMessageProperty(error: unknown): error is { message: string } {
+  return isObject(error) && 'message' in error && typeof error.message === 'string';
+}
+
+/**
+ * Type guard for objects with both 'code' and 'message' properties
+ * Commonly used for Firebase errors
+ */
+export function isFirebaseErrorLike(error: unknown): error is { code: string; message: string } {
+  return hasCodeProperty(error) && hasMessageProperty(error);
+}
+
+/**
+ * Type guard for objects with a 'name' property of type string
+ * Commonly used for Error objects
+ */
+export function hasNameProperty(error: unknown): error is { name: string } {
+  return isObject(error) && 'name' in error && typeof error.name === 'string';
+}
+
+/**
+ * Type guard for Error instances
+ * More reliable than instanceof for cross-realm errors
+ */
+export function isErrorLike(value: unknown): value is Error {
+  return (
+    isObject(value) &&
+    'message' in value &&
+    typeof value.message === 'string' &&
+    'stack' in value &&
+    (typeof value.stack === 'string' || value.stack === undefined)
+  );
+}
+
+/**
+ * Type guard for objects with a 'uid' property of type string
+ * Commonly used for Firebase user objects
+ */
+export function hasUidProperty(obj: unknown): obj is { uid: string } {
+  return isObject(obj) && 'uid' in obj && typeof obj.uid === 'string';
+}
+
+/**
+ * Type guard for objects with a 'email' property of type string
+ * Commonly used for Firebase user objects
+ */
+export function hasEmailProperty(obj: unknown): obj is { email: string | null } {
+  return isObject(obj) && 'email' in obj && (typeof obj.email === 'string' || obj.email === null);
+}
+
+/**
+ * Type guard for objects with a 'providerId' property
+ * Commonly used for Firebase user info objects
+ */
+export function hasProviderIdProperty(obj: unknown): obj is { providerId: string } {
+  return isObject(obj) && 'providerId' in obj && typeof obj.providerId === 'string';
+}
+
+/**
+ * Type guard for arrays
+ */
+export function isArray(value: unknown): value is unknown[] {
+  return Array.isArray(value);
+}
+
+/**
+ * Type guard for strings
+ */
+export function isString(value: unknown): value is string {
+  return typeof value === 'string';
+}
+
+/**
+ * Type guard for functions
+ */
+export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
+  return typeof value === 'function';
+}
+
+/**
+ * Check if object has a specific property
+ */
+export function hasProperty<T extends string>(
+  obj: unknown,
+  prop: T
+): obj is Record<T, unknown> {
+  return isObject(obj) && prop in obj;
+}
+
+/**
+ * Check if object has multiple properties
+ */
+export function hasProperties<T extends string>(
+  obj: unknown,
+  props: T[]
+): obj is Record<T, unknown> {
+  return isObject(obj) && props.every(prop => prop in obj);
+}

package/src/shared/infrastructure/base/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared Infrastructure Base Classes
+ *
+ * Eliminates code duplication across the codebase.
+ * Provides common functionality for services, error handling, and type guards.
+ *
+ * Usage:
+ * ```typescript
+ * import { ServiceBase, ErrorHandler, hasCodeProperty } from '@umituz/react-native-firebase/base';
+ * ```
+ */
+
+// ServiceBase - Base class for all services
+export { ServiceBase, type ServiceBaseOptions } from './ServiceBase';
+
+// ErrorHandler - Centralized error handling
+export { ErrorHandler, defaultErrorHandler, type ErrorHandlerOptions } from './ErrorHandler';
+
+// TypedGuard - Type-safe guard utilities
+export {
+  hasCodeProperty,
+  hasMessageProperty,
+  isFirebaseErrorLike,
+  hasNameProperty,
+  isErrorLike,
+  hasUidProperty,
+  hasEmailProperty,
+  hasProviderIdProperty,
+  isArray,
+  isString,
+  isFunction,
+  hasProperty,
+  hasProperties,
+} from './TypedGuard';

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