@umituz/react-native-subscription 2.35.22 → 2.35.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.35.22",
+  "version": "2.35.24",
   "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/revenuecat/infrastructure/services/ConfigurationStateManager.ts

@@ -3,6 +3,7 @@ import type { InitializeResult } from "../../../../shared/application/ports/IRev
 export class ConfigurationStateManager {
   private _isPurchasesConfigured = false;
   private _configurationPromise: Promise<InitializeResult> | null = null;
+  private _resolveConfiguration: ((value: InitializeResult) => void) | null = null;
 
   get isPurchasesConfigured(): boolean {
     return this._isPurchasesConfigured;
@@ -21,16 +22,17 @@ export class ConfigurationStateManager {
       throw new Error('Configuration already in progress');
     }
 
-    let capturedResolve: ((value: InitializeResult) => void) | null = null;
-
-    this._configurationPromise = new Promise((resolve) => {
-      capturedResolve = resolve;
+    // Create promise and store resolve function atomically
+    this._configurationPromise = new Promise<InitializeResult>((resolve) => {
+      this._resolveConfiguration = resolve;
     });
 
+    // Return resolve function
     return (value: InitializeResult) => {
-      if (capturedResolve) {
-        capturedResolve(value);
-        capturedResolve = null;
+      if (this._resolveConfiguration) {
+        const resolve = this._resolveConfiguration;
+        this._resolveConfiguration = null;
+        resolve(value);
       }
     };
   }
@@ -38,18 +40,22 @@ export class ConfigurationStateManager {
   completeConfiguration(success: boolean): void {
     this._isPurchasesConfigured = success;
 
-    if (success) {
+    // Cleanup promise state immediately (no setTimeout)
+    // If promise hasn't resolved yet, that's fine - it will still resolve via the callback
+    if (this._configurationPromise) {
       this._configurationPromise = null;
-    } else {
-      setTimeout(() => {
-        this._configurationPromise = null;
-      }, 1000);
+    }
+
+    // Clear resolve function if it still exists
+    if (this._resolveConfiguration) {
+      this._resolveConfiguration = null;
     }
   }
 
   reset(): void {
     this._isPurchasesConfigured = false;
     this._configurationPromise = null;
+    this._resolveConfiguration = null;
   }
 }
 

package/src/domains/revenuecat/infrastructure/services/RevenueCatInitializer.types.ts

@@ -5,5 +5,5 @@ export interface InitializerDeps {
   isInitialized: () => boolean;
   getCurrentUserId: () => string | null;
   setInitialized: (value: boolean) => void;
-  setCurrentUserId: (userId: string | undefined) => void;
+  setCurrentUserId: (userId: string | null | undefined) => void;
 }

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

@@ -2,8 +2,8 @@ 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 { syncPremiumStatus } from "../../../subscription/infrastructure/utils/PremiumStatusSyncer";
 import { UserSwitchMutex } from "./UserSwitchMutex";
+import { getPremiumEntitlement } from "../../core/types";
 
 declare const __DEV__: boolean;
 
@@ -151,7 +151,38 @@ export async function handleInitialConfiguration(
       });
     }
 
-    await syncPremiumStatus(deps.config, currentUserId, customerInfo);
+    // Sync premium status via callback (if configured)
+    if (deps.config.onPremiumStatusChanged) {
+      try {
+        const premiumEntitlement = getPremiumEntitlement(
+          customerInfo,
+          deps.config.entitlementIdentifier
+        );
+
+        if (premiumEntitlement) {
+          await deps.config.onPremiumStatusChanged(
+            currentUserId,
+            true,
+            premiumEntitlement.productIdentifier,
+            premiumEntitlement.expirationDate ?? undefined,
+            premiumEntitlement.willRenew,
+            premiumEntitlement.periodType as "NORMAL" | "INTRO" | "TRIAL" | undefined
+          );
+        } else {
+          await deps.config.onPremiumStatusChanged(
+            currentUserId,
+            false,
+            undefined,
+            undefined,
+            undefined,
+            undefined
+          );
+        }
+      } catch (error) {
+        // Log error but don't fail initialization
+        console.error('[UserSwitchHandler] Premium status sync callback failed:', error);
+      }
+    }
 
     return buildSuccessResult(deps, customerInfo, offerings);
   } catch (error) {

package/src/domains/subscription/application/initializer/BackgroundInitializer.ts

@@ -36,8 +36,12 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
       try {
         await initializeInBackground(revenueCatUserId);
         lastUserId = revenueCatUserId;
-      } catch (_error) {
+      } catch (error) {
         // Background re-initialization errors are non-critical, already logged by SubscriptionManager
+        console.error('[BackgroundInitializer] Reinitialization failed:', {
+          userId: revenueCatUserId,
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }, AUTH_STATE_DEBOUNCE_MS);
   };

package/src/domains/subscription/infrastructure/hooks/customer-info/useCustomerInfo.ts

@@ -1,57 +1,52 @@
-import { useEffect, useState, useCallback, useRef } from "react";
-import Purchases, { type CustomerInfo } from "react-native-purchases";
+/**
+ * Customer Info Hook
+ * Fetches customer info without registering a listener
+ * CustomerInfoListenerManager handles all listener logic
+ */
+
+import { useQuery, useQueryClient } from "@umituz/react-native-design-system";
+import { useEffect, useRef } from "react";
+import Purchases from "react-native-purchases";
 import type { UseCustomerInfoResult } from "./types";
+import { SUBSCRIPTION_QUERY_KEYS } from "../subscriptionQueryKeys";
 
 export function useCustomerInfo(): UseCustomerInfoResult {
-  const [customerInfo, setCustomerInfo] = useState<CustomerInfo | null>(null);
-  const [loading, setLoading] = useState(true);
-  const [isFetching, setIsFetching] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const fetchCustomerInfo = useCallback(async () => {
-    try {
-      setIsFetching(true);
-      setError(null);
-
-      const info = await Purchases.getCustomerInfo();
-
-      setCustomerInfo(info);
-    } catch (err) {
-      const errorMessage =
-        err instanceof Error ? err.message : "Failed to fetch customer info";
-      setError(errorMessage);
-    } finally {
-      setLoading(false);
-      setIsFetching(false);
-    }
-  }, []);
-
-  const listenerRef = useRef<((info: CustomerInfo) => void) | null>(null);
+  const queryClient = useQueryClient();
+  const mountedRef = useRef(true);
 
   useEffect(() => {
-    fetchCustomerInfo();
-
-    const listener = (info: CustomerInfo) => {
-      setCustomerInfo(info);
-      setError(null);
-    };
-
-    listenerRef.current = listener;
-    Purchases.addCustomerInfoUpdateListener(listener);
-
+    mountedRef.current = true;
     return () => {
-      if (listenerRef.current) {
-        Purchases.removeCustomerInfoUpdateListener(listenerRef.current);
-        listenerRef.current = null;
-      }
+      mountedRef.current = false;
     };
-  }, [fetchCustomerInfo]); // fetchCustomerInfo is stable (empty deps), included for lint
+  }, []);
+
+  const query = useQuery({
+    queryKey: SUBSCRIPTION_QUERY_KEYS.customerInfo,
+    queryFn: async () => {
+      const info = await Purchases.getCustomerInfo();
+      return info;
+    },
+    staleTime: 30 * 1000, // 30 seconds
+    gcTime: 5 * 60 * 1000, // 5 minutes
+    refetchOnMount: true,
+    refetchOnWindowFocus: false,
+    retry: 2,
+  });
+
+  // Expose refetch as a method
+  const refetch = async () => {
+    if (!mountedRef.current) return;
+    await queryClient.invalidateQueries({
+      queryKey: SUBSCRIPTION_QUERY_KEYS.customerInfo,
+    });
+  };
 
   return {
-    customerInfo,
-    loading,
-    error,
-    refetch: fetchCustomerInfo,
-    isFetching,
+    customerInfo: query.data ?? null,
+    loading: query.isLoading,
+    error: query.error?.message ?? null,
+    refetch,
+    isFetching: query.isFetching,
   };
 }

package/src/domains/subscription/infrastructure/hooks/subscriptionQueryKeys.ts

@@ -13,6 +13,7 @@ export const SUBSCRIPTION_QUERY_KEYS = {
   packages: ["subscription", "packages"] as const,
   initialized: (userId: string) =>
     ["subscription", "initialized", userId] as const,
+  customerInfo: ["subscription", "customerInfo"] as const,
 } as const;
 
 

package/src/domains/subscription/infrastructure/hooks/useSubscriptionPackages.ts

@@ -26,22 +26,19 @@ export const useSubscriptionPackages = () => {
   const queryClient = useQueryClient();
   const prevUserIdRef = useRef(userId);
 
+  // Check if initialized (BackgroundInitializer handles initialization)
+  const isInitialized = userId
+    ? SubscriptionManager.isInitializedForUser(userId)
+    : SubscriptionManager.isInitialized();
+
   const query = useQuery({
     queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, userId ?? "anonymous"] as const,
     queryFn: async () => {
-      if (userId) {
-        if (!SubscriptionManager.isInitializedForUser(userId)) {
-          await SubscriptionManager.initialize(userId);
-        }
-      } else {
-        if (!SubscriptionManager.isInitialized()) {
-          await SubscriptionManager.initialize(undefined);
-        }
-      }
-
+      // No side effects - just fetch packages
+      // Initialization is handled by BackgroundInitializer
       return SubscriptionManager.getPackages();
     },
-    enabled: isConfigured,
+    enabled: isConfigured && isInitialized,
     gcTime: 5 * 60 * 1000,
     staleTime: 2 * 60 * 1000,
     refetchOnMount: true,

package/src/domains/subscription/infrastructure/services/listeners/CustomerInfoHandler.ts

@@ -14,8 +14,13 @@ async function handleRenewal(
 
   try {
     await onRenewalDetected(userId, productId, expirationDate, customerInfo);
-  } catch (_error) {
+  } catch (error) {
     // Callback errors should not break customer info processing
+    console.error('[CustomerInfoHandler] Renewal callback failed:', {
+      userId,
+      productId,
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
 }
 
@@ -31,8 +36,15 @@ async function handlePlanChange(
 
   try {
     await onPlanChanged(userId, newProductId, previousProductId, isUpgrade, customerInfo);
-  } catch (_error) {
+  } catch (error) {
     // Callback errors should not break customer info processing
+    console.error('[CustomerInfoHandler] Plan change callback failed:', {
+      userId,
+      newProductId,
+      previousProductId,
+      isUpgrade,
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
 }
 
@@ -43,8 +55,12 @@ async function handlePremiumStatusSync(
 ): Promise<void> {
   try {
     await syncPremiumStatus(config, userId, customerInfo);
-  } catch (_error) {
+  } catch (error) {
     // Sync errors are logged by PremiumStatusSyncer, don't break processing
+    console.error('[CustomerInfoHandler] Premium status sync failed:', {
+      userId,
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
 }
 

package/src/domains/subscription/infrastructure/utils/InitializationCache.ts

@@ -1,52 +1,51 @@
 /**
  * Initialization Cache
  * Manages promise caching and user state for initialization
- * Thread-safe: Uses mutex pattern to prevent race conditions
+ * Thread-safe: Uses atomic promise-based locking pattern
  */
 
 export class InitializationCache {
     private initPromise: Promise<boolean> | null = null;
     private currentUserId: string | null = null;
-    // Mutex to prevent race condition during initialization
-    private initializationInProgress = false;
-    // Track which userId the promise is for (separate from currentUserId which is set after completion)
+    // Track which userId the promise is for
     private promiseUserId: string | null = null;
-    // Track promise completion state to avoid returning failed promises
+    // Track promise completion state
     private promiseCompleted = true;
+    // Pending initialization queue
+    private pendingQueue: Map<string, Promise<boolean>> = new Map();
 
     /**
      * Atomically check if reinitialization is needed AND reserve the slot
      * Returns: { shouldInit: boolean, existingPromise: Promise | null }
      */
     tryAcquireInitialization(userId: string): { shouldInit: boolean; existingPromise: Promise<boolean> | null } {
-        // If initialization is in progress for the same user, return existing promise
-        if (this.initializationInProgress && this.promiseUserId === userId && this.initPromise) {
-            return { shouldInit: false, existingPromise: this.initPromise };
+        // Check if there's already a pending promise for this user in the queue
+        const queuedPromise = this.pendingQueue.get(userId);
+        if (queuedPromise) {
+            return { shouldInit: false, existingPromise: queuedPromise };
         }
 
-        // If already initialized for this user and promise completed successfully, return it
-        // Only return cached promise if it completed AND it's for the same user
-        if (this.initPromise && this.currentUserId === userId && !this.initializationInProgress && this.promiseCompleted) {
+        // If already initialized for this user and promise completed successfully
+        if (
+            this.initPromise &&
+            this.currentUserId === userId &&
+            this.promiseCompleted &&
+            this.promiseUserId === userId
+        ) {
             return { shouldInit: false, existingPromise: this.initPromise };
         }
 
-        // Different user, no initialization, or failed promise - need to reinitialize
-        // Atomically set the flag and clear previous state if needed
-        if (!this.initializationInProgress) {
-            this.initializationInProgress = true;
-            this.promiseUserId = userId;
-            this.promiseCompleted = false;
-            return { shouldInit: true, existingPromise: null };
-        }
-
-        // If we reach here, initialization is in progress for a different user
-        // Don't return another user's promise - caller should retry
-        return { shouldInit: false, existingPromise: null };
+        // Different user or not initialized - need to initialize
+        return { shouldInit: true, existingPromise: null };
     }
 
     setPromise(promise: Promise<boolean>, userId: string): void {
+        // Add to pending queue immediately (atomic operation)
+        this.pendingQueue.set(userId, promise);
+
         this.initPromise = promise;
         this.promiseUserId = userId;
+        this.promiseCompleted = false;
 
         const targetUserId = userId;
 
@@ -69,9 +68,8 @@ export class InitializationCache {
                 return false;
             })
             .finally(() => {
-                if (this.initializationInProgress) {
-                    this.initializationInProgress = false;
-                }
+                // Remove from queue when complete
+                this.pendingQueue.delete(targetUserId);
             });
     }
 
@@ -82,8 +80,8 @@ export class InitializationCache {
     reset(): void {
         this.initPromise = null;
         this.currentUserId = null;
-        this.initializationInProgress = false;
         this.promiseUserId = null;
         this.promiseCompleted = true;
+        this.pendingQueue.clear();
     }
 }

package/src/domains/subscription/infrastructure/utils/PremiumStatusSyncer.ts

@@ -46,6 +46,10 @@ export async function syncPremiumStatus(
         }
         return { success: true };
     } catch (error) {
+        console.error('[PremiumStatusSyncer] Premium status callback failed:', {
+            userId,
+            error: error instanceof Error ? error.message : String(error)
+        });
 
         return {
             success: false,
@@ -68,8 +72,13 @@ export async function notifyPurchaseCompleted(
 
     try {
         await config.onPurchaseCompleted(userId, productId, customerInfo, source, packageType);
-    } catch (_error) {
+    } catch (error) {
         // Silently fail callback notifications to prevent crashing the main flow
+        console.error('[PremiumStatusSyncer] Purchase completed callback failed:', {
+            userId,
+            productId,
+            error: error instanceof Error ? error.message : String(error)
+        });
     }
 }
 

package/src/domains/subscription/presentation/useFeatureGate.ts

@@ -25,7 +25,6 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
   const { creditBalanceRef, hasSubscriptionRef, onShowPaywallRef, requiredCreditsRef, isCreditsLoadedRef } = useSyncedRefs(creditBalance, hasSubscription, onShowPaywall, requiredCredits, isCreditsLoaded);
 
   useEffect(() => {
-
     const shouldExecute = canExecuteAuthAction(
       isWaitingForAuthCreditsRef.current,
       isCreditsLoaded,
@@ -46,9 +45,11 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
     if (isWaitingForAuthCreditsRef.current && isCreditsLoaded && pendingActionRef.current) {
       isWaitingForAuthCreditsRef.current = false;
       isWaitingForPurchaseRef.current = true;
-      onShowPaywall(requiredCredits);
+      // Use ref to avoid unstable callback dependency
+      onShowPaywallRef.current(requiredCreditsRef.current);
     }
-  }, [isCreditsLoaded, creditBalance, hasSubscription, requiredCredits, onShowPaywall]);
+    // Removed onShowPaywall from dependencies - using ref instead
+  }, [isCreditsLoaded, creditBalance, hasSubscription, requiredCredits, onShowPaywallRef, requiredCreditsRef]);
 
   useEffect(() => {
 

package/src/domains/subscription/presentation/useSubscriptionStatus.ts

@@ -19,7 +19,9 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
   const queryClient = useQueryClient();
   const isConfigured = SubscriptionManager.isConfigured();
 
-  const queryEnabled = isAuthenticated(userId) && isConfigured;
+  // Check if initialized (BackgroundInitializer handles initialization)
+  const isInitialized = userId ? SubscriptionManager.isInitializedForUser(userId) : false;
+  const queryEnabled = isAuthenticated(userId) && isConfigured && isInitialized;
 
   const { data, status, error, refetch } = useQuery({
     queryKey: subscriptionStatusQueryKeys.user(userId),
@@ -28,10 +30,8 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
         return null;
       }
 
-      if (!SubscriptionManager.isInitializedForUser(userId)) {
-        await SubscriptionManager.initialize(userId);
-      }
-
+      // No side effects - just check premium status
+      // Initialization is handled by BackgroundInitializer
       try {
         const result = await SubscriptionManager.checkPremiumStatus();
         return result;