@umituz/react-native-subscription 3.1.9 → 3.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "3.1.9",
+  "version": "3.1.11",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domains/credits/presentation/useCreditsRealTime.ts

@@ -1,10 +1,10 @@
-import { useEffect, useState, useCallback } from "react";
-import { onSnapshot, type DocumentSnapshot } from "firebase/firestore";
-import type { UserCredits } from "../core/Credits";
+import { useMemo } from "react";
+import type { DocumentReference } from "firebase/firestore";
+import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
 import { getCreditsConfig } from "../infrastructure/CreditsRepositoryManager";
 import { mapCreditsDocumentToEntity } from "../core/CreditsMapper";
-import { requireFirestore, buildDocRef, type CollectionConfig } from "../../../shared/infrastructure/firestore/collectionUtils";
-import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
+import { requireFirestore, buildDocRef } from "../../../shared/infrastructure/firestore/collectionUtils";
+import { useFirestoreDocumentRealTime } from "../../../shared/presentation/hooks/useFirestoreRealTime";
 
 /**
  * Real-time sync for credits using Firestore onSnapshot.
@@ -20,91 +20,49 @@ import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
  * @returns Credits state and loading status
  */
 export function useCreditsRealTime(userId: string | null | undefined) {
-  const [credits, setCredits] = useState<UserCredits | null>(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState<Error | null>(null);
-
-  useEffect(() => {
-    // Reset state when userId changes
-    if (!userId) {
-      setCredits(null);
-      setIsLoading(false);
-      setError(null);
-      return;
-    }
-
-    setIsLoading(true);
-    setError(null);
-
-    try {
-      const db = requireFirestore();
-      const config = getCreditsConfig();
+  // Build document reference
+  const docRef = useMemo(() => {
+    if (!userId) return null;
 
-      // Build doc ref using same logic as repository
-      const collectionConfig: CollectionConfig = {
-        collectionName: config.collectionName,
-        useUserSubcollection: config.useUserSubcollection,
-      };
-      const docRef = buildDocRef(db, userId, "balance", collectionConfig);
-
-      // Real-time listener
-      const unsubscribe = onSnapshot(
-        docRef,
-        (snapshot: DocumentSnapshot) => {
-          if (snapshot.exists()) {
-            const entity = mapCreditsDocumentToEntity(snapshot.data() as UserCreditsDocumentRead);
-            setCredits(entity);
-          } else {
-            setCredits(null);
-          }
-          setIsLoading(false);
-        },
-        (err: Error) => {
-          console.error("[useCreditsRealTime] Snapshot error:", err);
-          setError(err);
-          setIsLoading(false);
-        }
-      );
-
-      return () => {
-        unsubscribe();
-      };
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      console.error("[useCreditsRealTime] Setup error:", err);
-      setError(error);
-      setIsLoading(false);
-    }
+    const db = requireFirestore();
+    const config = getCreditsConfig();
+    const ref = buildDocRef(db, userId, "balance", config);
+    return ref as DocumentReference<UserCreditsDocumentRead>;
   }, [userId]);
 
-  const refetch = useCallback(() => {
-    // Real-time sync doesn't need refetch, but keep for API compatibility
-    // The snapshot listener will automatically update when data changes
-    if (__DEV__) {
-      console.warn("[useCreditsRealTime] Refetch called - not needed for real-time sync");
-    }
-  }, []);
+  // Use generic real-time sync hook
+  const { data, isLoading, error, refetch } = useFirestoreDocumentRealTime(
+    userId,
+    docRef,
+    mapCreditsDocumentToEntity,
+    "useCreditsRealTime"
+  );
 
   return {
-    credits,
+    credits: data,
     isLoading,
     error,
-    refetch, // No-op but kept for compatibility
+    refetch,
   };
 }
 
 /**
  * Hook to get derived credit values with real-time sync.
  * This is the real-time equivalent of the computed values in useCredits.
+ *
+ * PERFORMANCE: Uses useMemo to avoid recalculating on every render
  */
 export function useCreditsRealTimeDerived(userId: string | null | undefined) {
   const { credits, isLoading } = useCreditsRealTime(userId);
 
-  const hasCredits = (credits?.credits ?? 0) > 0;
-  const creditsPercent = credits ? Math.min(
-    (credits.credits / credits.creditLimit) * 100,
-    100
-  ) : 0;
+  const { hasCredits, creditsPercent } = useMemo(() => {
+    const hasCredits = (credits?.credits ?? 0) > 0;
+    const creditsPercent = credits ? Math.min(
+      (credits.credits / credits.creditLimit) * 100,
+      100
+    ) : 0;
+    return { hasCredits, creditsPercent };
+  }, [credits]); // Include full credits object to catch all changes
 
   return {
     hasCredits,

package/src/domains/credits/utils/creditValidation.ts

@@ -1,27 +1,6 @@
-import { isValidNumber, isNonNegativeNumber } from "../../../shared/utils/validators";
+/**
+ * Credit validation utilities
+ * Re-exports validation functions from creditCalculations for backwards compatibility
+ */
 
-const isValidBalance = (balance: number | null | undefined): balance is number => {
-  return isValidNumber(balance) && isNonNegativeNumber(balance);
-};
-
-const isValidCost = (cost: number): boolean => {
-  return isValidNumber(cost) && isNonNegativeNumber(cost);
-};
-
-const isValidMaxCredits = (max: number): boolean => {
-  return isValidNumber(max) && max > 0;
-};
-
-export const canAffordAmount = (balance: number | null | undefined, cost: number): boolean => {
-  if (!isValidBalance(balance) || !isValidCost(cost)) return false;
-  return balance >= cost;
-};
-
-export const calculateSafePercentage = (
-  current: number | null | undefined,
-  max: number
-): number => {
-  if (!isValidNumber(current) || !isValidMaxCredits(max)) return 0;
-  const percentage = (current / max) * 100;
-  return Math.min(Math.max(percentage, 0), 100);
-};
+export { canAffordAmount, calculateSafePercentage } from './creditCalculations';

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -1,24 +1,14 @@
 /**
  * Paywall Actions Hook
  *
- * Handles purchase and restore operations with premium verification.
- * Ref management and success checking extracted to utilities.
+ * Main entry point that combines purchase and restore handlers.
+ * Handlers extracted to separate modules for better maintainability.
  */
 
-import { useState, useCallback, useRef, useMemo } from "react";
-import type { PurchasesPackage } from "react-native-purchases";
-import { usePremiumVerification } from "./usePaywallActions.utils";
-
-interface UsePaywallActionsParams {
-  packages?: PurchasesPackage[];
-  purchasePackage: (pkg: PurchasesPackage) => Promise<boolean>;
-  restorePurchase: () => Promise<boolean>;
-  source?: string; // PurchaseSource
-  onPurchaseSuccess?: () => void;
-  onPurchaseError?: (error: Error | string) => void;
-  onAuthRequired?: () => void;
-  onClose?: () => void;
-}
+import { useState, useRef, useMemo } from "react";
+import type { UsePaywallActionsParams } from "./usePaywallActions.types";
+import { usePurchaseHandler } from "./usePaywallPurchase";
+import { useRestoreHandler } from "./usePaywallRestore";
 
 export function usePaywallActions({
   packages = [],
@@ -35,8 +25,6 @@ export function usePaywallActions({
   const isProcessingRef = useRef(isProcessing);
   isProcessingRef.current = isProcessing;
 
-  const { verifyPremiumStatus } = usePremiumVerification();
-
   // Ref management
   const callbacksRef = useRef({
     purchasePackage,
@@ -59,128 +47,28 @@ export function usePaywallActions({
     packages,
   };
 
-  // ─────────────────────────────────────────────────────────────
-  // PURCHASE HANDLER
-  // ─────────────────────────────────────────────────────────────
-
-  const handlePurchase = useCallback(async () => {
-    const currentSelectedId = selectedPlanId;
-    if (!currentSelectedId) return;
-    if (isProcessingRef.current) return;
-
-    const pkg = callbacksRef.current.packages.find((p) => p.product.identifier === currentSelectedId);
-    if (!pkg) {
-      callbacksRef.current.onPurchaseError?.(new Error(`Package not found: ${currentSelectedId}`));
-      return;
-    }
-
-    if (__DEV__) {
-      console.log('[usePaywallActions] 🛒 Starting purchase', {
-        productId: pkg.product.identifier,
-      });
-    }
-
-    setIsProcessing(true);
-
-    try {
-      const success = await callbacksRef.current.purchasePackage(pkg);
-
-      if (__DEV__) {
-        console.log('[usePaywallActions] ✅ Purchase completed', { success });
-      }
-
-      let isActuallySuccessful = success === true;
-
-      // Fallback verification if success is undefined
-      if (success === undefined) {
-        isActuallySuccessful = await verifyPremiumStatus();
-      }
-
-      if (isActuallySuccessful) {
-        if (__DEV__) {
-          console.log('[usePaywallActions] 🎉 Purchase successful, closing paywall');
-        }
-        callbacksRef.current.onPurchaseSuccess?.();
-        callbacksRef.current.onClose?.();
-      } else {
-        if (__DEV__) {
-          console.warn('[usePaywallActions] ⚠️ Purchase did not indicate success');
-        }
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error('[usePaywallActions] ❌ Purchase error:', error);
-      }
-      callbacksRef.current.onPurchaseError?.(error instanceof Error ? error : new Error(String(error)));
-    } finally {
-      setIsProcessing(false);
-    }
-  }, [selectedPlanId, verifyPremiumStatus]);
-
-  // ─────────────────────────────────────────────────────────────
-  // RESTORE HANDLER
-  // ─────────────────────────────────────────────────────────────
-
-  const handleRestore = useCallback(async () => {
-    if (isProcessingRef.current) return;
-
-    if (__DEV__) {
-      console.log('[usePaywallActions] 🔄 Starting restore');
-    }
-
-    setIsProcessing(true);
-
-    try {
-      const success = await callbacksRef.current.restorePurchase();
-
-      if (__DEV__) {
-        console.log('[usePaywallActions] ✅ Restore completed', { success });
-      }
-
-      let isActuallySuccessful = success === true;
-
-      // Fallback verification if success is undefined
-      if (success === undefined) {
-        isActuallySuccessful = await verifyPremiumStatus();
-      }
-
-      if (isActuallySuccessful) {
-        if (__DEV__) {
-          console.log('[usePaywallActions] 🎉 Restore successful, closing paywall');
-        }
-        callbacksRef.current.onPurchaseSuccess?.();
-        callbacksRef.current.onClose?.();
-      } else {
-        if (__DEV__) {
-          console.warn('[usePaywallActions] ⚠️ Restore did not indicate success');
-        }
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.error('[usePaywallActions] ❌ Restore error:', error);
-      }
-      callbacksRef.current.onPurchaseError?.(error instanceof Error ? error : new Error(String(error)));
-    } finally {
-      setIsProcessing(false);
-    }
-  }, [verifyPremiumStatus]);
+  // Extracted handlers
+  const handlePurchase = usePurchaseHandler({
+    selectedPlanId,
+    isProcessingRef,
+    callbacksRef,
+  });
 
-  // ─────────────────────────────────────────────────────────────
-  // RESET
-  // ─────────────────────────────────────────────────────────────
+  const handleRestore = useRestoreHandler({
+    isProcessingRef,
+    callbacksRef,
+  });
 
-  const resetState = useCallback(() => {
+  // Reset state
+  const resetState = () => {
     if (__DEV__) {
       console.log('[usePaywallActions] 🧹 Resetting state');
     }
     setSelectedPlanId(null);
     setIsProcessing(false);
-  }, []);
-
-  // ─────────────────────────────────────────────────────────────
-  // RETURN
-  // ─────────────────────────────────────────────────────────────
+  };
 
+  // Return API
   return useMemo(() => ({
     selectedPlanId,
     setSelectedPlanId,
@@ -188,5 +76,5 @@ export function usePaywallActions({
     handlePurchase,
     handleRestore,
     resetState,
-  }), [selectedPlanId, isProcessing, handlePurchase, handleRestore, resetState]);
+  }), [selectedPlanId, isProcessing, handlePurchase, handleRestore]);
 }

package/src/domains/paywall/hooks/usePaywallActions.types.ts

@@ -0,0 +1,16 @@
+/**
+ * Paywall Actions Types
+ */
+
+import type { PurchasesPackage } from "react-native-purchases";
+
+export interface UsePaywallActionsParams {
+  packages?: PurchasesPackage[];
+  purchasePackage: (pkg: PurchasesPackage) => Promise<boolean>;
+  restorePurchase: () => Promise<boolean>;
+  source?: string;
+  onPurchaseSuccess?: () => void;
+  onPurchaseError?: (error: Error | string) => void;
+  onAuthRequired?: () => void;
+  onClose?: () => void;
+}

package/src/domains/paywall/hooks/usePaywallPurchase.ts

@@ -0,0 +1,78 @@
+/**
+ * Paywall Purchase Handler
+ *
+ * Extracted purchase logic from usePaywallActions for better modularity.
+ */
+
+import { useCallback } from "react";
+import type { UsePaywallActionsParams } from "./usePaywallActions.types";
+import { usePremiumVerification } from "./usePaywallActions.utils";
+
+interface UsePurchaseHandlerParams {
+  selectedPlanId: string | null;
+  isProcessingRef: React.MutableRefObject<boolean>;
+  callbacksRef: React.MutableRefObject<UsePaywallActionsParams>;
+}
+
+/**
+ * Hook to handle purchase operations.
+ * Extracted for better testability and modularity.
+ */
+export function usePurchaseHandler({
+  selectedPlanId,
+  isProcessingRef,
+  callbacksRef,
+}: UsePurchaseHandlerParams) {
+  const { verifyPremiumStatus } = usePremiumVerification();
+
+  const handlePurchase = useCallback(async () => {
+    const currentSelectedId = selectedPlanId;
+    if (!currentSelectedId) return;
+    if (isProcessingRef.current) return;
+
+    const pkg = callbacksRef.current.packages?.find((p) => p.product.identifier === currentSelectedId);
+    if (!pkg) {
+      callbacksRef.current.onPurchaseError?.(new Error(`Package not found: ${currentSelectedId}`));
+      return;
+    }
+
+    if (__DEV__) {
+      console.log('[usePurchaseHandler] 🛒 Starting purchase', {
+        productId: pkg.product.identifier,
+      });
+    }
+
+    try {
+      const success = await callbacksRef.current.purchasePackage(pkg);
+
+      if (__DEV__) {
+        console.log('[usePurchaseHandler] ✅ Purchase completed', { success });
+      }
+
+      let isActuallySuccessful = success === true;
+
+      if (success === undefined) {
+        isActuallySuccessful = await verifyPremiumStatus();
+      }
+
+      if (isActuallySuccessful) {
+        if (__DEV__) {
+          console.log('[usePurchaseHandler] 🎉 Purchase successful, closing paywall');
+        }
+        callbacksRef.current.onPurchaseSuccess?.();
+        callbacksRef.current.onClose?.();
+      } else {
+        if (__DEV__) {
+          console.warn('[usePurchaseHandler] ⚠️ Purchase did not indicate success');
+        }
+      }
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[usePurchaseHandler] ❌ Purchase error:', error);
+      }
+      callbacksRef.current.onPurchaseError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  }, [selectedPlanId, verifyPremiumStatus, callbacksRef, isProcessingRef]);
+
+  return handlePurchase;
+}

package/src/domains/paywall/hooks/usePaywallRestore.ts

@@ -0,0 +1,66 @@
+/**
+ * Paywall Restore Handler
+ *
+ * Extracted restore logic from usePaywallActions for better modularity.
+ */
+
+import { useCallback } from "react";
+import type { UsePaywallActionsParams } from "./usePaywallActions.types";
+import { usePremiumVerification } from "./usePaywallActions.utils";
+
+interface UseRestoreHandlerParams {
+  isProcessingRef: React.MutableRefObject<boolean>;
+  callbacksRef: React.MutableRefObject<UsePaywallActionsParams>;
+}
+
+/**
+ * Hook to handle restore operations.
+ * Extracted for better testability and modularity.
+ */
+export function useRestoreHandler({
+  isProcessingRef,
+  callbacksRef,
+}: UseRestoreHandlerParams) {
+  const { verifyPremiumStatus } = usePremiumVerification();
+
+  const handleRestore = useCallback(async () => {
+    if (isProcessingRef.current) return;
+
+    if (__DEV__) {
+      console.log('[useRestoreHandler] 🔄 Starting restore');
+    }
+
+    try {
+      const success = await callbacksRef.current.restorePurchase();
+
+      if (__DEV__) {
+        console.log('[useRestoreHandler] ✅ Restore completed', { success });
+      }
+
+      let isActuallySuccessful = success === true;
+
+      if (success === undefined) {
+        isActuallySuccessful = await verifyPremiumStatus();
+      }
+
+      if (isActuallySuccessful) {
+        if (__DEV__) {
+          console.log('[useRestoreHandler] 🎉 Restore successful, closing paywall');
+        }
+        callbacksRef.current.onPurchaseSuccess?.();
+        callbacksRef.current.onClose?.();
+      } else {
+        if (__DEV__) {
+          console.warn('[useRestoreHandler] ⚠️ Restore did not indicate success');
+        }
+      }
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[useRestoreHandler] ❌ Restore error:', error);
+      }
+      callbacksRef.current.onPurchaseError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  }, [verifyPremiumStatus, callbacksRef, isProcessingRef]);
+
+  return handleRestore;
+}

package/src/domains/revenuecat/infrastructure/services/userSwitchCore.ts

@@ -0,0 +1,116 @@
+/**
+ * User Switch Core Handler
+ *
+ * Core user switch logic. Handles switching between anonymous and authenticated users.
+ */
+
+import Purchases, { type CustomerInfo } from "react-native-purchases";
+import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
+import type { InitializerDeps } from "./RevenueCatInitializer.types";
+import { FAILED_INITIALIZATION_RESULT } from "./initializerConstants";
+import { UserSwitchMutex } from "./UserSwitchMutex";
+import { ANONYMOUS_CACHE_KEY } from "../../../subscription/core/SubscriptionConstants";
+import {
+  normalizeUserId,
+  isAnonymousId,
+  buildSuccessResult,
+  fetchOfferingsSafe,
+} from "./userSwitchHelpers";
+
+declare const __DEV__: boolean;
+
+/**
+ * Handle user switch operation with mutex protection.
+ */
+export async function handleUserSwitch(
+  deps: InitializerDeps,
+  userId: string
+): Promise<InitializeResult> {
+  const mutexKey = userId || ANONYMOUS_CACHE_KEY;
+
+  const { shouldProceed, existingPromise } = await UserSwitchMutex.acquire(mutexKey);
+
+  if (!shouldProceed && existingPromise) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchCore] Using result from active switch operation');
+    }
+    return existingPromise as Promise<InitializeResult>;
+  }
+
+  const switchOperation = performUserSwitch(deps, userId);
+  UserSwitchMutex.setPromise(switchOperation);
+  return switchOperation;
+}
+
+/**
+ * Perform the actual user switch operation.
+ */
+async function performUserSwitch(
+  deps: InitializerDeps,
+  userId: string
+): Promise<InitializeResult> {
+  try {
+    const currentAppUserId = await Purchases.getAppUserID();
+    const normalizedUserId = normalizeUserId(userId);
+    const normalizedCurrentUserId = isAnonymousId(currentAppUserId) ? null : currentAppUserId;
+
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchCore] performUserSwitch:', {
+        providedUserId: userId,
+        normalizedUserId: normalizedUserId || '(null - anonymous)',
+        currentAppUserId,
+        normalizedCurrentUserId: normalizedCurrentUserId || '(null - anonymous)',
+        needsSwitch: normalizedCurrentUserId !== normalizedUserId,
+      });
+    }
+
+    let customerInfo: CustomerInfo;
+
+    if (normalizedCurrentUserId !== normalizedUserId) {
+      if (normalizedUserId) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log('[UserSwitchCore] Calling Purchases.logIn() to switch from anonymous to:', normalizedUserId);
+        }
+        const result = await Purchases.logIn(normalizedUserId!);
+        customerInfo = result.customerInfo;
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log('[UserSwitchCore] Purchases.logIn() successful, created:', result.created);
+        }
+      } else {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log('[UserSwitchCore] User is anonymous, fetching customer info');
+        }
+        customerInfo = await Purchases.getCustomerInfo();
+      }
+    } else {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log('[UserSwitchCore] No user switch needed, fetching current customer info');
+      }
+      customerInfo = await Purchases.getCustomerInfo();
+    }
+
+    deps.setInitialized(true);
+    deps.setCurrentUserId(normalizedUserId || undefined);
+    const offerings = await fetchOfferingsSafe();
+
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchCore] User switch completed successfully');
+    }
+
+    return buildSuccessResult(deps, customerInfo, offerings);
+  } catch (error) {
+    let currentAppUserId = 'unknown';
+    try {
+      currentAppUserId = await Purchases.getAppUserID();
+    } catch {
+      // Ignore error in error handler
+    }
+
+    console.error('[UserSwitchCore] Failed during user switch or fetch', {
+      userId,
+      currentAppUserId,
+      error
+    });
+    return FAILED_INITIALIZATION_RESULT;
+  }
+}