@umituz/react-native-subscription 2.26.19 → 2.26.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.26.19",
+  "version": "2.26.20",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -33,6 +33,7 @@
   },
   "peerDependencies": {
     "@tanstack/react-query": ">=5.0.0",
+    "@umituz/react-native-auth": ">=3.0.0",
     "expo-constants": ">=17.0.0",
     "expo-image": ">=3.0.0",
     "firebase": ">=10.0.0",

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

@@ -44,7 +44,6 @@ export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
   const { data: allPackages = [], isLoading } = useSubscriptionPackages(userId ?? undefined);
   const { eligibilityMap, checkEligibility } = useRevenueCatTrialEligibility();
   const { handlePurchase, handleRestore } = usePaywallActions({
-    userId: userId ?? undefined,
     source: purchaseSource,
     onPurchaseSuccess,
     onPurchaseError,

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -1,5 +1,9 @@
 import { useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
+import {
+  useAuthStore,
+  selectUserId,
+} from "@umituz/react-native-auth";
 import { useRestorePurchase } from "../../../revenuecat/presentation/hooks/useRestorePurchase";
 import { useAuthAwarePurchase } from "../../../presentation/hooks/useAuthAwarePurchase";
 import type { PurchaseSource } from "../../../domain/entities/Credits";
@@ -7,7 +11,6 @@ import type { PurchaseSource } from "../../../domain/entities/Credits";
 declare const __DEV__: boolean;
 
 interface UsePaywallActionsProps {
-  userId?: string;
   source?: PurchaseSource;
   onPurchaseSuccess?: () => void;
   onPurchaseError?: (error: string) => void;
@@ -16,38 +19,35 @@ interface UsePaywallActionsProps {
 }
 
 export const usePaywallActions = ({
-  userId,
   source,
   onPurchaseSuccess,
   onPurchaseError,
   onAuthRequired: _onAuthRequired,
   onClose,
 }: UsePaywallActionsProps) => {
-  const { handlePurchase: authAwarePurchase } = useAuthAwarePurchase({ source, userId });
-  const { mutateAsync: restorePurchases } = useRestorePurchase(userId);
+  const userId = useAuthStore(selectUserId);
+
+  const { handlePurchase: authAwarePurchase } = useAuthAwarePurchase({ source });
+  const { mutateAsync: restorePurchases } = useRestorePurchase(userId ?? undefined);
 
   const handlePurchase = useCallback(async (pkg: PurchasesPackage) => {
     try {
-      if (__DEV__) console.log("[PaywallActions] Purchase started:", pkg.product.identifier);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[PaywallActions] Purchase started:", pkg.product.identifier);
+      }
       const res = await authAwarePurchase(pkg, source);
-      if (__DEV__) console.log("[PaywallActions] Purchase result:", { res, productId: pkg.product.identifier });
       if (res) {
-        if (__DEV__) console.log("[PaywallActions] Purchase successful, closing paywall");
         onPurchaseSuccess?.();
         onClose();
-      } else {
-        if (__DEV__) console.log("[PaywallActions] Purchase returned false, paywall stays open");
       }
     } catch (err: unknown) {
       const message = err instanceof Error ? err.message : String(err);
-      if (__DEV__) console.log("[PaywallActions] Purchase error:", message);
       onPurchaseError?.(message);
     }
   }, [authAwarePurchase, source, onClose, onPurchaseSuccess, onPurchaseError]);
 
   const handleRestore = useCallback(async () => {
     try {
-      if (__DEV__) console.log("[PaywallActions] Restore started");
       const res = await restorePurchases();
       if (res.success) {
         onPurchaseSuccess?.();

package/src/domains/wallet/presentation/hooks/useTransactionHistory.ts

@@ -2,11 +2,15 @@
  * useTransactionHistory Hook
  *
  * TanStack Query hook for fetching credit transaction history.
- * Generic and reusable - uses config from TransactionRepository.
+ * Auth info automatically read from @umituz/react-native-auth.
  */
 
 import { useQuery } from "@umituz/react-native-design-system";
 import { useMemo } from "react";
+import {
+  useAuthStore,
+  selectUserId,
+} from "@umituz/react-native-auth";
 import type {
   CreditLog,
   TransactionRepositoryConfig,
@@ -15,21 +19,14 @@ import { TransactionRepository } from "../../infrastructure/repositories/Transac
 
 declare const __DEV__: boolean;
 
-const CACHE_CONFIG = {
-  staleTime: 60 * 1000, // 1 minute
-  gcTime: 5 * 60 * 1000, // 5 minutes
-};
-
 export const transactionQueryKeys = {
   all: ["transactions"] as const,
   user: (userId: string) => ["transactions", userId] as const,
 };
 
 export interface UseTransactionHistoryParams {
-  userId: string | undefined;
   config: TransactionRepositoryConfig;
   limit?: number;
-  enabled?: boolean;
 }
 
 export interface UseTransactionHistoryResult {
@@ -41,12 +38,11 @@ export interface UseTransactionHistoryResult {
 }
 
 export function useTransactionHistory({
-  userId,
   config,
   limit = 50,
-  enabled = true,
 }: UseTransactionHistoryParams): UseTransactionHistoryResult {
-  // Memoize repository to prevent recreation on every render
+  const userId = useAuthStore(selectUserId);
+
   const repository = useMemo(
     () => new TransactionRepository(config),
     [config]
@@ -68,17 +64,16 @@ export function useTransactionHistory({
 
       return result.data ?? [];
     },
-    enabled: enabled && !!userId,
-    staleTime: CACHE_CONFIG.staleTime,
-    gcTime: CACHE_CONFIG.gcTime,
+    enabled: !!userId,
+    staleTime: 0,
+    gcTime: 0,
   });
 
   const transactions = data ?? [];
 
-  if (__DEV__) {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
     console.log("[useTransactionHistory] State", {
-      userId,
-      enabled,
+      userId: userId?.slice(0, 8),
       isLoading,
       count: transactions.length,
     });

package/src/domains/wallet/presentation/hooks/useWallet.ts

@@ -6,21 +6,16 @@
  */
 
 import { useCallback, useMemo } from "react";
+import { useCredits } from "../../../../presentation/hooks/useCredits";
 import {
-    useCredits,
-    type UseCreditsParams,
-} from "../../../../presentation/hooks/useCredits";
-import {
-    useTransactionHistory,
-    type UseTransactionHistoryParams,
+  useTransactionHistory,
+  type UseTransactionHistoryParams,
 } from "./useTransactionHistory";
 import type { CreditLog } from "../../domain/types/transaction.types";
 
 export interface UseWalletParams {
-  userId: string | undefined;
   transactionConfig: UseTransactionHistoryParams["config"];
   transactionLimit?: number;
-  enabled?: boolean;
 }
 
 export interface UseWalletResult {
@@ -35,35 +30,24 @@ export interface UseWalletResult {
 }
 
 export function useWallet({
-  userId,
   transactionConfig,
   transactionLimit = 50,
-  enabled = true,
 }: UseWalletParams): UseWalletResult {
-  const creditsParams: UseCreditsParams = {
-    userId,
-    enabled,
-  };
-
-  const transactionParams: UseTransactionHistoryParams = {
-    userId,
-    config: transactionConfig,
-    limit: transactionLimit,
-    enabled,
-  };
-
   const {
     credits,
     isLoading: balanceLoading,
     refetch: refetchBalance,
     hasCredits,
-  } = useCredits(creditsParams);
+  } = useCredits();
 
   const {
     transactions,
     isLoading: transactionsLoading,
     refetch: refetchTransactions,
-  } = useTransactionHistory(transactionParams);
+  } = useTransactionHistory({
+    config: transactionConfig,
+    limit: transactionLimit,
+  });
 
   const balance = useMemo(() => {
     return credits?.credits ?? 0;

package/src/presentation/hooks/useAuthAwarePurchase.ts

@@ -37,7 +37,6 @@ export const clearSavedPurchase = (): void => {
 
 export interface UseAuthAwarePurchaseParams {
   source?: PurchaseSource;
-  userId?: string;
 }
 
 export interface UseAuthAwarePurchaseResult {
@@ -49,63 +48,44 @@ export interface UseAuthAwarePurchaseResult {
 export const useAuthAwarePurchase = (
   params?: UseAuthAwarePurchaseParams
 ): UseAuthAwarePurchaseResult => {
-  const { purchasePackage, restorePurchase } = usePremium(params?.userId);
+  const { purchasePackage, restorePurchase } = usePremium();
 
   const handlePurchase = useCallback(
     async (pkg: PurchasesPackage, source?: PurchaseSource): Promise<boolean> => {
-      if (__DEV__) {
-        console.log("[useAuthAwarePurchase] handlePurchase called:", {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[useAuthAwarePurchase] handlePurchase:", {
           productId: pkg.product.identifier,
           hasAuthProvider: !!globalAuthProvider,
         });
       }
 
       if (!globalAuthProvider) {
-        if (__DEV__) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.error("[useAuthAwarePurchase] Auth provider not configured");
         }
         return false;
       }
 
       const isAuth = globalAuthProvider.isAuthenticated();
-      if (__DEV__) {
-        console.log("[useAuthAwarePurchase] Auth check:", { isAuthenticated: isAuth });
-      }
 
       if (!isAuth) {
-        if (__DEV__) {
-          console.log("[useAuthAwarePurchase] Not authenticated, saving and showing auth");
-        }
         savedPackage = pkg;
         savedSource = source || params?.source || "settings";
         globalAuthProvider.showAuthModal();
         return false;
       }
 
-      if (__DEV__) {
-        console.log("[useAuthAwarePurchase] Calling purchasePackage");
-      }
-      const result = await purchasePackage(pkg);
-      if (__DEV__) {
-        console.log("[useAuthAwarePurchase] purchasePackage returned:", result);
-      }
-      return result;
+      return purchasePackage(pkg);
     },
     [purchasePackage, 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");
-      }
       globalAuthProvider.showAuthModal();
       return false;
     }
@@ -116,13 +96,10 @@ export const useAuthAwarePurchase = (
   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__) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[useAuthAwarePurchase] Executing saved purchase:", saved.pkg.product.identifier);
     }
 

package/src/presentation/hooks/useCredits.ts

@@ -1,18 +1,23 @@
 /**
  * useCredits Hook
  *
- * TanStack Query hook for fetching user credits.
- * Generic and reusable - uses config from module-level provider.
- * Auto-initializes free credits for new users if configured.
+ * Fetches user credits - NO CACHE, always fresh data.
+ * Auth info automatically read from @umituz/react-native-auth.
+ * Auto-initializes free credits for registered users only.
  */
 
 import { useQuery } from "@umituz/react-native-design-system";
 import { useCallback, useMemo, useEffect } from "react";
+import {
+  useAuthStore,
+  selectUserId,
+  selectIsAnonymous,
+} from "@umituz/react-native-auth";
 import type { UserCredits } from "../../domain/entities/Credits";
 import {
-    getCreditsRepository,
-    getCreditsConfig,
-    isCreditsRepositoryConfigured,
+  getCreditsRepository,
+  getCreditsConfig,
+  isCreditsRepositoryConfigured,
 } from "../../infrastructure/repositories/CreditsRepositoryProvider";
 
 declare const __DEV__: boolean;
@@ -22,33 +27,8 @@ export const creditsQueryKeys = {
   user: (userId: string) => ["credits", userId] as const,
 };
 
-/** Default stale time: 30 seconds - prevents infinite re-render loops */
-const DEFAULT_STALE_TIME = 30 * 1000;
-/** Default gc time: 5 minutes */
-const DEFAULT_GC_TIME = 5 * 60 * 1000;
-
-/**
- * Global tracker for free credits initialization attempts.
- * Shared across all useCredits hook instances to prevent multiple inits.
- */
 const freeCreditsInitAttempted = new Set<string>();
 
-export interface CreditsCacheConfig {
-  /** Time in ms before data is considered stale. Default: 30 seconds */
-  staleTime?: number;
-  /** Time in ms before inactive data is garbage collected. Default: 5 minutes */
-  gcTime?: number;
-}
-
-export interface UseCreditsParams {
-  userId: string | undefined;
-  enabled?: boolean;
-  /** Whether user is anonymous. Anonymous users don't get free credits. */
-  isAnonymous?: boolean;
-  /** Cache configuration. Default: 30 second staleTime, 5 minute gcTime */
-  cache?: CreditsCacheConfig;
-}
-
 export interface UseCreditsResult {
   credits: UserCredits | null;
   isLoading: boolean;
@@ -56,24 +36,18 @@ export interface UseCreditsResult {
   hasCredits: boolean;
   creditsPercent: number;
   refetch: () => void;
-  /** Check if user can afford a specific credit cost */
   canAfford: (cost: number) => boolean;
 }
 
-export const useCredits = ({
-  userId,
-  enabled = true,
-  isAnonymous = false,
-  cache,
-}: UseCreditsParams): UseCreditsResult => {
+export const useCredits = (): UseCreditsResult => {
+  const userId = useAuthStore(selectUserId);
+  const isAnonymous = useAuthStore(selectIsAnonymous);
+  const isRegisteredUser = !!userId && !isAnonymous;
+
   const isConfigured = isCreditsRepositoryConfigured();
   const config = getCreditsConfig();
 
-  // Default: 30 second stale time to prevent infinite re-render loops
-  const staleTime = cache?.staleTime ?? DEFAULT_STALE_TIME;
-  const gcTime = cache?.gcTime ?? DEFAULT_GC_TIME;
-
-  const queryEnabled = enabled && !!userId && isConfigured;
+  const queryEnabled = !!userId && isConfigured;
 
   const { data, isLoading, error, refetch, isFetched } = useQuery({
     queryKey: creditsQueryKeys.user(userId ?? ""),
@@ -87,7 +61,6 @@ export const useCredits = ({
         throw new Error(result.error?.message || "Failed to fetch credits");
       }
 
-      // Background sync: If mapper detected expired status, sync to Firestore
       if (result.data?.status === "expired") {
         repository.syncExpiredStatus(userId).catch((syncError) => {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -99,8 +72,8 @@ export const useCredits = ({
       return result.data || null;
     },
     enabled: queryEnabled,
-    staleTime,
-    gcTime,
+    staleTime: 0,
+    gcTime: 0,
     refetchOnMount: true,
     refetchOnWindowFocus: true,
     refetchOnReconnect: true,
@@ -108,33 +81,23 @@ export const useCredits = ({
 
   const credits = data ?? null;
 
-  // Auto-initialize free credits for new users
   const freeCredits = config.freeCredits ?? 0;
   const autoInit = config.autoInitializeFreeCredits !== false && freeCredits > 0;
 
   useEffect(() => {
-    // Only run if:
-    // 1. Query has completed (isFetched)
-    // 2. User is authenticated (not anonymous)
-    // 3. No credits data exists
-    // 4. Free credits configured
-    // 5. Auto-init enabled
-    // 6. Haven't already attempted for this user (global tracking)
-    // 7. User is NOT anonymous (anonymous users must register first)
     if (
       isFetched &&
       userId &&
-      !isAnonymous &&
+      isRegisteredUser &&
       isConfigured &&
       !credits &&
       autoInit &&
       !freeCreditsInitAttempted.has(userId)
     ) {
-      // Mark as attempted IMMEDIATELY to prevent other hook instances
       freeCreditsInitAttempted.add(userId);
 
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useCredits] Auto-initializing free credits for new registered user:", userId.slice(0, 8));
+        console.log("[useCredits] Initializing free credits for registered user:", userId.slice(0, 8));
       }
 
       const repository = getCreditsRepository();
@@ -152,25 +115,20 @@ export const useCredits = ({
       });
     } else if (isFetched && userId && isAnonymous && !credits && autoInit) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useCredits] Skipping free credits for anonymous user - registration required");
+        console.log("[useCredits] Skipping free credits - anonymous user must register first");
       }
     }
-  }, [isFetched, userId, isAnonymous, isConfigured, credits, autoInit, refetch]);
+  }, [isFetched, userId, isRegisteredUser, isAnonymous, isConfigured, credits, autoInit, refetch]);
 
-  // Memoize derived values to prevent unnecessary re-renders
   const derivedValues = useMemo(() => {
     const has = (credits?.credits ?? 0) > 0;
     const percent = credits
       ? Math.round((credits.credits / config.creditLimit) * 100)
       : 0;
 
-    return {
-      hasCredits: has,
-      creditsPercent: percent,
-    };
+    return { hasCredits: has, creditsPercent: percent };
   }, [credits, config.creditLimit]);
 
-  // Memoize canAfford to prevent recreation on every render
   const canAfford = useCallback(
     (cost: number): boolean => {
       if (!credits) return false;
@@ -190,11 +148,7 @@ export const useCredits = ({
   };
 };
 
-export const useHasCredits = (
-  userId: string | undefined,
-  isAnonymous?: boolean
-): boolean => {
-  const { credits } = useCredits({ userId, isAnonymous });
-  if (!credits) return false;
-  return credits.credits > 0;
+export const useHasCredits = (): boolean => {
+  const { hasCredits } = useCredits();
+  return hasCredits;
 };

package/src/presentation/hooks/usePremium.ts

@@ -1,101 +1,66 @@
 /**
  * usePremium Hook
- * Complete subscription management for 100+ apps
- * Works for both authenticated and anonymous users
  *
- * IMPORTANT: isPremium is based on actual RevenueCat subscription status,
- * NOT on whether credits document exists.
+ * Complete subscription management.
+ * Auth info automatically read from @umituz/react-native-auth.
  */
 
 import { useCallback } from 'react';
 import type { PurchasesPackage } from 'react-native-purchases';
+import {
+  useAuthStore,
+  selectUserId,
+} from "@umituz/react-native-auth";
 import type { UserCredits } from '../../domain/entities/Credits';
 import { useCredits } from './useCredits';
 import { useSubscriptionStatus } from './useSubscriptionStatus';
 import {
-    useSubscriptionPackages,
-    usePurchasePackage,
-    useRestorePurchase,
+  useSubscriptionPackages,
+  usePurchasePackage,
+  useRestorePurchase,
 } from '../../revenuecat/presentation/hooks/useSubscriptionQueries';
 import { usePaywallVisibility } from './usePaywallVisibility';
 
+declare const __DEV__: boolean;
+
 export interface UsePremiumResult {
-  /** User has active premium subscription */
   isPremium: boolean;
-  /** Loading credits or packages */
   isLoading: boolean;
-  /** Available subscription packages */
   packages: PurchasesPackage[];
-  /** User's credits (null if not premium) */
   credits: UserCredits | null;
-  /** Paywall visibility state */
   showPaywall: boolean;
-  /** Purchase a subscription package */
   purchasePackage: (pkg: PurchasesPackage) => Promise<boolean>;
-  /** Restore previous purchases */
   restorePurchase: () => Promise<boolean>;
-  /** Set paywall visibility */
   setShowPaywall: (show: boolean) => void;
-  /** Close paywall */
   closePaywall: () => void;
-  /** Open paywall */
   openPaywall: () => void;
 }
 
-/**
- * Complete premium subscription management
- *
- * @param userId - User ID (undefined for anonymous users)
- * @returns Premium status, packages, and subscription actions
- *
- * @example
- * ```typescript
- * const { isPremium, packages, purchasePackage } = usePremium(userId);
- * ```
- */
-export const usePremium = (userId?: string): UsePremiumResult => {
-  // Fetch real subscription status from RevenueCat
-  const { isPremium: subscriptionActive, isLoading: statusLoading } =
-    useSubscriptionStatus({
-      userId,
-      enabled: !!userId,
-    });
+export const usePremium = (): UsePremiumResult => {
+  const userId = useAuthStore(selectUserId);
 
-  // Fetch user credits (server state)
-  const { credits, isLoading: creditsLoading } = useCredits({
-    userId,
-    enabled: !!userId,
-  });
+  const { isPremium: subscriptionActive, isLoading: statusLoading } = useSubscriptionStatus();
+  const { credits, isLoading: creditsLoading } = useCredits();
 
-  // Fetch subscription packages (works for anonymous too)
-  const { data: packages = [], isLoading: packagesLoading } =
-    useSubscriptionPackages(userId);
+  const { data: packages = [], isLoading: packagesLoading } = useSubscriptionPackages(userId ?? undefined);
 
-  // Purchase and restore mutations
-  const purchaseMutation = usePurchasePackage(userId);
-  const restoreMutation = useRestorePurchase(userId);
+  const purchaseMutation = usePurchasePackage(userId ?? undefined);
+  const restoreMutation = useRestorePurchase(userId ?? undefined);
 
-  // Paywall visibility state
-  const { showPaywall, setShowPaywall, closePaywall, openPaywall } =
-    usePaywallVisibility();
+  const { showPaywall, setShowPaywall, closePaywall, openPaywall } = usePaywallVisibility();
 
-  // Premium status = actual subscription status from RevenueCat
   const isPremium = subscriptionActive;
 
-  // Purchase handler with proper error handling
   const handlePurchase = useCallback(
     async (pkg: PurchasesPackage): Promise<boolean> => {
-      if (__DEV__) {
-        console.log("[usePremium] handlePurchase called:", pkg.product.identifier);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[usePremium] handlePurchase:", pkg.product.identifier);
       }
       try {
         const result = await purchaseMutation.mutateAsync(pkg);
-        if (__DEV__) {
-          console.log("[usePremium] Purchase result:", { success: result.success });
-        }
         return result.success;
       } catch (error) {
-        if (__DEV__) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.error("[usePremium] Purchase failed:", error);
         }
         return false;
@@ -104,13 +69,12 @@ export const usePremium = (userId?: string): UsePremiumResult => {
     [purchaseMutation],
   );
 
-  // Restore handler with proper error handling
   const handleRestore = useCallback(async (): Promise<boolean> => {
     try {
       const result = await restoreMutation.mutateAsync();
       return result.success;
     } catch (error) {
-      if (__DEV__) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.error("[usePremium] Restore failed:", error);
       }
       return false;

package/src/presentation/hooks/useSavedPurchaseAutoExecution.ts

@@ -4,6 +4,11 @@
  */
 
 import { useEffect, useRef } from "react";
+import {
+  useAuthStore,
+  selectUserId,
+  selectIsAnonymous,
+} from "@umituz/react-native-auth";
 import { getSavedPurchase, clearSavedPurchase } from "./useAuthAwarePurchase";
 import { usePremium } from "./usePremium";
 import { SubscriptionManager } from "../../revenuecat";
@@ -12,8 +17,6 @@ import { usePurchaseLoadingStore } from "../stores";
 declare const __DEV__: boolean;
 
 export interface UseSavedPurchaseAutoExecutionParams {
-  userId?: string;
-  isAnonymous?: boolean;
   onSuccess?: () => void;
   onError?: (error: Error) => void;
 }
@@ -23,24 +26,26 @@ export interface UseSavedPurchaseAutoExecutionResult {
 }
 
 export const useSavedPurchaseAutoExecution = (
-  params: UseSavedPurchaseAutoExecutionParams
+  params?: UseSavedPurchaseAutoExecutionParams
 ): UseSavedPurchaseAutoExecutionResult => {
-  const { userId, isAnonymous, onSuccess, onError } = params;
-  const { purchasePackage } = usePremium(userId);
+  const { onSuccess, onError } = params ?? {};
+
+  const userId = useAuthStore(selectUserId);
+  const isAnonymous = useAuthStore(selectIsAnonymous);
+
+  const { purchasePackage } = usePremium();
   const { startPurchase, endPurchase } = usePurchaseLoadingStore();
 
   const prevIsAnonymousRef = useRef<boolean | undefined>(undefined);
   const isExecutingRef = useRef(false);
   const hasExecutedRef = useRef(false);
 
-  // Store callbacks in refs to avoid dependency changes
   const purchasePackageRef = useRef(purchasePackage);
   const onSuccessRef = useRef(onSuccess);
   const onErrorRef = useRef(onError);
   const startPurchaseRef = useRef(startPurchase);
   const endPurchaseRef = useRef(endPurchase);
 
-  // Update refs when values change
   useEffect(() => {
     purchasePackageRef.current = purchasePackage;
   }, [purchasePackage]);
@@ -69,10 +74,9 @@ export const useSavedPurchaseAutoExecution = (
     const wasAnonymous = prevIsAnonymous === true;
     const becameAuthenticated = wasAnonymous && isAuthenticated;
 
-    // Only log when there's a state change worth noting
     const shouldLog = prevIsAnonymousRef.current !== isAnonymous;
 
-    if (__DEV__ && shouldLog) {
+    if (typeof __DEV__ !== "undefined" && __DEV__ && shouldLog) {
       console.log("[SavedPurchaseAutoExecution] Auth state check:", {
         userId: userId?.slice(0, 8),
         prevIsAnonymous,
@@ -90,21 +94,15 @@ export const useSavedPurchaseAutoExecution = (
       });
     }
 
-    // Execute only once when transitioning from anonymous to authenticated
     if (
       becameAuthenticated &&
       savedPurchase &&
       !isExecutingRef.current &&
       !hasExecutedRef.current
     ) {
-      if (__DEV__) {
-        console.log("[SavedPurchaseAutoExecution] Triggering auto-execution...");
-      }
-
       hasExecutedRef.current = true;
       isExecutingRef.current = true;
 
-      // Execute purchase flow
       const executeFlow = async () => {
         const currentUserId = userId;
         if (!currentUserId) {
@@ -112,75 +110,31 @@ export const useSavedPurchaseAutoExecution = (
           return;
         }
 
-        if (__DEV__) {
-          console.log(
-            "[SavedPurchaseAutoExecution] Waiting for RevenueCat initialization...",
-            {
-              userId: currentUserId.slice(0, 8),
-              productId: savedPurchase.pkg.product.identifier,
-            }
-          );
-        }
-
         const maxAttempts = 20;
         const delayMs = 500;
 
         for (let attempt = 0; attempt < maxAttempts; attempt++) {
           const isReady = SubscriptionManager.isInitializedForUser(currentUserId);
 
-          if (__DEV__) {
-            console.log(
-              `[SavedPurchaseAutoExecution] Attempt ${attempt + 1}/${maxAttempts}, isReady: ${isReady}`
-            );
-          }
-
           if (isReady) {
             const pkg = savedPurchase.pkg;
             clearSavedPurchase();
 
-            if (__DEV__) {
-              console.log(
-                "[SavedPurchaseAutoExecution] RevenueCat ready, starting purchase...",
-                { productId: pkg.product.identifier, userId: currentUserId.slice(0, 8) }
-              );
-            }
-
             startPurchaseRef.current(pkg.product.identifier, "auto-execution");
 
             try {
-              if (__DEV__) {
-                console.log("[SavedPurchaseAutoExecution] Calling purchasePackage...");
-              }
-
               const success = await purchasePackageRef.current(pkg);
 
-              if (__DEV__) {
-                console.log("[SavedPurchaseAutoExecution] Purchase completed:", {
-                  success,
-                  productId: pkg.product.identifier,
-                });
-              }
-
               if (success && onSuccessRef.current) {
                 onSuccessRef.current();
               }
             } catch (error) {
-              if (__DEV__) {
-                console.error("[SavedPurchaseAutoExecution] Purchase error:", {
-                  error,
-                  productId: pkg.product.identifier,
-                });
-              }
               if (onErrorRef.current && error instanceof Error) {
                 onErrorRef.current(error);
               }
             } finally {
               endPurchaseRef.current();
               isExecutingRef.current = false;
-
-              if (__DEV__) {
-                console.log("[SavedPurchaseAutoExecution] Purchase flow finished");
-              }
             }
 
             return;
@@ -189,11 +143,6 @@ export const useSavedPurchaseAutoExecution = (
           await new Promise((resolve) => setTimeout(resolve, delayMs));
         }
 
-        if (__DEV__) {
-          console.log(
-            "[SavedPurchaseAutoExecution] Timeout waiting for RevenueCat, clearing saved purchase"
-          );
-        }
         clearSavedPurchase();
         isExecutingRef.current = false;
       };

package/src/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -1,7 +1,6 @@
 /**
  * useSubscriptionSettingsConfig Hook
  * Returns ready-to-use config for settings screens
- * Single Source of Truth: Firestore (credits document)
  */
 
 import { useMemo, useCallback } from "react";
@@ -24,58 +23,43 @@ export type {
   UseSubscriptionSettingsConfigParams,
 } from "../types/SubscriptionSettingsTypes";
 
-/**
- * Hook that returns ready-to-use subscription config for settings
- * Single Source of Truth: Firestore credits document
- */
 export const useSubscriptionSettingsConfig = (
-  params: UseSubscriptionSettingsConfigParams
+  params: Omit<UseSubscriptionSettingsConfigParams, 'userId'>
 ): SubscriptionSettingsConfig => {
-  const { userId, translations, creditLimit, upgradePrompt } = params;
+  const { translations, creditLimit, upgradePrompt } = params;
 
-  // Single Source of Truth: Firestore credits document
-  const { credits } = useCredits({ userId, enabled: !!userId });
+  const { credits } = useCredits();
   const { openPaywall } = usePaywallVisibility();
 
   const handleOpenPaywall = useCallback(() => {
     openPaywall("settings");
   }, [openPaywall]);
 
-  // All data from Firestore (Single Source of Truth)
   const isPremium = credits?.isPremium ?? false;
   const willRenew = credits?.willRenew ?? false;
 
-  // Expiration date from Firestore
   const expiresAtIso = credits?.expirationDate?.toISOString() ?? null;
-
-  // Purchase date from Firestore
   const purchasedAtIso = credits?.purchasedAt?.toISOString() ?? null;
 
-  // Credit limit from Firestore or config fallback
   const dynamicCreditLimit = useMemo(() => {
     if (credits?.creditLimit) return credits.creditLimit;
     const config = getCreditsConfig();
     return creditLimit ?? config.creditLimit;
   }, [credits?.creditLimit, creditLimit]);
 
-  // Formatted dates
   const formattedExpirationDate = useMemo(() => formatDate(expiresAtIso), [expiresAtIso]);
   const formattedPurchaseDate = useMemo(() => formatDate(purchasedAtIso), [purchasedAtIso]);
 
-  // Days remaining
   const daysRemaining = useMemo(() => calculateDaysRemaining(expiresAtIso), [expiresAtIso]);
 
-  // Period type from Firestore
   const periodType = credits?.periodType;
 
-  // Status type: prioritize Firestore status, then derive from willRenew + expiration + periodType
   const statusType: SubscriptionStatusType = credits?.status
     ? (credits.status as SubscriptionStatusType)
     : getSubscriptionStatusType(isPremium, willRenew, expiresAtIso, periodType);
 
   const creditsArray = useCreditsArray(credits, dynamicCreditLimit, translations);
 
-  // Centralized display flags
   const hasCredits = creditsArray.length > 0;
   const display = useMemo(() => ({
     showHeader: isPremium || hasCredits,
@@ -84,7 +68,6 @@ export const useSubscriptionSettingsConfig = (
     showExpirationDate: (isPremium || hasCredits) && !!expiresAtIso,
   }), [isPremium, hasCredits, upgradePrompt, expiresAtIso]);
 
-  // Build config
   return useMemo((): SubscriptionSettingsConfig => ({
     enabled: true,
     settingsItem: {

package/src/presentation/hooks/useSubscriptionStatus.ts

@@ -1,11 +1,15 @@
 /**
  * useSubscriptionStatus Hook
  *
- * TanStack Query hook for checking real subscription status from RevenueCat.
- * This provides the actual premium status based on entitlements, not credits.
+ * Checks real subscription status from RevenueCat.
+ * Auth info automatically read from @umituz/react-native-auth.
  */
 
 import { useQuery } from "@umituz/react-native-design-system";
+import {
+  useAuthStore,
+  selectUserId,
+} from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
 
 export const subscriptionStatusQueryKeys = {
@@ -21,34 +25,20 @@ export interface SubscriptionStatusResult {
   refetch: () => void;
 }
 
-export interface UseSubscriptionStatusParams {
-  userId: string | undefined;
-  enabled?: boolean;
-}
+export const useSubscriptionStatus = (): SubscriptionStatusResult => {
+  const userId = useAuthStore(selectUserId);
 
-/**
- * Check real subscription status from RevenueCat
- *
- * @param userId - User ID
- * @param enabled - Whether to enable the query
- * @returns Subscription status with isPremium flag
- */
-export const useSubscriptionStatus = ({
-  userId,
-  enabled = true,
-}: UseSubscriptionStatusParams): SubscriptionStatusResult => {
   const { data, isLoading, error, refetch } = useQuery({
     queryKey: subscriptionStatusQueryKeys.user(userId ?? ""),
     queryFn: async () => {
       if (!userId) {
         return { isPremium: false, expirationDate: null };
       }
-
       return SubscriptionManager.checkPremiumStatus();
     },
-    enabled: enabled && !!userId && SubscriptionManager.isInitializedForUser(userId),
-    staleTime: 0, // No cache - always fetch fresh premium status
-    gcTime: 0, // Don't cache - garbage collect immediately
+    enabled: !!userId && SubscriptionManager.isInitializedForUser(userId),
+    staleTime: 0,
+    gcTime: 0,
     refetchOnMount: true,
     refetchOnWindowFocus: true,
     refetchOnReconnect: true,