@umituz/react-native-subscription 2.20.3 → 2.20.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.20.3",
+  "version": "2.20.5",
   "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/infrastructure/services/CreditsInitializer.ts

@@ -95,6 +95,7 @@ export async function initializeCreditsTransaction(
         }
 
         // Create purchase metadata for history (only if productId and source exists and packageType detected)
+        // NOTE: Cannot use serverTimestamp() in arrays, using Date.now() instead
         const purchaseMetadata: PurchaseMetadata | undefined =
           productId && metadata?.source && packageType && packageType !== "unknown" ? {
             productId,
@@ -104,7 +105,7 @@ export async function initializeCreditsTransaction(
             type: purchaseType,
             platform,
             appVersion,
-            timestamp: now as any,
+            timestamp: Date.now() as any,  // Use Date.now() instead of serverTimestamp() for arrays
           } : undefined;
 
         // Update purchase history (keep last 10, only if metadata exists)

package/src/presentation/hooks/index.ts

@@ -1,6 +1,7 @@
 export * from "./useAuthAwarePurchase";
 export * from "./useAuthGate";
 export * from "./useAuthSubscriptionSync";
+export * from "./useSavedPurchaseAutoExecution";
 export * from "./useCreditChecker";
 export * from "./useCredits";
 export * from "./useCreditsGate";

package/src/presentation/hooks/useSavedPurchaseAutoExecution.ts

@@ -0,0 +1,135 @@
+/**
+ * Saved Purchase Auto-Execution Hook
+ * Automatically executes saved purchase when user converts from anonymous to authenticated
+ */
+
+import { useEffect, useRef, useCallback } from "react";
+import { getSavedPurchase, clearSavedPurchase } from "./useAuthAwarePurchase";
+import { usePremium } from "./usePremium";
+import { SubscriptionManager } from "../../revenuecat/infrastructure/services/SubscriptionManager";
+
+declare const __DEV__: boolean;
+
+export interface UseSavedPurchaseAutoExecutionParams {
+  userId?: string;
+  isAnonymous?: boolean;
+  onSuccess?: () => void;
+  onError?: (error: Error) => void;
+}
+
+export interface UseSavedPurchaseAutoExecutionResult {
+  isExecuting: boolean;
+}
+
+export const useSavedPurchaseAutoExecution = (
+  params: UseSavedPurchaseAutoExecutionParams
+): UseSavedPurchaseAutoExecutionResult => {
+  const { userId, isAnonymous, onSuccess, onError } = params;
+  const { purchasePackage } = usePremium(userId);
+
+  const prevIsAnonymousRef = useRef<boolean | undefined>(undefined);
+  const isExecutingRef = useRef(false);
+
+  const executeWithWait = useCallback(async () => {
+    const savedPurchase = getSavedPurchase();
+    if (!savedPurchase) return;
+
+    if (__DEV__) {
+      console.log(
+        "[SavedPurchaseAutoExecution] Waiting for RevenueCat initialization..."
+      );
+    }
+
+    isExecutingRef.current = true;
+
+    const maxAttempts = 20;
+    const delayMs = 500;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const isReady = SubscriptionManager.isInitializedForUser(userId);
+
+      if (__DEV__) {
+        console.log(
+          `[SavedPurchaseAutoExecution] Attempt ${attempt + 1}/${maxAttempts}, isReady: ${isReady}`
+        );
+      }
+
+      if (isReady) {
+        const pkg = savedPurchase.pkg;
+        clearSavedPurchase();
+
+        if (__DEV__) {
+          console.log(
+            "[SavedPurchaseAutoExecution] RevenueCat ready, executing purchase:",
+            pkg.product.identifier
+          );
+        }
+
+        try {
+          const success = await purchasePackage(pkg);
+
+          if (__DEV__) {
+            console.log("[SavedPurchaseAutoExecution] Purchase result:", success);
+          }
+
+          if (success && onSuccess) {
+            onSuccess();
+          }
+        } catch (error) {
+          if (__DEV__) {
+            console.error("[SavedPurchaseAutoExecution] Purchase failed:", error);
+          }
+          if (onError && error instanceof Error) {
+            onError(error);
+          }
+        } finally {
+          isExecutingRef.current = false;
+        }
+
+        return;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+
+    if (__DEV__) {
+      console.log(
+        "[SavedPurchaseAutoExecution] Timeout waiting for RevenueCat, clearing saved purchase"
+      );
+    }
+    clearSavedPurchase();
+    isExecutingRef.current = false;
+  }, [userId, purchasePackage, onSuccess, onError]);
+
+  useEffect(() => {
+    const isAuthenticated = !!userId && !isAnonymous;
+    const prevIsAnonymous = prevIsAnonymousRef.current;
+    const savedPurchase = getSavedPurchase();
+
+    const wasAnonymous = prevIsAnonymous === true;
+    const becameAuthenticated = wasAnonymous && isAuthenticated;
+
+    if (__DEV__) {
+      console.log("[SavedPurchaseAutoExecution] Check:", {
+        userId: userId?.slice(0, 8),
+        prevIsAnonymous,
+        isAnonymous,
+        isAuthenticated,
+        wasAnonymous,
+        becameAuthenticated,
+        hasSavedPurchase: !!savedPurchase,
+        willExecute: becameAuthenticated && !!savedPurchase && !isExecutingRef.current,
+      });
+    }
+
+    if (becameAuthenticated && savedPurchase && !isExecutingRef.current) {
+      executeWithWait();
+    }
+
+    prevIsAnonymousRef.current = isAnonymous;
+  }, [userId, isAnonymous, executeWithWait]);
+
+  return {
+    isExecuting: isExecutingRef.current,
+  };
+};