@umituz/react-native-subscription 2.31.9 → 2.31.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.31.9",
+  "version": "2.31.11",
   "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/credits/infrastructure/CreditsRepository.ts

@@ -1,5 +1,5 @@
 import { getDoc, setDoc } from "firebase/firestore";
-import { BaseRepository, type Firestore, type DocumentReference } from "@umituz/react-native-firebase";
+import { BaseRepository, serverTimestamp, type Firestore, type DocumentReference } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../core/Credits";
 import type { UserCreditsDocumentRead, PurchaseSource } from "../core/UserCreditsDocument";
 import { initializeCreditsTransaction } from "../application/CreditsInitializer";
@@ -146,7 +146,7 @@ export class CreditsRepository extends BaseRepository {
       isPremium: false,
       status: SUBSCRIPTION_STATUS.EXPIRED,
       willRenew: false,
-      expirationDate: new Date().toISOString()
+      expirationDate: serverTimestamp(),
     }, { merge: true });
   }
 }

package/src/domains/credits/presentation/useCredits.ts

@@ -44,9 +44,11 @@ export const useCredits = (): UseCreditsResult => {
       return result.data || null;
     },
     enabled: queryEnabled,
+    gcTime: 0,
+    staleTime: 0,
     refetchOnMount: "always",
-    refetchOnWindowFocus: true,
-    refetchOnReconnect: true,
+    refetchOnWindowFocus: "always",
+    refetchOnReconnect: "always",
   });
 
   const queryClient = useQueryClient();

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

@@ -40,6 +40,10 @@ export const useSubscriptionPackages = () => {
       return SubscriptionManager.getPackages();
     },
     enabled: isConfigured,
-
+    gcTime: 0,
+    staleTime: 0,
+    refetchOnMount: "always",
+    refetchOnWindowFocus: "always",
+    refetchOnReconnect: "always",
   });
 };

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

@@ -9,7 +9,8 @@ export async function fetchOfferings(deps: OfferingsFetcherDeps): Promise<Purcha
   try {
     const offerings = await Purchases.getOfferings();
     return offerings.current;
-  } catch {
+  } catch (error) {
+    console.error('[OfferingsFetcher] Failed to fetch offerings', { error });
     return null;
   }
 }

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

@@ -125,6 +125,13 @@ export async function handlePurchase(
       ? `${errorMessage} (Code: ${errorCode})`
       : errorMessage;
 
+    console.error('[PurchaseHandler] Purchase failed', {
+      productId: pkg.product.identifier,
+      userId,
+      errorCode,
+      error,
+    });
+
     throw new RevenueCatPurchaseError(
       enhancedMessage,
       pkg.product.identifier,

package/src/domains/subscription/infrastructure/services/RevenueCatService.types.ts

@@ -80,8 +80,8 @@ export class RevenueCatService implements IRevenueCatService {
         try {
             await Purchases.logOut();
             this.stateManager.setInitialized(false);
-        } catch {
-            // Ignore logout errors during reset
+        } catch (error) {
+            console.error('[RevenueCatService] Logout failed during reset', { error });
         }
     }
 }

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

@@ -40,35 +40,41 @@ export class InitializationCache {
         }
 
         // If we reach here, initialization is in progress for a different user
-        // Wait for current initialization to complete
-        return { shouldInit: false, existingPromise: this.initPromise };
+        // Don't return another user's promise - caller should retry
+        return { shouldInit: false, existingPromise: null };
     }
 
     setPromise(promise: Promise<boolean>, userId: string): void {
         this.initPromise = promise;
         this.promiseUserId = userId;
 
+        // Capture userId to prevent stale reference after catch clears promiseUserId
+        const targetUserId = userId;
+
         // Chain to mark completion and set currentUserId only on success
         promise
             .then((result) => {
-                if (result && this.promiseUserId === userId) {
-                    this.currentUserId = userId;
+                if (result && this.promiseUserId === targetUserId) {
+                    this.currentUserId = targetUserId;
                 }
                 this.promiseCompleted = true;
                 return result;
             })
-            .catch(() => {
+            .catch((error) => {
                 // On failure, clear the promise so retry is possible
-                if (this.promiseUserId === userId) {
+                if (this.promiseUserId === targetUserId) {
                     this.initPromise = null;
                     this.promiseUserId = null;
-                    this.currentUserId = null; // Clear user on failure
+                    this.currentUserId = null;
                 }
                 this.promiseCompleted = true;
+                console.error('[InitializationCache] Initialization failed', { userId: targetUserId, error });
+                // Re-throw so callers awaiting the promise see the error
+                throw error;
             })
             .finally(() => {
                 // Always release the mutex
-                if (this.promiseUserId === userId) {
+                if (this.promiseUserId === targetUserId) {
                     this.initializationInProgress = false;
                 }
             });

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

@@ -1,5 +1,5 @@
 import { useQuery, useQueryClient } from "@umituz/react-native-design-system";
-import { useEffect } from "react";
+import { useEffect, useRef } from "react";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
@@ -33,13 +33,24 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
       }
     },
     enabled: queryEnabled,
+    gcTime: 0,
+    staleTime: 0,
+    refetchOnMount: "always",
+    refetchOnWindowFocus: "always",
+    refetchOnReconnect: "always",
   });
 
-  // Clear cache on logout to prevent stale data
+  // Track previous userId to clear stale cache on logout/user switch
+  const prevUserIdRef = useRef(userId);
+
   useEffect(() => {
-    if (!isAuthenticated(userId)) {
+    const prevUserId = prevUserIdRef.current;
+    prevUserIdRef.current = userId;
+
+    // Clear previous user's cache when userId changes (logout or user switch)
+    if (prevUserId !== userId && isAuthenticated(prevUserId)) {
       queryClient.removeQueries({
-        queryKey: subscriptionStatusQueryKeys.user(userId)
+        queryKey: subscriptionStatusQueryKeys.user(prevUserId),
       });
     }
   }, [userId, queryClient]);

package/src/domains/trial/infrastructure/DeviceTrialRepository.ts

@@ -1,5 +1,5 @@
-import { doc, getDoc, setDoc } from "firebase/firestore";
-import { getFirestore, serverTimestamp, type Firestore } from "@umituz/react-native-firebase";
+import { doc } from "firebase/firestore";
+import { getFirestore, runTransaction, serverTimestamp, type Firestore, type Transaction } from "@umituz/react-native-firebase";
 import type { DeviceTrialRecord } from "../core/TrialTypes";
 
 const DEVICE_TRIALS_COLLECTION = "device_trials";
@@ -11,20 +11,34 @@ export class DeviceTrialRepository {
 
   async getRecord(deviceId: string): Promise<DeviceTrialRecord | null> {
     if (!this.db) return null;
-    const snap = await getDoc(doc(this.db, DEVICE_TRIALS_COLLECTION, deviceId));
+    const ref = doc(this.db, DEVICE_TRIALS_COLLECTION, deviceId);
+    const snap = await runTransaction(async (tx: Transaction) => {
+      return tx.get(ref);
+    });
     return snap.exists() ? snap.data() as DeviceTrialRecord : null;
   }
 
   async saveRecord(deviceId: string, data: Partial<DeviceTrialRecord>): Promise<boolean> {
     if (!this.db) return false;
     const ref = doc(this.db, DEVICE_TRIALS_COLLECTION, deviceId);
-    await setDoc(ref, { ...data, updatedAt: serverTimestamp() }, { merge: true });
-    
-    // Ensure createdAt exists
-    const snap = await getDoc(ref);
-    if (!snap.data()?.createdAt) {
-      await setDoc(ref, { createdAt: serverTimestamp() }, { merge: true });
-    }
+
+    // Atomic check-then-act: ensure createdAt is set only once
+    await runTransaction(async (tx: Transaction) => {
+      const snap = await tx.get(ref);
+      const existingData = snap.data();
+
+      const updateData: Record<string, unknown> = {
+        ...data,
+        updatedAt: serverTimestamp(),
+      };
+
+      if (!existingData?.createdAt) {
+        updateData.createdAt = serverTimestamp();
+      }
+
+      tx.set(ref, updateData, { merge: true });
+    });
+
     return true;
   }
 }

package/src/domains/wallet/presentation/hooks/useProductMetadata.ts

@@ -50,6 +50,11 @@ export function useProductMetadata({
       return service.getAll();
     },
     enabled,
+    gcTime: 0,
+    staleTime: 0,
+    refetchOnMount: "always",
+    refetchOnWindowFocus: "always",
+    refetchOnReconnect: "always",
   });
 
   const products = data ?? [];

package/src/domains/wallet/presentation/hooks/useTransactionHistory.ts

@@ -53,6 +53,11 @@ export function useTransactionHistory({
       return result.data ?? [];
     },
     enabled: !!userId,
+    gcTime: 0,
+    staleTime: 0,
+    refetchOnMount: "always",
+    refetchOnWindowFocus: "always",
+    refetchOnReconnect: "always",
   });
 
   const transactions = data ?? [];

package/src/shared/infrastructure/SubscriptionEventBus.ts

@@ -42,8 +42,8 @@ export class SubscriptionEventBus {
     this.listeners[event].forEach(callback => {
       try {
         callback(data);
-      } catch {
-        // Prevent one faulty listener from breaking other listeners
+      } catch (error) {
+        console.error('[SubscriptionEventBus] Listener error for event:', event, { error });
       }
     });
   }