@umituz/react-native-subscription 2.37.50 → 2.37.51

package/package.json

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

@@ -58,8 +58,9 @@ class SubscriptionManagerImpl {
     // Mark pending so React components know to wait
     initializationState.markPending();
 
+    const realUserId = actualUserId || null;
     const promise = this.performInitialization(actualUserId);
-    this.state.initCache.setPromise(promise, cacheKey);
+    this.state.initCache.setPromise(promise, cacheKey, realUserId);
     return promise;
   }
 

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

@@ -1,21 +1,22 @@
 export class InitializationCache {
     private initPromise: Promise<boolean> | null = null;
-    private currentUserId: string | null = null;
-    private promiseUserId: string | null = null;
+    private cacheKey: string | null = null;
+    private promiseCacheKey: string | null = null;
+    private resolvedUserId: string | null = null;
     private promiseCompleted = true;
     private pendingQueue: Map<string, Promise<boolean>> = new Map();
 
-    tryAcquireInitialization(userId: string): { shouldInit: boolean; existingPromise: Promise<boolean> | null } {
-        const queuedPromise = this.pendingQueue.get(userId);
+    tryAcquireInitialization(cacheKey: string): { shouldInit: boolean; existingPromise: Promise<boolean> | null } {
+        const queuedPromise = this.pendingQueue.get(cacheKey);
         if (queuedPromise) {
             return { shouldInit: false, existingPromise: queuedPromise };
         }
 
         if (
             this.initPromise &&
-            this.currentUserId === userId &&
+            this.cacheKey === cacheKey &&
             this.promiseCompleted &&
-            this.promiseUserId === userId
+            this.promiseCacheKey === cacheKey
         ) {
             return { shouldInit: false, existingPromise: this.initPromise };
         }
@@ -23,44 +24,47 @@ export class InitializationCache {
         return { shouldInit: true, existingPromise: null };
     }
 
-    setPromise(promise: Promise<boolean>, userId: string): void {
-        this.promiseUserId = userId;
+    setPromise(promise: Promise<boolean>, cacheKey: string, realUserId: string | null): void {
+        this.promiseCacheKey = cacheKey;
         this.promiseCompleted = false;
 
         const chain: Promise<boolean> = promise
             .then((result) => {
-                if (result && this.promiseUserId === userId) {
-                    this.currentUserId = userId;
+                if (result && this.promiseCacheKey === cacheKey) {
+                    this.cacheKey = cacheKey;
+                    this.resolvedUserId = realUserId;
                 }
                 this.promiseCompleted = true;
                 return result;
             })
             .catch((error) => {
-                if (this.promiseUserId === userId) {
+                if (this.promiseCacheKey === cacheKey) {
                     this.initPromise = null;
-                    this.promiseUserId = null;
-                    this.currentUserId = null;
+                    this.promiseCacheKey = null;
+                    this.cacheKey = null;
+                    this.resolvedUserId = null;
                 }
                 this.promiseCompleted = true;
-                console.error('[InitializationCache] Initialization failed', { userId, error });
+                console.error('[InitializationCache] Initialization failed', { cacheKey, error });
                 return false;
             })
             .finally(() => {
-                this.pendingQueue.delete(userId);
+                this.pendingQueue.delete(cacheKey);
             });
 
         this.initPromise = chain;
-        this.pendingQueue.set(userId, chain);
+        this.pendingQueue.set(cacheKey, chain);
     }
 
     getCurrentUserId(): string | null {
-        return this.currentUserId;
+        return this.resolvedUserId;
     }
 
     reset(): void {
         this.initPromise = null;
-        this.currentUserId = null;
-        this.promiseUserId = null;
+        this.cacheKey = null;
+        this.promiseCacheKey = null;
+        this.resolvedUserId = null;
         this.promiseCompleted = true;
         this.pendingQueue.clear();
     }