@umituz/react-native-subscription 2.32.0 → 2.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.32.0",
+  "version": "2.33.0",
   "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/infrastructure/CreditsRepository.ts

@@ -1,20 +1,15 @@
-import { getDoc, setDoc } from "firebase/firestore";
-import { BaseRepository, serverTimestamp, type Firestore, type DocumentReference } from "@umituz/react-native-firebase";
+import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
+import { BaseRepository } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../core/Credits";
-import type { UserCreditsDocumentRead, PurchaseSource } from "../core/UserCreditsDocument";
-import { initializeCreditsTransaction } from "../application/CreditsInitializer";
-import { mapCreditsDocumentToEntity } from "../core/CreditsMapper";
+import type { PurchaseSource } from "../core/UserCreditsDocument";
 import type { RevenueCatData } from "../../revenuecat/core/types";
 import { deductCreditsOperation } from "../application/DeductCreditsCommand";
-import { calculateCreditLimit } from "../application/CreditLimitCalculator";
 import { PURCHASE_TYPE, type PurchaseType } from "../../subscription/core/SubscriptionConstants";
 import { requireFirestore, buildDocRef, type CollectionConfig } from "../../../shared/infrastructure/firestore";
-import { SUBSCRIPTION_STATUS } from "../../subscription/core/SubscriptionConstants";
+import { fetchCredits, checkHasCredits } from "./operations/CreditsFetcher";
+import { syncExpiredStatus } from "./operations/CreditsWriter";
+import { initializeCreditsWithRetry } from "./operations/CreditsInitializer";
 
-/**
- * Credits Repository
- * Provides domain-specific database operations for credits system.
- */
 export class CreditsRepository extends BaseRepository {
   constructor(private config: CreditsConfig) {
     super(config.collectionName);
@@ -34,14 +29,7 @@ export class CreditsRepository extends BaseRepository {
 
   async getCredits(userId: string): Promise<CreditsResult> {
     const db = requireFirestore();
-    const snap = await getDoc(this.getRef(db, userId));
-
-    if (!snap.exists()) {
-      return { success: true, data: null, error: null };
-    }
-
-    const entity = mapCreditsDocumentToEntity(snap.data() as UserCreditsDocumentRead);
-    return { success: true, data: entity, error: null };
+    return fetchCredits(this.getRef(db, userId));
   }
 
   async initializeCredits(
@@ -53,101 +41,32 @@ export class CreditsRepository extends BaseRepository {
     type: PurchaseType = PURCHASE_TYPE.INITIAL
   ): Promise<CreditsResult> {
     const db = requireFirestore();
-    const creditLimit = calculateCreditLimit(productId, this.config);
-    const cfg = { ...this.config, creditLimit };
-
-    const maxRetries = 3;
-    let lastError: any;
-
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        const result = await initializeCreditsTransaction(
-          db,
-          this.getRef(db, userId),
-          cfg,
-          purchaseId,
-          {
-            productId,
-            source,
-            expirationDate: revenueCatData.expirationDate,
-            willRenew: revenueCatData.willRenew,
-            originalTransactionId: revenueCatData.originalTransactionId,
-            isPremium: revenueCatData.isPremium,
-            periodType: revenueCatData.periodType,
-            unsubscribeDetectedAt: revenueCatData.unsubscribeDetectedAt,
-            billingIssueDetectedAt: revenueCatData.billingIssueDetectedAt,
-            store: revenueCatData.store,
-            ownershipType: revenueCatData.ownershipType,
-            type,
-          }
-        );
-
-        return {
-          success: true,
-          data: result.finalData ? mapCreditsDocumentToEntity(result.finalData) : null,
-          error: null,
-        };
-      } catch (error: any) {
-        lastError = error;
-
-        const isTransientError =
-          error?.code === 'already-exists' ||
-          error?.code === 'DEADLINE_EXCEEDED' ||
-          error?.code === 'UNAVAILABLE' ||
-          error?.code === 'RESOURCE_EXHAUSTED' ||
-          error?.message?.includes('already-exists') ||
-          error?.message?.includes('timeout') ||
-          error?.message?.includes('unavailable');
-
-        if (isTransientError && attempt < maxRetries - 1) {
-          await new Promise(resolve => setTimeout(resolve, 100 * (attempt + 1)));
-          continue;
-        }
-        break;
-      }
-    }
-
-    const errorMessage = lastError instanceof Error
-      ? lastError.message
-      : typeof lastError === 'string'
-        ? lastError
-        : 'Unknown error during credit initialization';
-
-    const errorCode = lastError?.code ?? 'UNKNOWN_ERROR';
-
-    return {
-      success: false,
-      data: null,
-      error: {
-        message: errorMessage,
-        code: errorCode,
-      },
-    };
+    return initializeCreditsWithRetry({
+      db,
+      ref: this.getRef(db, userId),
+      config: this.config,
+      userId,
+      purchaseId,
+      productId,
+      source,
+      revenueCatData,
+      type,
+    });
   }
 
-  /**
-   * Deducts credits using atomic transaction logic.
-   */
   async deductCredit(userId: string, cost: number): Promise<DeductCreditsResult> {
     const db = requireFirestore();
     return deductCreditsOperation(db, this.getRef(db, userId), cost, userId);
   }
 
   async hasCredits(userId: string, cost: number): Promise<boolean> {
-    const result = await this.getCredits(userId);
-    if (!result.success || !result.data) return false;
-    return result.data.credits >= cost;
+    const db = requireFirestore();
+    return checkHasCredits(this.getRef(db, userId), cost);
   }
 
   async syncExpiredStatus(userId: string): Promise<void> {
     const db = requireFirestore();
-    const ref = this.getRef(db, userId);
-    await setDoc(ref, {
-      isPremium: false,
-      status: SUBSCRIPTION_STATUS.EXPIRED,
-      willRenew: false,
-      expirationDate: serverTimestamp(),
-    }, { merge: true });
+    await syncExpiredStatus(this.getRef(db, userId));
   }
 }
 

package/src/domains/credits/infrastructure/operations/CreditsFetcher.ts

@@ -0,0 +1,23 @@
+import { getDoc } from "firebase/firestore";
+import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
+import type { CreditsResult } from "../../core/Credits";
+import type { UserCreditsDocumentRead } from "../../core/UserCreditsDocument";
+import { mapCreditsDocumentToEntity } from "../../core/CreditsMapper";
+import { requireFirestore } from "../../../../shared/infrastructure/firestore";
+
+export async function fetchCredits(ref: DocumentReference): Promise<CreditsResult> {
+  const snap = await getDoc(ref);
+
+  if (!snap.exists()) {
+    return { success: true, data: null, error: null };
+  }
+
+  const entity = mapCreditsDocumentToEntity(snap.data() as UserCreditsDocumentRead);
+  return { success: true, data: entity, error: null };
+}
+
+export async function checkHasCredits(ref: DocumentReference, cost: number): Promise<boolean> {
+  const result = await fetchCredits(ref);
+  if (!result.success || !result.data) return false;
+  return result.data.credits >= cost;
+}

package/src/domains/credits/infrastructure/operations/CreditsInitializer.ts

@@ -0,0 +1,98 @@
+import type { Firestore, DocumentReference } from "@umituz/react-native-firebase";
+import type { CreditsConfig, CreditsResult } from "../../core/Credits";
+import type { UserCreditsDocumentRead, PurchaseSource } from "../../core/UserCreditsDocument";
+import { initializeCreditsTransaction } from "../../application/CreditsInitializer";
+import { mapCreditsDocumentToEntity } from "../../core/CreditsMapper";
+import type { RevenueCatData } from "../../../revenuecat/core/types";
+import { calculateCreditLimit } from "../../application/CreditLimitCalculator";
+import { PURCHASE_TYPE, type PurchaseType } from "../../../subscription/core/SubscriptionConstants";
+
+interface InitializeCreditsParams {
+  db: Firestore;
+  ref: DocumentReference;
+  config: CreditsConfig;
+  userId: string;
+  purchaseId: string;
+  productId: string;
+  source: PurchaseSource;
+  revenueCatData: RevenueCatData;
+  type?: PurchaseType;
+}
+
+function isTransientError(error: any): boolean {
+  return (
+    error?.code === 'already-exists' ||
+    error?.code === 'DEADLINE_EXCEEDED' ||
+    error?.code === 'UNAVAILABLE' ||
+    error?.code === 'RESOURCE_EXHAUSTED' ||
+    error?.message?.includes('already-exists') ||
+    error?.message?.includes('timeout') ||
+    error?.message?.includes('unavailable')
+  );
+}
+
+export async function initializeCreditsWithRetry(params: InitializeCreditsParams): Promise<CreditsResult> {
+  const { db, ref, config, purchaseId, productId, source, revenueCatData, type = PURCHASE_TYPE.INITIAL } = params;
+
+  const creditLimit = calculateCreditLimit(productId, config);
+  const cfg = { ...config, creditLimit };
+
+  const maxRetries = 3;
+  let lastError: any;
+
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const result = await initializeCreditsTransaction(
+        db,
+        ref,
+        cfg,
+        purchaseId,
+        {
+          productId,
+          source,
+          expirationDate: revenueCatData.expirationDate,
+          willRenew: revenueCatData.willRenew,
+          originalTransactionId: revenueCatData.originalTransactionId,
+          isPremium: revenueCatData.isPremium,
+          periodType: revenueCatData.periodType,
+          unsubscribeDetectedAt: revenueCatData.unsubscribeDetectedAt,
+          billingIssueDetectedAt: revenueCatData.billingIssueDetectedAt,
+          store: revenueCatData.store,
+          ownershipType: revenueCatData.ownershipType,
+          type,
+        }
+      );
+
+      return {
+        success: true,
+        data: result.finalData ? mapCreditsDocumentToEntity(result.finalData) : null,
+        error: null,
+      };
+    } catch (error: any) {
+      lastError = error;
+
+      if (isTransientError(error) && attempt < maxRetries - 1) {
+        await new Promise(resolve => setTimeout(resolve, 100 * (attempt + 1)));
+        continue;
+      }
+      break;
+    }
+  }
+
+  const errorMessage = lastError instanceof Error
+    ? lastError.message
+    : typeof lastError === 'string'
+      ? lastError
+      : 'Unknown error during credit initialization';
+
+  const errorCode = lastError?.code ?? 'UNKNOWN_ERROR';
+
+  return {
+    success: false,
+    data: null,
+    error: {
+      message: errorMessage,
+      code: errorCode,
+    },
+  };
+}

package/src/domains/credits/infrastructure/operations/CreditsWriter.ts

@@ -0,0 +1,13 @@
+import { setDoc } from "firebase/firestore";
+import type { DocumentReference } from "@umituz/react-native-firebase";
+import { serverTimestamp } from "@umituz/react-native-firebase";
+import { SUBSCRIPTION_STATUS } from "../../../subscription/core/SubscriptionConstants";
+
+export async function syncExpiredStatus(ref: DocumentReference): Promise<void> {
+  await setDoc(ref, {
+    isPremium: false,
+    status: SUBSCRIPTION_STATUS.EXPIRED,
+    willRenew: false,
+    expirationDate: serverTimestamp(),
+  }, { merge: true });
+}

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/RenewalDetector";
+
+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/RenewalDetector";
+
+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,105 @@
+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,
+  isAlreadyPurchasedError,
+  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()));
+}