@umituz/react-native-subscription 2.33.8 → 2.34.0

package/package.json

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

@@ -6,6 +6,8 @@ import { emitCreditsUpdated } from "./syncEventEmitter";
 import { generateInitSyncId, generateStatusSyncId } from "./syncIdGenerators";
 import { NO_SUBSCRIPTION_PRODUCT_ID, DEFAULT_FREE_USER_DATA } from "./syncConstants";
 
+declare const __DEV__: boolean;
+
 export const handleExpiredSubscription = async (userId: string): Promise<void> => {
   await getCreditsRepository().syncExpiredStatus(userId);
   emitCreditsUpdated(userId);
@@ -32,6 +34,17 @@ export const handlePremiumStatusSync = async (
   willRenew: boolean,
   periodType: PeriodType | null
 ): Promise<void> => {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[StatusChangeHandlers] handlePremiumStatusSync called:", {
+      userId,
+      isPremium,
+      productId,
+      expiresAt,
+      willRenew,
+      periodType,
+    });
+  }
+
   const revenueCatData: RevenueCatData = {
     expirationDate: expiresAt,
     willRenew,
@@ -45,6 +58,17 @@ export const handlePremiumStatusSync = async (
   };
 
   const statusSyncId = generateStatusSyncId(userId, isPremium);
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[StatusChangeHandlers] Calling initializeCredits with:", {
+      userId,
+      statusSyncId,
+      productId,
+      source: PURCHASE_SOURCE.SETTINGS,
+      type: PURCHASE_TYPE.INITIAL,
+    });
+  }
+
   await getCreditsRepository().initializeCredits(
     userId,
     statusSyncId,
@@ -54,5 +78,13 @@ export const handlePremiumStatusSync = async (
     PURCHASE_TYPE.INITIAL
   );
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[StatusChangeHandlers] initializeCredits completed, emitting credits updated event");
+  }
+
   emitCreditsUpdated(userId);
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[StatusChangeHandlers] ✅ handlePremiumStatusSync completed successfully");
+  }
 };

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/services/CustomerInfoListenerManager.ts

@@ -3,12 +3,22 @@ import type { RevenueCatConfig } from "../../../revenuecat/core/types";
 import { ListenerState } from "./listeners/ListenerState";
 import { processCustomerInfo } from "./listeners/CustomerInfoHandler";
 
+declare const __DEV__: boolean;
+
 export class CustomerInfoListenerManager {
   private state = new ListenerState();
 
   setUserId(userId: string, config: RevenueCatConfig): void {
     const wasUserChange = this.state.hasUserChanged(userId);
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CustomerInfoListener] setUserId called:", {
+        userId,
+        wasUserChange,
+        hasListener: !!this.state.listener,
+      });
+    }
+
     if (wasUserChange) {
       this.removeListener();
       this.state.resetRenewalState();
@@ -22,6 +32,9 @@ export class CustomerInfoListenerManager {
   }
 
   clearUserId(): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CustomerInfoListener] clearUserId called");
+    }
     this.state.currentUserId = null;
     this.state.resetRenewalState();
   }
@@ -29,8 +42,25 @@ export class CustomerInfoListenerManager {
   setupListener(config: RevenueCatConfig): void {
     this.removeListener();
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CustomerInfoListener] setupListener: Registering listener");
+    }
+
     this.state.listener = async (customerInfo: CustomerInfo) => {
-      if (!this.state.currentUserId) return;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CustomerInfoListener] 🔔 LISTENER TRIGGERED!", {
+          userId: this.state.currentUserId,
+          activeEntitlements: Object.keys(customerInfo.entitlements.active),
+          entitlementsCount: Object.keys(customerInfo.entitlements.all).length,
+        });
+      }
+
+      if (!this.state.currentUserId) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[CustomerInfoListener] No userId - skipping");
+        }
+        return;
+      }
 
       this.state.renewalState = await processCustomerInfo(
         customerInfo,
@@ -38,9 +68,17 @@ export class CustomerInfoListenerManager {
         this.state.renewalState,
         config
       );
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CustomerInfoListener] processCustomerInfo completed");
+      }
     };
 
     Purchases.addCustomerInfoUpdateListener(this.state.listener);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CustomerInfoListener] Listener registered successfully");
+    }
   }
 
   removeListener(): void {

package/src/domains/subscription/infrastructure/services/listeners/CustomerInfoHandler.ts

@@ -3,6 +3,8 @@ import type { RevenueCatConfig } from "../../../../revenuecat/core/types";
 import { syncPremiumStatus } from "../../utils/PremiumStatusSyncer";
 import { detectRenewal, updateRenewalState, type RenewalState } from "../../utils/renewal";
 
+declare const __DEV__: boolean;
+
 async function handleRenewal(
   userId: string,
   productId: string,
@@ -67,13 +69,34 @@ export async function processCustomerInfo(
   renewalState: RenewalState,
   config: RevenueCatConfig
 ): Promise<RenewalState> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[CustomerInfoHandler] processCustomerInfo called:", {
+      userId,
+      renewalState,
+      entitlementId: config.entitlementIdentifier,
+      activeEntitlements: Object.keys(customerInfo.entitlements.active),
+    });
+  }
+
   const renewalResult = detectRenewal(
     renewalState,
     customerInfo,
     config.entitlementIdentifier
   );
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[CustomerInfoHandler] Renewal detection result:", {
+      isRenewal: renewalResult.isRenewal,
+      isPlanChange: renewalResult.isPlanChange,
+      productId: renewalResult.productId,
+      previousProductId: renewalResult.previousProductId,
+    });
+  }
+
   if (renewalResult.isRenewal) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CustomerInfoHandler] Handling renewal");
+    }
     await handleRenewal(
       userId,
       renewalResult.productId!,
@@ -84,6 +107,9 @@ export async function processCustomerInfo(
   }
 
   if (renewalResult.isPlanChange) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CustomerInfoHandler] Handling plan change");
+    }
     await handlePlanChange(
       userId,
       renewalResult.productId!,
@@ -95,6 +121,9 @@ export async function processCustomerInfo(
   }
 
   if (!renewalResult.isRenewal && !renewalResult.isPlanChange) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[CustomerInfoHandler] Handling premium status sync (new purchase or status update)");
+    }
     await handlePremiumStatusSync(config, userId, customerInfo);
   }
 

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

@@ -22,6 +22,8 @@ async function executeConsumablePurchase(
   };
 }
 
+declare const __DEV__: boolean;
+
 async function executeSubscriptionPurchase(
   config: RevenueCatConfig,
   userId: string,
@@ -32,13 +34,30 @@ async function executeSubscriptionPurchase(
   const isPremium = !!customerInfo.entitlements.active[entitlementIdentifier];
   const source = getSavedPurchase()?.source;
 
-  if (isPremium) {
-    await syncPremiumStatus(config, userId, customerInfo);
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[PurchaseExecutor] executeSubscriptionPurchase:", {
+      userId,
+      productId,
+      isPremium,
+      entitlementIdentifier,
+      activeEntitlements: Object.keys(customerInfo.entitlements.active),
+      source,
+    });
+  }
+
+  await syncPremiumStatus(config, userId, customerInfo);
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[PurchaseExecutor] syncPremiumStatus completed");
   }
 
   await notifyPurchaseCompleted(config, userId, productId, customerInfo, source);
   clearSavedPurchase();
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[PurchaseExecutor] Purchase flow completed successfully");
+  }
+
   return {
     success: true,
     isPremium,

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

@@ -8,12 +8,26 @@ import type { RevenueCatConfig } from "../../../revenuecat/core/types";
 import type { PurchaseSource } from "../../../subscription/core/SubscriptionConstants";
 import { getPremiumEntitlement } from "../../../revenuecat/core/types";
 
+declare const __DEV__: boolean;
+
 export async function syncPremiumStatus(
     config: RevenueCatConfig,
     userId: string,
     customerInfo: CustomerInfo
 ): Promise<void> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[PremiumStatusSyncer] syncPremiumStatus called:", {
+            userId,
+            hasCallback: !!config.onPremiumStatusChanged,
+            entitlementId: config.entitlementIdentifier,
+            activeEntitlements: Object.keys(customerInfo.entitlements.active),
+        });
+    }
+
     if (!config.onPremiumStatusChanged) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[PremiumStatusSyncer] No onPremiumStatusChanged callback - skipping");
+        }
         return;
     }
 
@@ -22,8 +36,21 @@ export async function syncPremiumStatus(
         config.entitlementIdentifier
     );
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[PremiumStatusSyncer] Premium entitlement:", {
+            found: !!premiumEntitlement,
+            productId: premiumEntitlement?.productIdentifier,
+            expirationDate: premiumEntitlement?.expirationDate,
+            willRenew: premiumEntitlement?.willRenew,
+            periodType: premiumEntitlement?.periodType,
+        });
+    }
+
     try {
         if (premiumEntitlement) {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.log("[PremiumStatusSyncer] Calling onPremiumStatusChanged with premium=true");
+            }
             await config.onPremiumStatusChanged(
                 userId,
                 true,
@@ -33,8 +60,14 @@ export async function syncPremiumStatus(
                 premiumEntitlement.periodType as "NORMAL" | "INTRO" | "TRIAL" | undefined
             );
         } else {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.log("[PremiumStatusSyncer] Calling onPremiumStatusChanged with premium=false");
+            }
             await config.onPremiumStatusChanged(userId, false, undefined, undefined, undefined, undefined);
         }
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[PremiumStatusSyncer] onPremiumStatusChanged completed successfully");
+        }
     } catch (error) {
         console.error('[PremiumStatusSyncer] Premium status change callback failed', {
             userId,

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