@umituz/react-native-subscription 2.43.5 → 2.43.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.43.5",
+  "version": "2.43.7",
   "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/credits/application/DeductCreditsCommand.ts

@@ -1,7 +1,6 @@
 import { runTransaction, serverTimestamp, type Transaction, type DocumentReference, type Firestore } from "@umituz/react-native-firebase";
 import type { DeductCreditsResult } from "../core/Credits";
 import { CREDIT_ERROR_CODES, MAX_SINGLE_DEDUCTION } from "../core/CreditsConstants";
-import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
 export async function deductCreditsOperation(
   _db: Firestore,
@@ -65,8 +64,6 @@ export async function deductCreditsOperation(
 
     if (__DEV__) console.log('[DeductCreditsCommand] transaction SUCCESS, remaining:', remaining);
 
-    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
-
     return {
       success: true,
       remainingCredits: remaining,

package/src/domains/credits/application/RefundCreditsCommand.ts

@@ -1,7 +1,6 @@
 import { runTransaction, serverTimestamp, type Transaction, type DocumentReference, type Firestore } from "@umituz/react-native-firebase";
 import type { DeductCreditsResult } from "../core/Credits";
 import { CREDIT_ERROR_CODES } from "../core/CreditsConstants";
-import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
 export async function refundCreditsOperation(
   _db: Firestore,
@@ -53,8 +52,6 @@ export async function refundCreditsOperation(
       return updated;
     });
 
-    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
-
     return {
       success: true,
       remainingCredits: remaining,

package/src/domains/credits/presentation/deduct-credit/mutationConfig.ts

@@ -72,7 +72,7 @@ export function createDeductCreditMutationConfig(
         );
       }
     },
-    // onSuccess removed - CREDITS_UPDATED event handles invalidation
-    // Optimistic update already applied, event will trigger refetch if needed
+    // onSuccess removed - real-time sync (onSnapshot) handles automatic updates
+    // Optimistic update already applied, real-time listener will confirm actual value
   };
 }

package/src/domains/credits/presentation/deduct-credit/useDeductCredit.ts

@@ -56,7 +56,7 @@ export const useDeductCredit = ({
     try {
       const result = await repository.refundCredit(userId, amount);
       if (result.success) {
-        // CREDITS_UPDATED event emitted by RefundCreditsCommand handles invalidation
+        // Real-time sync (onSnapshot) handles automatic update
         return true;
       }
       return false;
@@ -70,7 +70,7 @@ export const useDeductCredit = ({
       }
       return false;
     }
-  }, [userId, repository, queryClient]);
+  }, [userId, repository]);
 
   return {
     checkCredits,

package/src/domains/credits/presentation/useCredits.ts

@@ -1,27 +1,22 @@
-import { useQuery, useQueryClient } from "@umituz/react-native-design-system/tanstack";
-import { useCallback, useMemo, useEffect } from "react";
+import { useCallback, useMemo } from "react";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
-import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
-import { SHORT_CACHE_CONFIG } from "../../../shared/infrastructure/react-query/queryConfig";
-import { usePreviousUserCleanup } from "../../../shared/infrastructure/react-query/hooks/usePreviousUserCleanup";
 import {
-  getCreditsRepository,
   getCreditsConfig,
   isCreditsRepositoryConfigured,
 } from "../infrastructure/CreditsRepositoryManager";
 import { calculateSafePercentage, canAffordAmount } from "../utils/creditValidation";
 import { isAuthenticated } from "../../subscription/utils/authGuards";
-import { creditsQueryKeys } from "./creditsQueryKeys";
 import type { UseCreditsResult, CreditsLoadStatus } from "./useCredits.types";
-import type { UserCredits } from "../core/Credits";
+import { useCreditsRealTime } from "./useCreditsRealTime";
 
 const deriveLoadStatus = (
-  queryStatus: "pending" | "error" | "success",
+  isLoading: boolean,
+  error: Error | null,
   queryEnabled: boolean
 ): CreditsLoadStatus => {
   if (!queryEnabled) return "idle";
-  if (queryStatus === "pending") return "loading";
-  if (queryStatus === "error") return "error";
+  if (isLoading) return "loading";
+  if (error) return "error";
   return "ready";
 };
 
@@ -33,41 +28,7 @@ export const useCredits = (): UseCreditsResult => {
   const hasUser = isAuthenticated(userId);
   const queryEnabled = hasUser && isConfigured;
 
-  const { data, status, error, refetch } = useQuery<UserCredits | null, Error>({
-    queryKey: creditsQueryKeys.user(userId),
-    queryFn: async () => {
-      if (!hasUser || !isConfigured) return null;
-
-      const repository = getCreditsRepository();
-      const result = await repository.getCredits(userId);
-
-      if (!result.success) {
-        throw new Error(result.error?.message || "Failed to fetch credits");
-      }
-
-      return result.data ?? null;
-    },
-    enabled: queryEnabled,
-    ...SHORT_CACHE_CONFIG,
-  });
-
-  const queryClient = useQueryClient();
-
-  usePreviousUserCleanup(userId, queryClient, creditsQueryKeys.user);
-
-  useEffect(() => {
-    if (!hasUser) return undefined;
-
-    const unsubscribe = subscriptionEventBus.on(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, (updatedUserId) => {
-      if (updatedUserId === userId) {
-        queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(userId) });
-      }
-    });
-
-    return unsubscribe;
-  }, [userId, hasUser, queryClient]);
-
-  const credits = data ?? null;
+  const { credits, isLoading, error } = useCreditsRealTime(userId);
 
   const derivedValues = useMemo(() => {
     const has = (credits?.credits ?? 0) > 0;
@@ -81,19 +42,18 @@ export const useCredits = (): UseCreditsResult => {
     [credits]
   );
 
-  const loadStatus = deriveLoadStatus(status, queryEnabled);
+  const loadStatus = deriveLoadStatus(isLoading, error, queryEnabled);
   const isCreditsLoaded = loadStatus === "ready";
-  const isLoading = loadStatus === "loading";
 
   return {
     credits,
     isLoading,
     isCreditsLoaded,
     loadStatus,
-    error: error instanceof Error ? error : null,
+    error,
     hasCredits: derivedValues.hasCredits,
     creditsPercent: derivedValues.creditsPercent,
-    refetch,
+    refetch: async () => {},
     canAfford,
   };
 };

package/src/domains/credits/presentation/useCreditsRealTime.ts

@@ -0,0 +1,115 @@
+import { useEffect, useState, useCallback } from "react";
+import { onSnapshot } from "firebase/firestore";
+import type { UserCredits } from "../core/Credits";
+import { getCreditsConfig } from "../infrastructure/CreditsRepositoryManager";
+import { mapCreditsDocumentToEntity } from "../core/CreditsMapper";
+import { requireFirestore, buildDocRef, type CollectionConfig } from "../../../shared/infrastructure/firestore/collectionUtils";
+import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
+
+/**
+ * Real-time sync for credits using Firestore onSnapshot.
+ * Provides instant updates without cache invalidation complexity.
+ *
+ * Benefits:
+ * - Zero cache invalidation needed
+ * - Instant updates from Firestore
+ * - Always consistent with server state
+ * - Simpler code (no event listeners needed)
+ *
+ * @param userId - User ID to sync credits for
+ * @returns Credits state and loading status
+ */
+export function useCreditsRealTime(userId: string | null | undefined) {
+  const [credits, setCredits] = useState<UserCredits | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    // Reset state when userId changes
+    if (!userId) {
+      setCredits(null);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const db = requireFirestore();
+      const config = getCreditsConfig();
+
+      // Build doc ref using same logic as repository
+      const collectionConfig: CollectionConfig = {
+        collectionName: config.collectionName,
+        useUserSubcollection: config.useUserSubcollection,
+      };
+      const docRef = buildDocRef(db, userId, "balance", collectionConfig);
+
+      // Real-time listener
+      const unsubscribe = onSnapshot(
+        docRef,
+        (snapshot) => {
+          if (snapshot.exists()) {
+            const entity = mapCreditsDocumentToEntity(snapshot.data() as UserCreditsDocumentRead);
+            setCredits(entity);
+          } else {
+            setCredits(null);
+          }
+          setIsLoading(false);
+        },
+        (err) => {
+          console.error("[useCreditsRealTime] Snapshot error:", err);
+          setError(err as Error);
+          setIsLoading(false);
+        }
+      );
+
+      return () => {
+        unsubscribe();
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error("[useCreditsRealTime] Setup error:", err);
+      setError(error);
+      setIsLoading(false);
+    }
+  }, [userId]);
+
+  const refetch = useCallback(() => {
+    // Real-time sync doesn't need refetch, but keep for API compatibility
+    // The snapshot listener will automatically update when data changes
+    if (__DEV__) {
+      console.warn("[useCreditsRealTime] Refetch called - not needed for real-time sync");
+    }
+  }, []);
+
+  return {
+    credits,
+    isLoading,
+    error,
+    refetch, // No-op but kept for compatibility
+  };
+}
+
+/**
+ * Hook to get derived credit values with real-time sync.
+ * This is the real-time equivalent of the computed values in useCredits.
+ */
+export function useCreditsRealTimeDerived(userId: string | null | undefined) {
+  const { credits, isLoading } = useCreditsRealTime(userId);
+
+  const hasCredits = (credits?.credits ?? 0) > 0;
+  const creditsPercent = credits ? Math.min(
+    (credits.credits / credits.creditLimit) * 100,
+    100
+  ) : 0;
+
+  return {
+    hasCredits,
+    creditsPercent,
+    isLoading,
+    credits,
+  };
+}

package/src/domains/subscription/application/SubscriptionSyncProcessor.ts

@@ -234,7 +234,6 @@ export class SubscriptionSyncProcessor {
         throw new Error(`[SubscriptionSyncProcessor] Credit initialization failed for purchase: ${result.error?.message ?? 'unknown'}`);
       }
 
-      this.emitCreditsUpdated(creditsUserId);
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log('[SubscriptionSyncProcessor] 🟢 processPurchase: Credits initialized successfully', {
           creditsUserId,
@@ -271,7 +270,6 @@ export class SubscriptionSyncProcessor {
         throw new Error(`[SubscriptionSyncProcessor] Credit initialization failed for renewal: ${result.error?.message ?? 'unknown'}`);
       }
 
-      this.emitCreditsUpdated(creditsUserId);
     } finally {
       this.purchaseInProgress = false;
     }
@@ -315,7 +313,6 @@ export class SubscriptionSyncProcessor {
 
   private async expireSubscription(userId: string): Promise<void> {
     await getCreditsRepository().syncExpiredStatus(userId);
-    this.emitCreditsUpdated(userId);
   }
 
   private async syncPremiumStatus(userId: string, event: PremiumStatusChangedEvent): Promise<void> {
@@ -357,7 +354,6 @@ export class SubscriptionSyncProcessor {
       store: event.store ?? null,
       ownershipType: event.ownershipType ?? null,
     });
-    this.emitCreditsUpdated(userId);
 
     if (__DEV__) {
       console.log('[SubscriptionSyncProcessor] 🟢 syncPremiumStatus: Completed', {
@@ -367,8 +363,4 @@ export class SubscriptionSyncProcessor {
       });
     }
   }
-
-  private emitCreditsUpdated(userId: string): void {
-    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
-  }
 }

package/src/domains/subscription/infrastructure/hooks/usePurchasePackage.ts

@@ -1,4 +1,4 @@
-import { useMutation, useQueryClient } from "@umituz/react-native-design-system/tanstack";
+import { useMutation } from "@umituz/react-native-design-system/tanstack";
 import type { PurchasesPackage } from "react-native-purchases";
 import { useAlert } from "@umituz/react-native-design-system/molecules";
 import {
@@ -6,7 +6,6 @@ import {
   selectUserId,
 } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
-import { SUBSCRIPTION_QUERY_KEYS } from "./subscriptionQueryKeys";
 import { getErrorMessage } from "../../../revenuecat/core/errors/RevenueCatErrorHandler";
 
 interface PurchaseMutationResult {
@@ -16,7 +15,6 @@ interface PurchaseMutationResult {
 
 export const usePurchasePackage = () => {
   const userId = useAuthStore(selectUserId);
-  const queryClient = useQueryClient();
   const { showSuccess, showError } = useAlert();
 
   return useMutation({
@@ -37,14 +35,6 @@ export const usePurchasePackage = () => {
     onSuccess: (result) => {
       if (result.success) {
         showSuccess("Purchase Successful", "Your subscription is now active!");
-
-        // Invalidate packages cache (no event listener for packages)
-        queryClient.invalidateQueries({ queryKey: SUBSCRIPTION_QUERY_KEYS.packages });
-
-        // Credits and subscription status are invalidated via events:
-        // - CREDITS_UPDATED event (SubscriptionSyncProcessor → useCredits)
-        // - PREMIUM_STATUS_CHANGED event (SubscriptionSyncProcessor → useSubscriptionStatus)
-        // No manual invalidation needed here
       } else {
         showError("Purchase Failed", "Unable to complete purchase. Please try again.");
       }

package/src/domains/subscription/infrastructure/hooks/useRestorePurchase.ts

@@ -1,11 +1,10 @@
-import { useMutation, useQueryClient } from "@umituz/react-native-design-system/tanstack";
+import { useMutation } from "@umituz/react-native-design-system/tanstack";
 import { useAlert } from "@umituz/react-native-design-system/molecules";
 import {
   useAuthStore,
   selectUserId,
 } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
-import { SUBSCRIPTION_QUERY_KEYS } from "./subscriptionQueryKeys";
 import { getErrorMessage } from "../../../revenuecat/core/errors/RevenueCatErrorHandler";
 
 interface RestoreResult {
@@ -15,7 +14,6 @@ interface RestoreResult {
 
 export const useRestorePurchase = () => {
   const userId = useAuthStore(selectUserId);
-  const queryClient = useQueryClient();
   const { showSuccess, showInfo, showError } = useAlert();
 
   return useMutation({
@@ -29,14 +27,6 @@ export const useRestorePurchase = () => {
     },
     onSuccess: (result) => {
       if (result.success) {
-        // Invalidate packages cache (no event listener for packages)
-        queryClient.invalidateQueries({ queryKey: SUBSCRIPTION_QUERY_KEYS.packages });
-
-        // Credits and subscription status are invalidated via events:
-        // - CREDITS_UPDATED event (SubscriptionSyncProcessor → useCredits)
-        // - PREMIUM_STATUS_CHANGED event (SubscriptionSyncProcessor → useSubscriptionStatus)
-        // No manual invalidation needed here
-
         if (result.productId) {
           showSuccess("Restore Successful", "Your subscription has been restored!");
         } else {

package/src/domains/subscription/infrastructure/hooks/useSubscriptionPackages.ts

@@ -1,21 +1,20 @@
-import { useQuery, useQueryClient } from "@umituz/react-native-design-system/tanstack";
-import { useEffect, useRef, useSyncExternalStore } from "react";
+import { useState, useEffect, useSyncExternalStore, useRef, useCallback } from "react";
 import {
   useAuthStore,
   selectUserId,
 } from "@umituz/react-native-auth";
 import { SubscriptionManager } from '../../infrastructure/managers/SubscriptionManager';
 import { initializationState } from "../../infrastructure/state/initializationState";
-import {
-  SUBSCRIPTION_QUERY_KEYS,
-} from "./subscriptionQueryKeys";
 
 export const useSubscriptionPackages = () => {
   const userId = useAuthStore(selectUserId);
   const isConfigured = SubscriptionManager.isConfigured();
-  const queryClient = useQueryClient();
   const prevUserIdRef = useRef(userId);
 
+  const [packages, setPackages] = useState<any[] | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
   const initState = useSyncExternalStore(
     initializationState.subscribe,
     initializationState.getSnapshot,
@@ -24,45 +23,48 @@ export const useSubscriptionPackages = () => {
 
   const isInitialized = initState.initialized || SubscriptionManager.isInitialized();
 
-  const query = useQuery({
-    queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, userId ?? "anonymous"] as const,
-    queryFn: async () => {
-      return SubscriptionManager.getPackages();
-    },
-    enabled: isConfigured && isInitialized,
-    gcTime: 5 * 60 * 1000,
-    staleTime: 2 * 60 * 1000,
-    refetchOnMount: true,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: true,
-  });
+  const fetchPackages = useCallback(async () => {
+    if (!isConfigured || !isInitialized) {
+      setPackages(null);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const result = await SubscriptionManager.getPackages();
+      setPackages(result);
+    } catch (err) {
+      setError(err as Error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [isConfigured, isInitialized]);
+
+  useEffect(() => {
+    fetchPackages();
+  }, [fetchPackages]);
 
   useEffect(() => {
     const prevUserId = prevUserIdRef.current;
     prevUserIdRef.current = userId;
 
     if (prevUserId !== userId) {
-      // Clean up previous user's cache to prevent data leakage
-      if (prevUserId) {
-        queryClient.cancelQueries({
-          queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, prevUserId],
-        });
-        queryClient.removeQueries({
-          queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, prevUserId],
-        });
-      } else {
-        queryClient.cancelQueries({
-          queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, "anonymous"],
-        });
-        queryClient.removeQueries({
-          queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, "anonymous"],
-        });
-      }
-
-      // No need to invalidate - removeQueries already cleared cache
-      // Query will refetch automatically on mount if needed
+      fetchPackages();
     }
-  }, [userId, queryClient]);
+  }, [userId, fetchPackages]);
+
+  const refetch = useCallback(() => {
+    fetchPackages();
+  }, [fetchPackages]);
 
-  return query;
+  return {
+    data: packages,
+    isLoading,
+    error,
+    refetch,
+  };
 };

package/src/domains/subscription/presentation/screens/SubscriptionDetailScreen.tsx

@@ -7,7 +7,6 @@ import { useAppDesignTokens } from "@umituz/react-native-design-system/theme";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
 import { ScreenLayout } from "../../../../shared/presentation/layouts/ScreenLayout";
 import { getCreditsRepository } from "../../../credits/infrastructure/CreditsRepositoryManager";
-import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../../shared/infrastructure/SubscriptionEventBus";
 import { SubscriptionHeader } from "./components/SubscriptionHeader";
 import { CreditsList } from "./components/CreditsList";
 import { UpgradePrompt } from "./components/UpgradePrompt";
@@ -116,7 +115,6 @@ const DevTestPanel: React.FC<{ statusType: string }> = ({ statusType }) => {
     const userId = selectUserId(useAuthStore.getState());
     if (!userId) throw new Error("No userId found");
     await getCreditsRepository().syncExpiredStatus(userId);
-    subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
   }), [run]);
 
   const handleRestore = useCallback(() => run("Restore", async () => {

package/src/domains/subscription/presentation/useSubscriptionStatus.ts

@@ -1,26 +1,21 @@
-import { useQuery, useQueryClient } from "@umituz/react-native-design-system/tanstack";
-import { useEffect, useSyncExternalStore } from "react";
+import { useState, useEffect, useSyncExternalStore, useCallback } from "react";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
 import { initializationState } from "../infrastructure/state/initializationState";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
-import { SubscriptionStatusResult } from "./useSubscriptionStatus.types";
+import type { SubscriptionStatusResult } from "./useSubscriptionStatus.types";
+import type { PremiumStatus } from "../core/types/PremiumStatus";
 import { isAuthenticated } from "../utils/authGuards";
-import { SHORT_CACHE_CONFIG } from "../../../shared/infrastructure/react-query/queryConfig";
-import { usePreviousUserCleanup } from "../../../shared/infrastructure/react-query/hooks/usePreviousUserCleanup";
-
-export const subscriptionStatusQueryKeys = {
-  all: ["subscriptionStatus"] as const,
-  user: (userId: string | null | undefined) =>
-    userId ? (["subscriptionStatus", userId] as const) : (["subscriptionStatus"] as const),
-};
 
 export const useSubscriptionStatus = (): SubscriptionStatusResult => {
   const userId = useAuthStore(selectUserId);
-  const queryClient = useQueryClient();
   const isConfigured = SubscriptionManager.isConfigured();
   const hasUser = isAuthenticated(userId);
 
+  const [data, setData] = useState<PremiumStatus | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
   const initState = useSyncExternalStore(
     initializationState.subscribe,
     initializationState.getSnapshot,
@@ -31,22 +26,30 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
     ? initState.initialized && initState.userId === userId
     : false;
 
-  const queryEnabled = hasUser && isConfigured && isInitialized;
+  const fetchStatus = useCallback(async () => {
+    if (!hasUser || !isConfigured || !isInitialized) {
+      setData(null);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
 
-  const { data, status, error, refetch } = useQuery({
-    queryKey: subscriptionStatusQueryKeys.user(userId),
-    queryFn: async () => {
-      if (!hasUser) {
-        return null;
-      }
+    setIsLoading(true);
+    setError(null);
 
-      return SubscriptionManager.checkPremiumStatus();
-    },
-    enabled: queryEnabled,
-    ...SHORT_CACHE_CONFIG,
-  });
+    try {
+      const result = await SubscriptionManager.checkPremiumStatus();
+      setData(result);
+    } catch (err) {
+      setError(err as Error);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [hasUser, isConfigured, isInitialized]);
 
-  usePreviousUserCleanup(userId, queryClient, subscriptionStatusQueryKeys.user);
+  useEffect(() => {
+    fetchStatus();
+  }, [fetchStatus]);
 
   useEffect(() => {
     if (!hasUser) return undefined;
@@ -55,34 +58,18 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
       SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED,
       (event: { userId: string; isPremium: boolean }) => {
         if (event.userId === userId) {
-          queryClient.invalidateQueries({
-            queryKey: subscriptionStatusQueryKeys.user(userId),
-          });
+          fetchStatus();
         }
       }
     );
 
     return unsubscribe;
-  }, [userId, hasUser, queryClient]);
-
-  const isLoading = status === "pending";
+  }, [userId, hasUser, fetchStatus]);
 
   return {
-    isPremium: data?.isPremium ?? false,
-    expirationDate: data?.expirationDate ?? null,
-    willRenew: data?.willRenew ?? false,
-    productIdentifier: data?.productIdentifier ?? null,
-    originalPurchaseDate: data?.originalPurchaseDate ?? null,
-    latestPurchaseDate: data?.latestPurchaseDate ?? null,
-    billingIssuesDetected: data?.billingIssuesDetected ?? false,
-    isSandbox: data?.isSandbox ?? false,
-    periodType: data?.periodType ?? null,
-    packageType: data?.packageType ?? null,
-    store: data?.store ?? null,
-    gracePeriodExpiresDate: data?.gracePeriodExpiresDate ?? null,
-    unsubscribeDetectedAt: data?.unsubscribeDetectedAt ?? null,
+    ...data,
     isLoading,
-    error: error as Error | null,
-    refetch,
-  };
+    error,
+    refetch: fetchStatus,
+  } as SubscriptionStatusResult;
 };

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

@@ -1,17 +1,11 @@
-import { useQuery } from "@umituz/react-native-design-system/tanstack";
-import { useMemo } from "react";
+import { useState, useEffect } from "react";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
-import { MEDIUM_CACHE_CONFIG } from "../../../../shared/infrastructure/react-query/queryConfig";
+import { collection, onSnapshot, query, orderBy, limit, Query } from "firebase/firestore";
 import type {
   CreditLog,
   TransactionRepositoryConfig,
 } from "../../domain/types/transaction.types";
-import { TransactionRepository } from "../../infrastructure/repositories/transaction/TransactionRepository";
-
-const transactionQueryKeys = {
-  all: ["transactions"] as const,
-  user: (userId: string) => ["transactions", userId] as const,
-};
+import { requireFirestore } from "../../../../shared/infrastructure/firestore/collectionUtils";
 
 export interface UseTransactionHistoryParams {
   config: TransactionRepositoryConfig;
@@ -28,43 +22,75 @@ interface UseTransactionHistoryResult {
 
 export function useTransactionHistory({
   config,
-  limit = 50,
+  limit: limitCount = 50,
 }: UseTransactionHistoryParams): UseTransactionHistoryResult {
   const userId = useAuthStore(selectUserId);
+  const [transactions, setTransactions] = useState<CreditLog[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
 
-  const repository = useMemo(
-    () => new TransactionRepository(config),
-    [config]
-  );
+  useEffect(() => {
+    if (!userId) {
+      setTransactions([]);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
 
-  const hasUser = !!userId;
+    setIsLoading(true);
+    setError(null);
 
-  const { data, isLoading, error, refetch } = useQuery({
-    queryKey: [...transactionQueryKeys.user(userId ?? ""), limit],
-    queryFn: async () => {
-      if (!userId) return [];
+    try {
+      const db = requireFirestore();
+      const collectionPath = config.useUserSubcollection
+        ? `users/${userId}/${config.collectionName}`
+        : config.collectionName;
 
-      const result = await repository.getTransactions({
-        userId,
-        limit,
-      });
+      const q = query(
+        collection(db, collectionPath),
+        orderBy("timestamp", "desc"),
+        limit(limitCount)
+      ) as Query;
 
-      if (!result.success) {
-        throw new Error(result.error?.message || "Failed to fetch history");
-      }
+      const unsubscribe = onSnapshot(
+        q,
+        (snapshot) => {
+          const logs: CreditLog[] = [];
+          snapshot.forEach((doc) => {
+            logs.push({
+              id: doc.id,
+              ...doc.data(),
+            } as CreditLog);
+          });
+          setTransactions(logs);
+          setIsLoading(false);
+        },
+        (err) => {
+          console.error("[useTransactionHistory] Snapshot error:", err);
+          setError(err as Error);
+          setIsLoading(false);
+        }
+      );
 
-      return result.data ?? [];
-    },
-    enabled: hasUser,
-    ...MEDIUM_CACHE_CONFIG,
-  });
+      return () => unsubscribe();
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      console.error("[useTransactionHistory] Setup error:", err);
+      setError(error);
+      setIsLoading(false);
+    }
+  }, [userId, config.collectionName, config.useUserSubcollection, limitCount]);
 
-  const transactions = data ?? [];
+  const refetch = () => {
+    if (__DEV__) {
+      console.warn("[useTransactionHistory] Refetch called - not needed for real-time sync");
+    }
+  };
 
   return {
     transactions,
     isLoading,
-    error: error as Error | null,
+    error,
     refetch,
     isEmpty: transactions.length === 0,
   };

package/src/domains/subscription/infrastructure/hooks/subscriptionQueryKeys.ts

@@ -1,6 +0,0 @@
-export const SUBSCRIPTION_QUERY_KEYS = {
-  packages: ["subscription", "packages"] as const,
-  initialized: (userId: string) =>
-    ["subscription", "initialized", userId] as const,
-  customerInfo: ["subscription", "customerInfo"] as const,
-} as const;

package/src/shared/infrastructure/react-query/hooks/usePreviousUserCleanup.ts

@@ -1,22 +0,0 @@
-import { useEffect, useRef } from "react";
-import type { QueryClient } from "@umituz/react-native-design-system/tanstack";
-import { isAuthenticated } from "../../../../domains/subscription/utils/authGuards";
-
-export function usePreviousUserCleanup(
-  userId: string | null | undefined,
-  queryClient: QueryClient,
-  queryKey: (userId: string) => readonly unknown[]
-): void {
-  const prevUserIdRef = useRef(userId);
-
-  useEffect(() => {
-    const prevUserId = prevUserIdRef.current;
-    prevUserIdRef.current = userId;
-
-    if (prevUserId !== userId && isAuthenticated(prevUserId)) {
-      queryClient.removeQueries({
-        queryKey: queryKey(prevUserId),
-      });
-    }
-  }, [userId, queryClient, queryKey]);
-}

package/src/shared/infrastructure/react-query/queryConfig.ts

@@ -1,38 +0,0 @@
-/**
- * Query cache configurations for optimal performance
- * Uses event-based invalidation via subscriptionEventBus for real-time updates
- */
-
-/**
- * Short-lived cache for frequently changing data (credits, subscription status)
- * Events automatically invalidate the cache, so we can safely cache for 60s
- */
-export const SHORT_CACHE_CONFIG = {
-  gcTime: 1000 * 60, // 1 minute - keep in memory for 1 minute
-  staleTime: 1000 * 30, // 30 seconds - consider stale after 30s
-  refetchOnMount: false, // Don't refetch on mount if cache exists
-  refetchOnWindowFocus: false, // Don't refetch on app focus
-  refetchOnReconnect: true, // Refetch on reconnect only
-};
-
-/**
- * Medium cache for relatively stable data (packages, transaction history)
- */
-export const MEDIUM_CACHE_CONFIG = {
-  gcTime: 1000 * 60 * 5, // 5 minutes
-  staleTime: 1000 * 60 * 2, // 2 minutes
-  refetchOnMount: false,
-  refetchOnWindowFocus: false,
-  refetchOnReconnect: true,
-};
-
-/**
- * Long cache for rarely changing data (config, metadata)
- */
-export const LONG_CACHE_CONFIG = {
-  gcTime: 1000 * 60 * 30, // 30 minutes
-  staleTime: 1000 * 60 * 10, // 10 minutes
-  refetchOnMount: false,
-  refetchOnWindowFocus: false,
-  refetchOnReconnect: true,
-};