@umituz/react-native-subscription 2.35.15 → 2.35.17

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

@@ -6,8 +6,6 @@ import { executeFeatureAction } from "./featureGateActions";
 
 export type { UseFeatureGateParams, UseFeatureGateResult } from "./useFeatureGate.types";
 
-declare const __DEV__: boolean;
-
 export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResult {
   const {
     isAuthenticated,
@@ -27,16 +25,6 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
   const { creditBalanceRef, hasSubscriptionRef, onShowPaywallRef, requiredCreditsRef, isCreditsLoadedRef } = useSyncedRefs(creditBalance, hasSubscription, onShowPaywall, requiredCredits, isCreditsLoaded);
 
   useEffect(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[FeatureGate] Auth completion useEffect triggered:", {
-        isWaitingForAuthCredits: isWaitingForAuthCreditsRef.current,
-        isCreditsLoaded,
-        hasPendingAction: !!pendingActionRef.current,
-        hasSubscription,
-        creditBalance,
-        requiredCredits,
-      });
-    }
 
     const shouldExecute = canExecuteAuthAction(
       isWaitingForAuthCreditsRef.current,
@@ -47,14 +35,7 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
       requiredCredits
     );
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[FeatureGate] canExecuteAuthAction:", shouldExecute);
-    }
-
     if (shouldExecute) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[FeatureGate] ✅ EXECUTING PENDING ACTION after auth!");
-      }
       isWaitingForAuthCreditsRef.current = false;
       const action = pendingActionRef.current!;
       pendingActionRef.current = null;
@@ -63,9 +44,6 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
     }
 
     if (isWaitingForAuthCreditsRef.current && isCreditsLoaded && pendingActionRef.current) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[FeatureGate] Auth credits loaded but insufficient, showing paywall");
-      }
       isWaitingForAuthCreditsRef.current = false;
       isWaitingForPurchaseRef.current = true;
       onShowPaywall(requiredCredits);
@@ -73,16 +51,6 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
   }, [isCreditsLoaded, creditBalance, hasSubscription, requiredCredits, onShowPaywall]);
 
   useEffect(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[FeatureGate] Purchase completion useEffect triggered:", {
-        creditBalance,
-        prevCreditBalance: prevCreditBalanceRef.current,
-        hasSubscription,
-        prevHasSubscription: hasSubscriptionRef.current,
-        isWaitingForPurchase: isWaitingForPurchaseRef.current,
-        hasPendingAction: !!pendingActionRef.current,
-      });
-    }
 
     const shouldExecute = canExecutePurchaseAction(
       isWaitingForPurchaseRef.current,
@@ -93,14 +61,7 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
       !!pendingActionRef.current
     );
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[FeatureGate] canExecutePurchaseAction:", shouldExecute);
-    }
-
     if (shouldExecute) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[FeatureGate] ✅ EXECUTING PENDING ACTION after purchase!");
-      }
       const action = pendingActionRef.current!;
       pendingActionRef.current = null;
       isWaitingForPurchaseRef.current = false;
@@ -108,7 +69,7 @@ export function useFeatureGate(params: UseFeatureGateParams): UseFeatureGateResu
     }
 
     prevCreditBalanceRef.current = creditBalance;
-    hasSubscriptionRef.current = hasSubscription;
+    // hasSubscriptionRef is already synced by useSyncedRefs, no need to update manually
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [creditBalance, hasSubscription]);
 

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

@@ -1,10 +1,12 @@
 import { useQuery, useQueryClient } from "@umituz/react-native-design-system";
-import { useEffect, useRef } from "react";
+import { useEffect } from "react";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
 import { SubscriptionManager } from "../infrastructure/managers/SubscriptionManager";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 import { SubscriptionStatusResult } from "./useSubscriptionStatus.types";
 import { isAuthenticated } from "../utils/authGuards";
+import { NO_CACHE_QUERY_CONFIG } from "../../../shared/infrastructure/react-query/queryConfig";
+import { usePreviousUserCleanup } from "../../../shared/infrastructure/react-query/hooks/usePreviousUserCleanup";
 
 export const subscriptionStatusQueryKeys = {
   all: ["subscriptionStatus"] as const,
@@ -38,27 +40,11 @@ export const useSubscriptionStatus = (): SubscriptionStatusResult => {
       }
     },
     enabled: queryEnabled,
-    gcTime: 0,
-    staleTime: 0,
-    refetchOnMount: "always",
-    refetchOnWindowFocus: "always",
-    refetchOnReconnect: "always",
+    ...NO_CACHE_QUERY_CONFIG,
   });
 
-  // Track previous userId to clear stale cache on logout/user switch
-  const prevUserIdRef = useRef(userId);
-
-  useEffect(() => {
-    const prevUserId = prevUserIdRef.current;
-    prevUserIdRef.current = userId;
-
-    // Clear previous user's cache when userId changes (logout or user switch)
-    if (prevUserId !== userId && isAuthenticated(prevUserId)) {
-      queryClient.removeQueries({
-        queryKey: subscriptionStatusQueryKeys.user(prevUserId),
-      });
-    }
-  }, [userId, queryClient]);
+  // Clean up previous user's cache on logout/user switch
+  usePreviousUserCleanup(userId, queryClient, subscriptionStatusQueryKeys.user);
 
   useEffect(() => {
     if (!isAuthenticated(userId)) return undefined;

package/src/domains/subscription/utils/authGuards.ts

@@ -1,5 +1,29 @@
 import { isDefined } from "../../../shared/utils/validators";
 
-export const isAuthenticated = (userId: string | null | undefined): userId is string => {
+export function isAuthenticated(userId: string | null | undefined): userId is string {
   return isDefined(userId) && userId.length > 0;
-};
+}
+
+/**
+ * Requires user to be authenticated, throws if not
+ * Type guard that asserts userId is string
+ *
+ * @param userId - User ID to check
+ * @param errorMessage - Custom error message (optional)
+ * @throws Error if user is not authenticated
+ *
+ * @example
+ * function purchaseProduct(userId: string | null) {
+ *   requireAuthentication(userId); // throws if null/undefined
+ *   // TypeScript now knows userId is string
+ *   await purchase(userId);
+ * }
+ */
+export function requireAuthentication(
+  userId: string | null | undefined,
+  errorMessage = "User not authenticated"
+): asserts userId is string {
+  if (!isAuthenticated(userId)) {
+    throw new Error(errorMessage);
+  }
+}

package/src/domains/subscription/utils/expirationHelpers.ts

@@ -1,5 +1,5 @@
-const DAYS_REMAINING_WARNING_THRESHOLD = 7;
+import { EXPIRATION_WARNING_THRESHOLD_DAYS } from '../constants/thresholds';
 
 export function shouldHighlightExpiration(daysRemaining: number | null | undefined): boolean {
-  return daysRemaining !== null && daysRemaining !== undefined && daysRemaining > 0 && daysRemaining <= DAYS_REMAINING_WARNING_THRESHOLD;
+  return daysRemaining !== null && daysRemaining !== undefined && daysRemaining > 0 && daysRemaining <= EXPIRATION_WARNING_THRESHOLD_DAYS;
 }

package/src/domains/trial/application/TrialEligibilityService.ts

@@ -12,7 +12,7 @@ export class TrialEligibilityService {
 
     const { hasUsedTrial, trialInProgress, userIds = [] } = record;
 
-    if (userId && userIds.includes(userId)) {
+    if (userId && userId.length > 0 && userIds.includes(userId)) {
       return { eligible: false, reason: "user_already_used", deviceId };
     }
 

package/src/domains/trial/application/TrialService.ts

@@ -26,9 +26,17 @@ const repository = new DeviceTrialRepository();
 
 export const getDeviceId = () => PersistentDeviceIdService.getDeviceId();
 
+/**
+ * Ensures a valid device ID is available
+ * Uses provided deviceId if non-empty, otherwise fetches from PersistentDeviceIdService
+ */
+async function ensureDeviceId(deviceId?: string): Promise<string> {
+  return (deviceId && deviceId.length > 0) ? deviceId : await getDeviceId();
+}
+
 export async function checkTrialEligibility(userId?: string, deviceId?: string): Promise<TrialEligibilityResult> {
   try {
-    const id = deviceId || await getDeviceId();
+    const id = await ensureDeviceId(deviceId);
     const record = await repository.getRecord(id);
     return TrialEligibilityService.check(userId, id, record);
   } catch {
@@ -38,7 +46,7 @@ export async function checkTrialEligibility(userId?: string, deviceId?: string):
 
 export async function recordTrialStart(userId: string, deviceId?: string): Promise<boolean> {
   try {
-    const id = deviceId || await getDeviceId();
+    const id = await ensureDeviceId(deviceId);
     const record: TrialRecordWrite = {
       deviceId: id,
       trialInProgress: true,
@@ -54,7 +62,7 @@ export async function recordTrialStart(userId: string, deviceId?: string): Promi
 
 export async function recordTrialEnd(deviceId?: string): Promise<boolean> {
   try {
-    const id = deviceId || await getDeviceId();
+    const id = await ensureDeviceId(deviceId);
     const record: TrialRecordWrite = {
       hasUsedTrial: true,
       trialInProgress: false,
@@ -68,7 +76,7 @@ export async function recordTrialEnd(deviceId?: string): Promise<boolean> {
 
 export async function recordTrialConversion(deviceId?: string): Promise<boolean> {
   try {
-    const id = deviceId || await getDeviceId();
+    const id = await ensureDeviceId(deviceId);
     const record: TrialRecordWrite = {
       hasUsedTrial: true,
       trialInProgress: false,

package/src/domains/wallet/infrastructure/repositories/transaction/TransactionWriter.ts

@@ -34,7 +34,7 @@ export async function addTransaction(
         change,
         reason,
         ...metadata,
-        createdAt: Date.now(),
+        createdAt: Date.now(), // Approximate - actual server timestamp written to Firestore
       },
     };
   } catch (error) {

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

@@ -1,5 +1,6 @@
 import { useQuery } from "@umituz/react-native-design-system";
 import { useMemo } from "react";
+import { NO_CACHE_QUERY_CONFIG } from "../../../../shared/infrastructure/react-query/queryConfig";
 import type {
   ProductMetadata,
   ProductMetadataConfig,
@@ -50,11 +51,7 @@ export function useProductMetadata({
       return service.getAll();
     },
     enabled,
-    gcTime: 0,
-    staleTime: 0,
-    refetchOnMount: "always",
-    refetchOnWindowFocus: "always",
-    refetchOnReconnect: "always",
+    ...NO_CACHE_QUERY_CONFIG,
   });
 
   const products = data ?? [];

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

@@ -1,6 +1,7 @@
 import { useQuery } from "@umituz/react-native-design-system";
 import { useMemo } from "react";
 import { useAuthStore, selectUserId } from "@umituz/react-native-auth";
+import { NO_CACHE_QUERY_CONFIG } from "../../../../shared/infrastructure/react-query/queryConfig";
 import type {
   CreditLog,
   TransactionRepositoryConfig,
@@ -53,11 +54,7 @@ export function useTransactionHistory({
       return result.data ?? [];
     },
     enabled: !!userId,
-    gcTime: 0,
-    staleTime: 0,
-    refetchOnMount: "always",
-    refetchOnWindowFocus: "always",
-    refetchOnReconnect: "always",
+    ...NO_CACHE_QUERY_CONFIG,
   });
 
   const transactions = data ?? [];

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

@@ -0,0 +1,39 @@
+/**
+ * User Cache Cleanup Hook
+ * Automatically cleans up previous user's query cache when userId changes
+ */
+
+import { useEffect, useRef } from "react";
+import type { QueryClient } from "@umituz/react-native-design-system";
+import { isAuthenticated } from "../../../../domains/subscription/utils/authGuards";
+
+/**
+ * Cleans up previous user's cache when userId changes (logout or user switch)
+ * Prevents data leakage between users
+ *
+ * @param userId - Current user ID
+ * @param queryClient - TanStack Query client
+ * @param queryKey - Query key factory function that takes userId
+ *
+ * @example
+ * usePreviousUserCleanup(userId, queryClient, (id) => creditsQueryKeys.user(id));
+ */
+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;
+
+    // Clear previous user's cache when userId changes (logout or user switch)
+    if (prevUserId !== userId && isAuthenticated(prevUserId)) {
+      queryClient.removeQueries({
+        queryKey: queryKey(prevUserId),
+      });
+    }
+  }, [userId, queryClient, queryKey]);
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Shared TanStack Query Configuration
+ * Common query configurations to ensure consistency across hooks
+ */
+
+/**
+ * Configuration for queries that should never cache
+ * Used for real-time sensitive data (subscriptions, credits, transactions)
+ *
+ * - gcTime: 0 - Don't keep unused data in memory
+ * - staleTime: 0 - Always consider data stale
+ * - refetchOnMount: "always" - Always refetch when component mounts
+ * - refetchOnWindowFocus: "always" - Always refetch when window regains focus
+ * - refetchOnReconnect: "always" - Always refetch when reconnecting
+ */
+export const NO_CACHE_QUERY_CONFIG = {
+  gcTime: 0,
+  staleTime: 0,
+  refetchOnMount: "always" as const,
+  refetchOnWindowFocus: "always" as const,
+  refetchOnReconnect: "always" as const,
+};

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

@@ -0,0 +1,46 @@
+/**
+ * Query Invalidation Utilities
+ * Centralized functions for invalidating multiple related queries
+ */
+
+import type { QueryClient } from "@umituz/react-native-design-system";
+import { creditsQueryKeys } from "../../../domains/credits/presentation/creditsQueryKeys";
+import { subscriptionStatusQueryKeys } from "../../../domains/subscription/presentation/useSubscriptionStatus";
+
+// Subscription packages query key
+export const SUBSCRIPTION_QUERY_KEYS = {
+  packages: ["subscription", "packages"] as const,
+};
+
+/**
+ * Invalidates all subscription-related queries
+ * Use after purchases, restores, or subscription changes
+ *
+ * @param queryClient - TanStack Query client
+ * @param userId - Optional user ID to invalidate user-specific queries
+ *
+ * @example
+ * // After successful purchase
+ * await invalidateSubscriptionQueries(queryClient, userId);
+ */
+export async function invalidateSubscriptionQueries(
+  queryClient: QueryClient,
+  userId?: string | null
+): Promise<void> {
+  // Invalidate packages (affects all users)
+  await queryClient.invalidateQueries({
+    queryKey: SUBSCRIPTION_QUERY_KEYS.packages,
+  });
+
+  // Invalidate user-specific queries if userId provided
+  if (userId) {
+    await Promise.all([
+      queryClient.invalidateQueries({
+        queryKey: subscriptionStatusQueryKeys.user(userId),
+      }),
+      queryClient.invalidateQueries({
+        queryKey: creditsQueryKeys.user(userId),
+      }),
+    ]);
+  }
+}

package/src/shared/presentation/hooks/useServiceCall.ts

@@ -4,6 +4,7 @@
  */
 
 import { useState, useCallback, useRef, useEffect } from "react";
+import { normalizeError } from "../../utils/errorUtils";
 
 export interface ServiceCallState<T> {
   data: T | null;
@@ -54,7 +55,7 @@ export function useServiceCall<T>(
       setState({ data, isLoading: false, error: null });
       onSuccessRef.current?.(data);
     } catch (error) {
-      const errorObj = error instanceof Error ? error : new Error("Service call failed");
+      const errorObj = normalizeError(error, "Service call failed");
       setState({ data: null, isLoading: false, error: errorObj });
       onErrorRef.current?.(errorObj);
     } finally {

package/src/shared/utils/errorUtils.ts

@@ -0,0 +1,32 @@
+/**
+ * Error Utilities
+ * Common error handling and normalization functions
+ */
+
+/**
+ * Normalizes unknown error types to Error objects
+ * Useful for catch blocks where error type is unknown
+ *
+ * @param error - The error to normalize (unknown type)
+ * @param fallbackMessage - Message to use if error is not an Error object
+ * @returns Always returns an Error object
+ *
+ * @example
+ * try {
+ *   await someOperation();
+ * } catch (error) {
+ *   const err = normalizeError(error, "Operation failed");
+ *   console.error(err.message);
+ * }
+ */
+export function normalizeError(
+  error: unknown,
+  fallbackMessage = "Unknown error"
+): Error {
+  if (error instanceof Error) {
+    return error;
+  }
+
+  const message = typeof error === "string" ? error : String(error);
+  return new Error(message || fallbackMessage);
+}

package/src/utils/appUtils.ts

@@ -4,6 +4,12 @@
 import { Platform } from "react-native";
 import Constants from "expo-constants";
 
+/**
+ * Development mode flag
+ * Safe check for __DEV__ that works in all environments
+ */
+export const IS_DEV_MODE = typeof __DEV__ !== "undefined" && __DEV__;
+
 /**
  * Gets the current app version from Expo constants
  */

package/src/domains/subscription/presentation/components/details/PremiumDetailsCard.constants.ts

@@ -1 +0,0 @@
-export const DAYS_REMAINING_WARNING_THRESHOLD = 7;

package/src/domains/subscription/presentation/screens/components/SubscriptionHeader.constants.ts

@@ -1 +0,0 @@
-export const EXPIRING_SOON_THRESHOLD_DAYS = 7;