@umituz/react-native-subscription 2.32.1 → 2.33.1

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

@@ -1,145 +1,57 @@
-/**
- * Customer Info Listener Manager
- * Handles RevenueCat customer info update listeners with renewal detection
- */
-
-import Purchases, {
-    type CustomerInfo,
-    type CustomerInfoUpdateListener,
-} from "react-native-purchases";
+import Purchases, { type CustomerInfo } from "react-native-purchases";
 import type { RevenueCatConfig } from "../../../revenuecat/core/types";
-import { syncPremiumStatus } from "../utils/PremiumStatusSyncer";
-import {
-    detectRenewal,
-    updateRenewalState,
-    type RenewalState,
-} from "../utils/RenewalDetector";
+import { ListenerState } from "./listeners/ListenerState";
+import { processCustomerInfo } from "./listeners/CustomerInfoHandler";
 
 export class CustomerInfoListenerManager {
-    private listener: CustomerInfoUpdateListener | null = null;
-    private currentUserId: string | null = null;
-    private renewalState: RenewalState = {
-        previousExpirationDate: null,
-        previousProductId: null,
-    };
-
-    setUserId(userId: string, config: RevenueCatConfig): void {
-        const wasUserChange = this.currentUserId && this.currentUserId !== userId;
+  private state = new ListenerState();
 
-        // Clean up old listener and reset state when user changes
-        if (wasUserChange) {
-            this.removeListener();
-            this.renewalState = {
-                previousExpirationDate: null,
-                previousProductId: null,
-            };
-        }
-
-        this.currentUserId = userId;
-
-        // Setup new listener for new user or if no listener exists
-        if (wasUserChange || !this.listener) {
-            this.setupListener(config);
-        }
-    }
+  setUserId(userId: string, config: RevenueCatConfig): void {
+    const wasUserChange = this.state.hasUserChanged(userId);
 
-    clearUserId(): void {
-        this.currentUserId = null;
-        this.renewalState = {
-            previousExpirationDate: null,
-            previousProductId: null,
-        };
+    if (wasUserChange) {
+      this.removeListener();
+      this.state.resetRenewalState();
     }
 
-    setupListener(config: RevenueCatConfig): void {
-        this.removeListener();
+    this.state.currentUserId = userId;
 
-        this.listener = async (customerInfo: CustomerInfo) => {
-            if (!this.currentUserId) {
-                return;
-            }
+    if (wasUserChange || !this.state.listener) {
+      this.setupListener(config);
+    }
+  }
 
-            const renewalResult = detectRenewal(
-                this.renewalState,
-                customerInfo,
-                config.entitlementIdentifier
-            );
+  clearUserId(): void {
+    this.state.currentUserId = null;
+    this.state.resetRenewalState();
+  }
 
-            // Handle renewal (same product, extended expiration)
-            if (renewalResult.isRenewal && config.onRenewalDetected) {
-                try {
-                    await config.onRenewalDetected(
-                        this.currentUserId,
-                        renewalResult.productId!,
-                        renewalResult.newExpirationDate!,
-                        customerInfo
-                    );
-                } catch (error) {
-                    console.error('[CustomerInfoListenerManager] Renewal detection callback failed', {
-                        userId: this.currentUserId,
-                        productId: renewalResult.productId,
-                        error
-                    });
-                    // Swallow error to prevent listener crash
-                }
-            }
+  setupListener(config: RevenueCatConfig): void {
+    this.removeListener();
 
-            // Handle plan change (upgrade/downgrade)
-            if (renewalResult.isPlanChange && config.onPlanChanged) {
-                try {
-                    await config.onPlanChanged(
-                        this.currentUserId,
-                        renewalResult.productId!,
-                        renewalResult.previousProductId!,
-                        renewalResult.isUpgrade,
-                        customerInfo
-                    );
-                } catch (error) {
-                    console.error('[CustomerInfoListenerManager] Plan change callback failed', {
-                        userId: this.currentUserId,
-                        productId: renewalResult.productId,
-                        previousProductId: renewalResult.previousProductId,
-                        isUpgrade: renewalResult.isUpgrade,
-                        error
-                    });
-                    // Swallow error to prevent listener crash
-                }
-            }
+    this.state.listener = async (customerInfo: CustomerInfo) => {
+      if (!this.state.currentUserId) return;
 
-            this.renewalState = updateRenewalState(this.renewalState, renewalResult);
+      this.state.renewalState = await processCustomerInfo(
+        customerInfo,
+        this.state.currentUserId,
+        this.state.renewalState,
+        config
+      );
+    };
 
-            // Only sync premium status if NOT a renewal or plan change
-            // This prevents double credit initialization
-            if (!renewalResult.isRenewal && !renewalResult.isPlanChange) {
-                try {
-                    await syncPremiumStatus(config, this.currentUserId, customerInfo);
-                } catch (error) {
-                    console.error('[CustomerInfoListenerManager] Premium status sync failed', {
-                        userId: this.currentUserId,
-                        error
-                    });
-                    // Swallow error to prevent listener crash
-                }
-            }
-        };
+    Purchases.addCustomerInfoUpdateListener(this.state.listener);
+  }
 
-        Purchases.addCustomerInfoUpdateListener(this.listener);
+  removeListener(): void {
+    if (this.state.listener) {
+      Purchases.removeCustomerInfoUpdateListener(this.state.listener);
+      this.state.listener = null;
     }
+  }
 
-    removeListener(): void {
-        if (this.listener) {
-            Purchases.removeCustomerInfoUpdateListener(this.listener);
-            this.listener = null;
-        }
-    }
-
-    destroy(): void {
-        this.removeListener();
-        this.clearUserId();
-        // Reset renewal state to ensure clean state
-        this.renewalState = {
-            previousExpirationDate: null,
-            previousProductId: null,
-        };
-    }
+  destroy(): void {
+    this.removeListener();
+    this.state.reset();
+  }
 }

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

@@ -1,143 +1,37 @@
-import Purchases, { type PurchasesPackage } from "react-native-purchases";
+import type { PurchasesPackage } from "react-native-purchases";
 import type { PurchaseResult } from "../../../../shared/application/ports/IRevenueCatService";
-import {
-  RevenueCatPurchaseError,
-  RevenueCatInitializationError,
-  RevenueCatNetworkError,
-} from "../../../revenuecat/core/errors";
 import type { RevenueCatConfig } from "../../../revenuecat/core/types";
-import {
-  isUserCancelledError,
-  isNetworkError,
-  isAlreadyPurchasedError,
-  isInvalidCredentialsError,
-  getRawErrorMessage,
-  getErrorCode,
-} from "../../../revenuecat/core/types";
-import { syncPremiumStatus, notifyPurchaseCompleted } from "../utils/PremiumStatusSyncer";
-import { getSavedPurchase, clearSavedPurchase } from "../../presentation/useAuthAwarePurchase";
-import { handleRestore } from "./RestoreHandler";
+import { isUserCancelledError, isAlreadyPurchasedError } from "../../../revenuecat/core/types";
+import { validatePurchaseReady, isConsumableProduct } from "./purchase/PurchaseValidator";
+import { executePurchase } from "./purchase/PurchaseExecutor";
+import { handleAlreadyPurchasedError, handlePurchaseError } from "./purchase/PurchaseErrorHandler";
 
 export interface PurchaseHandlerDeps {
   config: RevenueCatConfig;
   isInitialized: () => boolean;
 }
 
-function isConsumableProduct(pkg: PurchasesPackage, consumableIds: string[]): boolean {
-  if (consumableIds.length === 0) return false;
-  const identifier = pkg.product.identifier.toLowerCase();
-  return consumableIds.some((id) => identifier.includes(id.toLowerCase()));
-}
-
 export async function handlePurchase(
   deps: PurchaseHandlerDeps,
   pkg: PurchasesPackage,
   userId: string
 ): Promise<PurchaseResult> {
-  if (!deps.isInitialized()) throw new RevenueCatInitializationError();
+  validatePurchaseReady(deps.isInitialized());
 
   const consumableIds = deps.config.consumableProductIdentifiers || [];
   const isConsumable = isConsumableProduct(pkg, consumableIds);
-  const entitlementIdentifier = deps.config.entitlementIdentifier;
 
   try {
-    const { customerInfo } = await Purchases.purchasePackage(pkg);
-    const savedPurchase = getSavedPurchase();
-    const source = savedPurchase?.source;
-
-    if (isConsumable) {
-      await notifyPurchaseCompleted(deps.config, userId, pkg.product.identifier, customerInfo, source);
-      clearSavedPurchase();
-      return { success: true, isPremium: false, customerInfo, isConsumable: true, productId: pkg.product.identifier };
-    }
-
-    const isPremium = !!customerInfo.entitlements.active[entitlementIdentifier];
-
-    if (isPremium) {
-      await syncPremiumStatus(deps.config, userId, customerInfo);
-      await notifyPurchaseCompleted(deps.config, userId, pkg.product.identifier, customerInfo, source);
-      clearSavedPurchase();
-      return { success: true, isPremium: true, customerInfo, productId: pkg.product.identifier };
-    }
-
-    // Purchase completed but no entitlement - still notify (test store scenario)
-    await notifyPurchaseCompleted(deps.config, userId, pkg.product.identifier, customerInfo, source);
-    clearSavedPurchase();
-    return { success: true, isPremium: false, customerInfo, productId: pkg.product.identifier };
+    return await executePurchase(deps.config, userId, pkg, isConsumable);
   } catch (error) {
-    // User cancelled - not an error, just return false
     if (isUserCancelledError(error)) {
       return { success: false, isPremium: false, productId: pkg.product.identifier };
     }
 
-    // Already purchased - auto-restore (RevenueCat best practice)
     if (isAlreadyPurchasedError(error)) {
-      try {
-        const restoreResult = await handleRestore(deps, userId);
-        if (restoreResult.success && restoreResult.isPremium) {
-          // Restore succeeded, notify and return success
-          if (restoreResult.customerInfo) {
-            await notifyPurchaseCompleted(deps.config, userId, pkg.product.identifier, restoreResult.customerInfo, getSavedPurchase()?.source);
-          }
-          clearSavedPurchase();
-          return {
-            success: true,
-            isPremium: true,
-            customerInfo: restoreResult.customerInfo,
-            productId: restoreResult.productId || pkg.product.identifier,
-          };
-        }
-      } catch (_restoreError) {
-        // Restore failed, throw original error
-        throw new RevenueCatPurchaseError(
-          "You already own this subscription, but restore failed. Please try restoring purchases manually.",
-          pkg.product.identifier,
-          error instanceof Error ? error : undefined
-        );
-      }
-      // Restore succeeded but no premium - throw original error
-      throw new RevenueCatPurchaseError(
-        "You already own this subscription, but it could not be activated.",
-        pkg.product.identifier,
-        error instanceof Error ? error : undefined
-      );
-    }
-
-    // Network error - throw specific error type
-    if (isNetworkError(error)) {
-      throw new RevenueCatNetworkError(
-        "Network error during purchase. Please check your internet connection and try again.",
-        error instanceof Error ? error : undefined
-      );
+      return await handleAlreadyPurchasedError(deps, userId, pkg, error);
     }
 
-    // Invalid credentials - configuration error
-    if (isInvalidCredentialsError(error)) {
-      throw new RevenueCatPurchaseError(
-        "App configuration error. Please contact support.",
-        pkg.product.identifier,
-        error instanceof Error ? error : undefined
-      );
-    }
-
-    // Generic error with code
-    const errorCode = getErrorCode(error);
-    const errorMessage = getRawErrorMessage(error, "Purchase failed");
-    const enhancedMessage = errorCode
-      ? `${errorMessage} (Code: ${errorCode})`
-      : errorMessage;
-
-    console.error('[PurchaseHandler] Purchase failed', {
-      productId: pkg.product.identifier,
-      userId,
-      errorCode,
-      error,
-    });
-
-    throw new RevenueCatPurchaseError(
-      enhancedMessage,
-      pkg.product.identifier,
-      error instanceof Error ? error : undefined
-    );
+    return handlePurchaseError(error, pkg, userId);
   }
 }

package/src/domains/subscription/infrastructure/services/listeners/CustomerInfoHandler.ts

@@ -0,0 +1,102 @@
+import type { CustomerInfo } from "react-native-purchases";
+import type { RevenueCatConfig } from "../../../../revenuecat/core/types";
+import { syncPremiumStatus } from "../../utils/PremiumStatusSyncer";
+import { detectRenewal, updateRenewalState, type RenewalState } from "../../utils/renewal";
+
+async function handleRenewal(
+  userId: string,
+  productId: string,
+  expirationDate: string,
+  customerInfo: CustomerInfo,
+  onRenewalDetected?: RevenueCatConfig['onRenewalDetected']
+): Promise<void> {
+  if (!onRenewalDetected) return;
+
+  try {
+    await onRenewalDetected(userId, productId, expirationDate, customerInfo);
+  } catch (error) {
+    console.error('[CustomerInfoHandler] Renewal detection callback failed', {
+      userId,
+      productId,
+      error
+    });
+  }
+}
+
+async function handlePlanChange(
+  userId: string,
+  newProductId: string,
+  previousProductId: string,
+  isUpgrade: boolean,
+  customerInfo: CustomerInfo,
+  onPlanChanged?: RevenueCatConfig['onPlanChanged']
+): Promise<void> {
+  if (!onPlanChanged) return;
+
+  try {
+    await onPlanChanged(userId, newProductId, previousProductId, isUpgrade, customerInfo);
+  } catch (error) {
+    console.error('[CustomerInfoHandler] Plan change callback failed', {
+      userId,
+      newProductId,
+      previousProductId,
+      isUpgrade,
+      error
+    });
+  }
+}
+
+async function handlePremiumStatusSync(
+  config: RevenueCatConfig,
+  userId: string,
+  customerInfo: CustomerInfo
+): Promise<void> {
+  try {
+    await syncPremiumStatus(config, userId, customerInfo);
+  } catch (error) {
+    console.error('[CustomerInfoHandler] Premium status sync failed', {
+      userId,
+      error
+    });
+  }
+}
+
+export async function processCustomerInfo(
+  customerInfo: CustomerInfo,
+  userId: string,
+  renewalState: RenewalState,
+  config: RevenueCatConfig
+): Promise<RenewalState> {
+  const renewalResult = detectRenewal(
+    renewalState,
+    customerInfo,
+    config.entitlementIdentifier
+  );
+
+  if (renewalResult.isRenewal) {
+    await handleRenewal(
+      userId,
+      renewalResult.productId!,
+      renewalResult.newExpirationDate!,
+      customerInfo,
+      config.onRenewalDetected
+    );
+  }
+
+  if (renewalResult.isPlanChange) {
+    await handlePlanChange(
+      userId,
+      renewalResult.productId!,
+      renewalResult.previousProductId!,
+      renewalResult.isUpgrade,
+      customerInfo,
+      config.onPlanChanged
+    );
+  }
+
+  if (!renewalResult.isRenewal && !renewalResult.isPlanChange) {
+    await handlePremiumStatusSync(config, userId, customerInfo);
+  }
+
+  return updateRenewalState(renewalState, renewalResult);
+}

package/src/domains/subscription/infrastructure/services/listeners/ListenerState.ts

@@ -0,0 +1,31 @@
+import type { CustomerInfoUpdateListener } from "react-native-purchases";
+import type { RenewalState } from "../../utils/renewal";
+
+export class ListenerState {
+  listener: CustomerInfoUpdateListener | null = null;
+  currentUserId: string | null = null;
+  renewalState: RenewalState = {
+    previousExpirationDate: null,
+    previousProductId: null,
+  };
+
+  reset(): void {
+    this.listener = null;
+    this.currentUserId = null;
+    this.renewalState = {
+      previousExpirationDate: null,
+      previousProductId: null,
+    };
+  }
+
+  resetRenewalState(): void {
+    this.renewalState = {
+      previousExpirationDate: null,
+      previousProductId: null,
+    };
+  }
+
+  hasUserChanged(newUserId: string): boolean {
+    return !!(this.currentUserId && this.currentUserId !== newUserId);
+  }
+}

package/src/domains/subscription/infrastructure/services/purchase/PurchaseErrorHandler.ts

@@ -0,0 +1,104 @@
+import type { PurchasesPackage } from "react-native-purchases";
+import type { PurchaseResult } from "../../../../../shared/application/ports/IRevenueCatService";
+import {
+  RevenueCatPurchaseError,
+  RevenueCatNetworkError,
+} from "../../../../revenuecat/core/errors";
+import {
+  isUserCancelledError,
+  isNetworkError,
+  isInvalidCredentialsError,
+  getRawErrorMessage,
+  getErrorCode,
+} from "../../../../revenuecat/core/types";
+import { getSavedPurchase, clearSavedPurchase } from "../../../presentation/useAuthAwarePurchase";
+import { notifyPurchaseCompleted } from "../../utils/PremiumStatusSyncer";
+import { handleRestore } from "../RestoreHandler";
+import type { PurchaseHandlerDeps } from "../PurchaseHandler";
+
+export async function handleAlreadyPurchasedError(
+  deps: PurchaseHandlerDeps,
+  userId: string,
+  pkg: PurchasesPackage,
+  error: unknown
+): Promise<PurchaseResult> {
+  try {
+    const restoreResult = await handleRestore(deps, userId);
+    if (restoreResult.success && restoreResult.isPremium && restoreResult.customerInfo) {
+      await notifyPurchaseCompleted(
+        deps.config,
+        userId,
+        pkg.product.identifier,
+        restoreResult.customerInfo,
+        getSavedPurchase()?.source
+      );
+      clearSavedPurchase();
+      return {
+        success: true,
+        isPremium: true,
+        customerInfo: restoreResult.customerInfo,
+        productId: restoreResult.productId || pkg.product.identifier,
+      };
+    }
+  } catch (_restoreError) {
+    throw new RevenueCatPurchaseError(
+      "You already own this subscription, but restore failed. Please try restoring purchases manually.",
+      pkg.product.identifier,
+      error instanceof Error ? error : undefined
+    );
+  }
+
+  throw new RevenueCatPurchaseError(
+    "You already own this subscription, but it could not be activated.",
+    pkg.product.identifier,
+    error instanceof Error ? error : undefined
+  );
+}
+
+export function handlePurchaseError(
+  error: unknown,
+  pkg: PurchasesPackage,
+  userId: string
+): never {
+  if (isUserCancelledError(error)) {
+    throw new RevenueCatPurchaseError(
+      "Purchase cancelled",
+      pkg.product.identifier,
+      error instanceof Error ? error : undefined
+    );
+  }
+
+  if (isNetworkError(error)) {
+    throw new RevenueCatNetworkError(
+      "Network error during purchase. Please check your internet connection and try again.",
+      error instanceof Error ? error : undefined
+    );
+  }
+
+  if (isInvalidCredentialsError(error)) {
+    throw new RevenueCatPurchaseError(
+      "App configuration error. Please contact support.",
+      pkg.product.identifier,
+      error instanceof Error ? error : undefined
+    );
+  }
+
+  const errorCode = getErrorCode(error);
+  const errorMessage = getRawErrorMessage(error, "Purchase failed");
+  const enhancedMessage = errorCode
+    ? `${errorMessage} (Code: ${errorCode})`
+    : errorMessage;
+
+  console.error('[PurchaseHandler] Purchase failed', {
+    productId: pkg.product.identifier,
+    userId,
+    errorCode,
+    error,
+  });
+
+  throw new RevenueCatPurchaseError(
+    enhancedMessage,
+    pkg.product.identifier,
+    error instanceof Error ? error : undefined
+  );
+}

package/src/domains/subscription/infrastructure/services/purchase/PurchaseExecutor.ts

@@ -0,0 +1,70 @@
+import Purchases, { type PurchasesPackage, type CustomerInfo } from "react-native-purchases";
+import type { PurchaseResult } from "../../../../../shared/application/ports/IRevenueCatService";
+import type { RevenueCatConfig } from "../../../../revenuecat/core/types";
+import { syncPremiumStatus, notifyPurchaseCompleted } from "../../utils/PremiumStatusSyncer";
+import { getSavedPurchase, clearSavedPurchase } from "../../../presentation/useAuthAwarePurchase";
+
+async function executeConsumablePurchase(
+  config: RevenueCatConfig,
+  userId: string,
+  productId: string,
+  customerInfo: CustomerInfo
+): Promise<PurchaseResult> {
+  const source = getSavedPurchase()?.source;
+  await notifyPurchaseCompleted(config, userId, productId, customerInfo, source);
+  clearSavedPurchase();
+  return {
+    success: true,
+    isPremium: false,
+    customerInfo,
+    isConsumable: true,
+    productId,
+  };
+}
+
+async function executeSubscriptionPurchase(
+  config: RevenueCatConfig,
+  userId: string,
+  productId: string,
+  customerInfo: CustomerInfo,
+  entitlementIdentifier: string
+): Promise<PurchaseResult> {
+  const isPremium = !!customerInfo.entitlements.active[entitlementIdentifier];
+  const source = getSavedPurchase()?.source;
+
+  if (isPremium) {
+    await syncPremiumStatus(config, userId, customerInfo);
+  }
+
+  await notifyPurchaseCompleted(config, userId, productId, customerInfo, source);
+  clearSavedPurchase();
+
+  return {
+    success: true,
+    isPremium,
+    customerInfo,
+    productId,
+  };
+}
+
+export async function executePurchase(
+  config: RevenueCatConfig,
+  userId: string,
+  pkg: PurchasesPackage,
+  isConsumable: boolean
+): Promise<PurchaseResult> {
+  const { customerInfo } = await Purchases.purchasePackage(pkg);
+  const productId = pkg.product.identifier;
+
+  if (isConsumable) {
+    return executeConsumablePurchase(config, userId, productId, customerInfo);
+  }
+
+  return executeSubscriptionPurchase(
+    config,
+    userId,
+    productId,
+    customerInfo,
+    config.entitlementIdentifier
+  );
+}

package/src/domains/subscription/infrastructure/services/purchase/PurchaseValidator.ts

@@ -0,0 +1,14 @@
+import type { PurchasesPackage } from "react-native-purchases";
+import { RevenueCatInitializationError } from "../../../../revenuecat/core/errors";
+
+export function validatePurchaseReady(isInitialized: boolean): void {
+  if (!isInitialized) {
+    throw new RevenueCatInitializationError();
+  }
+}
+
+export function isConsumableProduct(pkg: PurchasesPackage, consumableIds: string[]): boolean {
+  if (consumableIds.length === 0) return false;
+  const identifier = pkg.product.identifier.toLowerCase();
+  return consumableIds.some((id) => identifier.includes(id.toLowerCase()));
+}

package/src/domains/subscription/infrastructure/utils/renewal/PackageTierComparator.ts

@@ -0,0 +1,14 @@
+import { detectPackageType } from "../../../../../utils/packageTypeDetector";
+
+const PACKAGE_TIER_ORDER: Record<string, number> = {
+  weekly: 1,
+  monthly: 2,
+  yearly: 3,
+  unknown: 0,
+};
+
+export function getPackageTier(productId: string | null): number {
+  if (!productId) return 0;
+  const packageType = detectPackageType(productId);
+  return PACKAGE_TIER_ORDER[packageType] ?? 0;
+}