@umituz/react-native-subscription 2.20.1 → 2.20.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.20.1",
+  "version": "2.20.2",
   "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

@@ -2,7 +2,6 @@ import { useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
 import { useRestorePurchase } from "../../../revenuecat/presentation/hooks/useRestorePurchase";
 import { useAuthAwarePurchase } from "../../../presentation/hooks/useAuthAwarePurchase";
-import { usePendingPurchaseStore } from "../../../infrastructure/stores/PendingPurchaseStore";
 import type { PurchaseSource } from "../../../domain/entities/Credits";
 
 declare const __DEV__: boolean;
@@ -26,15 +25,8 @@ export const usePaywallActions = ({
 }: UsePaywallActionsProps) => {
   const { handlePurchase: authAwarePurchase } = useAuthAwarePurchase({ source, userId });
   const { mutateAsync: restorePurchases } = useRestorePurchase(userId);
-  const { isExecuting } = usePendingPurchaseStore();
 
   const handlePurchase = useCallback(async (pkg: PurchasesPackage) => {
-    // Block if a pending purchase is already being executed
-    if (isExecuting) {
-      if (__DEV__) console.log("[PaywallActions] Purchase blocked - pending purchase in progress");
-      return;
-    }
-
     try {
       if (__DEV__) console.log("[PaywallActions] Purchase started:", pkg.product.identifier);
       const res = await authAwarePurchase(pkg, source);
@@ -46,7 +38,7 @@ export const usePaywallActions = ({
       const message = err instanceof Error ? err.message : String(err);
       onPurchaseError?.(message);
     }
-  }, [authAwarePurchase, source, onClose, onPurchaseSuccess, onPurchaseError, isExecuting]);
+  }, [authAwarePurchase, source, onClose, onPurchaseSuccess, onPurchaseError]);
 
   const handleRestore = useCallback(async () => {
     try {

package/src/index.ts

@@ -18,13 +18,11 @@ export { initializeSubscription, type SubscriptionInitConfig, type CreditPackage
 export { CreditsRepository, createCreditsRepository } from "./infrastructure/repositories/CreditsRepository";
 export { configureCreditsRepository, getCreditsRepository, getCreditsConfig, resetCreditsRepository, isCreditsRepositoryConfigured } from "./infrastructure/repositories/CreditsRepositoryProvider";
 export {
-  usePendingPurchaseStore,
-  type PendingPurchaseData,
-} from "./infrastructure/stores/PendingPurchaseStore";
-export {
-  usePendingPurchaseHandler,
-  type UsePendingPurchaseHandlerParams,
-} from "./presentation/hooks/usePendingPurchaseHandler";
+  getSavedPurchase,
+  clearSavedPurchase,
+  configureAuthProvider,
+  type PurchaseAuthProvider,
+} from "./presentation/hooks/useAuthAwarePurchase";
 
 // Presentation Layer - Hooks
 export * from "./presentation/hooks";

package/src/presentation/hooks/useAuthAwarePurchase.ts

@@ -1,31 +1,38 @@
 /**
  * Auth-Aware Purchase Hook
- * Uses globally configured auth provider
- * Configure once at app start with configureAuthProvider()
+ * Handles purchase flow with authentication requirement
  */
 
 import { useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
 import { usePremium } from "./usePremium";
-import { usePendingPurchaseStore } from "../../infrastructure/stores/PendingPurchaseStore";
 import type { PurchaseSource } from "../../domain/entities/Credits";
 
 declare const __DEV__: boolean;
 
 export interface PurchaseAuthProvider {
-    isAuthenticated: () => boolean;
-    showAuthModal: () => void;
+  isAuthenticated: () => boolean;
+  showAuthModal: () => void;
 }
 
-// Global auth provider - configured once at app start
 let globalAuthProvider: PurchaseAuthProvider | null = null;
+let savedPackage: PurchasesPackage | null = null;
+let savedSource: PurchaseSource | null = null;
 
-/**
- * Configure auth provider for purchases
- * Call this once at app initialization
- */
 export const configureAuthProvider = (provider: PurchaseAuthProvider): void => {
-    globalAuthProvider = provider;
+  globalAuthProvider = provider;
+};
+
+export const getSavedPurchase = (): { pkg: PurchasesPackage; source: PurchaseSource } | null => {
+  if (savedPackage && savedSource) {
+    return { pkg: savedPackage, source: savedSource };
+  }
+  return null;
+};
+
+export const clearSavedPurchase = (): void => {
+  savedPackage = null;
+  savedSource = null;
 };
 
 export interface UseAuthAwarePurchaseParams {
@@ -34,84 +41,81 @@ export interface UseAuthAwarePurchaseParams {
 }
 
 export interface UseAuthAwarePurchaseResult {
-    handlePurchase: (pkg: PurchasesPackage, source?: PurchaseSource) => Promise<boolean>;
-    handleRestore: () => Promise<boolean>;
+  handlePurchase: (pkg: PurchasesPackage, source?: PurchaseSource) => Promise<boolean>;
+  handleRestore: () => Promise<boolean>;
+  executeSavedPurchase: () => Promise<boolean>;
 }
 
 export const useAuthAwarePurchase = (
   params?: UseAuthAwarePurchaseParams
 ): UseAuthAwarePurchaseResult => {
-    const { purchasePackage, restorePurchase, closePaywall } = usePremium(params?.userId);
-    const { setPendingPurchase } = usePendingPurchaseStore();
-
-    const handlePurchase = useCallback(
-        async (pkg: PurchasesPackage, source?: PurchaseSource): Promise<boolean> => {
-            // SECURITY: Block purchase if auth provider not configured
-            if (!globalAuthProvider) {
-                if (__DEV__) {
-                    console.error(
-                        "[useAuthAwarePurchase] CRITICAL: Auth provider not configured. " +
-                        "Call configureAuthProvider() at app start. Purchase blocked for security.",
-                    );
-                }
-                return false;
-            }
-
-            // Block purchase if user not authenticated (anonymous users cannot purchase)
-            if (!globalAuthProvider.isAuthenticated()) {
-                if (__DEV__) {
-                    console.log(
-                        "[useAuthAwarePurchase] User not authenticated, saving pending purchase and opening auth modal",
-                    );
-                }
-
-                // Save pending purchase
-                setPendingPurchase({
-                  package: pkg,
-                  source: source || params?.source || "settings",
-                  selectedAt: Date.now(),
-                });
-
-                closePaywall();
-                globalAuthProvider.showAuthModal();
-                return false;
-            }
-
-            return purchasePackage(pkg);
-        },
-        [purchasePackage, closePaywall, setPendingPurchase, params?.source],
-    );
-
-    const handleRestore = useCallback(async (): Promise<boolean> => {
-        // SECURITY: Block restore if auth provider not configured
-        if (!globalAuthProvider) {
-            if (__DEV__) {
-                console.error(
-                    "[useAuthAwarePurchase] CRITICAL: Auth provider not configured. " +
-                    "Call configureAuthProvider() at app start. Restore blocked for security.",
-                );
-            }
-            // Block restore - never allow without auth provider
-            return false;
-        }
+  const { purchasePackage, restorePurchase, closePaywall } = usePremium(params?.userId);
 
-        // Block restore if user not authenticated
-        if (!globalAuthProvider.isAuthenticated()) {
-            if (__DEV__) {
-                console.log(
-                    "[useAuthAwarePurchase] User not authenticated, opening auth modal",
-                );
-            }
-            closePaywall();
-            globalAuthProvider.showAuthModal();
-            return false;
+  const handlePurchase = useCallback(
+    async (pkg: PurchasesPackage, source?: PurchaseSource): Promise<boolean> => {
+      if (!globalAuthProvider) {
+        if (__DEV__) {
+          console.error("[useAuthAwarePurchase] Auth provider not configured");
         }
+        return false;
+      }
 
-        return restorePurchase();
-    }, [restorePurchase, closePaywall]);
-
-    return {
-        handlePurchase,
-        handleRestore,
-    };
+      if (!globalAuthProvider.isAuthenticated()) {
+        if (__DEV__) {
+          console.log("[useAuthAwarePurchase] Not authenticated, saving and showing auth");
+        }
+        savedPackage = pkg;
+        savedSource = source || params?.source || "settings";
+        closePaywall();
+        globalAuthProvider.showAuthModal();
+        return false;
+      }
+
+      return purchasePackage(pkg);
+    },
+    [purchasePackage, closePaywall, params?.source]
+  );
+
+  const handleRestore = useCallback(async (): Promise<boolean> => {
+    if (!globalAuthProvider) {
+      if (__DEV__) {
+        console.error("[useAuthAwarePurchase] Auth provider not configured");
+      }
+      return false;
+    }
+
+    if (!globalAuthProvider.isAuthenticated()) {
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] Not authenticated for restore");
+      }
+      closePaywall();
+      globalAuthProvider.showAuthModal();
+      return false;
+    }
+
+    return restorePurchase();
+  }, [restorePurchase, closePaywall]);
+
+  const executeSavedPurchase = useCallback(async (): Promise<boolean> => {
+    const saved = getSavedPurchase();
+    if (!saved) {
+      if (__DEV__) {
+        console.log("[useAuthAwarePurchase] No saved purchase to execute");
+      }
+      return false;
+    }
+
+    if (__DEV__) {
+      console.log("[useAuthAwarePurchase] Executing saved purchase:", saved.pkg.product.identifier);
+    }
+
+    clearSavedPurchase();
+    return purchasePackage(saved.pkg);
+  }, [purchasePackage]);
+
+  return {
+    handlePurchase,
+    handleRestore,
+    executeSavedPurchase,
+  };
 };

package/src/revenuecat/infrastructure/services/PurchaseHandler.ts

@@ -18,7 +18,7 @@ import {
     syncPremiumStatus,
     notifyPurchaseCompleted,
 } from "../utils/PremiumStatusSyncer";
-import { usePendingPurchaseStore } from "../../../infrastructure/stores/PendingPurchaseStore";
+import { getSavedPurchase, clearSavedPurchase } from "../../../presentation/hooks/useAuthAwarePurchase";
 
 export interface PurchaseHandlerDeps {
     config: RevenueCatConfig;
@@ -77,10 +77,9 @@ export async function handlePurchase(
             });
         }
 
-        // Get purchase source from pending purchase store
-        const pendingPurchaseStore = usePendingPurchaseStore.getState();
-        const pending = pendingPurchaseStore.getPendingPurchase();
-        const source = pending?.source;
+        // Get purchase source from saved purchase
+        const savedPurchase = getSavedPurchase();
+        const source = savedPurchase?.source;
 
         if (isConsumable) {
             if (__DEV__) {
@@ -94,7 +93,7 @@ export async function handlePurchase(
                 source
             );
             // Clear pending purchase after successful purchase
-            pendingPurchaseStore.clearPendingPurchase();
+            clearSavedPurchase();
             return {
                 success: true,
                 isPremium: false,
@@ -129,7 +128,7 @@ export async function handlePurchase(
                 source
             );
             // Clear pending purchase after successful purchase
-            pendingPurchaseStore.clearPendingPurchase();
+            clearSavedPurchase();
             return { success: true, isPremium: true, customerInfo };
         }
 
@@ -147,7 +146,7 @@ export async function handlePurchase(
                 source
             );
             // Clear pending purchase after successful purchase
-            pendingPurchaseStore.clearPendingPurchase();
+            clearSavedPurchase();
             return { success: true, isPremium: false, customerInfo };
         }
 

package/src/infrastructure/stores/PendingPurchaseStore.ts

@@ -1,63 +0,0 @@
-/**
- * Pending Purchase Store
- * Manages pending purchase state for auth-required purchases
- */
-
-import { createStore } from "@umituz/react-native-design-system";
-import type { PurchasesPackage } from "react-native-purchases";
-import type { PurchaseSource } from "../../domain/entities/Credits";
-
-export interface PendingPurchaseData {
-  package: PurchasesPackage;
-  source: PurchaseSource;
-  selectedAt: number;
-  metadata?: Record<string, unknown>;
-}
-
-interface PendingPurchaseState {
-  pending: PendingPurchaseData | null;
-  isExecuting: boolean;
-}
-
-interface PendingPurchaseActions {
-  setPendingPurchase: (data: PendingPurchaseData) => void;
-  getPendingPurchase: () => PendingPurchaseData | null;
-  clearPendingPurchase: () => void;
-  hasPendingPurchase: () => boolean;
-  setExecuting: (executing: boolean) => void;
-}
-
-const initialState: PendingPurchaseState = {
-  pending: null,
-  isExecuting: false,
-};
-
-export const usePendingPurchaseStore = createStore<
-  PendingPurchaseState,
-  PendingPurchaseActions
->({
-  name: "pending-purchase-store",
-  initialState,
-  persist: false,
-  actions: (set, get) => ({
-    setPendingPurchase: (data: PendingPurchaseData) => {
-      set({ pending: data });
-    },
-
-    getPendingPurchase: () => {
-      return get().pending;
-    },
-
-    clearPendingPurchase: () => {
-      set({ pending: null });
-    },
-
-    hasPendingPurchase: () => {
-      return get().pending !== null;
-    },
-
-    setExecuting: (executing: boolean) => {
-      set({ isExecuting: executing });
-    },
-  }),
-});

package/src/presentation/hooks/usePendingPurchaseHandler.ts

@@ -1,79 +0,0 @@
-/**
- * Pending Purchase Handler Hook
- * Automatically executes pending purchase after successful authentication
- */
-
-import { useEffect, useRef } from "react";
-import { usePendingPurchaseStore } from "../../infrastructure/stores/PendingPurchaseStore";
-import { usePremium } from "./usePremium";
-
-declare const __DEV__: boolean;
-
-export interface UsePendingPurchaseHandlerParams {
-  userId: string | undefined;
-  isAuthenticated: boolean;
-}
-
-/**
- * Hook to handle pending purchases after authentication
- * Call this in app root after auth initialization
- */
-export const usePendingPurchaseHandler = ({
-  userId,
-  isAuthenticated,
-}: UsePendingPurchaseHandlerParams): void => {
-  const { pending, clearPendingPurchase, setExecuting } = usePendingPurchaseStore();
-  const { purchasePackage } = usePremium(userId);
-  const isExecutingRef = useRef(false);
-  const executedPackageIdRef = useRef<string | null>(null);
-
-  useEffect(() => {
-    if (!isAuthenticated || !userId || !pending) {
-      return;
-    }
-
-    // Prevent duplicate executions
-    if (isExecutingRef.current) {
-      return;
-    }
-
-    // Prevent re-executing the same package
-    if (executedPackageIdRef.current === pending.package.identifier) {
-      return;
-    }
-
-    const executePendingPurchase = async () => {
-      isExecutingRef.current = true;
-      executedPackageIdRef.current = pending.package.identifier;
-      setExecuting(true);
-
-      if (__DEV__) {
-        console.log(
-          "[usePendingPurchaseHandler] Executing pending purchase:",
-          {
-            packageId: pending.package.identifier,
-            source: pending.source,
-            selectedAt: new Date(pending.selectedAt).toISOString(),
-          }
-        );
-      }
-
-      try {
-        await purchasePackage(pending.package);
-      } catch (error) {
-        if (__DEV__) {
-          console.error(
-            "[usePendingPurchaseHandler] Failed to execute pending purchase:",
-            error
-          );
-        }
-      } finally {
-        clearPendingPurchase();
-        isExecutingRef.current = false;
-        setExecuting(false);
-      }
-    };
-
-    void executePendingPurchase();
-  }, [isAuthenticated, userId, pending, clearPendingPurchase, purchasePackage, setExecuting]);
-};