@umituz/react-native-subscription 2.24.1 → 2.24.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.24.1",
+  "version": "2.24.3",
   "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/presentation/hooks/useCredits.ts

@@ -5,8 +5,6 @@
  * Generic and reusable - uses config from module-level provider.
  */
 
-declare const __DEV__: boolean;
-
 import { useQuery } from "@umituz/react-native-design-system";
 import { useCallback, useMemo } from "react";
 import type { UserCredits } from "../../domain/entities/Credits";
@@ -65,37 +63,23 @@ export const useCredits = ({
 
   const queryEnabled = enabled && !!userId && isConfigured;
 
-  if (__DEV__) {
-    console.log("[useCredits] Query state:", {
-      userId: userId?.slice(0, 8),
-      enabled,
-      isConfigured,
-      queryEnabled,
-    });
-  }
-
   const { data, isLoading, error, refetch } = useQuery({
     queryKey: creditsQueryKeys.user(userId ?? ""),
     queryFn: async () => {
       if (!userId || !isConfigured) {
-        if (__DEV__) console.log("[useCredits] Query skipped:", { hasUserId: !!userId, isConfigured });
         return null;
       }
-      if (__DEV__) console.log("[useCredits] Executing queryFn for userId:", userId.slice(0, 8));
       const repository = getCreditsRepository();
       const result = await repository.getCredits(userId);
       if (!result.success) {
-        if (__DEV__) console.error("[useCredits] Query failed:", result.error?.message);
         throw new Error(result.error?.message || "Failed to fetch credits");
       }
 
       // Background sync: If mapper detected expired status, sync to Firestore
       if (result.data?.status === "expired") {
-        if (__DEV__) console.log("[useCredits] Detected expired subscription, syncing...");
         repository.syncExpiredStatus(userId).catch(() => {});
       }
 
-      if (__DEV__) console.log("[useCredits] Query success:", { hasData: !!result.data, credits: result.data?.credits, status: result.data?.status });
       return result.data || null;
     },
     enabled: queryEnabled,

package/src/presentation/hooks/useCreditsGate.ts

@@ -21,8 +21,6 @@
 
 import { useCallback } from "react";
 
-declare const __DEV__: boolean;
-
 export interface UseCreditsGateParams {
   /** Whether user has enough credits for the action */
   hasCredits: boolean;
@@ -52,27 +50,12 @@ export function useCreditsGate(
   const requireCredits = useCallback(
     (_action: () => void | Promise<void>): boolean => {
       if (!hasCredits) {
-        if (__DEV__) {
-           
-          console.log("[useCreditsGate] Insufficient credits", {
-            creditBalance,
-            requiredCredits,
-          });
-        }
         onCreditsRequired(requiredCredits);
         return false;
       }
-
-      if (__DEV__) {
-         
-        console.log("[useCreditsGate] Has credits, proceeding", {
-          creditBalance,
-          requiredCredits,
-        });
-      }
       return true;
     },
-    [hasCredits, creditBalance, requiredCredits, onCreditsRequired]
+    [hasCredits, requiredCredits, onCreditsRequired]
   );
 
   return {

package/src/presentation/hooks/useSavedPurchaseAutoExecution.ts

@@ -3,7 +3,7 @@
  * Automatically executes saved purchase when user converts from anonymous to authenticated
  */
 
-import { useEffect, useRef, useCallback } from "react";
+import { useEffect, useRef } from "react";
 import { getSavedPurchase, clearSavedPurchase } from "./useAuthAwarePurchase";
 import { usePremium } from "./usePremium";
 import { SubscriptionManager } from "../../revenuecat";
@@ -31,97 +31,35 @@ export const useSavedPurchaseAutoExecution = (
 
   const prevIsAnonymousRef = useRef<boolean | undefined>(undefined);
   const isExecutingRef = useRef(false);
+  const hasExecutedRef = useRef(false);
 
-  const executeWithWait = useCallback(async () => {
-    const savedPurchase = getSavedPurchase();
-    if (!savedPurchase || !userId) return;
-
-    if (__DEV__) {
-      console.log(
-        "[SavedPurchaseAutoExecution] Waiting for RevenueCat initialization...",
-        { userId: userId.slice(0, 8), productId: savedPurchase.pkg.product.identifier }
-      );
-    }
-
-    isExecutingRef.current = true;
-
-    const maxAttempts = 20;
-    const delayMs = 500;
-
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const isReady = SubscriptionManager.isInitializedForUser(userId);
-
-      if (__DEV__) {
-        console.log(
-          `[SavedPurchaseAutoExecution] Attempt ${attempt + 1}/${maxAttempts}, isReady: ${isReady}`
-        );
-      }
-
-      if (isReady) {
-        const pkg = savedPurchase.pkg;
-        clearSavedPurchase();
-
-        if (__DEV__) {
-          console.log(
-            "[SavedPurchaseAutoExecution] RevenueCat ready, starting purchase...",
-            { productId: pkg.product.identifier, userId: userId.slice(0, 8) }
-          );
-        }
-
-        // Start global loading state
-        startPurchase(pkg.product.identifier, "auto-execution");
+  // Store callbacks in refs to avoid dependency changes
+  const purchasePackageRef = useRef(purchasePackage);
+  const onSuccessRef = useRef(onSuccess);
+  const onErrorRef = useRef(onError);
+  const startPurchaseRef = useRef(startPurchase);
+  const endPurchaseRef = useRef(endPurchase);
 
-        try {
-          if (__DEV__) {
-            console.log("[SavedPurchaseAutoExecution] Calling purchasePackage...");
-          }
-
-          const success = await purchasePackage(pkg);
-
-          if (__DEV__) {
-            console.log("[SavedPurchaseAutoExecution] Purchase completed:", {
-              success,
-              productId: pkg.product.identifier
-            });
-          }
-
-          if (success && onSuccess) {
-            onSuccess();
-          }
-        } catch (error) {
-          if (__DEV__) {
-            console.error("[SavedPurchaseAutoExecution] Purchase error:", {
-              error,
-              productId: pkg.product.identifier
-            });
-          }
-          if (onError && error instanceof Error) {
-            onError(error);
-          }
-        } finally {
-          // End global loading state
-          endPurchase();
-          isExecutingRef.current = false;
+  // Update refs when values change
+  useEffect(() => {
+    purchasePackageRef.current = purchasePackage;
+  }, [purchasePackage]);
 
-          if (__DEV__) {
-            console.log("[SavedPurchaseAutoExecution] Purchase flow finished");
-          }
-        }
+  useEffect(() => {
+    onSuccessRef.current = onSuccess;
+  }, [onSuccess]);
 
-        return;
-      }
+  useEffect(() => {
+    onErrorRef.current = onError;
+  }, [onError]);
 
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
+  useEffect(() => {
+    startPurchaseRef.current = startPurchase;
+  }, [startPurchase]);
 
-    if (__DEV__) {
-      console.log(
-        "[SavedPurchaseAutoExecution] Timeout waiting for RevenueCat, clearing saved purchase"
-      );
-    }
-    clearSavedPurchase();
-    isExecutingRef.current = false;
-  }, [userId, purchasePackage, onSuccess, onError, startPurchase, endPurchase]);
+  useEffect(() => {
+    endPurchaseRef.current = endPurchase;
+  }, [endPurchase]);
 
   useEffect(() => {
     const isAuthenticated = !!userId && !isAnonymous;
@@ -131,7 +69,10 @@ export const useSavedPurchaseAutoExecution = (
     const wasAnonymous = prevIsAnonymous === true;
     const becameAuthenticated = wasAnonymous && isAuthenticated;
 
-    if (__DEV__) {
+    // Only log when there's a state change worth noting
+    const shouldLog = prevIsAnonymousRef.current !== isAnonymous;
+
+    if (__DEV__ && shouldLog) {
       console.log("[SavedPurchaseAutoExecution] Auth state check:", {
         userId: userId?.slice(0, 8),
         prevIsAnonymous,
@@ -141,19 +82,127 @@ export const useSavedPurchaseAutoExecution = (
         becameAuthenticated,
         hasSavedPurchase: !!savedPurchase,
         savedProductId: savedPurchase?.pkg.product.identifier,
-        willExecute: becameAuthenticated && !!savedPurchase && !isExecutingRef.current,
+        willExecute:
+          becameAuthenticated &&
+          !!savedPurchase &&
+          !isExecutingRef.current &&
+          !hasExecutedRef.current,
       });
     }
 
-    if (becameAuthenticated && savedPurchase && !isExecutingRef.current) {
+    // Execute only once when transitioning from anonymous to authenticated
+    if (
+      becameAuthenticated &&
+      savedPurchase &&
+      !isExecutingRef.current &&
+      !hasExecutedRef.current
+    ) {
       if (__DEV__) {
         console.log("[SavedPurchaseAutoExecution] Triggering auto-execution...");
       }
-      executeWithWait();
+
+      hasExecutedRef.current = true;
+      isExecutingRef.current = true;
+
+      // Execute purchase flow
+      const executeFlow = async () => {
+        const currentUserId = userId;
+        if (!currentUserId) {
+          isExecutingRef.current = false;
+          return;
+        }
+
+        if (__DEV__) {
+          console.log(
+            "[SavedPurchaseAutoExecution] Waiting for RevenueCat initialization...",
+            {
+              userId: currentUserId.slice(0, 8),
+              productId: savedPurchase.pkg.product.identifier,
+            }
+          );
+        }
+
+        const maxAttempts = 20;
+        const delayMs = 500;
+
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+          const isReady = SubscriptionManager.isInitializedForUser(currentUserId);
+
+          if (__DEV__) {
+            console.log(
+              `[SavedPurchaseAutoExecution] Attempt ${attempt + 1}/${maxAttempts}, isReady: ${isReady}`
+            );
+          }
+
+          if (isReady) {
+            const pkg = savedPurchase.pkg;
+            clearSavedPurchase();
+
+            if (__DEV__) {
+              console.log(
+                "[SavedPurchaseAutoExecution] RevenueCat ready, starting purchase...",
+                { productId: pkg.product.identifier, userId: currentUserId.slice(0, 8) }
+              );
+            }
+
+            startPurchaseRef.current(pkg.product.identifier, "auto-execution");
+
+            try {
+              if (__DEV__) {
+                console.log("[SavedPurchaseAutoExecution] Calling purchasePackage...");
+              }
+
+              const success = await purchasePackageRef.current(pkg);
+
+              if (__DEV__) {
+                console.log("[SavedPurchaseAutoExecution] Purchase completed:", {
+                  success,
+                  productId: pkg.product.identifier,
+                });
+              }
+
+              if (success && onSuccessRef.current) {
+                onSuccessRef.current();
+              }
+            } catch (error) {
+              if (__DEV__) {
+                console.error("[SavedPurchaseAutoExecution] Purchase error:", {
+                  error,
+                  productId: pkg.product.identifier,
+                });
+              }
+              if (onErrorRef.current && error instanceof Error) {
+                onErrorRef.current(error);
+              }
+            } finally {
+              endPurchaseRef.current();
+              isExecutingRef.current = false;
+
+              if (__DEV__) {
+                console.log("[SavedPurchaseAutoExecution] Purchase flow finished");
+              }
+            }
+
+            return;
+          }
+
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+
+        if (__DEV__) {
+          console.log(
+            "[SavedPurchaseAutoExecution] Timeout waiting for RevenueCat, clearing saved purchase"
+          );
+        }
+        clearSavedPurchase();
+        isExecutingRef.current = false;
+      };
+
+      executeFlow();
     }
 
     prevIsAnonymousRef.current = isAnonymous;
-  }, [userId, isAnonymous, executeWithWait]);
+  }, [userId, isAnonymous]);
 
   return {
     isExecuting: isExecutingRef.current,