@umituz/react-native-subscription 2.4.0 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "Complete subscription management with RevenueCat, paywall UI, and credits system for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -35,6 +35,7 @@
     "@umituz/react-native-firestore": "latest",
     "@umituz/react-native-legal": "latest",
     "@umituz/react-native-localization": "latest",
+    "@umituz/react-native-sentry": "latest",
     "expo-constants": ">=16.0.0",
     "firebase": ">=10.0.0",
     "react": ">=18.2.0",
@@ -47,6 +48,7 @@
     "@umituz/react-native-firestore": "latest",
     "@umituz/react-native-legal": "latest",
     "@umituz/react-native-localization": "latest",
+    "@umituz/react-native-sentry": "latest",
     "@tanstack/react-query": "^5.0.0",
     "expo-constants": "~16.0.0",
     "firebase": "^10.0.0",

package/src/index.ts

@@ -305,6 +305,12 @@ export {
   resetRevenueCatService,
 } from "./revenuecat/infrastructure/services/RevenueCatService";
 
+export {
+  SubscriptionManager,
+  type SubscriptionManagerConfig,
+  type PremiumStatus,
+} from "./revenuecat/infrastructure/managers/SubscriptionManager";
+
 // =============================================================================
 // REVENUECAT - Hooks
 // =============================================================================

package/src/revenuecat/infrastructure/handlers/PackageHandler.ts

@@ -0,0 +1,128 @@
+/**
+ * Package Handler
+ * Handles package operations (fetch, purchase, restore, premium status)
+ */
+
+import type { PurchasesPackage } from "react-native-purchases";
+import type { IRevenueCatService } from "../../application/ports/IRevenueCatService";
+import { getPremiumEntitlement } from "../../domain/types/RevenueCatTypes";
+import {
+  trackPackageError,
+  addPackageBreadcrumb,
+  trackPackageWarning,
+} from "@umituz/react-native-sentry";
+
+export interface PremiumStatus {
+  isPremium: boolean;
+  expirationDate: Date | null;
+}
+
+export class PackageHandler {
+  constructor(
+    private service: IRevenueCatService | null,
+    private entitlementId: string
+  ) {}
+
+  setService(service: IRevenueCatService | null): void {
+    this.service = service;
+  }
+
+  async fetchPackages(): Promise<PurchasesPackage[]> {
+    if (!this.service?.isInitialized()) {
+      trackPackageWarning("subscription", "Fetch packages called but not initialized", {});
+      return [];
+    }
+
+    try {
+      const offering = await this.service.fetchOfferings();
+
+      addPackageBreadcrumb("subscription", "Packages fetched", {
+        identifier: offering?.identifier,
+        count: offering?.availablePackages?.length ?? 0,
+      });
+
+      return offering?.availablePackages ?? [];
+    } catch (error) {
+      trackPackageError(error instanceof Error ? error : new Error(String(error)), {
+        packageName: "subscription",
+        operation: "fetch_packages",
+      });
+      return [];
+    }
+  }
+
+  async purchase(pkg: PurchasesPackage, userId: string): Promise<boolean> {
+    if (!this.service?.isInitialized()) {
+      trackPackageWarning("subscription", "Purchase attempted but not initialized", {
+        productId: pkg.product.identifier,
+      });
+      return false;
+    }
+
+    try {
+      const result = await this.service.purchasePackage(pkg, userId);
+      return result.success;
+    } catch (error) {
+      trackPackageError(error instanceof Error ? error : new Error(String(error)), {
+        packageName: "subscription",
+        operation: "purchase",
+        userId,
+        productId: pkg.product.identifier,
+      });
+      return false;
+    }
+  }
+
+  async restore(userId: string): Promise<boolean> {
+    if (!this.service?.isInitialized()) {
+      trackPackageWarning("subscription", "Restore attempted but not initialized", {});
+      return false;
+    }
+
+    try {
+      const result = await this.service.restorePurchases(userId);
+      return result.success;
+    } catch (error) {
+      trackPackageError(error instanceof Error ? error : new Error(String(error)), {
+        packageName: "subscription",
+        operation: "restore",
+        userId,
+      });
+      return false;
+    }
+  }
+
+  async checkPremiumStatus(userId: string): Promise<PremiumStatus> {
+    if (!this.service?.isInitialized()) {
+      return { isPremium: false, expirationDate: null };
+    }
+
+    try {
+      const restoreResult = await this.service.restorePurchases(userId);
+
+      if (restoreResult.customerInfo) {
+        const entitlement = getPremiumEntitlement(
+          restoreResult.customerInfo,
+          this.entitlementId
+        );
+        if (entitlement) {
+          return {
+            isPremium: true,
+            expirationDate: entitlement.expirationDate
+              ? new Date(entitlement.expirationDate)
+              : null,
+          };
+        }
+      }
+
+      return { isPremium: restoreResult.isPremium, expirationDate: null };
+    } catch (error) {
+      trackPackageError(error instanceof Error ? error : new Error(String(error)), {
+        packageName: "subscription",
+        operation: "check_premium_status",
+        userId,
+      });
+      return { isPremium: false, expirationDate: null };
+    }
+  }
+}

package/src/revenuecat/infrastructure/managers/SubscriptionManager.ts

@@ -0,0 +1,153 @@
+/**
+ * Subscription Manager
+ * Facade for subscription operations
+ * Coordinates UserIdProvider, InitializationCache, and PackageHandler
+ */
+
+import type { PurchasesPackage } from "react-native-purchases";
+import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
+import type { IRevenueCatService } from "../../application/ports/IRevenueCatService";
+import { initializeRevenueCatService, getRevenueCatService } from "../services/RevenueCatService";
+import { UserIdProvider } from "../utils/UserIdProvider";
+import { InitializationCache } from "../utils/InitializationCache";
+import { PackageHandler, type PremiumStatus } from "../handlers/PackageHandler";
+import {
+  trackPackageError,
+  addPackageBreadcrumb,
+  trackPackageWarning,
+} from "@umituz/react-native-sentry";
+
+export interface SubscriptionManagerConfig {
+  config: RevenueCatConfig;
+  apiKey: string;
+  getAnonymousUserId?: () => Promise<string>;
+}
+
+class SubscriptionManagerImpl {
+  private managerConfig: SubscriptionManagerConfig | null = null;
+  private serviceInstance: IRevenueCatService | null = null;
+  private userIdProvider = new UserIdProvider();
+  private initCache = new InitializationCache();
+  private packageHandler: PackageHandler | null = null;
+
+  configure(config: SubscriptionManagerConfig): void {
+    this.managerConfig = config;
+    this.packageHandler = new PackageHandler(null, config.config.entitlementIdentifier);
+
+    if (config.getAnonymousUserId) {
+      this.userIdProvider.configure(config.getAnonymousUserId);
+    }
+
+    addPackageBreadcrumb("subscription", "Manager configured", {
+      entitlementId: config.config.entitlementIdentifier,
+    });
+  }
+
+  private ensureConfigured(): void {
+    if (!this.managerConfig || !this.packageHandler) {
+      const error = new Error("SubscriptionManager not configured");
+      trackPackageError(error, {
+        packageName: "subscription",
+        operation: "ensure_configured",
+      });
+      throw error;
+    }
+  }
+
+  private async performInitialization(userId: string): Promise<boolean> {
+    this.ensureConfigured();
+
+    try {
+      await initializeRevenueCatService(this.managerConfig!.config);
+      this.serviceInstance = getRevenueCatService();
+
+      if (!this.serviceInstance) {
+        trackPackageWarning("subscription", "Service instance not created", { userId });
+        return false;
+      }
+
+      this.packageHandler!.setService(this.serviceInstance);
+
+      const result = await this.serviceInstance.initialize(userId, this.managerConfig!.apiKey);
+      return result.success;
+    } catch (error) {
+      trackPackageError(error instanceof Error ? error : new Error(String(error)), {
+        packageName: "subscription",
+        operation: "initialize",
+        userId,
+      });
+      throw error;
+    }
+  }
+
+  async initialize(userId?: string): Promise<boolean> {
+    this.ensureConfigured();
+
+    const effectiveUserId = userId || (await this.userIdProvider.getOrCreateAnonymousUserId());
+
+    if (!this.initCache.shouldReinitialize(effectiveUserId)) {
+      const existingPromise = this.initCache.getExistingPromise();
+      if (existingPromise) return existingPromise;
+    }
+
+    if (this.initCache.shouldReinitialize(effectiveUserId) && this.serviceInstance) {
+      await this.serviceInstance.reset();
+    }
+
+    const promise = this.performInitialization(effectiveUserId);
+    this.initCache.setPromise(promise, effectiveUserId);
+
+    return promise;
+  }
+
+  isInitialized(): boolean {
+    return this.serviceInstance?.isInitialized() ?? false;
+  }
+
+  isInitializedForUser(userId: string): boolean {
+    return this.serviceInstance?.isInitialized() === true &&
+           this.initCache.getCurrentUserId() === userId;
+  }
+
+  async getPackages(): Promise<PurchasesPackage[]> {
+    this.ensureConfigured();
+    if (!this.serviceInstance) {
+      this.serviceInstance = getRevenueCatService();
+      this.packageHandler!.setService(this.serviceInstance);
+    }
+    return this.packageHandler!.fetchPackages();
+  }
+
+  async purchasePackage(pkg: PurchasesPackage): Promise<boolean> {
+    this.ensureConfigured();
+    const userId = this.initCache.getCurrentUserId();
+    if (!userId) return false;
+    return this.packageHandler!.purchase(pkg, userId);
+  }
+
+  async restore(): Promise<boolean> {
+    this.ensureConfigured();
+    const userId = this.initCache.getCurrentUserId();
+    if (!userId) return false;
+    return this.packageHandler!.restore(userId);
+  }
+
+  async checkPremiumStatus(): Promise<PremiumStatus> {
+    this.ensureConfigured();
+    const userId = this.initCache.getCurrentUserId();
+    if (!userId) return { isPremium: false, expirationDate: null };
+    return this.packageHandler!.checkPremiumStatus(userId);
+  }
+
+  async reset(): Promise<void> {
+    if (this.serviceInstance) {
+      await this.serviceInstance.reset();
+    }
+    this.initCache.reset();
+    this.userIdProvider.reset();
+    this.serviceInstance = null;
+    addPackageBreadcrumb("subscription", "Manager reset completed", {});
+  }
+}
+
+export const SubscriptionManager = new SubscriptionManagerImpl();

package/src/revenuecat/infrastructure/services/PurchaseHandler.ts

@@ -18,6 +18,10 @@ import {
   syncPremiumStatus,
   notifyPurchaseCompleted,
 } from "../utils/PremiumStatusSyncer";
+import {
+  trackPackageError,
+  addPackageBreadcrumb,
+} from "@umituz/react-native-sentry";
 
 export interface PurchaseHandlerDeps {
   config: RevenueCatConfig;
@@ -42,12 +46,20 @@ export async function handlePurchase(
   pkg: PurchasesPackage,
   userId: string
 ): Promise<PurchaseResult> {
-  if (__DEV__) {
-    console.log("[RevenueCat] handlePurchase() called for:", pkg.product.identifier);
-  }
+  addPackageBreadcrumb("subscription", "Purchase started", {
+    productId: pkg.product.identifier,
+    userId,
+  });
 
   if (!deps.isInitialized()) {
-    throw new RevenueCatInitializationError();
+    const error = new RevenueCatInitializationError();
+    trackPackageError(error, {
+      packageName: "subscription",
+      operation: "purchase",
+      userId,
+      productId: pkg.product.identifier,
+    });
+    throw error;
   }
 
 
@@ -85,15 +97,35 @@ export async function handlePurchase(
       return { success: true, isPremium: true, customerInfo };
     }
 
-    throw new RevenueCatPurchaseError(
+    const entitlementError = new RevenueCatPurchaseError(
       "Purchase completed but premium entitlement not active",
       pkg.product.identifier
     );
+    trackPackageError(entitlementError, {
+      packageName: "subscription",
+      operation: "purchase",
+      userId,
+      productId: pkg.product.identifier,
+      reason: "entitlement_not_active",
+    });
+    throw entitlementError;
   } catch (error) {
     if (isUserCancelledError(error)) {
+      addPackageBreadcrumb("subscription", "Purchase cancelled by user", {
+        productId: pkg.product.identifier,
+        userId,
+      });
       return { success: false, isPremium: false };
     }
     const errorMessage = getErrorMessage(error, "Purchase failed");
-    throw new RevenueCatPurchaseError(errorMessage, pkg.product.identifier);
+    const purchaseError = new RevenueCatPurchaseError(errorMessage, pkg.product.identifier);
+    trackPackageError(purchaseError, {
+      packageName: "subscription",
+      operation: "purchase",
+      userId,
+      productId: pkg.product.identifier,
+      originalError: error instanceof Error ? error.message : String(error),
+    });
+    throw purchaseError;
   }
 }

package/src/revenuecat/infrastructure/services/RestoreHandler.ts

@@ -15,6 +15,10 @@ import {
   syncPremiumStatus,
   notifyRestoreCompleted,
 } from "../utils/PremiumStatusSyncer";
+import {
+  trackPackageError,
+  addPackageBreadcrumb,
+} from "@umituz/react-native-sentry";
 
 export interface RestoreHandlerDeps {
   config: RevenueCatConfig;
@@ -29,12 +33,18 @@ export async function handleRestore(
   deps: RestoreHandlerDeps,
   userId: string
 ): Promise<RestoreResult> {
+  addPackageBreadcrumb("subscription", "Restore started", { userId });
+
   if (!deps.isInitialized()) {
-    throw new RevenueCatInitializationError();
+    const error = new RevenueCatInitializationError();
+    trackPackageError(error, {
+      packageName: "subscription",
+      operation: "restore",
+      userId,
+    });
+    throw error;
   }
 
-
-
   try {
     const customerInfo = await Purchases.restorePurchases();
     const entitlementIdentifier = deps.config.entitlementIdentifier;
@@ -42,12 +52,28 @@ export async function handleRestore(
 
     if (isPremium) {
       await syncPremiumStatus(deps.config, userId, customerInfo);
+      addPackageBreadcrumb("subscription", "Restore successful - premium active", {
+        userId,
+        entitlementId: entitlementIdentifier,
+      });
+    } else {
+      addPackageBreadcrumb("subscription", "Restore completed - no premium found", {
+        userId,
+      });
     }
+
     await notifyRestoreCompleted(deps.config, userId, isPremium, customerInfo);
 
     return { success: isPremium, isPremium, customerInfo };
   } catch (error) {
     const errorMessage = getErrorMessage(error, "Restore failed");
-    throw new RevenueCatRestoreError(errorMessage);
+    const restoreError = new RevenueCatRestoreError(errorMessage);
+    trackPackageError(restoreError, {
+      packageName: "subscription",
+      operation: "restore",
+      userId,
+      originalError: error instanceof Error ? error.message : String(error),
+    });
+    throw restoreError;
   }
 }

package/src/revenuecat/infrastructure/services/RevenueCatService.ts

@@ -19,6 +19,11 @@ import { handlePurchase } from "./PurchaseHandler";
 import { handleRestore } from "./RestoreHandler";
 import { CustomerInfoListenerManager } from "./CustomerInfoListenerManager";
 import { ServiceStateManager } from "./ServiceStateManager";
+import {
+  trackPackageError,
+  addPackageBreadcrumb,
+  trackPackageWarning,
+} from "@umituz/react-native-sentry";
 
 export class RevenueCatService implements IRevenueCatService {
   private stateManager: ServiceStateManager;
@@ -50,31 +55,46 @@ export class RevenueCatService implements IRevenueCatService {
   async initialize(userId: string, apiKey?: string): Promise<InitializeResult> {
     // If already initialized for this user, return success immediately
     if (this.isInitialized() && this.getCurrentUserId() === userId) {
-      if (__DEV__) {
-        console.log("[RevenueCat] Already initialized for user:", userId);
-      }
-      return { success: true, offering: (await this.fetchOfferings()), hasPremium: false }; // fetchOfferings handles cache usually
+      addPackageBreadcrumb("subscription", "Already initialized", { userId });
+      return { success: true, offering: (await this.fetchOfferings()), hasPremium: false };
     }
 
-    const result = await initializeSDK(
-      {
-        config: this.stateManager.getConfig(),
-        isUsingTestStore: () => this.isUsingTestStore(),
-        isInitialized: () => this.isInitialized(),
-        getCurrentUserId: () => this.stateManager.getCurrentUserId(),
-        setInitialized: (value) => this.stateManager.setInitialized(value),
-        setCurrentUserId: (id) => this.stateManager.setCurrentUserId(id),
-      },
-      userId,
-      apiKey
-    );
+    addPackageBreadcrumb("subscription", "Initialization started", { userId });
 
-    if (result.success) {
-      this.listenerManager.setUserId(userId);
-      this.listenerManager.setupListener(this.stateManager.getConfig());
-    }
+    try {
+      const result = await initializeSDK(
+        {
+          config: this.stateManager.getConfig(),
+          isUsingTestStore: () => this.isUsingTestStore(),
+          isInitialized: () => this.isInitialized(),
+          getCurrentUserId: () => this.stateManager.getCurrentUserId(),
+          setInitialized: (value) => this.stateManager.setInitialized(value),
+          setCurrentUserId: (id) => this.stateManager.setCurrentUserId(id),
+        },
+        userId,
+        apiKey
+      );
+
+      if (result.success) {
+        this.listenerManager.setUserId(userId);
+        this.listenerManager.setupListener(this.stateManager.getConfig());
+        addPackageBreadcrumb("subscription", "Initialization successful", { userId });
+      } else {
+        trackPackageWarning("subscription", "Initialization failed", {
+          userId,
+          hasOffering: !!result.offering,
+        });
+      }
 
-    return result;
+      return result;
+    } catch (error) {
+      trackPackageError(error instanceof Error ? error : new Error(String(error)), {
+        packageName: "subscription",
+        operation: "initialize",
+        userId,
+      });
+      throw error;
+    }
   }
 
   async fetchOfferings(): Promise<PurchasesOffering | null> {
@@ -113,13 +133,20 @@ export class RevenueCatService implements IRevenueCatService {
   async reset(): Promise<void> {
     if (!this.isInitialized()) return;
 
+    addPackageBreadcrumb("subscription", "Reset started", {
+      userId: this.getCurrentUserId(),
+    });
+
     this.listenerManager.destroy();
 
     try {
       await Purchases.logOut();
       this.stateManager.setInitialized(false);
-    } catch {
-      // Reset errors are non-critical
+      addPackageBreadcrumb("subscription", "Reset successful", {});
+    } catch (error) {
+      trackPackageWarning("subscription", "Reset failed (non-critical)", {
+        error: error instanceof Error ? error.message : String(error),
+      });
     }
   }
 }

package/src/revenuecat/infrastructure/utils/InitializationCache.ts

@@ -0,0 +1,45 @@
+/**
+ * Initialization Cache
+ * Manages promise caching and user state for initialization
+ */
+
+import { addPackageBreadcrumb } from "@umituz/react-native-sentry";
+
+export class InitializationCache {
+  private initPromise: Promise<boolean> | null = null;
+  private currentUserId: string | null = null;
+
+  shouldReinitialize(userId: string): boolean {
+    if (!this.initPromise) {
+      return true;
+    }
+
+    if (this.currentUserId !== userId) {
+      addPackageBreadcrumb("subscription", "User changed, reinitialize needed", {
+        oldUserId: this.currentUserId,
+        newUserId: userId,
+      });
+      return true;
+    }
+
+    return false;
+  }
+
+  getExistingPromise(): Promise<boolean> | null {
+    return this.initPromise;
+  }
+
+  setPromise(promise: Promise<boolean>, userId: string): void {
+    this.initPromise = promise;
+    this.currentUserId = userId;
+  }
+
+  getCurrentUserId(): string | null {
+    return this.currentUserId;
+  }
+
+  reset(): void {
+    this.initPromise = null;
+    this.currentUserId = null;
+  }
+}

package/src/revenuecat/infrastructure/utils/UserIdProvider.ts

@@ -0,0 +1,45 @@
+/**
+ * User ID Provider
+ * Manages user ID retrieval (anonymous or authenticated)
+ */
+
+import {
+  trackPackageError,
+  addPackageBreadcrumb,
+} from "@umituz/react-native-sentry";
+
+export class UserIdProvider {
+  private cachedAnonUserId: string | null = null;
+  private getAnonymousUserIdFn: (() => Promise<string>) | null = null;
+
+  configure(getAnonymousUserId: () => Promise<string>): void {
+    this.getAnonymousUserIdFn = getAnonymousUserId;
+    addPackageBreadcrumb("subscription", "UserIdProvider configured", {});
+  }
+
+  async getOrCreateAnonymousUserId(): Promise<string> {
+    if (this.cachedAnonUserId) {
+      return this.cachedAnonUserId;
+    }
+
+    if (!this.getAnonymousUserIdFn) {
+      const error = new Error("Anonymous user ID provider not configured");
+      trackPackageError(error, {
+        packageName: "subscription",
+        operation: "get_anon_user_id",
+      });
+      throw error;
+    }
+
+    this.cachedAnonUserId = await this.getAnonymousUserIdFn();
+    addPackageBreadcrumb("subscription", "Anonymous user ID created", {
+      userId: this.cachedAnonUserId,
+    });
+
+    return this.cachedAnonUserId;
+  }
+
+  reset(): void {
+    this.cachedAnonUserId = null;
+  }
+}