@umituz/react-native-subscription 2.13.11 → 2.13.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.13.11",
+  "version": "2.13.13",
   "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/presentation/hooks/useCredits.ts

@@ -7,6 +7,8 @@
 
 import { useQuery } from "@tanstack/react-query";
 import type { UserCredits, CreditType } from "../../domain/entities/Credits";
+
+declare const __DEV__: boolean;
 import {
   getCreditsRepository,
   getCreditsConfig,
@@ -64,6 +66,18 @@ export const useCredits = ({
   const hasTextCredits = (credits?.textCredits ?? 0) > 0;
   const hasImageCredits = (credits?.imageCredits ?? 0) > 0;
 
+  if (__DEV__) {
+    console.log("[useCredits] State", {
+      userId,
+      enabled,
+      isLoading,
+      imageCredits: credits?.imageCredits ?? 0,
+      textCredits: credits?.textCredits ?? 0,
+      hasImageCredits,
+      hasTextCredits,
+    });
+  }
+
   const textCreditsPercent = credits
     ? Math.round((credits.textCredits / config.textCreditLimit) * 100)
     : 0;

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,118 @@ 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;
+
+  if (__DEV__) {
+    console.log("[useFeatureGate] Hook state", {
+      userId,
+      isAuthenticated,
+      creditType,
+      hasCredits,
+      creditBalance,
+      isLoading,
+    });
+  }
 
   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,
   };
 }