@umituz/react-native-subscription 2.13.17 → 2.13.19

package/package.json

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

@@ -391,6 +391,8 @@ export {
   type PremiumStatus,
 } from "./revenuecat/infrastructure/managers/SubscriptionManager";
 
+export type { RestoreResultInfo } from "./revenuecat/infrastructure/handlers/PackageHandler";
+
 // =============================================================================
 // REVENUECAT - Hooks
 // =============================================================================

package/src/presentation/hooks/usePaywallOperations.ts

@@ -36,6 +36,10 @@ export interface UsePaywallOperationsResult {
     handleInAppPurchase: (pkg: PurchasesPackage) => Promise<boolean>;
     /** Handle in-app restore (with auto-close logic) */
     handleInAppRestore: () => Promise<boolean>;
+    /** Complete pending purchase after authentication */
+    completePendingPurchase: () => Promise<boolean>;
+    /** Clear pending package without purchasing */
+    clearPendingPackage: () => void;
 }
 
 export function usePaywallOperations({
@@ -155,11 +159,46 @@ export function usePaywallOperations({
         [executeRestore, closePaywall]
     );
 
+    const completePendingPurchase = useCallback(async (): Promise<boolean> => {
+        if (!pendingPackage) {
+            if (__DEV__) {
+                console.log("[usePaywallOperations] No pending package to complete");
+            }
+            return false;
+        }
+
+        if (__DEV__) {
+            console.log("[usePaywallOperations] Completing pending purchase:", pendingPackage.identifier);
+        }
+
+        const pkg = pendingPackage;
+        setPendingPackage(null);
+
+        const success = await purchasePackage(pkg);
+
+        if (success) {
+            if (onPurchaseSuccess) onPurchaseSuccess();
+        } else {
+            Alert.alert(
+                t("premium.purchaseError"),
+                t("premium.purchaseErrorMessage")
+            );
+        }
+
+        return success;
+    }, [pendingPackage, purchasePackage, onPurchaseSuccess, t]);
+
+    const clearPendingPackage = useCallback(() => {
+        setPendingPackage(null);
+    }, []);
+
     return {
         pendingPackage,
         handlePurchase,
         handleRestore,
         handleInAppPurchase,
         handleInAppRestore,
+        completePendingPurchase,
+        clearPendingPackage,
     };
 }

package/src/presentation/hooks/usePremium.ts

@@ -89,11 +89,11 @@ export const usePremium = (userId?: string): UsePremiumResult => {
   const handlePurchase = useCallback(
     async (pkg: PurchasesPackage): Promise<boolean> => {
       try {
-        const success = await purchaseMutation.mutateAsync(pkg);
-        return success;
+        const result = await purchaseMutation.mutateAsync(pkg);
+        return result.success;
       } catch (error) {
         if (__DEV__) {
-          console.error('[usePremium] Purchase failed:', error);
+          console.error("[usePremium] Purchase failed:", error);
         }
         return false;
       }
@@ -104,11 +104,11 @@ export const usePremium = (userId?: string): UsePremiumResult => {
   // Restore handler with proper error handling
   const handleRestore = useCallback(async (): Promise<boolean> => {
     try {
-      const success = await restoreMutation.mutateAsync();
-      return success;
+      const result = await restoreMutation.mutateAsync();
+      return result.success;
     } catch (error) {
       if (__DEV__) {
-        console.error('[usePremium] Restore failed:', error);
+        console.error("[usePremium] Restore failed:", error);
       }
       return false;
     }

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

@@ -4,8 +4,8 @@
  */
 
 import type { PurchasesPackage } from "react-native-purchases";
-import type { IRevenueCatService } from '../../application/ports/IRevenueCatService';
-import { getPremiumEntitlement } from '../../domain/types/RevenueCatTypes';
+import type { IRevenueCatService } from "../../application/ports/IRevenueCatService";
+import { getPremiumEntitlement } from "../../domain/types/RevenueCatTypes";
 import {
   trackPackageError,
   addPackageBreadcrumb,
@@ -17,6 +17,11 @@ export interface PremiumStatus {
   expirationDate: Date | null;
 }
 
+export interface RestoreResultInfo {
+  success: boolean;
+  productId: string | null;
+}
+
 export class PackageHandler {
   constructor(
     private service: IRevenueCatService | null,
@@ -89,22 +94,35 @@ export class PackageHandler {
     }
   }
 
-  async restore(userId: string): Promise<boolean> {
+  async restore(userId: string): Promise<RestoreResultInfo> {
     if (!this.service?.isInitialized()) {
       trackPackageWarning("subscription", "Restore attempted but not initialized", {});
-      return false;
+      return { success: false, productId: null };
     }
 
     try {
       const result = await this.service.restorePurchases(userId);
-      return result.success;
+
+      // Extract product ID from active entitlement
+      let productId: string | null = null;
+      if (result.success && result.customerInfo) {
+        const entitlement = getPremiumEntitlement(
+          result.customerInfo,
+          this.entitlementId
+        );
+        if (entitlement) {
+          productId = entitlement.productIdentifier;
+        }
+      }
+
+      return { success: result.success, productId };
     } catch (error) {
       trackPackageError(error instanceof Error ? error : new Error(String(error)), {
         packageName: "subscription",
         operation: "restore",
         userId,
       });
-      return false;
+      return { success: false, productId: null };
     }
   }
 

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

@@ -5,13 +5,13 @@
  */
 
 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 } from '../handlers/PackageHandler';
-import type { PremiumStatus } from '../handlers/PackageHandler';
+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 } from "../handlers/PackageHandler";
+import type { PremiumStatus, RestoreResultInfo } from "../handlers/PackageHandler";
 import {
   trackPackageError,
   addPackageBreadcrumb,
@@ -138,10 +138,10 @@ class SubscriptionManagerImpl {
     return this.packageHandler!.purchase(pkg, userId);
   }
 
-  async restore(): Promise<boolean> {
+  async restore(): Promise<RestoreResultInfo> {
     this.ensureConfigured();
     const userId = this.initCache.getCurrentUserId();
-    if (!userId) return false;
+    if (!userId) return { success: false, productId: null };
     return this.packageHandler!.restore(userId);
   }
 

package/src/revenuecat/presentation/hooks/usePurchasePackage.ts

@@ -1,37 +1,43 @@
 /**
  * Purchase Package Hook
  * TanStack mutation for purchasing subscription packages
+ * Automatically initializes credits after successful purchase
  */
 
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import type { PurchasesPackage } from "react-native-purchases";
-import { SubscriptionManager } from '../../infrastructure/managers/SubscriptionManager';
+import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
 import {
   trackPackageError,
   addPackageBreadcrumb,
 } from "@umituz/react-native-sentry";
 import { SUBSCRIPTION_QUERY_KEYS } from "./subscriptionQueryKeys";
 import { creditsQueryKeys } from "../../../presentation/hooks/useCredits";
+import { getCreditsRepository } from "../../../infrastructure/repositories/CreditsRepositoryProvider";
+
+interface PurchaseResult {
+  success: boolean;
+  productId: string;
+}
 
 /**
  * Purchase a subscription package
+ * After successful purchase, automatically initializes credits
  */
 export const usePurchasePackage = (userId: string | undefined) => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async (pkg: PurchasesPackage) => {
+    mutationFn: async (pkg: PurchasesPackage): Promise<PurchaseResult> => {
       if (!userId) {
         throw new Error("User not authenticated");
       }
 
-      addPackageBreadcrumb("subscription", "Purchase started", {
-        packageId: pkg.identifier,
-        userId,
-      });
+      const productId = pkg.product.identifier;
 
-      addPackageBreadcrumb("subscription", "Purchase mutation started", {
+      addPackageBreadcrumb("subscription", "Purchase started", {
         packageId: pkg.identifier,
+        productId,
         userId,
       });
 
@@ -40,35 +46,57 @@ export const usePurchasePackage = (userId: string | undefined) => {
       if (success) {
         addPackageBreadcrumb("subscription", "Purchase success", {
           packageId: pkg.identifier,
+          productId,
           userId,
         });
 
-        addPackageBreadcrumb("subscription", "Purchase mutation success", {
-          packageId: pkg.identifier,
+        // Initialize credits immediately after purchase
+        const repository = getCreditsRepository();
+        const creditResult = await repository.initializeCredits(
           userId,
-        });
+          pkg.identifier,
+          productId
+        );
+
+        if (creditResult.success) {
+          addPackageBreadcrumb("subscription", "Credits initialized", {
+            productId,
+            userId,
+          });
+
+          // Update cache immediately for instant UI update
+          if (creditResult.data) {
+            queryClient.setQueryData(
+              creditsQueryKeys.user(userId),
+              creditResult.data
+            );
+          }
+        } else {
+          addPackageBreadcrumb("subscription", "Credits initialization failed", {
+            productId,
+            userId,
+            error: creditResult.error?.message,
+          });
+        }
       } else {
         addPackageBreadcrumb("subscription", "Purchase cancelled", {
           packageId: pkg.identifier,
           userId,
         });
-
-        addPackageBreadcrumb("subscription", "Purchase mutation failed", {
-          packageId: pkg.identifier,
-          userId,
-        });
       }
 
-      return success;
+      return { success, productId };
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: SUBSCRIPTION_QUERY_KEYS.packages,
-      });
-      if (userId) {
+    onSuccess: (result) => {
+      if (result.success) {
         queryClient.invalidateQueries({
-          queryKey: creditsQueryKeys.user(userId),
+          queryKey: SUBSCRIPTION_QUERY_KEYS.packages,
         });
+        if (userId) {
+          queryClient.invalidateQueries({
+            queryKey: creditsQueryKeys.user(userId),
+          });
+        }
       }
     },
     onError: (error) => {

package/src/revenuecat/presentation/hooks/useRestorePurchase.ts

@@ -1,24 +1,33 @@
 /**
  * Restore Purchase Hook
  * TanStack mutation for restoring previous purchases
+ * Automatically initializes credits after successful restore
  */
 
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { SubscriptionManager } from '../../infrastructure/managers/SubscriptionManager';
+import { SubscriptionManager } from "../../infrastructure/managers/SubscriptionManager";
 import {
   trackPackageError,
   addPackageBreadcrumb,
 } from "@umituz/react-native-sentry";
 import { SUBSCRIPTION_QUERY_KEYS } from "./subscriptionQueryKeys";
+import { creditsQueryKeys } from "../../../presentation/hooks/useCredits";
+import { getCreditsRepository } from "../../../infrastructure/repositories/CreditsRepositoryProvider";
+
+interface RestoreResult {
+  success: boolean;
+  productId: string | null;
+}
 
 /**
  * Restore previous purchases
+ * After successful restore, automatically initializes credits
  */
 export const useRestorePurchase = (userId: string | undefined) => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async () => {
+    mutationFn: async (): Promise<RestoreResult> => {
       if (!userId) {
         throw new Error("User not authenticated");
       }
@@ -27,32 +36,63 @@ export const useRestorePurchase = (userId: string | undefined) => {
         userId,
       });
 
-      addPackageBreadcrumb("subscription", "Restore mutation started", {
-        userId,
-      });
-
-      const success = await SubscriptionManager.restore();
+      const result = await SubscriptionManager.restore();
 
-      if (success) {
+      if (result.success) {
         addPackageBreadcrumb("subscription", "Restore success", {
           userId,
+          productId: result.productId,
         });
 
-        addPackageBreadcrumb("subscription", "Restore mutation success", {
-          userId,
-        });
+        // Initialize credits if we have a product ID
+        if (result.productId) {
+          const repository = getCreditsRepository();
+          const creditResult = await repository.initializeCredits(
+            userId,
+            undefined,
+            result.productId
+          );
+
+          if (creditResult.success) {
+            addPackageBreadcrumb("subscription", "Credits initialized after restore", {
+              productId: result.productId,
+              userId,
+            });
+
+            // Update cache immediately for instant UI update
+            if (creditResult.data) {
+              queryClient.setQueryData(
+                creditsQueryKeys.user(userId),
+                creditResult.data
+              );
+            }
+          } else {
+            addPackageBreadcrumb("subscription", "Credits initialization failed after restore", {
+              productId: result.productId,
+              userId,
+              error: creditResult.error?.message,
+            });
+          }
+        }
       } else {
-        addPackageBreadcrumb("subscription", "Restore mutation failed", {
+        addPackageBreadcrumb("subscription", "Restore failed - no premium found", {
           userId,
         });
       }
 
-      return success;
+      return result;
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({
-        queryKey: SUBSCRIPTION_QUERY_KEYS.packages,
-      });
+    onSuccess: (result) => {
+      if (result.success) {
+        queryClient.invalidateQueries({
+          queryKey: SUBSCRIPTION_QUERY_KEYS.packages,
+        });
+        if (userId) {
+          queryClient.invalidateQueries({
+            queryKey: creditsQueryKeys.user(userId),
+          });
+        }
+      }
     },
     onError: (error) => {
       trackPackageError(