@umituz/react-native-subscription 2.34.0 → 2.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.34.0",
+  "version": "2.35.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/application/DeductCreditsCommand.ts

@@ -13,6 +13,17 @@ export async function deductCreditsOperation(
   cost: number,
   userId: string
 ): Promise<DeductCreditsResult> {
+  if (!userId || userId.trim().length === 0) {
+    return {
+      success: false,
+      remainingCredits: null,
+      error: {
+        message: 'Valid userId is required for credit deduction',
+        code: 'INVALID_USER'
+      }
+    };
+  }
+
   try {
     const remaining = await runTransaction(async (tx: Transaction) => {
       const docSnap = await tx.get(creditsRef);

package/src/domains/credits/application/creditOperationUtils.ts

@@ -90,5 +90,9 @@ export function shouldSkipStatusSyncWrite(
     existingData.status === newCreditsData.status &&
     existingData.credits === newCreditsData.credits &&
     existingData.creditLimit === newCreditsData.creditLimit &&
-    existingData.productId === newCreditsData.productId;
+    existingData.productId === newCreditsData.productId &&
+    existingData.willRenew === newCreditsData.willRenew &&
+    existingData.expirationDate === newCreditsData.expirationDate &&
+    existingData.canceledAt === newCreditsData.canceledAt &&
+    existingData.billingIssueDetectedAt === newCreditsData.billingIssueDetectedAt;
 }

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

@@ -72,7 +72,12 @@ export async function initializeCreditsWithRetry(params: InitializeCreditsParams
       lastError = error;
 
       if (isTransientError(error) && attempt < maxRetries - 1) {
-        await new Promise(resolve => setTimeout(resolve, 100 * (attempt + 1)));
+        const baseDelay = 100;
+        const maxDelay = 5000;
+        const exponentialDelay = baseDelay * Math.pow(2, attempt);
+        const jitter = Math.random() * baseDelay;
+        const delay = Math.min(exponentialDelay + jitter, maxDelay);
+        await new Promise(resolve => setTimeout(resolve, delay));
         continue;
       }
       break;

package/src/domains/credits/presentation/deduct-credit/useDeductCredit.ts

@@ -20,14 +20,21 @@ export const useDeductCredit = ({
     try {
       const res = await mutation.mutateAsync(cost);
       if (!res.success) {
-        if (res.error?.code === "CREDITS_EXHAUSTED") onCreditsExhausted?.();
+        if (res.error?.code === "CREDITS_EXHAUSTED") {
+          onCreditsExhausted?.();
+        }
         return false;
       }
       return true;
-    } catch {
-      return false;
+    } catch (error) {
+      console.error('[useDeductCredit] Unexpected error during credit deduction', {
+        cost,
+        userId,
+        error
+      });
+      throw error;
     }
-  }, [mutation, onCreditsExhausted]);
+  }, [mutation, onCreditsExhausted, userId]);
 
   const deductCredits = useCallback(async (cost: number): Promise<boolean> => {
     return await deductCredit(cost);

package/src/domains/credits/presentation/useCredits.ts

@@ -52,23 +52,18 @@ export const useCredits = (): UseCreditsResult => {
   });
 
   const queryClient = useQueryClient();
-  const queryClientRef = useRef(queryClient);
-
-  useEffect(() => {
-    queryClientRef.current = queryClient;
-  }, [queryClient]);
 
   useEffect(() => {
     if (!isAuthenticated(userId)) return undefined;
 
     const unsubscribe = subscriptionEventBus.on(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, (updatedUserId) => {
       if (updatedUserId === userId) {
-        queryClientRef.current.invalidateQueries({ queryKey: creditsQueryKeys.user(userId) });
+        queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(userId) });
       }
     });
 
     return unsubscribe;
-  }, [userId]);
+  }, [userId, queryClient]);
 
   const credits = data ?? null;
 

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -2,7 +2,7 @@
  * usePaywallActions Hook
  * Encapsulates purchase and restore flow for the paywall.
  */
-import { useState, useCallback } from "react";
+import { useState, useCallback, useRef, useEffect } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
 import { usePurchaseLoadingStore } from "../../subscription/presentation/stores";
 import type { PurchaseSource } from "../../subscription/core/SubscriptionConstants";
@@ -35,53 +35,87 @@ export function usePaywallActions({
 
   const isProcessing = isLocalProcessing || isGlobalPurchasing;
 
+  const onPurchaseRef = useRef(onPurchase);
+  const onRestoreRef = useRef(onRestore);
+  const onPurchaseSuccessRef = useRef(onPurchaseSuccess);
+  const onPurchaseErrorRef = useRef(onPurchaseError);
+  const onAuthRequiredRef = useRef(onAuthRequired);
+  const onCloseRef = useRef(onClose);
+
+  useEffect(() => {
+    onPurchaseRef.current = onPurchase;
+    onRestoreRef.current = onRestore;
+    onPurchaseSuccessRef.current = onPurchaseSuccess;
+    onPurchaseErrorRef.current = onPurchaseError;
+    onAuthRequiredRef.current = onAuthRequired;
+    onCloseRef.current = onClose;
+  });
+
   const handlePurchase = useCallback(async () => {
-    // If no plan selected, use the first available one as fallback or return
+    console.log('🔵 [usePaywallActions] handlePurchase called', {
+      selectedPlanId,
+      packagesCount: packages.length,
+      isProcessing,
+      hasOnPurchase: !!onPurchaseRef.current
+    });
+
     const planId = selectedPlanId || (packages.length > 0 ? packages[0]?.product.identifier : null);
-    
-    if (!planId || !onPurchase || isProcessing) {
-        if (!planId && onAuthRequired) onAuthRequired();
+
+    if (!planId || !onPurchaseRef.current || isProcessing) {
+        console.log('⚠️ [usePaywallActions] Purchase blocked', {
+          noPlanId: !planId,
+          noCallback: !onPurchaseRef.current,
+          isProcessing
+        });
+        if (!planId && onAuthRequiredRef.current) onAuthRequiredRef.current();
         return;
     }
 
+    console.log('🟢 [usePaywallActions] Starting purchase', { planId });
     setIsLocalProcessing(true);
-    // Map PurchaseSource to store's expected "manual" | "auto-execution"
     startPurchase(planId, "manual");
 
     try {
       const pkg = packages.find((p) => p.product.identifier === planId);
+      console.log('📦 [usePaywallActions] Package found:', !!pkg);
+
       if (pkg) {
-        const success = await onPurchase(pkg);
+        console.log('🚀 [usePaywallActions] Calling onPurchase callback');
+        const success = await onPurchaseRef.current(pkg);
+        console.log('✅ [usePaywallActions] onPurchase completed', { success });
+
         if (success !== false) {
-          onPurchaseSuccess?.();
-          onClose?.(); // Close on success if provided
+          onPurchaseSuccessRef.current?.();
+          onCloseRef.current?.();
         }
       }
     } catch (error) {
+      console.error('❌ [usePaywallActions] Purchase error:', error);
       const err = error instanceof Error ? error : new Error(String(error));
-      onPurchaseError?.(err);
+      onPurchaseErrorRef.current?.(err);
     } finally {
+      console.log('🏁 [usePaywallActions] Purchase flow finished');
       setIsLocalProcessing(false);
       endPurchase(planId);
     }
-  }, [selectedPlanId, packages, onPurchase, isProcessing, startPurchase, endPurchase, onPurchaseSuccess, onPurchaseError, onAuthRequired, onClose]);
+  }, [selectedPlanId, packages, isProcessing, startPurchase, endPurchase]);
 
   const handleRestore = useCallback(async () => {
-    if (!onRestore || isProcessing) return;
+    if (!onRestoreRef.current || isProcessing) return;
 
     setIsLocalProcessing(true);
     try {
-      const success = await onRestore();
+      const success = await onRestoreRef.current();
       if (success !== false) {
-        onPurchaseSuccess?.();
+        onPurchaseSuccessRef.current?.();
       }
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
-      onPurchaseError?.(err);
+      onPurchaseErrorRef.current?.(err);
     } finally {
       setIsLocalProcessing(false);
     }
-  }, [onRestore, isProcessing, onPurchaseSuccess, onPurchaseError]);
+  }, [isProcessing]);
 
   const resetState = useCallback(() => {
     setSelectedPlanId(null);

package/src/domains/revenuecat/infrastructure/services/ConfigurationStateManager.ts

@@ -22,21 +22,33 @@ export class ConfigurationStateManager {
       throw new Error('Configuration already in progress');
     }
 
+    let capturedResolve: ((value: InitializeResult) => void) | null = null;
+
     this._configurationPromise = new Promise((resolve) => {
+      capturedResolve = resolve;
       this._resolveConfiguration = resolve;
     });
 
     return (value: InitializeResult) => {
-      if (this._resolveConfiguration) {
-        this._resolveConfiguration(value);
+      if (capturedResolve) {
+        capturedResolve(value);
+        capturedResolve = null;
       }
     };
   }
 
   completeConfiguration(success: boolean): void {
     this._isPurchasesConfigured = success;
-    this._configurationPromise = null;
-    this._resolveConfiguration = null;
+
+    if (success) {
+      this._configurationPromise = null;
+      this._resolveConfiguration = null;
+    } else {
+      setTimeout(() => {
+        this._configurationPromise = null;
+        this._resolveConfiguration = null;
+      }, 1000);
+    }
   }
 
   reset(): void {

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

@@ -7,10 +7,13 @@ import { handleUserSwitch, handleInitialConfiguration, fetchCurrentUserData } fr
 
 export type { InitializerDeps } from "./RevenueCatInitializer.types";
 
+const MAX_CONFIG_START_RETRIES = 3;
+
 export async function initializeSDK(
   deps: InitializerDeps,
   userId: string,
-  apiKey?: string
+  apiKey?: string,
+  configStartRetryCount: number = 0
 ): Promise<InitializeResult> {
   if (deps.isInitialized() && deps.getCurrentUserId() === userId) {
     return fetchCurrentUserData(deps);
@@ -36,7 +39,7 @@ export async function initializeSDK(
       return FAILED_INITIALIZATION_RESULT;
     }
 
-    return initializeSDK(deps, userId, apiKey);
+    return initializeSDK(deps, userId, apiKey, configStartRetryCount);
   }
 
   const key = apiKey || resolveApiKey(deps.config);
@@ -48,12 +51,22 @@ export async function initializeSDK(
   try {
     resolveConfig = configState.startConfiguration();
   } catch (error) {
-    console.error('[RevenueCatInitializer] Failed to start configuration', {
+    if (configStartRetryCount >= MAX_CONFIG_START_RETRIES) {
+      console.error('[RevenueCatInitializer] Max configuration start retries reached', {
+        userId,
+        retryCount: configStartRetryCount,
+        error
+      });
+      return FAILED_INITIALIZATION_RESULT;
+    }
+
+    console.error('[RevenueCatInitializer] Failed to start configuration, retrying', {
       userId,
+      retryCount: configStartRetryCount,
       error
     });
     await new Promise(resolve => setTimeout(resolve, CONFIGURATION_RETRY_DELAY_MS));
-    return initializeSDK(deps, userId, apiKey);
+    return initializeSDK(deps, userId, apiKey, configStartRetryCount + 1);
   }
 
   const result = await handleInitialConfiguration(deps, userId, key);

package/src/domains/revenuecat/infrastructure/services/userSwitchHandler.ts

@@ -72,9 +72,16 @@ export async function handleUserSwitch(
 
     return buildSuccessResult(deps, customerInfo, offerings);
   } catch (error) {
+    let currentAppUserId = 'unknown';
+    try {
+      currentAppUserId = await Purchases.getAppUserID();
+    } catch {
+      // Ignore error in error handler
+    }
+
     console.error('[UserSwitchHandler] Failed during user switch or fetch', {
       userId,
-      currentAppUserId: await Purchases.getAppUserID().catch(() => 'unknown'),
+      currentAppUserId,
       error
     });
     return FAILED_INITIALIZATION_RESULT;

package/src/domains/subscription/application/SubscriptionSyncService.ts

@@ -14,8 +14,13 @@ export class SubscriptionSyncService {
     try {
       await this.processor.processPurchase(userId, productId, customerInfo, source);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, { userId, productId });
-    } catch (_err) {
-      // Swallow error - event bus consumers handle failures
+    } catch (error) {
+      console.error('[SubscriptionSyncService] Purchase processing failed', {
+        userId,
+        productId,
+        source,
+        error
+      });
     }
   }
 
@@ -23,8 +28,13 @@ export class SubscriptionSyncService {
     try {
       await this.processor.processRenewal(userId, productId, newExpirationDate, customerInfo);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, { userId, productId });
-    } catch (_err) {
-      // Swallow error - event bus consumers handle failures
+    } catch (error) {
+      console.error('[SubscriptionSyncService] Renewal processing failed', {
+        userId,
+        productId,
+        newExpirationDate,
+        error
+      });
     }
   }
 
@@ -39,8 +49,16 @@ export class SubscriptionSyncService {
     try {
       await this.processor.processStatusChange(userId, isPremium, productId, expiresAt, willRenew, periodType);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, { userId, isPremium });
-    } catch (_err) {
-      // Swallow error - event bus consumers handle failures
+    } catch (error) {
+      console.error('[SubscriptionSyncService] Status change processing failed', {
+        userId,
+        isPremium,
+        productId,
+        expiresAt,
+        willRenew,
+        periodType,
+        error
+      });
     }
   }
 }

package/src/domains/subscription/application/SubscriptionSyncUtils.ts

@@ -10,18 +10,41 @@ function validatePeriodType(periodType: string | undefined): PeriodType | null {
 }
 
 export const extractRevenueCatData = (customerInfo: CustomerInfo, entitlementId: string): RevenueCatData => {
+  if (!customerInfo) {
+    throw new Error('[extractRevenueCatData] customerInfo is required');
+  }
+  if (!entitlementId) {
+    throw new Error('[extractRevenueCatData] entitlementId is required');
+  }
+
   const entitlement = customerInfo.entitlements.active[entitlementId]
     ?? customerInfo.entitlements.all[entitlementId];
 
+  const isPremium = !!customerInfo.entitlements.active[entitlementId];
+
+  if (!entitlement) {
+    return {
+      expirationDate: null,
+      willRenew: null,
+      originalTransactionId: null,
+      periodType: null,
+      isPremium: false,
+      unsubscribeDetectedAt: null,
+      billingIssueDetectedAt: null,
+      store: null,
+      ownershipType: null,
+    };
+  }
+
   return {
-    expirationDate: entitlement?.expirationDate ?? customerInfo.latestExpirationDate ?? null,
-    willRenew: entitlement?.willRenew ?? false,
-    originalTransactionId: customerInfo.originalAppUserId ?? null,
-    periodType: validatePeriodType(entitlement?.periodType),
-    isPremium: !!customerInfo.entitlements.active[entitlementId],
-    unsubscribeDetectedAt: entitlement?.unsubscribeDetectedAt ?? null,
-    billingIssueDetectedAt: entitlement?.billingIssueDetectedAt ?? null,
-    store: entitlement?.store ?? null,
-    ownershipType: entitlement?.ownershipType ?? null,
+    expirationDate: entitlement.expirationDate ?? null,
+    willRenew: entitlement.willRenew ?? null,
+    originalTransactionId: entitlement.originalPurchaseDate ?? null,
+    periodType: validatePeriodType(entitlement.periodType),
+    isPremium,
+    unsubscribeDetectedAt: entitlement.unsubscribeDetectedAt ?? null,
+    billingIssueDetectedAt: entitlement.billingIssueDetectedAt ?? null,
+    store: entitlement.store ?? null,
+    ownershipType: entitlement.ownershipType ?? null,
   };
 };

package/src/domains/subscription/application/initializer/BackgroundInitializer.ts

@@ -4,7 +4,7 @@ import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 
 declare const __DEV__: boolean;
 
-export async function startBackgroundInitialization(config: SubscriptionInitConfig): Promise<void> {
+export async function startBackgroundInitialization(config: SubscriptionInitConfig): Promise<() => void> {
   const initializeInBackground = async (userId?: string): Promise<void> => {
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
       console.log('[BackgroundInitializer] initializeInBackground called with userId:', userId || '(undefined - anonymous)');
@@ -29,10 +29,20 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
 
   await initializeInBackground(initialUserId);
 
-  setupAuthStateListener(() => auth, (newUserId) => {
+  const unsubscribe = setupAuthStateListener(() => auth, async (newUserId) => {
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
       console.log('[BackgroundInitializer] Auth state listener triggered, reinitializing with userId:', newUserId || '(undefined - anonymous)');
     }
-    initializeInBackground(newUserId);
+    try {
+      await initializeInBackground(newUserId);
+    } catch (error) {
+      console.error('[BackgroundInitializer] Failed to reinitialize on auth change', { userId: newUserId, error });
+    }
   });
+
+  return () => {
+    if (unsubscribe) {
+      unsubscribe();
+    }
+  };
 }

package/src/domains/subscription/application/initializer/ServiceConfigurator.ts

@@ -7,9 +7,13 @@ import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 export function configureServices(config: SubscriptionInitConfig, apiKey: string): SubscriptionSyncService {
   const { entitlementId, credits, creditPackages, getFirebaseAuth, showAuthModal, onCreditsUpdated } = config;
 
+  if (!creditPackages) {
+    throw new Error('[ServiceConfigurator] creditPackages configuration is required');
+  }
+
   configureCreditsRepository({
     ...credits,
-    creditPackageAmounts: creditPackages!.amounts
+    creditPackageAmounts: creditPackages.amounts
   });
 
   const syncService = new SubscriptionSyncService(entitlementId);
@@ -18,7 +22,7 @@ export function configureServices(config: SubscriptionInitConfig, apiKey: string
     config: {
       apiKey,
       entitlementIdentifier: entitlementId,
-      consumableProductIdentifiers: [creditPackages!.identifierPattern],
+      consumableProductIdentifiers: [creditPackages.identifierPattern],
       onPurchaseCompleted: (u: string, p: string, c: any, s: any) => syncService.handlePurchase(u, p, c, s),
       onRenewalDetected: (u: string, p: string, expires: string, c: any) => syncService.handleRenewal(u, p, expires, c),
       onPremiumStatusChanged: (u: string, isP: boolean, pId: any, exp: any, willR: any, pt: any) => syncService.handlePremiumStatusChanged(u, isP, pId, exp, willR, pt),

package/src/domains/subscription/application/initializer/SubscriptionInitializer.ts

@@ -3,9 +3,10 @@ import { getApiKey, validateConfig } from "./ConfigValidator";
 import { configureServices } from "./ServiceConfigurator";
 import { startBackgroundInitialization } from "./BackgroundInitializer";
 
-export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<void> => {
+export const initializeSubscription = async (config: SubscriptionInitConfig): Promise<() => void> => {
   const apiKey = getApiKey(config);
   validateConfig(config);
   configureServices(config, apiKey);
-  await startBackgroundInitialization(config);
+  const cleanup = await startBackgroundInitialization(config);
+  return cleanup;
 };

package/src/domains/subscription/infrastructure/handlers/PackageHandler.ts

@@ -24,7 +24,15 @@ export class PackageHandler {
   }
 
   async purchase(pkg: PurchasesPackage, userId: string): Promise<boolean> {
-    return executePurchase(this.service, pkg, userId);
+    console.log('🔵 [PackageHandler] purchase called', {
+      productId: pkg.product.identifier,
+      userId
+    });
+
+    const result = await executePurchase(this.service, pkg, userId);
+    console.log('✅ [PackageHandler] purchase completed', { result });
+
+    return result;
   }
 
   async restore(userId: string): Promise<RestoreResultInfo> {

package/src/domains/subscription/infrastructure/handlers/package-operations/PackagePurchaser.ts

@@ -6,10 +6,20 @@ export async function executePurchase(
   pkg: PurchasesPackage,
   userId: string
 ): Promise<boolean> {
+  console.log('🔵 [executePurchase] Starting', {
+    productId: pkg.product.identifier,
+    userId,
+    isInitialized: service.isInitialized()
+  });
+
   if (!service.isInitialized()) {
+    console.error('❌ [executePurchase] Service not initialized!');
     throw new Error("Service not initialized");
   }
 
+  console.log('🚀 [executePurchase] Calling service.purchasePackage');
   const result = await service.purchasePackage(pkg, userId);
+  console.log('✅ [executePurchase] Completed', { success: result.success });
+
   return result.success;
 }

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

@@ -55,10 +55,16 @@ export const useSubscriptionPackages = () => {
 
     if (prevUserId !== userId) {
       if (prevUserId) {
+        queryClient.cancelQueries({
+          queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, prevUserId],
+        });
         queryClient.removeQueries({
           queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, prevUserId],
         });
       } else {
+        queryClient.cancelQueries({
+          queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, "anonymous"],
+        });
         queryClient.removeQueries({
           queryKey: [...SUBSCRIPTION_QUERY_KEYS.packages, "anonymous"],
         });

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

@@ -87,9 +87,20 @@ class SubscriptionManagerImpl {
   }
 
   async purchasePackage(pkg: PurchasesPackage): Promise<boolean> {
+    console.log('🔵 [SubscriptionManager] purchasePackage called', {
+      productId: pkg.product.identifier,
+      isConfigured: !!this.managerConfig,
+      hasPackageHandler: !!this.packageHandler
+    });
+
     this.ensureConfigured();
     this.ensurePackageHandlerInitialized();
-    return purchasePackageOperation(pkg, this.managerConfig, this.state, this.packageHandler!);
+
+    console.log('🚀 [SubscriptionManager] Calling purchasePackageOperation');
+    const result = await purchasePackageOperation(pkg, this.managerConfig, this.state, this.packageHandler!);
+    console.log('✅ [SubscriptionManager] purchasePackageOperation completed', { result });
+
+    return result;
   }
 
   async restore(): Promise<RestoreResultInfo> {

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

@@ -22,9 +22,18 @@ export const purchasePackageOperation = async (
   state: SubscriptionInternalState,
   packageHandler: PackageHandler
 ): Promise<boolean> => {
+  console.log('🔵 [purchasePackageOperation] Starting', {
+    productId: pkg.product.identifier
+  });
+
   ensureConfigured(managerConfig);
   const userId = getCurrentUserIdOrThrow(state);
-  return packageHandler.purchase(pkg, userId);
+
+  console.log('🚀 [purchasePackageOperation] Calling packageHandler.purchase', { userId });
+  const result = await packageHandler.purchase(pkg, userId);
+  console.log('✅ [purchasePackageOperation] Completed', { result });
+
+  return result;
 };
 
 export const restoreOperation = async (

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

@@ -22,8 +22,8 @@ export function ensureConfigured(config: SubscriptionManagerConfig | null): void
  */
 export function getCurrentUserIdOrThrow(state: SubscriptionInternalState): string {
     const userId = state.initCache.getCurrentUserId();
-    if (!userId) {
-        throw new Error("No current user found");
+    if (userId === null || userId === undefined) {
+        throw new Error("SubscriptionManager not initialized - no current user ID available");
     }
     return userId;
 }

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

@@ -55,22 +55,30 @@ export class CustomerInfoListenerManager {
         });
       }
 
-      if (!this.state.currentUserId) {
+      const capturedUserId = this.state.currentUserId;
+      if (!capturedUserId) {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[CustomerInfoListener] No userId - skipping");
         }
         return;
       }
 
-      this.state.renewalState = await processCustomerInfo(
+      const newRenewalState = await processCustomerInfo(
         customerInfo,
-        this.state.currentUserId,
+        capturedUserId,
         this.state.renewalState,
         config
       );
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CustomerInfoListener] processCustomerInfo completed");
+      if (this.state.currentUserId === capturedUserId) {
+        this.state.renewalState = newRenewalState;
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[CustomerInfoListener] processCustomerInfo completed");
+        }
+      } else {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[CustomerInfoListener] User changed during processing - discarding result");
+        }
       }
     };
 

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

@@ -16,22 +16,38 @@ export async function handlePurchase(
   pkg: PurchasesPackage,
   userId: string
 ): Promise<PurchaseResult> {
+  console.log('🔵 [PurchaseHandler] handlePurchase called', {
+    productId: pkg.product.identifier,
+    userId,
+    isInitialized: deps.isInitialized()
+  });
+
   validatePurchaseReady(deps.isInitialized());
 
   const consumableIds = deps.config.consumableProductIdentifiers || [];
   const isConsumable = isConsumableProduct(pkg, consumableIds);
 
+  console.log('📦 [PurchaseHandler] Product type', { isConsumable });
+
   try {
-    return await executePurchase(deps.config, userId, pkg, isConsumable);
+    console.log('🚀 [PurchaseHandler] Calling executePurchase');
+    const result = await executePurchase(deps.config, userId, pkg, isConsumable);
+    console.log('✅ [PurchaseHandler] executePurchase completed', { success: result.success });
+    return result;
   } catch (error) {
+    console.error('❌ [PurchaseHandler] Purchase failed', { error });
+
     if (isUserCancelledError(error)) {
+      console.log('⚠️ [PurchaseHandler] User cancelled');
       return { success: false, isPremium: false, productId: pkg.product.identifier };
     }
 
     if (isAlreadyPurchasedError(error)) {
+      console.log('⚠️ [PurchaseHandler] Already purchased');
       return await handleAlreadyPurchasedError(deps, userId, pkg, error);
     }
 
+    console.error('❌ [PurchaseHandler] Unhandled error');
     return handlePurchaseError(error, pkg, userId);
   }
 }

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

@@ -60,7 +60,16 @@ export class RevenueCatService implements IRevenueCatService {
     }
 
     async purchasePackage(pkg: PurchasesPackage, userId: string): Promise<PurchaseResult> {
-        return handlePurchase(this.getSDKParams(), pkg, userId);
+        console.log('🔵 [RevenueCatService] purchasePackage called', {
+            productId: pkg.product.identifier,
+            userId,
+            isInitialized: this.isInitialized()
+        });
+
+        const result = await handlePurchase(this.getSDKParams(), pkg, userId);
+        console.log('✅ [RevenueCatService] purchasePackage completed', { success: result.success });
+
+        return result;
     }
 
     async restorePurchases(userId: string): Promise<RestoreResult> {

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

@@ -10,9 +10,14 @@ async function executeConsumablePurchase(
   productId: string,
   customerInfo: CustomerInfo
 ): Promise<PurchaseResult> {
-  const source = getSavedPurchase()?.source;
+  const savedPurchase = getSavedPurchase();
+  const source = savedPurchase?.source;
+  if (savedPurchase) {
+    clearSavedPurchase();
+  }
+
   await notifyPurchaseCompleted(config, userId, productId, customerInfo, source);
-  clearSavedPurchase();
+
   return {
     success: true,
     isPremium: false,
@@ -32,7 +37,11 @@ async function executeSubscriptionPurchase(
   entitlementIdentifier: string
 ): Promise<PurchaseResult> {
   const isPremium = !!customerInfo.entitlements.active[entitlementIdentifier];
-  const source = getSavedPurchase()?.source;
+  const savedPurchase = getSavedPurchase();
+  const source = savedPurchase?.source;
+  if (savedPurchase) {
+    clearSavedPurchase();
+  }
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
     console.log("[PurchaseExecutor] executeSubscriptionPurchase:", {
@@ -52,7 +61,6 @@ async function executeSubscriptionPurchase(
   }
 
   await notifyPurchaseCompleted(config, userId, productId, customerInfo, source);
-  clearSavedPurchase();
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
     console.log("[PurchaseExecutor] Purchase flow completed successfully");
@@ -72,13 +80,24 @@ export async function executePurchase(
   pkg: PurchasesPackage,
   isConsumable: boolean
 ): Promise<PurchaseResult> {
+  console.log('🔵 [PurchaseExecutor] executePurchase called', {
+    productId: pkg.product.identifier,
+    userId,
+    isConsumable
+  });
+
+  console.log('🚀 [PurchaseExecutor] Calling Purchases.purchasePackage (RevenueCat SDK)');
   const { customerInfo } = await Purchases.purchasePackage(pkg);
+  console.log('✅ [PurchaseExecutor] Purchases.purchasePackage completed');
+
   const productId = pkg.product.identifier;
 
   if (isConsumable) {
+    console.log('💰 [PurchaseExecutor] Processing as consumable purchase');
     return executeConsumablePurchase(config, userId, productId, customerInfo);
   }
 
+  console.log('📅 [PurchaseExecutor] Processing as subscription purchase');
   return executeSubscriptionPurchase(
     config,
     userId,

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

@@ -48,10 +48,8 @@ export class InitializationCache {
         this.initPromise = promise;
         this.promiseUserId = userId;
 
-        // Capture userId to prevent stale reference after catch clears promiseUserId
         const targetUserId = userId;
 
-        // Chain to mark completion and set currentUserId only on success
         promise
             .then((result) => {
                 if (result && this.promiseUserId === targetUserId) {
@@ -61,7 +59,6 @@ export class InitializationCache {
                 return result;
             })
             .catch((error) => {
-                // On failure, clear the promise so retry is possible
                 if (this.promiseUserId === targetUserId) {
                     this.initPromise = null;
                     this.promiseUserId = null;
@@ -69,12 +66,10 @@ export class InitializationCache {
                 }
                 this.promiseCompleted = true;
                 console.error('[InitializationCache] Initialization failed', { userId: targetUserId, error });
-                // Re-throw so callers awaiting the promise see the error
-                throw error;
+                return false;
             })
             .finally(() => {
-                // Always release the mutex
-                if (this.promiseUserId === targetUserId) {
+                if (this.initializationInProgress) {
                     this.initializationInProgress = false;
                 }
             });

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

@@ -14,7 +14,7 @@ export async function syncPremiumStatus(
     config: RevenueCatConfig,
     userId: string,
     customerInfo: CustomerInfo
-): Promise<void> {
+): Promise<{ success: boolean; error?: Error }> {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[PremiumStatusSyncer] syncPremiumStatus called:", {
             userId,
@@ -28,7 +28,7 @@ export async function syncPremiumStatus(
         if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[PremiumStatusSyncer] No onPremiumStatusChanged callback - skipping");
         }
-        return;
+        return { success: true };
     }
 
     const premiumEntitlement = getPremiumEntitlement(
@@ -68,6 +68,7 @@ export async function syncPremiumStatus(
         if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[PremiumStatusSyncer] onPremiumStatusChanged completed successfully");
         }
+        return { success: true };
     } catch (error) {
         console.error('[PremiumStatusSyncer] Premium status change callback failed', {
             userId,
@@ -75,7 +76,10 @@ export async function syncPremiumStatus(
             productId: premiumEntitlement?.productIdentifier,
             error
         });
-        // Silently fail callback notifications to prevent crashing the main flow
+        return {
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error))
+        };
     }
 }
 

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

@@ -42,8 +42,8 @@ export function detectRenewal(
     };
   }
 
-  const newExpiration = new Date(newExpirationDate);
-  const previousExpiration = new Date(state.previousExpirationDate);
+  const newExpiration = new Date(newExpirationDate).getTime();
+  const previousExpiration = new Date(state.previousExpirationDate).getTime();
   const productChanged = productId !== state.previousProductId;
   const expirationExtended = newExpiration > previousExpiration;
 

package/src/domains/subscription/presentation/stores/purchaseLoadingStore.ts

@@ -25,12 +25,12 @@ export interface PurchaseLoadingActions {
 
 export type PurchaseLoadingStore = PurchaseLoadingState & PurchaseLoadingActions;
 
-const initialState: PurchaseLoadingState = {
+const createInitialState = (): PurchaseLoadingState => ({
   activePurchases: new Map(),
-};
+});
 
 export const usePurchaseLoadingStore = create<PurchaseLoadingStore>((set, get) => ({
-  ...initialState,
+  ...createInitialState(),
 
   startPurchase: (productId, source) => {
     set((state) => {
@@ -55,7 +55,7 @@ export const usePurchaseLoadingStore = create<PurchaseLoadingStore>((set, get) =
   },
 
   reset: () => {
-    set(initialState);
+    set(createInitialState());
   },
 }));
 

package/src/init/createSubscriptionInitModule.ts

@@ -21,7 +21,7 @@ export function createSubscriptionInitModule(config: SubscriptionInitModuleConfi
           return true;
         }
 
-        await initializeSubscription({ apiKey, ...subscriptionConfig });
+        const cleanup = await initializeSubscription({ apiKey, ...subscriptionConfig });
         return true;
       } catch {
         return false;

package/src/shared/infrastructure/SubscriptionEventBus.ts

@@ -39,12 +39,17 @@ export class SubscriptionEventBus {
 
   emit<T>(event: string, data: T): void {
     if (!this.listeners[event]) return;
+
     this.listeners[event].forEach(callback => {
-      try {
-        callback(data);
-      } catch (error) {
-        console.error('[SubscriptionEventBus] Listener error for event:', event, { error });
-      }
+      Promise.resolve().then(() => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error('[SubscriptionEventBus] Listener error for event:', event, { error });
+        }
+      }).catch(error => {
+        console.error('[SubscriptionEventBus] Async listener error for event:', event, { error });
+      });
     });
   }
 

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

@@ -3,7 +3,7 @@
  * Shared hook for handling service calls with loading, error, and success states
  */
 
-import { useState, useCallback } from "react";
+import { useState, useCallback, useRef, useEffect } from "react";
 
 export interface ServiceCallState<T> {
   data: T | null;
@@ -36,21 +36,31 @@ export function useServiceCall<T>(
     error: null,
   });
 
+  const onSuccessRef = useRef(onSuccess);
+  const onErrorRef = useRef(onError);
+  const onCompleteRef = useRef(onComplete);
+
+  useEffect(() => {
+    onSuccessRef.current = onSuccess;
+    onErrorRef.current = onError;
+    onCompleteRef.current = onComplete;
+  });
+
   const execute = useCallback(async () => {
     setState({ data: null, isLoading: true, error: null });
 
     try {
       const data = await serviceFn();
       setState({ data, isLoading: false, error: null });
-      onSuccess?.(data);
+      onSuccessRef.current?.(data);
     } catch (error) {
       const errorObj = error instanceof Error ? error : new Error("Service call failed");
       setState({ data: null, isLoading: false, error: errorObj });
-      onError?.(errorObj);
+      onErrorRef.current?.(errorObj);
     } finally {
-      onComplete?.();
+      onCompleteRef.current?.();
     }
-  }, [serviceFn, onSuccess, onError, onComplete]);
+  }, [serviceFn]);
 
   const reset = useCallback(() => {
     setState({ data: null, isLoading: false, error: null });