@umituz/react-native-subscription 2.27.113 → 2.27.115

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

@@ -5,24 +5,16 @@
  */
 
 import { useState, useEffect, useCallback, useRef } from "react";
-import Purchases, {
-  type IntroEligibility,
-  INTRO_ELIGIBILITY_STATUS,
-} from "react-native-purchases";
-import { getRevenueCatService } from "../../infrastructure/services/RevenueCatService";
+import { getRevenueCatService } from "../services/RevenueCatService";
+import {
+  checkTrialEligibility,
+  createFallbackEligibilityMap,
+  hasAnyEligibleTrial,
+  type ProductTrialEligibility,
+  type TrialEligibilityMap,
+} from "../utils/trialEligibilityUtils";
 
-/** Trial eligibility info for a single product */
-export interface ProductTrialEligibility {
-  /** Product identifier */
-  productId: string;
-  /** Whether eligible for introductory offer (free trial) */
-  eligible: boolean;
-  /** Trial duration in days (if available from product) */
-  trialDurationDays?: number;
-}
-
-/** Map of product ID to eligibility */
-export type TrialEligibilityMap = Record<string, ProductTrialEligibility>;
+export type { ProductTrialEligibility, TrialEligibilityMap };
 
 export interface UseRevenueCatTrialEligibilityResult {
   /** Map of product IDs to their trial eligibility */
@@ -37,17 +29,6 @@ export interface UseRevenueCatTrialEligibilityResult {
   getProductEligibility: (productId: string) => ProductTrialEligibility | null;
 }
 
-/** Cache duration in milliseconds (5 minutes) */
-const CACHE_DURATION_MS = 5 * 60 * 1000;
-
-/** Cached eligibility result */
-interface CachedEligibility {
-  data: TrialEligibilityMap;
-  timestamp: number;
-}
-
-let eligibilityCache: CachedEligibility | null = null;
-
 /**
  * Hook to check trial eligibility via RevenueCat
  * Uses Apple's introductory offer eligibility system
@@ -56,6 +37,7 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
   const [eligibilityMap, setEligibilityMap] = useState<TrialEligibilityMap>({});
   const [isLoading, setIsLoading] = useState(false);
   const isMountedRef = useRef(true);
+  const currentRequestRef = useRef<number | null>(null);
 
   useEffect(() => {
     isMountedRef.current = true;
@@ -69,69 +51,29 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
       return;
     }
 
-    // Check cache validity
-    if (
-      eligibilityCache &&
-      Date.now() - eligibilityCache.timestamp < CACHE_DURATION_MS
-    ) {
-      const allCached = productIds.every(
-        (id) => eligibilityCache?.data[id] !== undefined
-      );
-      if (allCached && isMountedRef.current) {
-        setEligibilityMap(eligibilityCache.data);
-        return;
-      }
-    }
-
     const service = getRevenueCatService();
     if (!service || !service.isInitialized()) {
       return;
     }
 
+    const requestId = Date.now();
+    currentRequestRef.current = requestId;
     setIsLoading(true);
 
     try {
-      const eligibilities: Record<string, IntroEligibility> =
-        await Purchases.checkTrialOrIntroductoryPriceEligibility(productIds);
-
-      const newMap: TrialEligibilityMap = {};
+      const newMap = await checkTrialEligibility(productIds);
 
-      for (const productId of productIds) {
-        const eligibility = eligibilities[productId];
-        const isEligible =
-          eligibility?.status === INTRO_ELIGIBILITY_STATUS.INTRO_ELIGIBILITY_STATUS_ELIGIBLE;
-
-        newMap[productId] = {
-          productId,
-          eligible: isEligible,
-          trialDurationDays: 7, // Default to 7 days as configured in App Store Connect
-        };
-      }
-
-      // Update cache
-      eligibilityCache = {
-        data: { ...eligibilityCache?.data, ...newMap },
-        timestamp: Date.now(),
-      };
-
-      if (isMountedRef.current) {
+      if (isMountedRef.current && currentRequestRef.current === requestId) {
         setEligibilityMap((prev) => ({ ...prev, ...newMap }));
       }
     } catch {
-      // On error, default to eligible (better UX)
-      const fallbackMap: TrialEligibilityMap = {};
-      for (const productId of productIds) {
-        fallbackMap[productId] = {
-          productId,
-          eligible: true,
-          trialDurationDays: 7,
-        };
-      }
-      if (isMountedRef.current) {
+      const fallbackMap = createFallbackEligibilityMap(productIds);
+
+      if (isMountedRef.current && currentRequestRef.current === requestId) {
         setEligibilityMap((prev) => ({ ...prev, ...fallbackMap }));
       }
     } finally {
-      if (isMountedRef.current) {
+      if (isMountedRef.current && currentRequestRef.current === requestId) {
         setIsLoading(false);
       }
     }
@@ -144,9 +86,7 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
     [eligibilityMap]
   );
 
-  const hasEligibleTrial = Object.values(eligibilityMap).some(
-    (e) => e.eligible
-  );
+  const hasEligibleTrial = hasAnyEligibleTrial(eligibilityMap);
 
   return {
     eligibilityMap,
@@ -157,9 +97,3 @@ export function useRevenueCatTrialEligibility(): UseRevenueCatTrialEligibilityRe
   };
 }
 
-/**
- * Clear eligibility cache (useful for testing)
- */
-export function clearTrialEligibilityCache(): void {
-  eligibilityCache = null;
-}

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -10,6 +10,12 @@ import { initializeRevenueCatService, getRevenueCatService } from "../services/R
 import { PackageHandler } from "../handlers/PackageHandler";
 import type { PremiumStatus, RestoreResultInfo } from "../handlers/PackageHandler";
 import { SubscriptionInternalState } from "./SubscriptionInternalState";
+import {
+    ensureConfigured,
+    getCurrentUserIdOrThrow,
+    getOrCreateService,
+    ensureServiceAvailable,
+} from "./subscriptionManagerUtils";
 
 export interface SubscriptionManagerConfig {
   config: RevenueCatConfig;
@@ -33,28 +39,17 @@ class SubscriptionManagerImpl {
       return;
     }
 
-    if (!this.serviceInstance) {
-      throw new Error("Service instance not available");
-    }
-
-    if (!this.managerConfig) {
-      throw new Error("Manager not configured");
-    }
+    ensureServiceAvailable(this.serviceInstance);
+    ensureConfigured(this.managerConfig);
 
     this.packageHandler = new PackageHandler(
-      this.serviceInstance,
-      this.managerConfig.config.entitlementIdentifier
+      this.serviceInstance!,
+      this.managerConfig!.config.entitlementIdentifier
     );
   }
 
-  private ensureConfigured(): void {
-    if (!this.managerConfig) {
-      throw new Error("SubscriptionManager not configured");
-    }
-  }
-
   async initialize(userId?: string): Promise<boolean> {
-    this.ensureConfigured();
+    ensureConfigured(this.managerConfig);
 
     const actualUserId = userId ?? (await this.managerConfig!.getAnonymousUserId());
     const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(actualUserId);
@@ -67,12 +62,10 @@ class SubscriptionManagerImpl {
         await initializeRevenueCatService(this.managerConfig!.config);
         this.serviceInstance = getRevenueCatService();
 
-        if (!this.serviceInstance) {
-          throw new Error("Service instance not available after initialization");
-        }
-
+        ensureServiceAvailable(this.serviceInstance);
         this.ensurePackageHandlerInitialized();
-        const result = await this.serviceInstance.initialize(actualUserId);
+
+        const result = await this.serviceInstance!.initialize(actualUserId);
         return result.success;
     })();
 
@@ -81,11 +74,7 @@ class SubscriptionManagerImpl {
   }
 
   isInitializedForUser(userId: string): boolean {
-    if (!this.serviceInstance) {
-      return false;
-    }
-
-    if (!this.serviceInstance.isInitialized()) {
+    if (!this.serviceInstance?.isInitialized()) {
       return false;
     }
 
@@ -93,57 +82,35 @@ class SubscriptionManagerImpl {
   }
 
   async getPackages(): Promise<PurchasesPackage[]> {
-    this.ensureConfigured();
-
-    if (!this.serviceInstance) {
-      this.serviceInstance = getRevenueCatService();
-    }
-
-    if (!this.serviceInstance) {
-      throw new Error("Service instance not available");
-    }
-
+    ensureConfigured(this.managerConfig);
+    this.serviceInstance = getOrCreateService(this.serviceInstance);
     this.ensurePackageHandlerInitialized();
+
     return this.packageHandler!.fetchPackages();
   }
 
   async purchasePackage(pkg: PurchasesPackage): Promise<boolean> {
-    this.ensureConfigured();
-
-    const userId = this.state.initCache.getCurrentUserId();
-    if (!userId) {
-      throw new Error("No current user found");
-    }
-
+    ensureConfigured(this.managerConfig);
+    const userId = getCurrentUserIdOrThrow(this.state);
     this.ensurePackageHandlerInitialized();
+
     return this.packageHandler!.purchase(pkg, userId);
   }
 
   async restore(): Promise<RestoreResultInfo> {
-    this.ensureConfigured();
-
-    const userId = this.state.initCache.getCurrentUserId();
-    if (!userId) {
-      throw new Error("No current user found");
-    }
-
+    ensureConfigured(this.managerConfig);
+    const userId = getCurrentUserIdOrThrow(this.state);
     this.ensurePackageHandlerInitialized();
+
     return this.packageHandler!.restore(userId);
   }
 
   async checkPremiumStatus(): Promise<PremiumStatus> {
-    this.ensureConfigured();
-
-    const userId = this.state.initCache.getCurrentUserId();
-    if (!userId) {
-      throw new Error("No current user found");
-    }
+    ensureConfigured(this.managerConfig);
+    getCurrentUserIdOrThrow(this.state);
+    ensureServiceAvailable(this.serviceInstance);
 
-    if (!this.serviceInstance) {
-      throw new Error("Service instance not available");
-    }
-
-    const customerInfo = await this.serviceInstance.getCustomerInfo();
+    const customerInfo = await this.serviceInstance!.getCustomerInfo();
 
     if (!customerInfo) {
       throw new Error("Customer info not available");
@@ -154,12 +121,10 @@ class SubscriptionManagerImpl {
   }
 
   async reset(): Promise<void> {
-    if (this.serviceInstance) {
-      await this.serviceInstance.reset();
-    }
-
+    await this.serviceInstance?.reset();
     this.state.reset();
     this.serviceInstance = null;
+    this.packageHandler = null;
   }
 
   isConfigured(): boolean {
@@ -167,19 +132,12 @@ class SubscriptionManagerImpl {
   }
 
   isInitialized(): boolean {
-    if (!this.serviceInstance) {
-      return false;
-    }
-
-    return this.serviceInstance.isInitialized();
+    return this.serviceInstance?.isInitialized() ?? false;
   }
 
   getEntitlementId(): string {
-    if (!this.managerConfig) {
-      throw new Error("SubscriptionManager not configured");
-    }
-
-    return this.managerConfig.config.entitlementIdentifier;
+    ensureConfigured(this.managerConfig);
+    return this.managerConfig!.config.entitlementIdentifier;
   }
 }
 

package/src/domains/subscription/infrastructure/managers/subscriptionManagerUtils.ts

@@ -0,0 +1,57 @@
+/**
+ * Subscription Manager Utilities
+ * Validation and helper functions for SubscriptionManager
+ */
+
+import type { SubscriptionManagerConfig } from "./SubscriptionManager";
+import type { IRevenueCatService } from "../../../../shared/application/ports/IRevenueCatService";
+import { SubscriptionInternalState } from "./SubscriptionInternalState";
+
+/**
+ * Validate that manager is configured
+ */
+export function ensureConfigured(config: SubscriptionManagerConfig | null): void {
+    if (!config) {
+        throw new Error("SubscriptionManager not configured");
+    }
+}
+
+/**
+ * Get current user ID or throw
+ */
+export function getCurrentUserIdOrThrow(state: SubscriptionInternalState): string {
+    const userId = state.initCache.getCurrentUserId();
+    if (!userId) {
+        throw new Error("No current user found");
+    }
+    return userId;
+}
+
+/**
+ * Get service instance or initialize
+ */
+export function getOrCreateService(
+    currentInstance: IRevenueCatService | null
+): IRevenueCatService {
+    if (currentInstance) {
+        return currentInstance;
+    }
+
+    const { getRevenueCatService } = require("../services/RevenueCatService");
+    const serviceInstance = getRevenueCatService();
+
+    if (!serviceInstance) {
+        throw new Error("Service instance not available");
+    }
+
+    return serviceInstance;
+}
+
+/**
+ * Validate service is available
+ */
+export function ensureServiceAvailable(service: IRevenueCatService | null): void {
+    if (!service) {
+        throw new Error("Service instance not available");
+    }
+}

package/src/domains/subscription/infrastructure/services/CustomerInfoListenerManager.ts

@@ -65,10 +65,8 @@ export class CustomerInfoListenerManager {
                         renewalResult.newExpirationDate!,
                         customerInfo
                     );
-                } catch (error) {
-                    if (__DEV__) {
-                        console.error("[CustomerInfoListener] Renewal callback failed:", error);
-                    }
+                } catch {
+                    // Silently fail listener callbacks to prevent crashing the main listener
                 }
             }
 
@@ -82,10 +80,8 @@ export class CustomerInfoListenerManager {
                         renewalResult.isUpgrade,
                         customerInfo
                     );
-                } catch (error) {
-                    if (__DEV__) {
-                        console.error("[CustomerInfoListener] Plan change callback failed:", error);
-                    }
+                } catch {
+                    // Silently fail listener callbacks to prevent crashing the main listener
                 }
             }
 
@@ -96,10 +92,8 @@ export class CustomerInfoListenerManager {
             if (!renewalResult.isRenewal && !renewalResult.isPlanChange) {
                 try {
                     await syncPremiumStatus(config, this.currentUserId, customerInfo);
-                } catch (error) {
-                    if (__DEV__) {
-                        console.error("[CustomerInfoListener] syncPremiumStatus failed:", error);
-                    }
+                } catch {
+                    // Silently fail listener callbacks to prevent crashing the main listener
                 }
             }
         };

package/src/domains/subscription/infrastructure/services/PurchaseHandler.ts

@@ -29,8 +29,6 @@ export async function handlePurchase(
   const entitlementIdentifier = deps.config.entitlementIdentifier;
 
   try {
-    if (__DEV__) console.log('[Purchase] Starting:', pkg.product.identifier);
-
     const { customerInfo } = await Purchases.purchasePackage(pkg);
     const savedPurchase = getSavedPurchase();
     const source = savedPurchase?.source;

package/src/domains/subscription/infrastructure/services/RevenueCatInitializer.ts

@@ -1,4 +1,4 @@
-import Purchases, { LOG_LEVEL, type CustomerInfo, type PurchasesOfferings } from "react-native-purchases";
+import Purchases, { type CustomerInfo, type PurchasesOfferings } from "react-native-purchases";
 import type { InitializeResult } from "../../../../shared/application/ports/IRevenueCatService";
 import type { RevenueCatConfig } from "../../core/RevenueCatConfig";
 import { resolveApiKey } from "../utils/ApiKeyResolver";
@@ -25,14 +25,13 @@ function configureLogHandler(): void {
   if (configurationState.isLogHandlerConfigured) return;
   if (typeof Purchases.setLogHandler !== 'function') return;
   try {
-    Purchases.setLogHandler((logLevel, message) => {
+    Purchases.setLogHandler((_logLevel, message) => {
       const ignoreMessages = ['Purchase was cancelled', 'AppTransaction', "Couldn't find previous transactions"];
       if (ignoreMessages.some(m => message.includes(m))) return;
-      if (logLevel === LOG_LEVEL.ERROR && __DEV__) console.error('[RevenueCat]', message);
     });
     configurationState.isLogHandlerConfigured = true;
   } catch {
-    // Native module not available (Expo Go)
+    // Failing to set log handler should not block initialization
   }
 }
 

package/src/domains/subscription/infrastructure/services/RevenueCatService.ts

@@ -108,11 +108,8 @@ export class RevenueCatService implements IRevenueCatService {
         try {
             await Purchases.logOut();
             this.stateManager.setInitialized(false);
-        } catch (error) {
-            // Log error for debugging but don't throw - reset is cleanup operation
-            if (__DEV__) {
-                console.error('[RevenueCatService] Reset failed:', error);
-            }
+        } catch {
+            // Silently fail during logout to allow cleanup to complete
         }
     }
 }

package/src/domains/subscription/infrastructure/utils/PremiumStatusSyncer.ts

@@ -35,10 +35,8 @@ export async function syncPremiumStatus(
         } else {
             await config.onPremiumStatusChanged(userId, false, undefined, undefined, undefined, undefined);
         }
-    } catch (error) {
-        if (__DEV__) {
-            console.error('[PremiumStatusSyncer] syncPremiumStatus failed:', error);
-        }
+    } catch {
+        // Silently fail callback notifications to prevent crashing the main flow
     }
 }
 
@@ -55,10 +53,8 @@ export async function notifyPurchaseCompleted(
 
     try {
         await config.onPurchaseCompleted(userId, productId, customerInfo, source);
-    } catch (error) {
-        if (__DEV__) {
-            console.error('[PremiumStatusSyncer] onPurchaseCompleted callback failed:', error);
-        }
+    } catch {
+        // Silently fail callback notifications to prevent crashing the main flow
     }
 }
 
@@ -74,9 +70,7 @@ export async function notifyRestoreCompleted(
 
     try {
         await config.onRestoreCompleted(userId, isPremium, customerInfo);
-    } catch (error) {
-        if (__DEV__) {
-            console.error('[PremiumStatusSyncer] notifyRestoreCompleted failed:', error);
-        }
+    } catch {
+        // Silently fail callback notifications to prevent crashing the main flow
     }
 }

package/src/domains/subscription/infrastructure/utils/authPurchaseState.ts

@@ -0,0 +1,69 @@
+/**
+ * Auth Purchase State Manager
+ * Manages global state for auth-aware purchase operations
+ */
+
+import type { PurchasesPackage } from "react-native-purchases";
+import type { PurchaseSource } from "../../core/SubscriptionConstants";
+
+export interface PurchaseAuthProvider {
+  isAuthenticated: () => boolean;
+  showAuthModal: () => void;
+}
+
+interface SavedPurchaseState {
+  pkg: PurchasesPackage;
+  source: PurchaseSource;
+  timestamp: number;
+}
+
+const SAVED_PURCHASE_EXPIRY_MS = 5 * 60 * 1000;
+
+class AuthPurchaseStateManager {
+  private authProvider: PurchaseAuthProvider | null = null;
+  private savedPurchaseState: SavedPurchaseState | null = null;
+
+  configure(provider: PurchaseAuthProvider): void {
+    this.authProvider = provider;
+  }
+
+  getProvider(): PurchaseAuthProvider | null {
+    return this.authProvider;
+  }
+
+  savePurchase(pkg: PurchasesPackage, source: PurchaseSource): void {
+    this.savedPurchaseState = {
+      pkg,
+      source,
+      timestamp: Date.now(),
+    };
+  }
+
+  getSavedPurchase(): { pkg: PurchasesPackage; source: PurchaseSource } | null {
+    if (!this.savedPurchaseState) {
+      return null;
+    }
+
+    const isExpired = Date.now() - this.savedPurchaseState.timestamp > SAVED_PURCHASE_EXPIRY_MS;
+    if (isExpired) {
+      this.savedPurchaseState = null;
+      return null;
+    }
+
+    return {
+      pkg: this.savedPurchaseState.pkg,
+      source: this.savedPurchaseState.source,
+    };
+  }
+
+  clearSavedPurchase(): void {
+    this.savedPurchaseState = null;
+  }
+
+  cleanup(): void {
+    this.authProvider = null;
+    this.savedPurchaseState = null;
+  }
+}
+
+export const authPurchaseStateManager = new AuthPurchaseStateManager();

package/src/domains/subscription/infrastructure/utils/trialEligibilityUtils.ts

@@ -0,0 +1,77 @@
+/**
+ * Trial Eligibility Utilities
+ * Business logic for checking trial eligibility
+ */
+
+import Purchases, {
+  type IntroEligibility,
+  INTRO_ELIGIBILITY_STATUS,
+} from "react-native-purchases";
+
+/** Trial eligibility info for a single product */
+export interface ProductTrialEligibility {
+  productId: string;
+  eligible: boolean;
+  trialDurationDays?: number;
+}
+
+/** Map of product ID to eligibility */
+export type TrialEligibilityMap = Record<string, ProductTrialEligibility>;
+
+/** Default trial duration in days */
+const DEFAULT_TRIAL_DURATION_DAYS = 7;
+
+/**
+ * Check trial eligibility for product IDs
+ */
+export async function checkTrialEligibility(
+  productIds: string[]
+): Promise<TrialEligibilityMap> {
+  const eligibilities: Record<string, IntroEligibility> =
+    await Purchases.checkTrialOrIntroductoryPriceEligibility(productIds);
+
+  const result: TrialEligibilityMap = {};
+
+  for (const productId of productIds) {
+    const eligibility = eligibilities[productId];
+    const isEligible =
+      eligibility?.status === INTRO_ELIGIBILITY_STATUS.INTRO_ELIGIBILITY_STATUS_ELIGIBLE;
+
+    result[productId] = {
+      productId,
+      eligible: isEligible,
+      trialDurationDays: DEFAULT_TRIAL_DURATION_DAYS,
+    };
+  }
+
+  return result;
+}
+
+/**
+ * Create fallback eligibility map (all eligible)
+ * Used when eligibility check fails
+ */
+export function createFallbackEligibilityMap(
+  productIds: string[]
+): TrialEligibilityMap {
+  const result: TrialEligibilityMap = {};
+
+  for (const productId of productIds) {
+    result[productId] = {
+      productId,
+      eligible: true,
+      trialDurationDays: DEFAULT_TRIAL_DURATION_DAYS,
+    };
+  }
+
+  return result;
+}
+
+/**
+ * Check if any product has eligible trial
+ */
+export function hasAnyEligibleTrial(
+  eligibilityMap: TrialEligibilityMap
+): boolean {
+  return Object.values(eligibilityMap).some((e) => e.eligible);
+}