@umituz/react-native-subscription 2.40.0 → 2.40.2

package/package.json

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

@@ -3,12 +3,11 @@ import { getAppVersion, validatePlatform } from "../../../utils/appUtils";
 
 import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
 import { runTransaction, serverTimestamp, type Transaction, type DocumentReference, type Firestore } from "@umituz/react-native-firebase";
-import { doc } from "firebase/firestore";
 import { getCreditDocumentOrDefault } from "./creditDocumentHelpers";
 import { calculateNewCredits, buildCreditsData } from "./creditOperationUtils";
 import { calculateCreditLimit } from "./CreditLimitCalculator";
 import { generatePurchaseMetadata } from "./PurchaseMetadataGenerator";
-import { PURCHASE_ID_PREFIXES, TRANSACTION_SUBCOLLECTION } from "../core/CreditsConstants";
+import { PURCHASE_ID_PREFIXES } from "../core/CreditsConstants";
 
 export async function initializeCreditsTransaction(
     _db: Firestore,
@@ -61,28 +60,6 @@ export async function initializeCreditsTransaction(
             };
         }
 
-        // User-specific transaction deduplication: prevent the same Apple/Google transaction
-        // from allocating credits multiple times for the same user.
-        // Path: users/{userId}/credits/processedTransactions/{transactionId}
-        if (metadata.storeTransactionId) {
-            const transactionRef = doc(_db, creditsRef.path, TRANSACTION_SUBCOLLECTION, metadata.storeTransactionId);
-            const transactionDoc = await transaction.get(transactionRef);
-            if (transactionDoc.exists()) {
-                if (__DEV__) {
-                    console.log('[CreditsInitializer] 🟡 Store transaction already processed, skipping', {
-                        userId,
-                        storeTransactionId: metadata.storeTransactionId,
-                        existingCredits: existingData.credits,
-                    });
-                }
-                return {
-                    credits: existingData.credits,
-                    alreadyProcessed: true,
-                    finalData: existingData
-                };
-            }
-        }
-
         if (__DEV__) {
             console.log('[CreditsInitializer] 🔵 Processing credit allocation', {
                 userId,
@@ -121,16 +98,6 @@ export async function initializeCreditsTransaction(
 
         transaction.set(creditsRef, creditsData, { merge: true });
 
-        // Register transaction in user-specific subcollection to prevent duplicate processing.
-        if (metadata.storeTransactionId) {
-            const transactionRef = doc(_db, creditsRef.path, TRANSACTION_SUBCOLLECTION, metadata.storeTransactionId);
-            transaction.set(transactionRef, {
-                purchaseId,
-                productId: metadata.productId,
-                createdAt: serverTimestamp(),
-            });
-        }
-
         if (__DEV__) {
             console.log('[CreditsInitializer] 🟢 Credit allocation successful', {
                 userId,

package/src/domains/credits/core/CreditsConstants.ts

@@ -14,11 +14,3 @@ export const PROCESSED_PURCHASES_WINDOW = 50;
 
 /** Maximum credits that can be deducted in a single operation. */
 export const MAX_SINGLE_DEDUCTION = 10000;
-
-/**
- * User-specific Firestore sub-collection for transaction deduplication.
- * Changed from global root-level collection to user-scoped collection
- * to match vivoim_app pattern and avoid Firestore permission issues.
- * Path: users/{userId}/credits/processedTransactions/{transactionId}
- */
-export const TRANSACTION_SUBCOLLECTION = 'processedTransactions';

package/src/domains/credits/infrastructure/CreditsRepository.ts

@@ -104,9 +104,6 @@ export class CreditsRepository extends BaseRepository {
       willRenew,
       expirationDate,
       periodType,
-      db,
-      userId,
-      storeTransactionId,
     );
   }
 }

package/src/domains/credits/infrastructure/operations/CreditsWriter.ts

@@ -1,13 +1,12 @@
-import type { DocumentReference, Transaction, Firestore } from "@umituz/react-native-firebase";
+import type { DocumentReference, Transaction } from "@umituz/react-native-firebase";
 import { runTransaction, serverTimestamp } from "@umituz/react-native-firebase";
-import { doc, getDoc, setDoc } from "firebase/firestore";
+import { getDoc, setDoc } from "firebase/firestore";
 import { SUBSCRIPTION_STATUS } from "../../../subscription/core/SubscriptionConstants";
 import { resolveSubscriptionStatus } from "../../../subscription/core/SubscriptionStatus";
 import type { SubscriptionMetadata } from "../../../subscription/core/types/SubscriptionMetadata";
 import { toTimestamp } from "../../../../shared/utils/dateConverter";
 import { isPast } from "../../../../utils/dateUtils";
 import { getAppVersion, validatePlatform } from "../../../../utils/appUtils";
-import { TRANSACTION_SUBCOLLECTION } from "../../core/CreditsConstants";
 
 // Fix: was getDoc+setDoc (non-atomic) — now uses runTransaction so concurrent
 // initializeCreditsTransaction and deductCreditsOperation no longer see stale
@@ -70,11 +69,8 @@ export async function syncPremiumMetadata(
  * NOTE: This uses non-atomic check-then-act (getDoc + setDoc). In theory, two concurrent
  * calls could both see no document and create duplicates. However, this is extremely rare
  * in practice because: (1) createRecoveryCreditsDocument is called after a successful
- * purchase which is already serialized, (2) the user-specific transaction check (below) prevents
- * duplicates, (3) even if two recovery docs are created, the credits document
- * logic is idempotent (same purchaseId processed twice is no-op). Making this atomic
- * would require a transaction spanning both the credits doc and transaction subcollection,
- * which adds complexity without meaningful benefit given the safeguards above.
+ * purchase which is already serialized, (2) the credits document logic is idempotent
+ * (same purchaseId processed twice is no-op).
  */
 export async function createRecoveryCreditsDocument(
   ref: DocumentReference,
@@ -83,35 +79,10 @@ export async function createRecoveryCreditsDocument(
   willRenew: boolean,
   expirationDate: string | null,
   periodType: string | null,
-  db?: Firestore,
-  userId?: string,
-  storeTransactionId?: string | null,
 ): Promise<boolean> {
   const existingDoc = await getDoc(ref);
   if (existingDoc.exists()) return false;
 
-  // User-specific deduplication: if this transaction was already processed
-  // for this user, skip recovery to prevent duplicate credit allocation.
-  if (db && userId && storeTransactionId) {
-    try {
-      const transactionRef = doc(db, ref.path, TRANSACTION_SUBCOLLECTION, storeTransactionId);
-      const transactionDoc = await getDoc(transactionRef);
-      if (transactionDoc.exists()) {
-        if (__DEV__) {
-          console.log(
-            `[CreditsWriter] Recovery skipped: transaction ${storeTransactionId} already processed for user ${userId}`
-          );
-        }
-        return false;
-      }
-    } catch (error) {
-      // Non-fatal: if transaction check fails, still create recovery doc as safety net
-      if (__DEV__) {
-        console.warn('[CreditsWriter] Transaction check failed during recovery:', error);
-      }
-    }
-  }
-
   const platform = validatePlatform();
   const appVersion = getAppVersion();
 

package/src/domains/paywall/hooks/usePaywallActions.ts

@@ -74,14 +74,33 @@ export function usePaywallActions({
       return;
     }
 
+    if (__DEV__) {
+      console.log('[usePaywallActions] Starting purchase', {
+        productId: pkg.product.identifier,
+        hasOnClose: !!onCloseRef.current,
+        hasOnSuccess: !!onPurchaseSuccessRef.current,
+      });
+    }
+
     setIsLocalProcessing(true);
     startPurchase(currentSelectedId, "manual");
 
     try {
       const success = await onPurchaseRef.current(pkg);
+      if (__DEV__) {
+        console.log('[usePaywallActions] Purchase completed', { success });
+      }
       if (success === true) {
+        if (__DEV__) {
+          console.log('[usePaywallActions] Purchase successful, calling onPurchaseSuccess and onClose');
+        }
         onPurchaseSuccessRef.current?.();
+        // Always close paywall on successful purchase
         onCloseRef.current?.();
+      } else {
+        if (__DEV__) {
+          console.warn('[usePaywallActions] Purchase returned false, not closing');
+        }
       }
     } catch (error) {
       onPurchaseErrorRef.current?.(error instanceof Error ? error : new Error(String(error)));
@@ -99,12 +118,29 @@ export function usePaywallActions({
 
     if (isProcessingRef.current) return;
 
+    if (__DEV__) {
+      console.log('[usePaywallActions] Starting restore', {
+        hasOnClose: !!onCloseRef.current,
+        hasOnSuccess: !!onPurchaseSuccessRef.current,
+      });
+    }
+
     setIsLocalProcessing(true);
     try {
       const success = await onRestoreRef.current();
+      if (__DEV__) {
+        console.log('[usePaywallActions] Restore completed', { success });
+      }
       if (success === true) {
+        if (__DEV__) {
+          console.log('[usePaywallActions] Restore successful, calling onPurchaseSuccess and onClose');
+        }
         onPurchaseSuccessRef.current?.();
         onCloseRef.current?.();
+      } else {
+        if (__DEV__) {
+          console.warn('[usePaywallActions] Restore returned false, not closing');
+        }
       }
     } catch (error) {
       onPurchaseErrorRef.current?.(error instanceof Error ? error : new Error(String(error)));