@umituz/react-native-subscription 2.37.14 → 2.37.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.37.14",
+  "version": "2.37.16",
   "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

@@ -19,7 +19,13 @@ class ConfigurationStateManager {
 
   startConfiguration(): (value: InitializeResult) => void {
     if (this._configurationPromise) {
-      throw new Error('Configuration already in progress');
+      // Resolve previous pending configuration as failed to prevent dangling promises
+      if (this._resolveConfiguration) {
+        const prevResolve = this._resolveConfiguration;
+        this._resolveConfiguration = null;
+        prevResolve({ success: false, offering: null, isPremium: false });
+      }
+      this._configurationPromise = null;
     }
 
     // Create promise and store resolve function atomically

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

@@ -3,10 +3,14 @@ import { getCurrentUserId, setupAuthStateListener } from "../SubscriptionAuthLis
 import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 
 const AUTH_STATE_DEBOUNCE_MS = 500; // Wait 500ms before processing auth state changes
+const MAX_RETRY_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 2000;
 
 export async function startBackgroundInitialization(config: SubscriptionInitConfig): Promise<() => void> {
   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
+  let retryTimer: ReturnType<typeof setTimeout> | null = null;
   let lastUserId: string | undefined = undefined;
+  let lastInitSucceeded = false;
 
   const initializeInBackground = async (revenueCatUserId?: string): Promise<void> => {
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
@@ -15,16 +19,49 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
     await SubscriptionManager.initialize(revenueCatUserId);
   };
 
+  const attemptInitWithRetry = async (revenueCatUserId?: string, attempt = 0): Promise<void> => {
+    try {
+      await initializeInBackground(revenueCatUserId);
+      lastUserId = revenueCatUserId;
+      lastInitSucceeded = true;
+    } catch (error) {
+      lastInitSucceeded = false;
+      console.error('[BackgroundInitializer] Initialization failed:', {
+        userId: revenueCatUserId,
+        attempt: attempt + 1,
+        maxAttempts: MAX_RETRY_ATTEMPTS,
+        error: error instanceof Error ? error.message : String(error)
+      });
+
+      if (attempt < MAX_RETRY_ATTEMPTS - 1) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log('[BackgroundInitializer] Scheduling retry', { attempt: attempt + 2 });
+        }
+        retryTimer = setTimeout(() => {
+          void attemptInitWithRetry(revenueCatUserId, attempt + 1);
+        }, RETRY_DELAY_MS * (attempt + 1));
+      } else {
+        // After all retries failed, set lastUserId so we don't block
+        // but mark as failed so next auth change can retry
+        lastUserId = revenueCatUserId;
+      }
+    }
+  };
+
   const debouncedInitialize = (revenueCatUserId?: string): void => {
-    // Clear any pending initialization
+    // Clear any pending initialization or retry
     if (debounceTimer) {
       clearTimeout(debounceTimer);
     }
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      retryTimer = null;
+    }
 
-    // If userId hasn't changed, skip
-    if (lastUserId === revenueCatUserId) {
+    // If userId hasn't changed AND last init succeeded, skip
+    if (lastUserId === revenueCatUserId && lastInitSucceeded) {
       if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        console.log('[BackgroundInitializer] UserId unchanged, skipping reinitialization');
+        console.log('[BackgroundInitializer] UserId unchanged and init succeeded, skipping');
       }
       return;
     }
@@ -33,18 +70,7 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
       if (typeof __DEV__ !== 'undefined' && __DEV__) {
         console.log('[BackgroundInitializer] Auth state listener triggered, reinitializing with userId:', revenueCatUserId || '(undefined - anonymous)');
       }
-      try {
-        await initializeInBackground(revenueCatUserId);
-        lastUserId = revenueCatUserId;
-      } catch (error) {
-        // Don't update lastUserId on failure — allow retry on next auth state change
-        // with the same userId (e.g., network blip recovers)
-        lastUserId = undefined;
-        console.error('[BackgroundInitializer] Reinitialization failed:', {
-          userId: revenueCatUserId,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
+      void attemptInitWithRetry(revenueCatUserId);
     }, AUTH_STATE_DEBOUNCE_MS);
   };
 
@@ -65,6 +91,7 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
   // This prevents a Firestore permission-denied error from querying with an anonymous ID.
   if (initialRevenueCatUserId) {
     await initializeInBackground(initialRevenueCatUserId);
+    lastInitSucceeded = true;
   } else if (typeof __DEV__ !== 'undefined' && __DEV__) {
     console.log('[BackgroundInitializer] Skipping anonymous init, waiting for auth state');
   }
@@ -75,6 +102,9 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
     if (debounceTimer) {
       clearTimeout(debounceTimer);
     }
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+    }
     if (unsubscribe) {
       unsubscribe();
     }

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

@@ -5,12 +5,13 @@
  */
 
 import { useQuery, useQueryClient } from "@umituz/react-native-design-system";
-import { useEffect, useRef } from "react";
+import { useEffect, useRef, useSyncExternalStore } from "react";
 import {
   useAuthStore,
   selectUserId,
 } from "@umituz/react-native-auth";
 import { SubscriptionManager } from '../../infrastructure/managers/SubscriptionManager';
+import { initializationState } from "../../infrastructure/state/initializationState";
 import {
   SUBSCRIPTION_QUERY_KEYS,
 } from "./subscriptionQueryKeys";
@@ -26,10 +27,18 @@ export const useSubscriptionPackages = () => {
   const queryClient = useQueryClient();
   const prevUserIdRef = useRef(userId);
 
-  // Check if initialized (BackgroundInitializer handles initialization)
+  // Reactive initialization state - triggers re-render when BackgroundInitializer completes
+  const initState = useSyncExternalStore(
+    initializationState.subscribe,
+    initializationState.getSnapshot,
+    initializationState.getSnapshot,
+  );
+
+  // For authenticated users: check reactive state matches current userId
+  // For anonymous users: check if initialized at all (reactive state or manager state)
   const isInitialized = userId
-    ? SubscriptionManager.isInitializedForUser(userId)
-    : SubscriptionManager.isInitialized();
+    ? initState.initialized && initState.userId === userId
+    : initState.initialized || SubscriptionManager.isInitialized();
 
   const query = useQuery({
     queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, userId ?? "anonymous"] as const,

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -8,6 +8,7 @@ import { createPackageHandler } from "./packageHandlerFactory";
 import { checkPremiumStatusFromService } from "./premiumStatusChecker";
 import { getPackagesOperation, purchasePackageOperation, restoreOperation } from "./managerOperations";
 import { performServiceInitialization } from "./initializationHandler";
+import { initializationState } from "../state/initializationState";
 
 class SubscriptionManagerImpl {
   private managerConfig: SubscriptionManagerConfig | null = null;
@@ -52,6 +53,9 @@ class SubscriptionManagerImpl {
       return existingPromise;
     }
 
+    // Mark pending so React components know to wait
+    initializationState.markPending();
+
     const promise = this.performInitialization(actualUserId);
     this.state.initCache.setPromise(promise, cacheKey);
     return promise;
@@ -70,6 +74,12 @@ class SubscriptionManagerImpl {
     this.serviceInstance = service ?? null;
     this.ensurePackageHandlerInitialized();
 
+    if (success) {
+      // Notify reactive state so React components re-render and enable their queries
+      const notifyUserId = (userId && userId.length > 0) ? userId : null;
+      initializationState.markInitialized(notifyUserId);
+    }
+
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
       console.log('[SubscriptionManager] Initialization completed:', { success });
     }
@@ -111,6 +121,7 @@ class SubscriptionManagerImpl {
     this.state.reset();
     this.serviceInstance = null;
     this.packageHandler = null;
+    initializationState.reset();
   }
 
   isConfigured = (): boolean => this.managerConfig !== null;

package/src/domains/subscription/infrastructure/services/OfferingsFetcher.ts

@@ -4,31 +4,59 @@ interface OfferingsFetcherDeps {
   isInitialized: () => boolean;
 }
 
+const MAX_FETCH_RETRIES = 2;
+const FETCH_RETRY_DELAY_MS = 1500;
+
 export async function fetchOfferings(deps: OfferingsFetcherDeps): Promise<PurchasesOffering | null> {
   if (!deps.isInitialized()) return null;
-  try {
-    const offerings = await Purchases.getOfferings();
-
-    if (__DEV__) {
-      console.log('[OfferingsFetcher] Offerings received:', {
-        hasCurrent: !!offerings.current,
-        currentId: offerings.current?.identifier,
-        allOfferingsCount: Object.keys(offerings.all).length,
-        allOfferingIds: Object.keys(offerings.all),
-      });
-    }
 
-    if (offerings.current) {
-      return offerings.current;
-    }
+  for (let attempt = 0; attempt <= MAX_FETCH_RETRIES; attempt++) {
+    try {
+      const offerings = await Purchases.getOfferings();
 
-    const allOfferings = Object.values(offerings.all);
-    if (allOfferings.length > 0) {
-      return allOfferings[0];
-    }
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log('[OfferingsFetcher] Offerings received:', {
+          attempt,
+          hasCurrent: !!offerings.current,
+          currentId: offerings.current?.identifier,
+          allOfferingsCount: Object.keys(offerings.all).length,
+          allOfferingIds: Object.keys(offerings.all),
+        });
+      }
+
+      if (offerings.current) {
+        return offerings.current;
+      }
 
-    return null;
-  } catch (error) {
-    throw new Error(`Failed to fetch offerings: ${error instanceof Error ? error.message : "Unknown error"}`);
+      const allOfferings = Object.values(offerings.all);
+      if (allOfferings.length > 0) {
+        return allOfferings[0];
+      }
+
+      // No offerings found - retry after delay (RevenueCat may still be syncing)
+      if (attempt < MAX_FETCH_RETRIES) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log('[OfferingsFetcher] No offerings found, retrying...', { attempt: attempt + 1 });
+        }
+        await new Promise<void>(resolve => setTimeout(resolve, FETCH_RETRY_DELAY_MS));
+        continue;
+      }
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn('[OfferingsFetcher] No offerings found after all retries');
+      }
+      return null;
+    } catch (error) {
+      if (attempt < MAX_FETCH_RETRIES) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn('[OfferingsFetcher] Fetch failed, retrying...', { attempt: attempt + 1, error });
+        }
+        await new Promise<void>(resolve => setTimeout(resolve, FETCH_RETRY_DELAY_MS));
+        continue;
+      }
+      throw new Error(`Failed to fetch offerings: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
+
+  return null;
 }

package/src/domains/subscription/infrastructure/state/initializationState.ts

@@ -0,0 +1,66 @@
+/**
+ * Reactive Initialization State
+ * Uses useSyncExternalStore pattern to make SubscriptionManager
+ * initialization state reactive for React components.
+ *
+ * Problem: SubscriptionManager.isInitializedForUser() is a plain method call.
+ * When BackgroundInitializer completes (500ms+ after auth), React components
+ * don't re-render because there's no reactive state change.
+ *
+ * Solution: This module provides a subscribe/getSnapshot interface that
+ * React's useSyncExternalStore can use to trigger re-renders when
+ * initialization completes.
+ */
+
+type Listener = () => void;
+
+interface InitState {
+  initialized: boolean;
+  userId: string | null;
+}
+
+let state: InitState = { initialized: false, userId: null };
+const listeners = new Set<Listener>();
+
+const notifyListeners = (): void => {
+  listeners.forEach((listener) => listener());
+};
+
+export const initializationState = {
+  subscribe: (listener: Listener): (() => void) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  },
+
+  getSnapshot: (): InitState => state,
+
+  /**
+   * Called by SubscriptionManager after successful initialization.
+   * Triggers re-render in all subscribed React components.
+   */
+  markInitialized: (userId: string | null): void => {
+    state = { initialized: true, userId };
+    notifyListeners();
+  },
+
+  /**
+   * Called when initialization starts for a new user (e.g., user switch).
+   * Resets the state so queries know they need to wait.
+   */
+  markPending: (): void => {
+    state = { initialized: false, userId: null };
+    notifyListeners();
+  },
+
+  /**
+   * Check if initialized for a specific user.
+   */
+  isInitializedForUser: (userId: string | null): boolean => {
+    return state.initialized && state.userId === userId;
+  },
+
+  reset: (): void => {
+    state = { initialized: false, userId: null };
+    notifyListeners();
+  },
+};

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

@@ -1,7 +1,8 @@
 import { useQuery, useQueryClient } from "@umituz/react-native-design-system";
-import { useEffect } from "react";
+import { useEffect, useSyncExternalStore } from "react";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
+import { initializationState } from "../infrastructure/state/initializationState";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 import { SubscriptionStatusResult } from "./useSubscriptionStatus.types";
 import { isAuthenticated } from "../utils/authGuards";
@@ -19,8 +20,18 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
   const queryClient = useQueryClient();
   const isConfigured = SubscriptionManager.isConfigured();
 
-  // Check if initialized (BackgroundInitializer handles initialization)
-  const isInitialized = userId ? SubscriptionManager.isInitializedForUser(userId) : false;
+  // Reactive initialization state - triggers re-render when BackgroundInitializer completes
+  const initState = useSyncExternalStore(
+    initializationState.subscribe,
+    initializationState.getSnapshot,
+    initializationState.getSnapshot,
+  );
+
+  // Check if initialized for this specific user (reactive)
+  const isInitialized = userId
+    ? initState.initialized && initState.userId === userId
+    : false;
+
   const queryEnabled = isAuthenticated(userId) && isConfigured && isInitialized;
 
   const { data, status, error, refetch } = useQuery({
@@ -84,7 +95,3 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
     refetch,
   };
 };
-
-
-
-