@umituz/react-native-subscription 2.35.12 → 2.35.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.35.12",
+  "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/components/PaywallContainer.tsx

@@ -4,7 +4,6 @@ import { useSubscriptionPackages } from "../../subscription/infrastructure/hooks
 import { useRevenueCatTrialEligibility } from "../../subscription/infrastructure/hooks/useRevenueCatTrialEligibility";
 import { createCreditAmountsFromPackages } from "../../../utils/creditMapper";
 import { PaywallModal } from "./PaywallModal";
-import { usePaywallActions } from "../hooks/usePaywallActions";
 import { useAuthAwarePurchase } from "../../subscription/presentation/useAuthAwarePurchase";
 import { useTrialEligibilityCheck } from "../hooks/useTrialEligibilityCheck";
 import type { PaywallContainerProps } from "./PaywallContainer.types";
@@ -36,20 +35,9 @@ export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
 
   const { data: packages = [], isLoading } = useSubscriptionPackages();
   const { eligibilityMap, checkEligibility } = useRevenueCatTrialEligibility();
-  
-  const { handlePurchase: performPurchase, handleRestore: performRestore } = useAuthAwarePurchase({ 
-    source: purchaseSource 
-  });
 
-  const { handlePurchase, handleRestore } = usePaywallActions({
-    packages,
-    onPurchase: performPurchase,
-    onRestore: performRestore,
-    source: purchaseSource,
-    onPurchaseSuccess,
-    onPurchaseError,
-    onAuthRequired,
-    onClose: handleClose,
+  const { handlePurchase: performPurchase, handleRestore: performRestore } = useAuthAwarePurchase({
+    source: purchaseSource
   });
 
   const trialEligibility = useTrialEligibilityCheck({
@@ -60,7 +48,6 @@ export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
     trialConfig,
   });
 
-  // Compute credit amounts from packageAllocations if not provided directly
   const creditAmounts = useMemo(() => {
     if (providedCreditAmounts) return providedCreditAmounts;
     if (!packageAllocations || packages.length === 0) return undefined;
@@ -81,10 +68,14 @@ export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
       bestValueIdentifier={bestValueIdentifier}
       creditAmounts={creditAmounts}
       creditsLabel={creditsLabel}
-      onPurchase={handlePurchase}
-      onRestore={handleRestore}
+      onPurchase={performPurchase}
+      onRestore={performRestore}
       trialEligibility={trialEligibility}
       trialSubtitleText={trialConfig?.enabled ? trialConfig.trialText : undefined}
+      onPurchaseSuccess={onPurchaseSuccess}
+      onPurchaseError={onPurchaseError}
+      onAuthRequired={onAuthRequired}
+      source={purchaseSource}
     />
   );
 };

package/src/domains/paywall/components/PaywallModal.tsx

@@ -11,10 +11,19 @@ import { usePaywallActions } from "../hooks/usePaywallActions";
 import { PaywallModalProps } from "./PaywallModal.types";
 
 export const PaywallModal: React.FC<PaywallModalProps> = React.memo((props) => {
-  const { visible, onClose, translations, packages = [], features = [], legalUrls = {}, bestValueIdentifier, creditAmounts, creditsLabel, heroImage, onPurchase, onRestore, trialEligibility = {}, trialSubtitleText } = props;
+  const { visible, onClose, translations, packages = [], features = [], legalUrls = {}, bestValueIdentifier, creditAmounts, creditsLabel, heroImage, onPurchase, onRestore, trialEligibility = {}, trialSubtitleText, onPurchaseSuccess, onPurchaseError, onAuthRequired, source } = props;
   const tokens = useAppDesignTokens();
   const insets = useSafeAreaInsets();
-  const { selectedPlanId, setSelectedPlanId, isProcessing, handlePurchase, handleRestore, resetState } = usePaywallActions({ packages, onPurchase, onRestore });
+  const { selectedPlanId, setSelectedPlanId, isProcessing, handlePurchase, handleRestore, resetState } = usePaywallActions({
+    packages,
+    onPurchase,
+    onRestore,
+    source,
+    onPurchaseSuccess,
+    onPurchaseError,
+    onAuthRequired,
+    onClose
+  });
 
   useEffect(() => {
     if (!visible) resetState();

package/src/domains/paywall/components/PaywallModal.types.ts

@@ -1,6 +1,7 @@
 import type { ImageSourcePropType } from "react-native";
 import type { PurchasesPackage } from "react-native-purchases";
 import type { SubscriptionFeature, PaywallTranslations, PaywallLegalUrls } from "../entities/types";
+import type { PurchaseSource } from "../../subscription/core/SubscriptionConstants";
 
 export interface TrialEligibilityInfo {
   eligible: boolean;
@@ -22,4 +23,8 @@ export interface PaywallModalProps {
   onRestore?: () => Promise<void | boolean>;
   trialEligibility?: Record<string, TrialEligibilityInfo>;
   trialSubtitleText?: string;
+  onPurchaseSuccess?: () => void;
+  onPurchaseError?: (error: Error | string) => void;
+  onAuthRequired?: () => void;
+  source?: PurchaseSource;
 }

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/infrastructure/handlers/PackageHandler.ts

@@ -24,14 +24,7 @@ export class PackageHandler {
   }
 
   async purchase(pkg: PurchasesPackage, userId: string): Promise<boolean> {
-    console.log('🔵 [PackageHandler] purchase called', {
-      productId: pkg.product.identifier,
-      userId
-    });
-
     const result = await executePurchase(this.service, pkg, userId);
-    console.log('✅ [PackageHandler] purchase completed', { result });
-
     return result;
   }
 

package/src/domains/subscription/infrastructure/handlers/package-operations/PackagePurchaser.ts

@@ -6,20 +6,10 @@ export async function executePurchase(
   pkg: PurchasesPackage,
   userId: string
 ): Promise<boolean> {
-  console.log('🔵 [executePurchase] Starting', {
-    productId: pkg.product.identifier,
-    userId,
-    isInitialized: service.isInitialized()
-  });
-
   if (!service.isInitialized()) {
-    console.error('❌ [executePurchase] Service not initialized!');
     throw new Error("Service not initialized");
   }
 
-  console.log('🚀 [executePurchase] Calling service.purchasePackage');
   const result = await service.purchasePackage(pkg, userId);
-  console.log('✅ [executePurchase] Completed', { success: result.success });
-
   return result.success;
 }

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -87,19 +87,9 @@ class SubscriptionManagerImpl {
   }
 
   async purchasePackage(pkg: PurchasesPackage): Promise<boolean> {
-    console.log('🔵 [SubscriptionManager] purchasePackage called', {
-      productId: pkg.product.identifier,
-      isConfigured: !!this.managerConfig,
-      hasPackageHandler: !!this.packageHandler
-    });
-
     this.ensureConfigured();
     this.ensurePackageHandlerInitialized();
-
-    console.log('🚀 [SubscriptionManager] Calling purchasePackageOperation');
     const result = await purchasePackageOperation(pkg, this.managerConfig, this.state, this.packageHandler!);
-    console.log('✅ [SubscriptionManager] purchasePackageOperation completed', { result });
-
     return result;
   }
 

package/src/domains/subscription/infrastructure/managers/managerOperations.ts

@@ -22,17 +22,9 @@ export const purchasePackageOperation = async (
   state: SubscriptionInternalState,
   packageHandler: PackageHandler
 ): Promise<boolean> => {
-  console.log('🔵 [purchasePackageOperation] Starting', {
-    productId: pkg.product.identifier
-  });
-
   ensureConfigured(managerConfig);
   const userId = getCurrentUserIdOrThrow(state);
-
-  console.log('🚀 [purchasePackageOperation] Calling packageHandler.purchase', { userId });
   const result = await packageHandler.purchase(pkg, userId);
-  console.log('✅ [purchasePackageOperation] Completed', { result });
-
   return result;
 };
 

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

@@ -16,38 +16,23 @@ export async function handlePurchase(
   pkg: PurchasesPackage,
   userId: string
 ): Promise<PurchaseResult> {
-  console.log('🔵 [PurchaseHandler] handlePurchase called', {
-    productId: pkg.product.identifier,
-    userId,
-    isInitialized: deps.isInitialized()
-  });
-
   validatePurchaseReady(deps.isInitialized());
 
   const consumableIds = deps.config.consumableProductIdentifiers || [];
   const isConsumable = isConsumableProduct(pkg, consumableIds);
 
-  console.log('📦 [PurchaseHandler] Product type', { isConsumable });
-
   try {
-    console.log('🚀 [PurchaseHandler] Calling executePurchase');
     const result = await executePurchase(deps.config, userId, pkg, isConsumable);
-    console.log('✅ [PurchaseHandler] executePurchase completed', { success: result.success });
     return result;
   } catch (error) {
-    console.error('❌ [PurchaseHandler] Purchase failed', { error });
-
     if (isUserCancelledError(error)) {
-      console.log('⚠️ [PurchaseHandler] User cancelled');
       return { success: false, isPremium: false, productId: pkg.product.identifier };
     }
 
     if (isAlreadyPurchasedError(error)) {
-      console.log('⚠️ [PurchaseHandler] Already purchased');
       return await handleAlreadyPurchasedError(deps, userId, pkg, error);
     }
 
-    console.error('❌ [PurchaseHandler] Unhandled error');
     return handlePurchaseError(error, pkg, userId);
   }
 }

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

@@ -60,15 +60,7 @@ export class RevenueCatService implements IRevenueCatService {
     }
 
     async purchasePackage(pkg: PurchasesPackage, userId: string): Promise<PurchaseResult> {
-        console.log('🔵 [RevenueCatService] purchasePackage called', {
-            productId: pkg.product.identifier,
-            userId,
-            isInitialized: this.isInitialized()
-        });
-
         const result = await handlePurchase(this.getSDKParams(), pkg, userId);
-        console.log('✅ [RevenueCatService] purchasePackage completed', { success: result.success });
-
         return result;
     }
 

package/src/domains/subscription/infrastructure/services/purchase/PurchaseExecutor.ts

@@ -77,26 +77,15 @@ export async function executePurchase(
   pkg: PurchasesPackage,
   isConsumable: boolean
 ): Promise<PurchaseResult> {
-  console.log('🔵 [PurchaseExecutor] executePurchase called', {
-    productId: pkg.product.identifier,
-    userId,
-    isConsumable,
-    packageType: pkg.packageType
-  });
-
-  console.log('🚀 [PurchaseExecutor] Calling Purchases.purchasePackage (RevenueCat SDK)');
   const { customerInfo } = await Purchases.purchasePackage(pkg);
-  console.log('✅ [PurchaseExecutor] Purchases.purchasePackage completed');
 
   const productId = pkg.product.identifier;
   const packageType = pkg.packageType ?? null;
 
   if (isConsumable) {
-    console.log('💰 [PurchaseExecutor] Processing as consumable purchase');
     return executeConsumablePurchase(config, userId, productId, customerInfo, packageType);
   }
 
-  console.log('📅 [PurchaseExecutor] Processing as subscription purchase');
   return executeSubscriptionPurchase(
     config,
     userId,

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> => {