@umituz/react-native-subscription 2.12.41 → 2.12.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.12.41",
+  "version": "2.12.43",
   "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/index.ts

@@ -243,6 +243,12 @@ export {
   type UsePremiumResult,
 } from "./presentation/hooks/usePremium";
 
+export {
+  usePaywallOperations,
+  type UsePaywallOperationsProps,
+  type UsePaywallOperationsResult,
+} from "./presentation/hooks/usePaywallOperations";
+
 export {
   useAuthSubscriptionSync,
   type AuthSubscriptionSyncConfig,

package/src/presentation/hooks/usePaywallOperations.ts

@@ -0,0 +1,165 @@
+/**
+ * Paywall Logic Hook
+ *
+ * Generic business logic for handling paywall interactions.
+ * Decouples logic from UI and specific App implementations.
+ * Follows "Package Driven Design" by accepting dynamic props.
+ */
+
+import { useState, useCallback } from "react";
+import { Alert } from "react-native";
+import { useLocalization } from "@umituz/react-native-localization";
+import { usePremium } from "./usePremium";
+import type { PurchasesPackage } from "react-native-purchases";
+
+export interface UsePaywallOperationsProps {
+    /** Current User ID (or undefined) */
+    userId: string | undefined;
+    /** Whether the user is anonymous/guest */
+    isAnonymous: boolean;
+    /** Callback when paywall should close (e.g. close button pressed) */
+    onPaywallClose?: () => void;
+    /** Callback when purchase completes successfully */
+    onPurchaseSuccess?: () => void;
+    /** Callback when authentication is required (e.g. for purchase) */
+    onAuthRequired?: () => void;
+}
+
+export interface UsePaywallOperationsResult {
+    /** Package that was pending purchase before auth interrupt */
+    pendingPackage: PurchasesPackage | null;
+    /** Handle purchasing a package */
+    handlePurchase: (pkg: PurchasesPackage) => Promise<boolean>;
+    /** Handle restoring purchases */
+    handleRestore: () => Promise<boolean>;
+    /** Handle in-app purchase (with auto-close logic) */
+    handleInAppPurchase: (pkg: PurchasesPackage) => Promise<boolean>;
+    /** Handle in-app restore (with auto-close logic) */
+    handleInAppRestore: () => Promise<boolean>;
+}
+
+export function usePaywallOperations({
+    userId,
+    isAnonymous,
+    onPaywallClose,
+    onPurchaseSuccess,
+    onAuthRequired,
+}: UsePaywallOperationsProps): UsePaywallOperationsResult {
+    const { t } = useLocalization();
+    const { purchasePackage, restorePurchase, closePaywall } = usePremium(userId);
+    const [pendingPackage, setPendingPackage] = useState<PurchasesPackage | null>(null);
+
+    /**
+     * Check if action requires authentication
+     * @returns true if authenticated, false if auth required
+     */
+    const checkAuth = useCallback((): boolean => {
+        if (!userId || isAnonymous) {
+            if (__DEV__) {
+                console.log("[usePaywallOperations] User not authenticated, triggering onAuthRequired");
+            }
+            if (onAuthRequired) {
+                onAuthRequired();
+            }
+            return false;
+        }
+        return true;
+    }, [userId, isAnonymous, onAuthRequired]);
+
+    /**
+     * Execute purchase flow with Alerts
+     */
+    const executePurchase = useCallback(
+        async (pkg: PurchasesPackage, onSuccess?: () => void): Promise<boolean> => {
+            // 1. Auth Check
+            if (!checkAuth()) {
+                setPendingPackage(pkg);
+                return false;
+            }
+
+            // 2. Purchase
+            const success = await purchasePackage(pkg);
+
+            // 3. Handle Result
+            if (success) {
+                if (onSuccess) onSuccess();
+            } else {
+                Alert.alert(
+                    t("premium.purchaseError"),
+                    t("premium.purchaseErrorMessage")
+                );
+            }
+            return success;
+        },
+        [checkAuth, purchasePackage, t]
+    );
+
+    /**
+     * Execute restore flow with Alerts
+     */
+    const executeRestore = useCallback(
+        async (onSuccess?: () => void): Promise<boolean> => {
+            // 1. Restore
+            const success = await restorePurchase();
+
+            // 2. Alert Result
+            Alert.alert(
+                success ? t("premium.restoreSuccess") : t("premium.restoreError"),
+                success
+                    ? t("premium.restoreMessage")
+                    : t("premium.restoreErrorMessage")
+            );
+
+            // 3. Handle Success
+            if (success) {
+                if (onSuccess) onSuccess();
+            }
+            return success;
+        },
+        [restorePurchase, t]
+    );
+
+    // ============================================================================
+    // Public Handlers
+    // ============================================================================
+
+    const handlePurchase = useCallback(
+        async (pkg: PurchasesPackage): Promise<boolean> => {
+            const result = await executePurchase(pkg, onPurchaseSuccess);
+            if (!result && !checkAuth()) {
+                if (onPaywallClose) onPaywallClose();
+            }
+            return result;
+        },
+        [executePurchase, onPurchaseSuccess, checkAuth, onPaywallClose]
+    );
+
+    const handleRestore = useCallback(
+        async (): Promise<boolean> => executeRestore(onPurchaseSuccess),
+        [executeRestore, onPurchaseSuccess]
+    );
+
+    const handleInAppPurchase = useCallback(
+        async (pkg: PurchasesPackage): Promise<boolean> => {
+            const result = await executePurchase(pkg, closePaywall);
+            if (!result && !checkAuth()) {
+                closePaywall();
+            }
+            return result;
+        },
+        [executePurchase, closePaywall, checkAuth]
+    );
+
+    const handleInAppRestore = useCallback(
+        async (): Promise<boolean> => executeRestore(closePaywall),
+        [executeRestore, closePaywall]
+    );
+
+    return {
+        pendingPackage,
+        handlePurchase,
+        handleRestore,
+        handleInAppPurchase,
+        handleInAppRestore,
+    };
+}

package/src/revenuecat/infrastructure/handlers/PackageHandler.ts

@@ -21,7 +21,7 @@ export class PackageHandler {
   constructor(
     private service: IRevenueCatService | null,
     private entitlementId: string
-  ) {}
+  ) { }
 
   setService(service: IRevenueCatService | null): void {
     this.service = service;
@@ -36,6 +36,19 @@ export class PackageHandler {
     try {
       const offering = await this.service.fetchOfferings();
 
+      if (__DEV__) {
+        console.log('[DEBUG PackageHandler] fetchOfferings result:', {
+          hasOffering: !!offering,
+          identifier: offering?.identifier,
+          packagesCount: offering?.availablePackages?.length ?? 0,
+          packages: offering?.availablePackages?.map(p => ({
+            identifier: p.identifier,
+            productIdentifier: p.product.identifier,
+            offeringIdentifier: p.offeringIdentifier
+          }))
+        });
+      }
+
       addPackageBreadcrumb("subscription", "Packages fetched", {
         identifier: offering?.identifier,
         count: offering?.availablePackages?.length ?? 0,
@@ -43,6 +56,9 @@ export class PackageHandler {
 
       return offering?.availablePackages ?? [];
     } catch (error) {
+      if (__DEV__) {
+        console.error('[DEBUG PackageHandler] fetchOfferings failed:', error);
+      }
       trackPackageError(error instanceof Error ? error : new Error(String(error)), {
         packageName: "subscription",
         operation: "fetch_packages",

package/src/revenuecat/presentation/hooks/useInitializeSubscription.ts

@@ -48,7 +48,7 @@ export const useInitializeSubscription = (userId: string | undefined) => {
         {
           packageName: "subscription",
           operation: "initialize_mutation",
-          userId: userId ?? "NO_USER",
+          userId: userId ?? "ANONYMOUS",
         }
       );
     },

package/src/revenuecat/presentation/hooks/usePurchasePackage.ts

@@ -11,6 +11,7 @@ import {
   addPackageBreadcrumb,
 } from "@umituz/react-native-sentry";
 import { SUBSCRIPTION_QUERY_KEYS } from "./subscriptionQueryKeys";
+import { creditsQueryKeys } from "../../../presentation/hooks/useCredits";
 
 /**
  * Purchase a subscription package
@@ -64,6 +65,11 @@ export const usePurchasePackage = (userId: string | undefined) => {
       queryClient.invalidateQueries({
         queryKey: SUBSCRIPTION_QUERY_KEYS.packages,
       });
+      if (userId) {
+        queryClient.invalidateQueries({
+          queryKey: creditsQueryKeys.user(userId),
+        });
+      }
     },
     onError: (error) => {
       trackPackageError(
@@ -71,7 +77,7 @@ export const usePurchasePackage = (userId: string | undefined) => {
         {
           packageName: "subscription",
           operation: "purchase_mutation",
-          userId: userId ?? "NO_USER",
+          userId: userId ?? "ANONYMOUS",
         }
       );
     },

package/src/revenuecat/presentation/hooks/useRestorePurchase.ts

@@ -60,7 +60,7 @@ export const useRestorePurchase = (userId: string | undefined) => {
         {
           packageName: "subscription",
           operation: "restore_mutation",
-          userId: userId ?? "NO_USER",
+          userId: userId ?? "ANONYMOUS",
         }
       );
     },

package/src/revenuecat/presentation/hooks/useSubscriptionPackages.ts

@@ -33,28 +33,35 @@ export const useSubscriptionPackages = (userId: string | undefined) => {
       });
 
       // Initialize if needed (works for both authenticated and anonymous users)
-      if (userId) {
-        if (!SubscriptionManager.isInitializedForUser(userId)) {
-          if (__DEV__) {
-            console.log('[DEBUG useSubscriptionPackages] Initializing for user:', userId);
+      try {
+        if (userId) {
+          if (!SubscriptionManager.isInitializedForUser(userId)) {
+            if (__DEV__) {
+              console.log('[DEBUG useSubscriptionPackages] Initializing for user:', userId);
+            }
+            await SubscriptionManager.initialize(userId);
+          } else {
+            if (__DEV__) {
+              console.log('[DEBUG useSubscriptionPackages] Already initialized for user:', userId);
+            }
           }
-          await SubscriptionManager.initialize(userId);
         } else {
-          if (__DEV__) {
-            console.log('[DEBUG useSubscriptionPackages] Already initialized for user:', userId);
+          if (!SubscriptionManager.isInitialized()) {
+            if (__DEV__) {
+              console.log('[DEBUG useSubscriptionPackages] Initializing for ANONYMOUS user');
+            }
+            await SubscriptionManager.initialize(undefined);
+          } else {
+            if (__DEV__) {
+              console.log('[DEBUG useSubscriptionPackages] Already initialized for ANONYMOUS');
+            }
           }
         }
-      } else {
-        if (!SubscriptionManager.isInitialized()) {
-          if (__DEV__) {
-            console.log('[DEBUG useSubscriptionPackages] Initializing for ANONYMOUS user');
-          }
-          await SubscriptionManager.initialize(undefined);
-        } else {
-          if (__DEV__) {
-            console.log('[DEBUG useSubscriptionPackages] Already initialized for ANONYMOUS');
-          }
+      } catch (error) {
+        if (__DEV__) {
+          console.error('[DEBUG useSubscriptionPackages] Initialization failed:', error);
         }
+        throw error;
       }
 
       if (__DEV__) {

package/src/utils/premiumStatusUtils.ts

@@ -26,21 +26,6 @@ import type { PremiumStatusFetcher } from './types';
  * @param isPremiumOrFetcher - Either boolean (sync) or PremiumStatusFetcher (async)
  * @returns boolean (sync) or Promise<boolean> (async) - Whether user has premium subscription
  */
-// Sync overload: when isPremium value is already known
-export function getIsPremium(
-  isGuestFlag: boolean,
-  userId: string | null,
-  isPremium: boolean,
-): boolean;
-
-// Async overload: when fetcher is provided
-export function getIsPremium(
-  isGuestFlag: boolean,
-  userId: string | null,
-  fetcher: PremiumStatusFetcher,
-): Promise<boolean>;
-
-// Implementation
 export function getIsPremium(
   isGuestFlag: boolean,
   userId: string | null,