@umituz/react-native-subscription 2.13.10 → 2.13.12

package/package.json

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

@@ -270,7 +270,7 @@ export {
 
 export {
   useAuthAwarePurchase,
-  type UseAuthAwarePurchaseParams,
+  configureAuthProvider,
   type UseAuthAwarePurchaseResult,
   type PurchaseAuthProvider,
 } from "./presentation/hooks/useAuthAwarePurchase";

package/src/presentation/hooks/useAuthAwarePurchase.ts

@@ -1,7 +1,7 @@
 /**
  * Auth-Aware Purchase Hook
- * Generic hook that works with any auth provider
- * Ensures user is authenticated before allowing purchases
+ * Uses globally configured auth provider
+ * Configure once at app start with configureAuthProvider()
  */
 
 import { useCallback } from "react";
@@ -13,52 +13,78 @@ export interface PurchaseAuthProvider {
     showAuthModal: () => void;
 }
 
-export interface UseAuthAwarePurchaseParams {
-    authProvider: PurchaseAuthProvider;
-}
+// Global auth provider - configured once at app start
+let globalAuthProvider: PurchaseAuthProvider | null = null;
+
+/**
+ * Configure auth provider for purchases
+ * Call this once at app initialization
+ */
+export const configureAuthProvider = (provider: PurchaseAuthProvider): void => {
+    globalAuthProvider = provider;
+    if (__DEV__) {
+        console.log("[useAuthAwarePurchase] Auth provider configured");
+    }
+};
 
 export interface UseAuthAwarePurchaseResult {
     handlePurchase: (pkg: PurchasesPackage) => Promise<boolean>;
     handleRestore: () => Promise<boolean>;
 }
 
-export const useAuthAwarePurchase = ({
-    authProvider,
-}: UseAuthAwarePurchaseParams): UseAuthAwarePurchaseResult => {
+export const useAuthAwarePurchase = (): UseAuthAwarePurchaseResult => {
     const { purchasePackage, restorePurchase, closePaywall } = usePremium();
 
     const handlePurchase = useCallback(
         async (pkg: PurchasesPackage): Promise<boolean> => {
-            if (!authProvider.isAuthenticated()) {
+            if (!globalAuthProvider) {
+                if (__DEV__) {
+                    console.warn(
+                        "[useAuthAwarePurchase] Auth provider not configured. Call configureAuthProvider() at app start.",
+                    );
+                }
+                return purchasePackage(pkg);
+            }
+
+            if (!globalAuthProvider.isAuthenticated()) {
                 if (__DEV__) {
                     console.log(
                         "[useAuthAwarePurchase] User not authenticated, opening auth modal",
                     );
                 }
                 closePaywall();
-                authProvider.showAuthModal();
+                globalAuthProvider.showAuthModal();
                 return false;
             }
 
             return purchasePackage(pkg);
         },
-        [purchasePackage, closePaywall, authProvider],
+        [purchasePackage, closePaywall],
     );
 
     const handleRestore = useCallback(async (): Promise<boolean> => {
-        if (!authProvider.isAuthenticated()) {
+        if (!globalAuthProvider) {
+            if (__DEV__) {
+                console.warn(
+                    "[useAuthAwarePurchase] Auth provider not configured. Call configureAuthProvider() at app start.",
+                );
+            }
+            return restorePurchase();
+        }
+
+        if (!globalAuthProvider.isAuthenticated()) {
             if (__DEV__) {
                 console.log(
                     "[useAuthAwarePurchase] User not authenticated, opening auth modal",
                 );
             }
             closePaywall();
-            authProvider.showAuthModal();
+            globalAuthProvider.showAuthModal();
             return false;
         }
 
         return restorePurchase();
-    }, [restorePurchase, closePaywall, authProvider]);
+    }, [restorePurchase, closePaywall]);
 
     return {
         handlePurchase,

package/src/presentation/hooks/useFeatureGate.ts

@@ -2,12 +2,12 @@
  * useFeatureGate Hook
  *
  * Feature gating with TanStack Query for server state.
- * Checks auth and premium status before allowing actions.
+ * Checks auth, premium status, AND credit balance before allowing actions.
  *
  * Flow:
  * 1. NOT authenticated → onShowAuthModal(callback)
- * 2. Authenticated but not premium → onShowPaywall()
- * 3. Authenticated and premium → Execute action
+ * 2. Authenticated but no credits → onShowPaywall()
+ * 3. Authenticated with credits → Execute action
  *
  * @example
  * ```typescript
@@ -16,6 +16,7 @@
  *   isAuthenticated: !!user,
  *   onShowAuthModal: (cb) => authModal.show(cb),
  *   onShowPaywall: () => setShowPaywall(true),
+ *   creditType: 'image', // or 'text'
  * });
  *
  * // Gate a premium feature
@@ -27,6 +28,7 @@
 
 import { useCallback } from "react";
 import { useCredits } from "./useCredits";
+import type { CreditType } from "../../domain/entities/Credits";
 
 declare const __DEV__: boolean;
 
@@ -39,67 +41,107 @@ export interface UseFeatureGateParams {
   onShowAuthModal: (pendingCallback: () => void | Promise<void>) => void;
   /** Callback to show paywall */
   onShowPaywall: () => void;
+  /** Credit type to check (default: 'image') */
+  creditType?: CreditType;
 }
 
 export interface UseFeatureGateResult {
-  /** Gate a feature - checks auth first, then premium (credits) */
+  /** Gate a feature - checks auth first, then credits balance */
   requireFeature: (action: () => void | Promise<void>) => void;
   /** Whether user is authenticated */
   isAuthenticated: boolean;
-  /** Whether user has premium access (has credits) */
-  isPremium: boolean;
+  /** Whether user has credits remaining */
+  hasCredits: boolean;
   /** Whether feature access is allowed */
   canAccess: boolean;
   /** Loading state */
   isLoading: boolean;
+  /** Current credit balance for the specified type */
+  creditBalance: number;
 }
 
 export function useFeatureGate(
   params: UseFeatureGateParams
 ): UseFeatureGateResult {
-  const { userId, isAuthenticated, onShowAuthModal, onShowPaywall } = params;
+  const {
+    userId,
+    isAuthenticated,
+    onShowAuthModal,
+    onShowPaywall,
+    creditType = "image",
+  } = params;
 
   // Use TanStack Query to get credits (server state)
-  const { credits, isLoading } = useCredits({
+  const { credits, isLoading, hasImageCredits, hasTextCredits } = useCredits({
     userId,
     enabled: isAuthenticated && !!userId,
   });
 
-  // User is premium if they have credits
-  // NOTE: This assumes credits system = premium subscription
-  // If your app uses CustomerInfo for premium status, use useCustomerInfo() instead
-  const isPremium = credits !== null;
+  // Check actual credit balance, not just existence
+  const hasCredits = creditType === "image" ? hasImageCredits : hasTextCredits;
+  const creditBalance =
+    creditType === "image"
+      ? credits?.imageCredits ?? 0
+      : credits?.textCredits ?? 0;
 
   const requireFeature = useCallback(
     (action: () => void | Promise<void>) => {
+      if (__DEV__) {
+        console.log("[useFeatureGate] requireFeature called", {
+          isAuthenticated,
+          hasCredits,
+          creditBalance,
+          creditType,
+        });
+      }
+
       // Step 1: Check authentication
       if (!isAuthenticated) {
+        if (__DEV__) {
+          console.log("[useFeatureGate] Not authenticated, showing auth modal");
+        }
         onShowAuthModal(() => {
           // We NO LONGER call action() blindly here.
           // The component will re-render with the new auth state,
           // and the user should be allowed to try the action again.
-          // This avoids executing actions before credits are loaded or verified.
         });
         return;
       }
 
-      // Step 2: Check premium (has credits from TanStack Query)
-      if (!isPremium) {
+      // Step 2: Check credit balance (not just existence)
+      if (!hasCredits) {
+        if (__DEV__) {
+          console.log("[useFeatureGate] No credits, showing paywall", {
+            creditBalance,
+            creditType,
+          });
+        }
         onShowPaywall();
         return;
       }
 
-      // Step 3: User is authenticated and premium - execute action
+      // Step 3: User is authenticated with credits - execute action
+      if (__DEV__) {
+        console.log("[useFeatureGate] Access granted, executing action");
+      }
       action();
     },
-    [isAuthenticated, isPremium, onShowAuthModal, onShowPaywall]
+    [
+      isAuthenticated,
+      hasCredits,
+      creditBalance,
+      creditType,
+      onShowAuthModal,
+      onShowPaywall,
+    ]
   );
 
   return {
     requireFeature,
     isAuthenticated,
-    isPremium,
-    canAccess: isAuthenticated && isPremium,
+    hasCredits,
+    canAccess: isAuthenticated && hasCredits,
     isLoading,
+    creditBalance,
   };
 }