@umituz/react-native-subscription 2.27.30 → 2.27.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.30",
+  "version": "2.27.31",
   "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/revenuecat/infrastructure/managers/SubscriptionManager.ts

@@ -64,9 +64,11 @@ class SubscriptionManagerImpl {
 
     const effectiveUserId = userId || (await this.userIdProvider.getOrCreateAnonymousUserId());
 
-    if (!this.initCache.shouldReinitialize(effectiveUserId)) {
-      const existingPromise = this.initCache.getExistingPromise();
-      if (existingPromise) return existingPromise;
+    // Atomic check-and-acquire to prevent race conditions
+    const { shouldInit, existingPromise } = this.initCache.tryAcquireInitialization(effectiveUserId);
+
+    if (!shouldInit && existingPromise) {
+      return existingPromise;
     }
 
     const promise = this.performInitialization(effectiveUserId);

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

@@ -20,6 +20,8 @@ export interface InitializerDeps {
 
 let isPurchasesConfigured = false;
 let isLogHandlerConfigured = false;
+// Mutex to prevent concurrent configuration
+let configurationInProgress = false;
 
 function configureLogHandler(): void {
     if (isLogHandlerConfigured) return;
@@ -97,12 +99,26 @@ export async function initializeSDK(
     }
 
     // Case 3: First time configuration
+    // Check mutex to prevent double configuration
+    if (configurationInProgress) {
+        // Wait a bit and retry - another thread is configuring
+        await new Promise(resolve => setTimeout(resolve, 100));
+        // After waiting, isPurchasesConfigured should be true
+        if (isPurchasesConfigured) {
+            return initializeSDK(deps, userId, apiKey);
+        }
+        return { success: false, offering: null, hasPremium: false };
+    }
+
     const key = apiKey || resolveApiKey(deps.config);
 
     if (!key) {
         return { success: false, offering: null, hasPremium: false };
     }
 
+    // Acquire mutex
+    configurationInProgress = true;
+
     try {
         configureLogHandler();
 
@@ -123,5 +139,8 @@ export async function initializeSDK(
     } catch (error) {
         getErrorMessage(error, "RevenueCat init failed");
         return { success: false, offering: null, hasPremium: false };
+    } finally {
+        // Release mutex
+        configurationInProgress = false;
     }
 }

package/src/revenuecat/infrastructure/utils/InitializationCache.ts

@@ -1,12 +1,43 @@
 /**
  * Initialization Cache
  * Manages promise caching and user state for initialization
+ * Thread-safe: Uses mutex pattern to prevent race conditions
  */
 
 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)
+    private promiseUserId: string | null = null;
 
+    /**
+     * 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 };
+        }
+
+        // If already initialized for this user and promise resolved successfully, return it
+        if (this.initPromise && this.currentUserId === userId && !this.initializationInProgress) {
+            return { shouldInit: false, existingPromise: this.initPromise };
+        }
+
+        // Different user or no initialization - need to reinitialize
+        // Atomically set the flag
+        this.initializationInProgress = true;
+        this.promiseUserId = userId;
+
+        return { shouldInit: true, existingPromise: null };
+    }
+
+    /**
+     * @deprecated Use tryAcquireInitialization instead for atomic operations
+     */
     shouldReinitialize(userId: string): boolean {
         if (!this.initPromise) {
             return true;
@@ -19,13 +50,38 @@ export class InitializationCache {
         return false;
     }
 
+    /**
+     * @deprecated Use tryAcquireInitialization instead for atomic operations
+     */
     getExistingPromise(): Promise<boolean> | null {
         return this.initPromise;
     }
 
     setPromise(promise: Promise<boolean>, userId: string): void {
         this.initPromise = promise;
-        this.currentUserId = userId;
+        this.promiseUserId = userId;
+
+        // Chain to mark completion and set currentUserId only on success
+        promise
+            .then((result) => {
+                if (result && this.promiseUserId === userId) {
+                    this.currentUserId = userId;
+                }
+                return result;
+            })
+            .catch(() => {
+                // On failure, clear the promise so retry is possible
+                if (this.promiseUserId === userId) {
+                    this.initPromise = null;
+                    this.promiseUserId = null;
+                }
+            })
+            .finally(() => {
+                // Always release the mutex
+                if (this.promiseUserId === userId) {
+                    this.initializationInProgress = false;
+                }
+            });
     }
 
     getCurrentUserId(): string | null {
@@ -35,5 +91,7 @@ export class InitializationCache {
     reset(): void {
         this.initPromise = null;
         this.currentUserId = null;
+        this.initializationInProgress = false;
+        this.promiseUserId = null;
     }
 }