@umituz/react-native-subscription 2.35.18 → 2.35.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.35.18",
+  "version": "2.35.19",
   "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/UserSwitchMutex.ts

@@ -0,0 +1,79 @@
+/**
+ * UserSwitchMutex
+ * Prevents concurrent Purchases.logIn() calls that cause RevenueCat 429 errors
+ */
+
+class UserSwitchMutexImpl {
+  private activeSwitchPromise: Promise<any> | null = null;
+  private activeUserId: string | null = null;
+  private lastSwitchTime = 0;
+  private readonly MIN_SWITCH_INTERVAL_MS = 1000; // Minimum 1 second between switches
+
+  /**
+   * Acquires the lock for user switch operation
+   * Returns existing promise if a switch is in progress for the same user
+   * Waits if a switch is in progress for a different user
+   */
+  async acquire(userId: string): Promise<{ shouldProceed: boolean; existingPromise?: Promise<any> }> {
+    // If a switch is in progress for the exact same user, return the existing promise
+    if (this.activeSwitchPromise && this.activeUserId === userId) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log('[UserSwitchMutex] Switch already in progress for this user, returning existing promise');
+      }
+      return { shouldProceed: false, existingPromise: this.activeSwitchPromise };
+    }
+
+    // If a switch is in progress for a different user, wait for it to complete
+    if (this.activeSwitchPromise) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log('[UserSwitchMutex] Waiting for active switch to complete...');
+      }
+      try {
+        await this.activeSwitchPromise;
+      } catch (error) {
+        // Ignore error, just wait for completion
+      }
+
+      // Add a small delay to avoid rapid-fire requests
+      const timeSinceLastSwitch = Date.now() - this.lastSwitchTime;
+      if (timeSinceLastSwitch < this.MIN_SWITCH_INTERVAL_MS) {
+        const delayNeeded = this.MIN_SWITCH_INTERVAL_MS - timeSinceLastSwitch;
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log(`[UserSwitchMutex] Rate limiting: waiting ${delayNeeded}ms`);
+        }
+        await new Promise(resolve => setTimeout(resolve, delayNeeded));
+      }
+    }
+
+    this.activeUserId = userId;
+    return { shouldProceed: true };
+  }
+
+  /**
+   * Sets the active promise for the current switch operation
+   */
+  setPromise(promise: Promise<any>): void {
+    this.activeSwitchPromise = promise;
+    this.lastSwitchTime = Date.now();
+
+    // Clear the lock when the promise completes (success or failure)
+    promise
+      .finally(() => {
+        if (this.activeSwitchPromise === promise) {
+          this.activeSwitchPromise = null;
+          this.activeUserId = null;
+        }
+      });
+  }
+
+  /**
+   * Resets the mutex state
+   */
+  reset(): void {
+    this.activeSwitchPromise = null;
+    this.activeUserId = null;
+    this.lastSwitchTime = 0;
+  }
+}
+
+export const UserSwitchMutex = new UserSwitchMutexImpl();

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

@@ -3,6 +3,7 @@ import type { InitializeResult } from "../../../../shared/application/ports/IRev
 import type { InitializerDeps } from "./RevenueCatInitializer.types";
 import { FAILED_INITIALIZATION_RESULT } from "./initializerConstants";
 import { syncPremiumStatus } from "../../../subscription/infrastructure/utils/PremiumStatusSyncer";
+import { UserSwitchMutex } from "./UserSwitchMutex";
 
 declare const __DEV__: boolean;
 
@@ -22,6 +23,27 @@ function isAnonymousId(userId: string): boolean {
 export async function handleUserSwitch(
   deps: InitializerDeps,
   userId: string
+): Promise<InitializeResult> {
+  const mutexKey = userId || '__anonymous__';
+
+  // Acquire mutex to prevent concurrent Purchases.logIn() calls
+  const { shouldProceed, existingPromise } = await UserSwitchMutex.acquire(mutexKey);
+
+  if (!shouldProceed && existingPromise) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchHandler] Using result from active switch operation');
+    }
+    return existingPromise;
+  }
+
+  const switchOperation = performUserSwitch(deps, userId);
+  UserSwitchMutex.setPromise(switchOperation);
+  return switchOperation;
+}
+
+async function performUserSwitch(
+  deps: InitializerDeps,
+  userId: string
 ): Promise<InitializeResult> {
   try {
     const currentAppUserId = await Purchases.getAppUserID();

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

@@ -2,7 +2,12 @@ import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionM
 import { getCurrentUserId, setupAuthStateListener } from "../SubscriptionAuthListener";
 import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 
+const AUTH_STATE_DEBOUNCE_MS = 500; // Wait 500ms before processing auth state changes
+
 export async function startBackgroundInitialization(config: SubscriptionInitConfig): Promise<() => void> {
+  let debounceTimer: NodeJS.Timeout | null = null;
+  let lastUserId: string | undefined = undefined;
+
   const initializeInBackground = async (revenueCatUserId?: string): Promise<void> => {
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
       console.log('[BackgroundInitializer] initializeInBackground called with userId:', revenueCatUserId || '(undefined - anonymous)');
@@ -10,12 +15,40 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
     await SubscriptionManager.initialize(revenueCatUserId);
   };
 
+  const debouncedInitialize = (revenueCatUserId?: string): void => {
+    // Clear any pending initialization
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+
+    // If userId hasn't changed, skip
+    if (lastUserId === revenueCatUserId) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log('[BackgroundInitializer] UserId unchanged, skipping reinitialization');
+      }
+      return;
+    }
+
+    debounceTimer = setTimeout(async () => {
+      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) {
+        // Background re-initialization errors are non-critical, already logged by SubscriptionManager
+      }
+    }, AUTH_STATE_DEBOUNCE_MS);
+  };
+
   const auth = config.getFirebaseAuth();
   if (!auth) {
     throw new Error("Firebase auth is not available");
   }
 
   const initialRevenueCatUserId = getCurrentUserId(() => auth);
+  lastUserId = initialRevenueCatUserId;
 
   if (typeof __DEV__ !== 'undefined' && __DEV__) {
     console.log('[BackgroundInitializer] Initial RevenueCat userId:', initialRevenueCatUserId || '(undefined - anonymous)');
@@ -23,18 +56,12 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
 
   await initializeInBackground(initialRevenueCatUserId);
 
-  const unsubscribe = setupAuthStateListener(() => auth, async (newRevenueCatUserId) => {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      console.log('[BackgroundInitializer] Auth state listener triggered, reinitializing with userId:', newRevenueCatUserId || '(undefined - anonymous)');
-    }
-    try {
-      await initializeInBackground(newRevenueCatUserId);
-    } catch (_error) {
-      // Background re-initialization errors are non-critical, already logged by SubscriptionManager
-    }
-  });
+  const unsubscribe = setupAuthStateListener(() => auth, debouncedInitialize);
 
   return () => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
     if (unsubscribe) {
       unsubscribe();
     }