@umituz/react-native-subscription 2.33.9 → 2.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.33.9",
+  "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

@@ -3,6 +3,8 @@ import type { InitializeResult } from "../../../../shared/application/ports/IRev
 import type { InitializerDeps } from "./RevenueCatInitializer.types";
 import { FAILED_INITIALIZATION_RESULT } from "./initializerConstants";
 
+declare const __DEV__: boolean;
+
 function buildSuccessResult(deps: InitializerDeps, customerInfo: CustomerInfo, offerings: any): InitializeResult {
   const isPremium = !!customerInfo.entitlements.active[deps.config.entitlementIdentifier];
   return { success: true, offering: offerings.current, isPremium };
@@ -13,7 +15,7 @@ function normalizeUserId(userId: string): string | null {
 }
 
 function isAnonymousId(userId: string): boolean {
-  return userId.startsWith('$RCAnonymous');
+  return userId.startsWith('$RCAnonymous') || userId.startsWith('device_');
 }
 
 export async function handleUserSwitch(
@@ -22,30 +24,64 @@ export async function handleUserSwitch(
 ): Promise<InitializeResult> {
   try {
     const currentAppUserId = await Purchases.getAppUserID();
-    let customerInfo;
-
     const normalizedUserId = normalizeUserId(userId);
     const normalizedCurrentUserId = isAnonymousId(currentAppUserId) ? null : currentAppUserId;
 
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchHandler] handleUserSwitch:', {
+        providedUserId: userId,
+        normalizedUserId: normalizedUserId || '(null - anonymous)',
+        currentAppUserId,
+        normalizedCurrentUserId: normalizedCurrentUserId || '(null - anonymous)',
+        needsSwitch: normalizedCurrentUserId !== normalizedUserId,
+      });
+    }
+
+    let customerInfo;
+
     if (normalizedCurrentUserId !== normalizedUserId) {
       if (normalizedUserId) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log('[UserSwitchHandler] Calling Purchases.logIn() to switch from anonymous to:', normalizedUserId);
+        }
         const result = await Purchases.logIn(normalizedUserId);
         customerInfo = result.customerInfo;
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log('[UserSwitchHandler] ✅ Purchases.logIn() successful, created:', result.created);
+        }
       } else {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          console.log('[UserSwitchHandler] User is anonymous, fetching customer info');
+        }
         customerInfo = await Purchases.getCustomerInfo();
       }
     } else {
+      if (typeof __DEV__ !== 'undefined' && __DEV__) {
+        console.log('[UserSwitchHandler] No user switch needed, fetching current customer info');
+      }
       customerInfo = await Purchases.getCustomerInfo();
     }
 
     deps.setInitialized(true);
     deps.setCurrentUserId(normalizedUserId);
     const offerings = await Purchases.getOfferings();
+
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchHandler] ✅ User switch completed successfully');
+    }
+
     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;
@@ -59,15 +95,38 @@ export async function handleInitialConfiguration(
 ): Promise<InitializeResult> {
   try {
     const normalizedUserId = normalizeUserId(userId);
+
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchHandler] handleInitialConfiguration:', {
+        providedUserId: userId,
+        normalizedUserId: normalizedUserId || '(null - anonymous)',
+        apiKeyPrefix: apiKey.substring(0, 5) + '...',
+        isTestKey: apiKey.startsWith('test_'),
+      });
+    }
+
     await Purchases.configure({ apiKey, appUserID: normalizedUserId });
     deps.setInitialized(true);
     deps.setCurrentUserId(normalizedUserId);
 
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[UserSwitchHandler] ✅ Purchases.configure() successful');
+    }
+
     const [customerInfo, offerings] = await Promise.all([
       Purchases.getCustomerInfo(),
       Purchases.getOfferings(),
     ]);
 
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      const currentUserId = await Purchases.getAppUserID();
+      console.log('[UserSwitchHandler] ✅ Initial configuration completed:', {
+        revenueCatUserId: currentUserId,
+        activeEntitlements: Object.keys(customerInfo.entitlements.active),
+        offeringsCount: offerings.all ? Object.keys(offerings.all).length : 0,
+      });
+    }
+
     return buildSuccessResult(deps, customerInfo, offerings);
   } catch (error) {
     console.error('[UserSwitchHandler] SDK configuration failed', {

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

@@ -1,18 +1,38 @@
 import type { FirebaseAuthLike } from "./SubscriptionInitializerTypes";
 
+declare const __DEV__: boolean;
+
 /**
  * Gets the current user ID from Firebase auth.
- * Returns undefined for anonymous users to prevent RevenueCat from using anonymous Firebase UIDs.
+ * Returns undefined for anonymous users to let RevenueCat generate its own anonymous ID.
  */
 export const getCurrentUserId = (getAuth: () => FirebaseAuthLike | null): string | undefined => {
   const auth = getAuth();
-  if (!auth) return undefined;
+  if (!auth) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionAuthListener] No auth available');
+    }
+    return undefined;
+  }
 
   const user = auth.currentUser;
-  if (!user) return undefined;
+  if (!user) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionAuthListener] No current user');
+    }
+    return undefined;
+  }
+
+  if (user.isAnonymous) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionAuthListener] Anonymous user - returning undefined (RevenueCat will use its own ID)');
+    }
+    return undefined;
+  }
 
-  // Don't return userId for anonymous users - let RevenueCat use its own anonymous ID
-  if (user.isAnonymous) return undefined;
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.log('[SubscriptionAuthListener] Authenticated user:', user.uid);
+  }
 
   return user.uid;
 };
@@ -20,18 +40,35 @@ export const getCurrentUserId = (getAuth: () => FirebaseAuthLike | null): string
 /**
  * Sets up auth state listener that will re-initialize subscription
  * when user auth state changes (login/logout).
- * Returns undefined for anonymous users to prevent RevenueCat from using anonymous Firebase UIDs.
+ * Returns undefined for anonymous users to let RevenueCat generate its own anonymous ID.
  */
 export const setupAuthStateListener = (
   getAuth: () => FirebaseAuthLike | null,
   onUserChange: (userId: string | undefined) => void
 ): (() => void) | null => {
   const auth = getAuth();
-  if (!auth) return null;
+  if (!auth) {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionAuthListener] Cannot setup listener - no auth available');
+    }
+    return null;
+  }
+
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.log('[SubscriptionAuthListener] Setting up auth state listener');
+  }
 
   return auth.onAuthStateChanged((user) => {
-    // Don't pass userId for anonymous users - let RevenueCat use its own anonymous ID
     const userId = (user && !user.isAnonymous) ? user.uid : undefined;
+
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[SubscriptionAuthListener] 🔔 Auth state changed:', {
+        hasUser: !!user,
+        isAnonymous: user?.isAnonymous,
+        userId: userId || '(undefined - anonymous)',
+      });
+    }
+
     onUserChange(userId);
   });
 };

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

@@ -2,8 +2,13 @@ import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionM
 import { getCurrentUserId, setupAuthStateListener } from "../SubscriptionAuthListener";
 import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 
-export async function startBackgroundInitialization(config: SubscriptionInitConfig): Promise<void> {
+declare const __DEV__: boolean;
+
+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)');
+    }
     await SubscriptionManager.initialize(userId);
   };
 
@@ -12,10 +17,32 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
     throw new Error("Firebase auth is not available");
   }
 
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.log('[BackgroundInitializer] Starting background initialization');
+  }
+
   const initialUserId = getCurrentUserId(() => auth);
+
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    console.log('[BackgroundInitializer] Initial userId:', initialUserId || '(undefined - anonymous)');
+  }
+
   await initializeInBackground(initialUserId);
 
-  setupAuthStateListener(() => auth, (newUserId) => {
-    initializeInBackground(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)');
+    }
+    try {
+      await initializeInBackground(newUserId);
+    } catch (error) {
+      console.error('[BackgroundInitializer] Failed to reinitialize on auth change', { userId: newUserId, error });
+    }
   });
+
+  return () => {
+    if (unsubscribe) {
+      unsubscribe();
+    }
+  };
 }