@umituz/react-native-subscription 2.43.6 → 2.43.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.43.6",
+  "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/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 updated via real-time sync:
-        // - Credits: Firestore onSnapshot (useCreditsRealTime)
-        // - Subscription status: PREMIUM_STATUS_CHANGED event (RevenueCat)
-        // 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 updated via real-time sync:
-        // - Credits: Firestore onSnapshot (useCreditsRealTime)
-        // - Subscription status: PREMIUM_STATUS_CHANGED event (RevenueCat)
-        // 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/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,
-};