@umituz/react-native-subscription 2.33.9 → 2.35.0

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

@@ -5,11 +5,15 @@ import { SubscriptionSyncService } from "../SubscriptionSyncService";
 import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 
 export function configureServices(config: SubscriptionInitConfig, apiKey: string): SubscriptionSyncService {
-  const { entitlementId, credits, creditPackages, getAnonymousUserId, getFirebaseAuth, showAuthModal, onCreditsUpdated } = config;
+  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,14 +22,13 @@ 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),
       onCreditsUpdated,
     },
     apiKey,
-    getAnonymousUserId: getAnonymousUserId!,
   });
 
   configureAuthProvider({

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/SubscriptionInternalState.ts

@@ -1,12 +1,9 @@
-import { UserIdProvider } from "../utils/UserIdProvider";
 import { InitializationCache } from "../utils/InitializationCache";
 
 export class SubscriptionInternalState {
-  public userIdProvider = new UserIdProvider();
   public initCache = new InitializationCache();
-  
+
   reset() {
-    this.userIdProvider.reset();
     this.initCache.reset();
   }
 }

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

@@ -17,7 +17,6 @@ class SubscriptionManagerImpl {
 
   configure(config: SubscriptionManagerConfig): void {
     this.managerConfig = config;
-    this.state.userIdProvider.configure(config.getAnonymousUserId);
   }
 
   private ensureConfigured(): void {
@@ -34,19 +33,22 @@ class SubscriptionManagerImpl {
   async initialize(userId?: string): Promise<boolean> {
     this.ensureConfigured();
 
-    let actualUserId: string | null = null;
+    const actualUserId: string = (userId && userId.length > 0) ? userId : '';
 
-    if (userId && userId.length > 0) {
-      actualUserId = userId;
-    } else {
-      const anonymousId = await this.managerConfig.getAnonymousUserId();
-      actualUserId = (anonymousId && anonymousId.length > 0) ? anonymousId : null;
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionManager] initialize called:', {
+        providedUserId: userId,
+        actualUserId: actualUserId || '(empty - RevenueCat will generate anonymous ID)',
+      });
     }
 
-    const cacheKey = actualUserId ?? '__anonymous__';
+    const cacheKey = actualUserId || '__anonymous__';
     const { shouldInit, existingPromise } = this.state.initCache.tryAcquireInitialization(cacheKey);
 
     if (!shouldInit && existingPromise) {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log('[SubscriptionManager] Using cached initialization for:', cacheKey);
+      }
       return existingPromise;
     }
 
@@ -55,11 +57,23 @@ class SubscriptionManagerImpl {
     return promise;
   }
 
-  private async performInitialization(userId: string | null): Promise<boolean> {
+  private async performInitialization(userId: string): Promise<boolean> {
     this.ensureConfigured();
-    const { service, success } = await performServiceInitialization(this.managerConfig.config, userId ?? '');
+
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionManager] performInitialization:', {
+        userId: userId || '(empty - anonymous)',
+      });
+    }
+
+    const { service, success } = await performServiceInitialization(this.managerConfig.config, userId);
     this.serviceInstance = service ?? null;
     this.ensurePackageHandlerInitialized();
+
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionManager] Initialization completed:', { success });
+    }
+
     return success;
   }
 
@@ -73,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/SubscriptionManager.types.ts

@@ -4,7 +4,6 @@ import type { PremiumStatus } from "../handlers/PurchaseStatusResolver";
 export interface SubscriptionManagerConfig {
   config: RevenueCatConfig;
   apiKey: string;
-  getAnonymousUserId: () => Promise<string>;
 }
 
 export type { PremiumStatus };

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 });

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

@@ -1,30 +0,0 @@
-/**
- * User ID Provider
- * Manages user ID retrieval (anonymous or authenticated)
- */
-
-export class UserIdProvider {
-    private cachedAnonUserId: string | null = null;
-    private getAnonymousUserIdFn: (() => Promise<string>) | null = null;
-
-    configure(getAnonymousUserId: () => Promise<string>): void {
-        this.getAnonymousUserIdFn = getAnonymousUserId;
-    }
-
-    async getOrCreateAnonymousUserId(): Promise<string> {
-        if (this.cachedAnonUserId) {
-            return this.cachedAnonUserId;
-        }
-
-        if (!this.getAnonymousUserIdFn) {
-            throw new Error("Anonymous user ID provider not configured");
-        }
-
-        this.cachedAnonUserId = await this.getAnonymousUserIdFn();
-        return this.cachedAnonUserId;
-    }
-
-    reset(): void {
-        this.cachedAnonUserId = null;
-    }
-}