@umituz/react-native-firebase 3.0.3 → 3.0.5

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

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

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

@@ -1,39 +1,155 @@
 /**
- * Service Client Singleton Base
- * Base singleton pattern for service clients
+ * Service Client Singleton Base Class
  *
- * Max lines: 150 (enforced for maintainability)
+ * 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;
+    }
 
-export abstract class ServiceClientSingleton<TInstance, TConfig = unknown> {
-  protected instance: TInstance | null = null;
-  protected initializationError: Error | null = 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;
+    }
 
-  protected constructor() {}
+    if (this.state.initializationError) {
+      return null;
+    }
 
-  abstract initialize(config?: TConfig): Promise<TInstance> | TInstance;
+    // Prevent concurrent auto-initialization attempts
+    if (this.initInProgress) {
+      return null;
+    }
 
-  getInstance(): TInstance {
-    if (!this.instance) {
-      throw new Error('Service not initialized. Call initialize() first.');
+    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 this.instance;
+
+    return null;
   }
 
+  /**
+   * Check if the service is initialized
+   */
   isInitialized(): boolean {
-    return this.instance !== null;
+    return this.state.isInitialized;
   }
 
-  getInitializationError(): Error | null {
-    return this.initializationError;
+  /**
+   * Get the initialization error if any
+   */
+  getInitializationError(): string | null {
+    return this.state.initializationError;
   }
 
-  setError(message: string): void {
-    this.initializationError = new Error(message);
+  /**
+   * Reset the service state
+   */
+  reset(): void {
+    this.state.instance = null;
+    this.state.initializationError = null;
+    this.state.isInitialized = false;
+    this.initInProgress = false;
   }
 
-  reset(): void {
-    this.instance = null;
-    this.initializationError = null;
+  /**
+   * Get the current instance without initialization
+   */
+  protected getCurrentInstance(): TInstance | null {
+    return this.state.instance;
+  }
+
+  /**
+   * Set initialization error
+   */
+  protected setError(error: string): void {
+    this.state.initializationError = error;
   }
 }

package/src/shared/infrastructure/config/clients/FirebaseClientSingleton.ts

@@ -5,7 +5,7 @@
 
 import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
 import type { IFirebaseClient } from '../../../../application/ports/IFirebaseClient';
-import type { FirebaseApp } from 'firebase/app';
+import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
 import { FirebaseClientState } from '../state/FirebaseClientState';
 import { FirebaseInitializationOrchestrator } from '../orchestrators/FirebaseInitializationOrchestrator';
 

package/src/shared/infrastructure/config/initializers/FirebaseAppInitializer.ts

@@ -0,0 +1,9 @@
+/**
+ * Firebase App Initializer
+ *
+ * Single Responsibility: Expose Firebase App type
+ */
+
+import type { FirebaseApp as FirebaseAppType } from 'firebase/app';
+
+export type FirebaseApp = FirebaseAppType;

package/src/shared/infrastructure/config/services/FirebaseInitializationService.ts

@@ -4,7 +4,7 @@
  */
 
 import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
-import type { FirebaseApp } from 'firebase/app';
+import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
 import { FirebaseClientSingleton } from '../clients/FirebaseClientSingleton';
 import { loadFirebaseConfig } from '../FirebaseConfigLoader';
 

package/src/shared/infrastructure/config/state/FirebaseClientState.ts

@@ -1,42 +1,20 @@
-import type { FirebaseApp } from 'firebase/app';
-
-export class FirebaseClientState {
-  private app: FirebaseApp | null = null;
-  private initializationError: string | null = null;
-  private isInitializedFlag = false;
-
+/**
+ * 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 '../initializers/FirebaseAppInitializer';
+import { ClientStateManager } from '../base/ClientStateManager';
+
+export class FirebaseClientState extends ClientStateManager<FirebaseApp> {
   getApp(): FirebaseApp | null {
-    return this.app;
+    return this.getInstance();
   }
 
   setApp(app: FirebaseApp | null): void {
-    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;
+    this.setInstance(app);
   }
 }

package/src/application/auth/index.ts

@@ -1,10 +0,0 @@
-/**
- * Auth Application Layer
- * Domain-Driven Design (DDD) - Application Exports
- *
- * Application use cases and ports for authentication.
- * Coordinates domain services and infrastructure.
- */
-
-// Export types when files are available
-// TODO: Implement AuthPort and UseCases

package/src/application/auth/use-cases/index.ts

@@ -1,6 +0,0 @@
-/**
- * Auth Use Cases
- * Application layer use cases for authentication
- */
-
-// TODO: Implement SignInUseCase and SignOutUseCase

package/src/domains/account-deletion/domain/index.ts

@@ -1,8 +0,0 @@
-/**
- * Account Deletion Domain Layer
- * Domain-Driven Design (DDD) - Domain Exports
- *
- * Pure domain logic without infrastructure concerns.
- */
-
-// TODO: Implement UserValidationService

package/src/domains/account-deletion/infrastructure/services/AccountDeletionExecutor.ts

@@ -1,79 +0,0 @@
-/**
- * Account Deletion Executor
- * Handles Firebase account deletion with reauthentication support
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { User } from 'firebase/auth';
-import type { AccountDeletionOptions } from '../../application/ports/reauthentication.types';
-import type { AccountDeletionResult } from './AccountDeletionTypes';
-
-export class AccountDeletionExecutor {
-  private deletionInProgress = false;
-
-  async deleteCurrentUser(_options: AccountDeletionOptions): Promise<AccountDeletionResult> {
-    if (this.deletionInProgress) {
-      return {
-        success: false,
-        error: {
-          code: 'deletion-in-progress',
-          message: 'Account deletion is already in progress',
-        },
-      };
-    }
-
-    this.deletionInProgress = true;
-
-    try {
-      // TODO: Implement actual deletion logic
-      return {
-        success: true,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          code: 'deletion-failed',
-          message: error instanceof Error ? error.message : 'Unknown error',
-        },
-      };
-    } finally {
-      this.deletionInProgress = false;
-    }
-  }
-
-  async deleteUserAccount(user: User | null): Promise<AccountDeletionResult> {
-    if (!user) {
-      return {
-        success: false,
-        error: {
-          code: 'no-user',
-          message: 'No user provided',
-        },
-      };
-    }
-
-    try {
-      await user.delete();
-      return {
-        success: true,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: {
-          code: 'deletion-failed',
-          message: error instanceof Error ? error.message : 'Unknown error',
-        },
-      };
-    }
-  }
-
-  isDeletionInProgress(): boolean {
-    return this.deletionInProgress;
-  }
-}
-
-export const accountDeletionExecutor = new AccountDeletionExecutor();
-export const createAccountDeletionExecutor = () => new AccountDeletionExecutor();

package/src/domains/account-deletion/infrastructure/services/AccountDeletionTypes.ts

@@ -1,32 +0,0 @@
-/**
- * Account Deletion Types
- * Single Responsibility: Define account deletion types
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import type { Result } from '../../../../shared/domain/utils';
-
-/**
- * Account deletion result
- */
-export interface AccountDeletionResult extends Result<void> {
-  readonly requiresReauth?: boolean;
-}
-
-/**
- * Reauthentication context
- */
-export interface ReauthenticationContext {
-  readonly user: import('firebase/auth').User;
-  readonly options: import('../../application/ports/reauthentication.types').AccountDeletionOptions;
-  readonly originalUserId?: string;
-}
-
-/**
- * Reauthentication result
- */
-export interface ReauthenticationResult {
-  readonly success: boolean;
-  readonly error?: { code?: string; message?: string };
-}

package/src/domains/auth/domain.ts

@@ -1,16 +0,0 @@
-/**
- * Firebase Auth Domain Layer
- * Domain-Driven Design (DDD) - Domain Exports
- *
- * Pure domain logic without infrastructure concerns.
- * Exports domain entities, value objects, and domain services.
- */
-
-// Domain Value Objects
-export type { FirebaseAuthConfig } from './domain/value-objects/FirebaseAuthConfig';
-
-// Domain Entities
-export {
-  isAnonymousUser,
-} from './domain/entities/AnonymousUser';
-export type { AnonymousUser } from './domain/entities/AnonymousUser';

package/src/domains/auth/infrastructure/config/index.ts

@@ -1,2 +0,0 @@
-export * from './FirebaseAuthClient';
-export * from './initializers';

package/src/domains/auth/infrastructure/config/initializers/index.ts

@@ -1 +0,0 @@
-export * from './FirebaseAuthInitializer';

package/src/domains/auth/infrastructure/services/index.ts

@@ -1,16 +0,0 @@
-export * from './anonymous-auth.service';
-export * from './apple-auth.service';
-export * from './apple-auth.types';
-export * from './auth-listener.service';
-export * from './auth-utils.service';
-export * from './email-auth.service';
-export * from './google-auth.service';
-export * from './google-auth.types';
-export * from './google-oauth.service';
-export * from './password.service';
-export * from './user-document-builder.util';
-export * from './user-document.service';
-export * from './user-document.types';
-export * from './crypto.util';
-export * from './firestore-utils.service';
-export * from './utils';

package/src/domains/auth/infrastructure/services/utils/index.ts

@@ -1 +0,0 @@
-export * from './auth-result-converter.util';

package/src/domains/auth/infrastructure/stores/index.ts

@@ -1 +0,0 @@
-export * from './auth.store';

package/src/domains/auth/infrastructure/utils/index.ts

@@ -1 +0,0 @@
-export * from './auth-guard.util';

package/src/domains/auth/infrastructure.ts

@@ -1,11 +0,0 @@
-/**
- * Auth Infrastructure Layer
- * Domain-Driven Design (DDD) - Infrastructure Exports
- *
- * Infrastructure implementations for authentication.
- */
-
-export * from './infrastructure/config';
-export * from './infrastructure/services';
-export * from './infrastructure/stores';
-export * from './infrastructure/utils';

package/src/domains/auth/presentation/hooks/useAppleAuth.ts

@@ -1,82 +0,0 @@
-/**
- * useAppleAuth Hook
- * Handles Apple Sign-In using Firebase auth
- *
- * Max lines: 150 (enforced for maintainability)
- */
-
-import { useState, useCallback } from 'react';
-import { Platform } from 'react-native';
-
-export interface UseAppleAuthResult {
-  signInWithApple: () => Promise<AppleAuthSignInResult>;
-  appleLoading: boolean;
-  appleAvailable: boolean;
-}
-
-export interface AppleAuthSignInResult {
-  success: boolean;
-  isNewUser?: boolean;
-  error?: string;
-}
-
-/**
- * Check if Apple Sign-In is available
- */
-function isAppleAuthAvailable(): boolean {
-  if (Platform.OS !== 'ios') {
-    return false;
-  }
-
-  // Check if expo-apple-authentication is available
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const AppleAuthentication = require('expo-apple-authentication');
-    return !!AppleAuthentication;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Hook for Apple authentication
- */
-export function useAppleAuth(): UseAppleAuthResult {
-  const [isLoading, setIsLoading] = useState(false);
-
-  const appleAvailable = isAppleAuthAvailable();
-
-  const signInWithApple = useCallback(async (): Promise<AppleAuthSignInResult> => {
-    if (!appleAvailable) {
-      return {
-        success: false,
-        error: 'Apple Sign-In is not available',
-      };
-    }
-
-    setIsLoading(true);
-
-    try {
-      // TODO: Implement actual Apple Sign-In logic
-      // This requires expo-apple-authentication
-      return {
-        success: true,
-        isNewUser: false,
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Apple Sign-In failed';
-      return {
-        success: false,
-        error: errorMessage,
-      };
-    } finally {
-      setIsLoading(false);
-    }
-  }, [appleAvailable]);
-
-  return {
-    signInWithApple,
-    appleLoading: isLoading,
-    appleAvailable,
-  };
-}

package/src/domains/auth/presentation.ts

@@ -1,31 +0,0 @@
-/**
- * Firebase Auth Presentation Layer
- * Domain-Driven Design (DDD) - Presentation Exports
- *
- * React hooks for Firebase authentication.
- * Provides clean interface for UI components.
- */
-
-export { useFirebaseAuth } from './presentation/hooks/useFirebaseAuth';
-export type { UseFirebaseAuthResult } from './presentation/hooks/useFirebaseAuth';
-
-export { useAnonymousAuth } from './presentation/hooks/useAnonymousAuth';
-export type { UseAnonymousAuthResult } from './presentation/hooks/useAnonymousAuth';
-
-export { useSocialAuth } from './presentation/hooks/useSocialAuth';
-export type {
-  SocialAuthConfig,
-  SocialAuthResult,
-  UseSocialAuthResult,
-} from './presentation/hooks/useSocialAuth';
-
-export { useGoogleOAuth } from './presentation/hooks/useGoogleOAuth';
-export type {
-  UseGoogleOAuthResult,
-} from './presentation/hooks/useGoogleOAuth';
-
-export { useAppleAuth } from './presentation/hooks/useAppleAuth';
-export type {
-  UseAppleAuthResult,
-  AppleAuthSignInResult,
-} from './presentation/hooks/useAppleAuth';