@umituz/react-native-subscription 2.33.9 → 2.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.33.9",
+  "version": "2.34.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/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,25 +24,52 @@ 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) {
     console.error('[UserSwitchHandler] Failed during user switch or fetch', {
@@ -59,15 +88,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/initializer/BackgroundInitializer.ts

@@ -2,8 +2,13 @@ import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionM
 import { getCurrentUserId, setupAuthStateListener } from "../SubscriptionAuthListener";
 import type { SubscriptionInitConfig } from "../SubscriptionInitializerTypes";
 
+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,22 @@ 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) => {
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      console.log('[BackgroundInitializer] Auth state listener triggered, reinitializing with userId:', newUserId || '(undefined - anonymous)');
+    }
     initializeInBackground(newUserId);
   });
 }

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

@@ -5,7 +5,7 @@ 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;
 
   configureCreditsRepository({
     ...credits,
@@ -25,7 +25,6 @@ export function configureServices(config: SubscriptionInitConfig, apiKey: string
       onCreditsUpdated,
     },
     apiKey,
-    getAnonymousUserId: getAnonymousUserId!,
   });
 
   configureAuthProvider({

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

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