@umituz/react-native-subscription 2.37.14 → 2.37.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.37.14",
+  "version": "2.37.15",
   "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);
   };
 
@@ -75,6 +101,9 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
     if (debounceTimer) {
       clearTimeout(debounceTimer);
     }
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+    }
     if (unsubscribe) {
       unsubscribe();
     }

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;
 }