@umituz/react-native-subscription 2.35.13 → 2.35.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.35.13",
+  "version": "2.35.14",
   "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/paywall/hooks/usePaywallActions.ts

@@ -7,6 +7,8 @@ import type { PurchasesPackage } from "react-native-purchases";
 import { usePurchaseLoadingStore } from "../../subscription/presentation/stores";
 import type { PurchaseSource } from "../../subscription/core/SubscriptionConstants";
 
+declare const __DEV__: boolean;
+
 export interface UsePaywallActionsParams {
   packages?: PurchasesPackage[];
   onPurchase?: (pkg: PurchasesPackage) => Promise<void | boolean>;
@@ -52,49 +54,163 @@ export function usePaywallActions({
   });
 
   const handlePurchase = useCallback(async () => {
-    if (!selectedPlanId || !onPurchaseRef.current || isProcessing) {
-      if (!selectedPlanId && onAuthRequiredRef.current) {
-        onAuthRequiredRef.current();
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[usePaywallActions] handlePurchase called", {
+        selectedPlanId,
+        hasOnPurchase: !!onPurchaseRef.current,
+        isProcessing,
+        packagesCount: packages.length,
+      });
+    }
+
+    if (!selectedPlanId) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn("[usePaywallActions] ❌ No plan selected");
+      }
+      return;
+    }
+
+    if (!onPurchaseRef.current) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[usePaywallActions] ❌ No onPurchase callback provided");
+      }
+      const err = new Error("Purchase handler not configured");
+      onPurchaseErrorRef.current?.(err);
+      return;
+    }
+
+    if (isProcessing) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn("[usePaywallActions] ⚠️ Already processing, ignoring duplicate request");
       }
       return;
     }
 
+    const pkg = packages.find((p) => p.product.identifier === selectedPlanId);
+
+    if (!pkg) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[usePaywallActions] ❌ Package not found", {
+          selectedPlanId,
+          availablePackages: packages.map(p => p.product.identifier),
+        });
+      }
+      const err = new Error(`Package not found: ${selectedPlanId}`);
+      onPurchaseErrorRef.current?.(err);
+      return;
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[usePaywallActions] ✅ Starting purchase", {
+        productId: pkg.product.identifier,
+        title: pkg.product.title,
+      });
+    }
+
     setIsLocalProcessing(true);
     startPurchase(selectedPlanId, "manual");
 
     try {
-      const pkg = packages.find((p) => p.product.identifier === selectedPlanId);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePaywallActions] 🚀 Calling onPurchase callback");
+      }
 
-      if (pkg) {
-        const success = await onPurchaseRef.current(pkg);
+      const success = await onPurchaseRef.current(pkg);
 
-        if (success !== false) {
-          onPurchaseSuccessRef.current?.();
-          onCloseRef.current?.();
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePaywallActions] 📦 Purchase result:", { success, type: typeof success });
+      }
+
+      if (success === true) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[usePaywallActions] ✅ Purchase successful, calling success callbacks");
+        }
+        onPurchaseSuccessRef.current?.();
+        onCloseRef.current?.();
+      } else if (success === false) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn("[usePaywallActions] ⚠️ Purchase returned false (user cancelled or failed)");
+        }
+      } else {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[usePaywallActions] ❌ Purchase returned unexpected value:", success);
         }
       }
     } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[usePaywallActions] ❌ Purchase error:", error);
+      }
       const err = error instanceof Error ? error : new Error(String(error));
       onPurchaseErrorRef.current?.(err);
     } finally {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePaywallActions] 🏁 Purchase completed, cleaning up");
+      }
       setIsLocalProcessing(false);
       endPurchase(selectedPlanId);
     }
   }, [selectedPlanId, packages, isProcessing, startPurchase, endPurchase]);
 
   const handleRestore = useCallback(async () => {
-    if (!onRestoreRef.current || isProcessing) return;
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[usePaywallActions] handleRestore called", {
+        hasOnRestore: !!onRestoreRef.current,
+        isProcessing,
+      });
+    }
+
+    if (!onRestoreRef.current) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[usePaywallActions] ❌ No onRestore callback provided");
+      }
+      const err = new Error("Restore handler not configured");
+      onPurchaseErrorRef.current?.(err);
+      return;
+    }
+
+    if (isProcessing) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.warn("[usePaywallActions] ⚠️ Already processing, ignoring restore request");
+      }
+      return;
+    }
 
     setIsLocalProcessing(true);
     try {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePaywallActions] 🚀 Calling onRestore callback");
+      }
+
       const success = await onRestoreRef.current();
-      if (success !== false) {
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePaywallActions] 📦 Restore result:", { success, type: typeof success });
+      }
+
+      if (success === true) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[usePaywallActions] ✅ Restore successful");
+        }
         onPurchaseSuccessRef.current?.();
+      } else if (success === false) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.warn("[usePaywallActions] ⚠️ Restore returned false");
+        }
+      } else {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[usePaywallActions] ❌ Restore returned unexpected value:", success);
+        }
       }
     } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[usePaywallActions] ❌ Restore error:", error);
+      }
       const err = error instanceof Error ? error : new Error(String(error));
       onPurchaseErrorRef.current?.(err);
     } finally {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePaywallActions] 🏁 Restore completed");
+      }
       setIsLocalProcessing(false);
     }
   }, [isProcessing]);

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

@@ -9,6 +9,8 @@ import { usePremium } from "./usePremium";
 import type { PurchaseSource } from "../core/SubscriptionConstants";
 import { authPurchaseStateManager } from "../infrastructure/utils/authPurchaseState";
 
+declare const __DEV__: boolean;
+
 export type { PurchaseAuthProvider } from "../infrastructure/utils/authPurchaseState";
 
 export const configureAuthProvider = (provider: import("../infrastructure/utils/authPurchaseState").PurchaseAuthProvider): void => {
@@ -44,38 +46,85 @@ export const useAuthAwarePurchase = (
 
   const handlePurchase = useCallback(
     async (pkg: PurchasesPackage, source?: PurchaseSource): Promise<boolean> => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useAuthAwarePurchase] handlePurchase called", {
+          productId: pkg.product.identifier,
+          source: source || params?.source,
+        });
+      }
+
       const authProvider = authPurchaseStateManager.getProvider();
 
       if (!authProvider) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[useAuthAwarePurchase] ❌ No auth provider configured");
+        }
         return false;
       }
 
       const isAuth = authProvider.isAuthenticated();
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useAuthAwarePurchase] Auth status:", { isAuth });
+      }
+
       if (!isAuth) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[useAuthAwarePurchase] 🔐 User not authenticated, saving purchase and showing auth modal");
+        }
         authPurchaseStateManager.savePurchase(pkg, source || params?.source || "settings");
         authProvider.showAuthModal();
         return false;
       }
 
-      return purchasePackage(pkg);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useAuthAwarePurchase] ✅ User authenticated, proceeding with purchase");
+      }
+
+      const result = await purchasePackage(pkg);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useAuthAwarePurchase] Purchase result:", result);
+      }
+
+      return result;
     },
     [purchasePackage, params?.source]
   );
 
   const handleRestore = useCallback(async (): Promise<boolean> => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useAuthAwarePurchase] handleRestore called");
+    }
+
     const authProvider = authPurchaseStateManager.getProvider();
 
     if (!authProvider) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[useAuthAwarePurchase] ❌ No auth provider configured");
+      }
       return false;
     }
 
     if (!authProvider.isAuthenticated()) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useAuthAwarePurchase] 🔐 User not authenticated, showing auth modal");
+      }
       authProvider.showAuthModal();
       return false;
     }
 
-    return restorePurchase();
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useAuthAwarePurchase] ✅ User authenticated, proceeding with restore");
+    }
+
+    const result = await restorePurchase();
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[useAuthAwarePurchase] Restore result:", result);
+    }
+
+    return result;
   }, [restorePurchase]);
 
   const executeSavedPurchase = useCallback(async (): Promise<boolean> => {