@umituz/react-native-firebase 2.4.29 → 2.4.32

package/src/shared/domain/utils/id-generator.util.ts

@@ -11,40 +11,3 @@
 export function generateUniqueId(): string {
   return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
 }
-
-/**
- * Generate a short random ID
- * Useful for temporary identifiers where uniqueness within scope is sufficient
- * @returns Random identifier string
- */
-export function generateShortId(length: number = 8): string {
-  return Math.random().toString(36).substring(2, 2 + length);
-}
-
-/**
- * Generate a UUID-like ID
- * Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
- * @returns UUID-like identifier string
- */
-export function generateUUID(): string {
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === 'x' ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
-}
-
-/**
- * Generate a nanoid-like ID
- * Uses URL-safe characters for better compatibility
- * @param length - Length of the ID (default: 21)
- * @returns URL-safe unique identifier string
- */
-export function generateNanoId(length: number = 21): string {
-  const chars = 'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW';
-  let result = '';
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  return result;
-}

package/src/shared/domain/utils/index.ts

@@ -6,112 +6,22 @@
 // Result types and helpers
 export type {
   Result,
-  SuccessResult,
-  FailureResult,
-  ErrorInfo,
 } from './result/result-types';
 
 export {
   successResult,
-  failureResult,
   failureResultFrom,
-  failureResultFromError,
 } from './result/result-creators';
 
-export {
-  isSuccess,
-  isFailure,
-  getDataOrDefault,
-  mapResult,
-  chainResults,
-} from './result/result-helpers';
-
 // Async operation execution
 export {
   executeOperation,
-  executeOperationWithCode,
-  executeVoidOperation,
   executeAuthOperation,
-  executeAll,
-  executeSequence,
-  executeWithRetry,
-  executeWithTimeout,
 } from './async-executor.util';
 
-// Service configuration
-export {
-  ConfigurableService,
-  createConfigurableService,
-  type ConfigState,
-  type IConfigurableService,
-} from './service-config.util';
-
-// Credential utilities
-export {
-  generateGoogleCredential,
-  generateAppleCredential,
-  isAppleSignInAvailable,
-  performAppleSignIn,
-  isValidEmailPassword,
-  type EmailPasswordCredential,
-  type CredentialGenerator,
-} from './credential.util';
-
 // Error handling
 export { toErrorInfo } from './error-handlers/error-converters';
 
-export {
-  hasErrorCode,
-  isCancelledError,
-  isQuotaErrorInfo,
-  isNetworkError,
-  isAuthError,
-  isQuotaError,
-  isRetryableError,
-} from './error-handlers/error-checkers';
-
 export {
   ERROR_MESSAGES,
-  getQuotaErrorMessage,
-  getRetryableErrorMessage,
 } from './error-handlers/error-messages';
-
-// Type guards
-export {
-  hasCodeProperty,
-  hasMessageProperty,
-  hasCodeAndMessageProperties,
-} from './type-guards.util';
-
-// Validation
-export {
-  isValidString,
-  isEmptyString,
-  isDefined,
-} from './validators/string.validator';
-
-export {
-  isValidFirebaseApiKey,
-  isValidFirebaseAuthDomain,
-  isValidFirebaseProjectId,
-} from './validators/firebase.validator';
-
-export {
-  isValidUrl,
-  isValidHttpsUrl,
-} from './validators/url.validator';
-
-export { isValidEmail } from './validators/user-input.validator';
-
-export {
-  isNonEmptyArray,
-  isInRange,
-  isPositive,
-  isNonNegative,
-} from './validators/generic.validator';
-
-// ID generation
-export {
-  generateUniqueId,
-  generateShortId,
-} from './id-generator.util';

package/src/shared/domain/utils/result/result-creators.ts

@@ -16,7 +16,7 @@ export function successResult<T = void>(data?: T): SuccessResult<T> {
 /**
  * Create a failure result with error information
  */
-export function failureResult(error: ErrorInfo): FailureResult {
+function failureResult(error: ErrorInfo): FailureResult {
   return { success: false, error };
 }
 

package/src/shared/domain/utils/result/result-helpers.ts

@@ -3,8 +3,7 @@
  * Utility functions for working with Result type
  */
 
-import type { Result, SuccessResult, FailureResult } from './result-types';
-import { successResult } from './result-creators';
+import type { Result, SuccessResult } from './result-types';
 
 /**
  * Check if result is successful
@@ -12,49 +11,3 @@ import { successResult } from './result-creators';
 export function isSuccess<T>(result: Result<T>): result is SuccessResult<T> {
   return result.success === true && result.error === undefined;
 }
-
-/**
- * Check if result is a failure
- */
-export function isFailure<T>(result: Result<T>): result is FailureResult {
-  return result.success === false && result.error !== undefined;
-}
-
-/**
- * Get data from result or return default
- */
-export function getDataOrDefault<T>(result: Result<T>, defaultValue: T): T {
-  return isSuccess(result) ? (result.data ?? defaultValue) : defaultValue;
-}
-
-/**
- * Map success result data to another type
- */
-export function mapResult<T, U>(
-  result: Result<T>,
-  mapper: (data: T) => U
-): Result<U> {
-  if (isSuccess(result) && result.data !== undefined) {
-    return successResult(mapper(result.data));
-  }
-  // Return a new failure result to avoid type conflicts
-  if (isFailure(result)) {
-    return { success: false, error: result.error };
-  }
-  return successResult();
-}
-
-/**
- * Chain multiple results, stopping at first failure
- */
-export async function chainResults<T>(
-  ...operations: (() => Promise<Result<T>>)[]
-): Promise<Result<T>> {
-  for (const operation of operations) {
-    const result = await operation();
-    if (isFailure(result)) {
-      return result;
-    }
-  }
-  return successResult();
-}

package/src/shared/domain/utils/service-config.util.ts

@@ -3,26 +3,16 @@ import { ERROR_MESSAGES } from './error-handlers/error-messages';
 /**
  * Configuration state management
  */
-export interface ConfigState<TConfig> {
+interface ConfigState<TConfig> {
   config: TConfig | null;
   initialized: boolean;
 }
 
-/**
- * Configurable service interface
- */
-export interface IConfigurableService<TConfig> {
-  configure(config: TConfig): void;
-  isConfigured(): boolean;
-  getConfig(): TConfig | null;
-  reset(): void;
-}
-
 /**
  * Base class for configurable services
  * Provides configuration management pattern
  */
-export class ConfigurableService<TConfig = unknown> implements IConfigurableService<TConfig> {
+export class ConfigurableService<TConfig = unknown> {
   protected configState: ConfigState<TConfig>;
   private customValidator?: (config: TConfig) => boolean;
 
@@ -81,12 +71,3 @@ export class ConfigurableService<TConfig = unknown> implements IConfigurableServ
     return this.configState.config;
   }
 }
-
-/**
- * Create a configurable service instance
- */
-export function createConfigurableService<TConfig>(
-  validator?: (config: TConfig) => boolean
-): ConfigurableService<TConfig> {
-  return new ConfigurableService<TConfig>(validator);
-}

package/src/shared/domain/utils/type-guards.util.ts

@@ -7,33 +7,11 @@
 
 /**
  * Type guard for non-null objects
- * Eliminates duplicate object checking pattern throughout the codebase
- *
- * @example
- * ```typescript
- * if (isObject(value)) {
- *   // value is Record<string, unknown>
- * }
- * ```
  */
-export function isObject(value: unknown): value is Record<string, unknown> {
+function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
 
-/**
- * Type guard for objects with a specific property
- *
- * @param value - Value to check
- * @param key - Property key to check for
- * @returns True if value is an object with the specified property
- */
-export function hasProperty<K extends string>(
-  value: unknown,
-  key: K
-): value is Record<K, unknown> {
-  return isObject(value) && key in value;
-}
-
 /**
  * Type guard for objects with a 'code' property of type string
  * Commonly used for Firebase errors and other error objects
@@ -57,35 +35,3 @@ export function hasMessageProperty(error: unknown): error is { message: string }
     typeof (error as { message: unknown }).message === 'string'
   );
 }
-
-/**
- * Type guard for objects with both 'code' and 'message' properties
- * Commonly used for Firebase error objects
- */
-export function hasCodeAndMessageProperties(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 as { name: unknown }).name === 'string'
-  );
-}
-
-/**
- * Type guard for objects with a 'stack' property of type string
- * Commonly used for Error objects
- */
-export function hasStackProperty(error: unknown): error is { stack: string } {
-  return (
-    isObject(error) &&
-    'stack' in error &&
-    typeof (error as { stack: unknown }).stack === 'string'
-  );
-}

package/src/shared/domain/utils/validators/firebase.validator.ts

@@ -31,14 +31,3 @@ export function isValidFirebaseAuthDomain(authDomain: string): boolean {
   );
 }
 
-/**
- * Validate Firebase projectId format
- * Project IDs must be 6-30 characters, lowercase, alphanumeric, and may contain hyphens
- */
-export function isValidFirebaseProjectId(projectId: string): boolean {
-  if (!isValidString(projectId)) {
-    return false;
-  }
-  const pattern = /^[a-z0-9][a-z0-9-]{4,28}[a-z0-9]$/;
-  return pattern.test(projectId);
-}

package/src/shared/domain/utils/validators/string.validator.ts

@@ -9,17 +9,3 @@
 export function isValidString(value: unknown): value is string {
   return typeof value === 'string' && value.trim().length > 0;
 }
-
-/**
- * Check if a string is empty or whitespace only
- */
-export function isEmptyString(value: unknown): boolean {
-  return typeof value === 'string' && value.trim().length === 0;
-}
-
-/**
- * Check if value is defined (not null or undefined)
- */
-export function isDefined<T>(value: T | null | undefined): value is T {
-  return value !== null && value !== undefined;
-}

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

@@ -7,7 +7,7 @@
  * @template TInstance - The service instance type (e.g., FirebaseApp, Firestore, Auth)
  */
 
-export interface ClientState<TInstance> {
+interface ClientState<TInstance> {
   instance: TInstance | null;
   initializationError: string | null;
   isInitialized: boolean;

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

@@ -14,13 +14,13 @@
  * @template TConfig - The configuration type (optional)
  */
 
-export interface ServiceClientState<TInstance> {
+interface ServiceClientState<TInstance> {
   instance: TInstance | null;
   initializationError: string | null;
   isInitialized: boolean;
 }
 
-export interface ServiceClientOptions<TInstance, TConfig = unknown> {
+interface ServiceClientOptions<TInstance, TConfig = unknown> {
   serviceName: string;
   initializer?: (config?: TConfig) => TInstance | null;
   autoInitializer?: () => TInstance | null;

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

@@ -1,99 +1,9 @@
 /**
  * Firebase App Initializer
  *
- * Single Responsibility: Initialize Firebase App instance
+ * Single Responsibility: Expose Firebase App type
  */
 
-import {
-  initializeApp,
-  getApps,
-  type FirebaseApp as FirebaseAppType,
-} from 'firebase/app';
-import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
-import { FirebaseInitializationError } from '../../../domain/errors/FirebaseError';
+import type { FirebaseApp as FirebaseAppType } from 'firebase/app';
 
 export type FirebaseApp = FirebaseAppType;
-
-/**
- * Firebase configuration mapper
- */
-class FirebaseConfigMapper {
-  /**
-   * Map domain config to Firebase SDK config
-   */
-  static toFirebaseConfig(config: FirebaseConfig): Record<string, string | undefined> {
-    return {
-      apiKey: config.apiKey,
-      authDomain: config.authDomain,
-      projectId: config.projectId,
-      storageBucket: config.storageBucket,
-      messagingSenderId: config.messagingSenderId,
-      appId: config.appId,
-    };
-  }
-}
-
-/**
- * Firebase App manager
- */
-class FirebaseAppManager {
-  /**
-   * Check if Firebase App is already initialized
-   */
-  static isInitialized(): boolean {
-    try {
-      const existingApps = getApps();
-      return existingApps.length > 0;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Get existing Firebase App instance
-   */
-  static getExistingApp(): FirebaseApp | null {
-    try {
-      const existingApps = getApps();
-      return existingApps.length > 0 ? existingApps[0] ?? null : null;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Create new Firebase App instance
-   */
-  static createApp(config: FirebaseConfig): FirebaseApp {
-    try {
-      const firebaseConfig = FirebaseConfigMapper.toFirebaseConfig(config);
-      return initializeApp(firebaseConfig);
-    } catch (error) {
-      throw new FirebaseInitializationError(
-        `Failed to initialize Firebase App: ${
-          error instanceof Error ? error.message : 'Unknown error'
-        }`,
-        error
-      );
-    }
-  }
-}
-
-/**
- * Initializes Firebase App
- */
-export class FirebaseAppInitializer {
-  /**
-   * Initialize or get existing Firebase App
-   */
-  static initialize(config: FirebaseConfig): FirebaseApp {
-    // Return existing app if already initialized
-    const existingApp = FirebaseAppManager.getExistingApp();
-    if (existingApp) {
-      return existingApp;
-    }
-
-    // Create new app
-    return FirebaseAppManager.createApp(config);
-  }
-}

package/src/domains/auth/domain/errors/FirebaseAuthError.ts

@@ -1,18 +0,0 @@
-/**
- * Firebase Auth Error Classes
- * Custom error types for Firebase Auth operations
- */
-
-export class FirebaseAuthError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'FirebaseAuthError';
-  }
-}
-
-export class FirebaseAuthInitializationError extends FirebaseAuthError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'FirebaseAuthInitializationError';
-  }
-}

package/src/domains/auth/infrastructure/services/auth-guard.service.ts

@@ -1,101 +0,0 @@
-/**
- * Auth Guard Service
- * Single Responsibility: Validate authenticated user access
- *
- * SOLID: Single Responsibility - Only handles auth validation
- * Generic implementation for all React Native apps
- */
-
-import {
-  getCurrentUserId,
-  getCurrentUser,
-} from './auth-utils.service';
-import { ERROR_MESSAGES } from '../../../../shared/domain/utils/error-handlers/error-messages';
-import { withAuth, withAuthSync } from '../utils/auth-guard.util';
-
-/**
- * Auth Guard Service
- * Provides authentication validation for protected operations
- */
-export class AuthGuardService {
-  /**
-   * Check if user is authenticated (not guest)
-   * @throws Error if user is not authenticated
-   */
-  async requireAuthenticatedUser(): Promise<string> {
-    const result = await withAuth(async (auth) => {
-      const userId = getCurrentUserId(auth);
-      if (!userId) {
-        throw new Error(ERROR_MESSAGES.AUTH.NOT_AUTHENTICATED);
-      }
-
-      const currentUser = getCurrentUser(auth);
-      if (!currentUser) {
-        throw new Error(ERROR_MESSAGES.AUTH.NOT_AUTHENTICATED);
-      }
-
-      if (currentUser.isAnonymous) {
-        throw new Error(ERROR_MESSAGES.AUTH.NON_ANONYMOUS_ONLY);
-      }
-
-      return userId;
-    });
-
-    if (!result.success) {
-      throw new Error(result.error?.message || 'Authentication failed');
-    }
-
-    if (!result.data) {
-      throw new Error('No user ID returned');
-    }
-
-    return result.data;
-  }
-
-  /**
-   * Check if user is authenticated (not guest)
-   * Returns null if not authenticated instead of throwing
-   */
-  async getAuthenticatedUserId(): Promise<string | null> {
-    try {
-      return await this.requireAuthenticatedUser();
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Check if current user is authenticated (not guest)
-   */
-  isAuthenticated(): boolean {
-    const result = withAuthSync((auth) => {
-      const currentUser = getCurrentUser(auth);
-      if (!currentUser) {
-        return false;
-      }
-
-      // User must not be anonymous
-      return !currentUser.isAnonymous;
-    });
-
-    return result.success && result.data ? result.data : false;
-  }
-
-  /**
-   * Check if current user is guest (anonymous)
-   */
-  isGuest(): boolean {
-    const result = withAuthSync((auth) => {
-      const currentUser = getCurrentUser(auth);
-      if (!currentUser) {
-        return false;
-      }
-
-      return currentUser.isAnonymous;
-    });
-
-    return result.success && result.data ? result.data : false;
-  }
-}
-
-export const authGuardService = new AuthGuardService();

package/src/domains/auth/presentation/hooks/shared/auth-hooks.util.ts

@@ -1,60 +0,0 @@
-/**
- * Auth-Specific Hooks
- * React hooks for Firebase Auth state management
- */
-
-import { useRef, useEffect } from 'react';
-import { onAuthStateChanged, type Auth, type User } from 'firebase/auth';
-
-/**
- * Create an auth state handler
- */
-export function createAuthStateHandler(
-  setState: (user: User | null) => void,
-  setLoading: (loading: boolean) => void,
-  setError: (error: Error | null) => void
-): (user: User | null) => void {
-  return (user: User | null) => {
-    try {
-      setState(user);
-      setError(null);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error('Auth state update failed');
-      setError(error);
-    } finally {
-      setLoading(false);
-    }
-  };
-}
-
-/**
- * Hook for managing auth listener lifecycle
- */
-export function useAuthListener(
-  auth: Auth | null,
-  onAuthStateChange: (user: User | null) => void
-): void {
-  const unsubscribeRef = useRef<(() => void) | null>(null);
-
-  useEffect(() => {
-    // Cleanup previous listener
-    if (unsubscribeRef.current) {
-      unsubscribeRef.current();
-      unsubscribeRef.current = null;
-    }
-
-    if (!auth) {
-      onAuthStateChange(null);
-      return;
-    }
-
-    unsubscribeRef.current = onAuthStateChanged(auth, onAuthStateChange);
-
-    return () => {
-      if (unsubscribeRef.current) {
-        unsubscribeRef.current();
-        unsubscribeRef.current = null;
-      }
-    };
-  }, [auth, onAuthStateChange]);
-}