@umituz/react-native-subscription 2.13.16 → 2.13.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.13.16",
+  "version": "2.13.18",
   "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/paywall/components/PaywallModal.tsx

@@ -227,7 +227,7 @@ const styles = StyleSheet.create({
     modalContent: { padding: 0, borderWidth: 0, overflow: "hidden" },
     container: { flex: 1 },
     closeBtn: { position: "absolute", top: 12, right: 12, width: 32, height: 32, borderRadius: 16, justifyContent: "center", alignItems: "center", zIndex: 10 },
-    scroll: { flexGrow: 1, padding: 16, paddingTop: 48 },
+    scroll: { flexGrow: 1, padding: 16, paddingTop: 48, paddingBottom: 32 },
     header: { alignItems: "center", marginBottom: 12 },
     title: { fontWeight: "700", textAlign: "center", marginBottom: 4 },
     subtitle: { textAlign: "center" },

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/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/presentation/screens/components/SubscriptionHeader.tsx

@@ -153,10 +153,13 @@ const styles = StyleSheet.create({
         flexDirection: "row",
         justifyContent: "space-between",
         alignItems: "center",
+        gap: 16,
     },
     label: {
+        flex: 1,
     },
     value: {
         fontWeight: "600",
+        textAlign: "right",
     },
 });

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(