@umituz/react-native-firebase 2.5.1 → 2.6.1

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

@@ -0,0 +1,220 @@
+/**
+ * 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/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/state/FirebaseClientState.ts

@@ -1,20 +1,42 @@
-/**
- * Firebase Client State Manager
- * Manages the state of Firebase initialization
- *
- * Single Responsibility: Only manages initialization state
- * Uses generic ClientStateManager for shared functionality
- */
-
 import type { FirebaseApp } from 'firebase/app';
-import { ClientStateManager } from '../base/ClientStateManager';
 
-export class FirebaseClientState extends ClientStateManager<FirebaseApp> {
+export class FirebaseClientState {
+  private app: FirebaseApp | null = null;
+  private initializationError: string | null = null;
+  private isInitializedFlag = false;
+
   getApp(): FirebaseApp | null {
-    return this.getInstance();
+    return this.app;
   }
 
   setApp(app: FirebaseApp | null): void {
-    this.setInstance(app);
+    this.app = app;
+    this.isInitializedFlag = app !== null;
+  }
+
+  setInstance(app: FirebaseApp | null): void {
+    this.setApp(app);
+  }
+
+  getInstance(): FirebaseApp | null {
+    return this.getApp();
+  }
+
+  isInitialized(): boolean {
+    return this.isInitializedFlag;
+  }
+
+  getInitializationError(): string | null {
+    return this.initializationError;
+  }
+
+  setInitializationError(error: string | null): void {
+    this.initializationError = error;
+  }
+
+  reset(): void {
+    this.app = null;
+    this.initializationError = null;
+    this.isInitializedFlag = false;
   }
 }

package/src/shared/infrastructure/config/base/ClientStateManager.ts

@@ -1,82 +0,0 @@
-/**
- * Client State Manager
- *
- * Generic state management for Firebase service clients.
- * Provides centralized state tracking for initialization status, errors, and instances.
- *
- * @template TInstance - The service instance type (e.g., FirebaseApp, Firestore, Auth)
- */
-
-interface ClientState<TInstance> {
-  instance: TInstance | null;
-  initializationError: string | null;
-  isInitialized: boolean;
-}
-
-/**
- * Generic client state manager
- * Handles initialization state, error tracking, and instance management
- */
-export class ClientStateManager<TInstance> {
-  private state: ClientState<TInstance>;
-
-  constructor() {
-    this.state = {
-      instance: null,
-      initializationError: null,
-      isInitialized: false,
-    };
-  }
-
-  /**
-   * Get the current instance
-   */
-  getInstance(): TInstance | null {
-    return this.state.instance;
-  }
-
-  /**
-   * Set the instance
-   */
-  setInstance(instance: TInstance | null): void {
-    this.state.instance = instance;
-    this.state.isInitialized = instance !== 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;
-  }
-
-  /**
-   * Set the initialization error
-   */
-  setInitializationError(error: string | null): void {
-    this.state.initializationError = error;
-  }
-
-  /**
-   * Reset the state
-   */
-  reset(): void {
-    this.state.instance = null;
-    this.state.initializationError = null;
-    this.state.isInitialized = false;
-  }
-
-  /**
-   * Get the current state (read-only)
-   */
-  getState(): Readonly<ClientState<TInstance>> {
-    return this.state;
-  }
-}