@umituz/react-native-subscription 2.39.12 → 2.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.39.12",
+  "version": "2.40.0",
   "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

@@ -8,7 +8,7 @@ import { getCreditDocumentOrDefault } from "./creditDocumentHelpers";
 import { calculateNewCredits, buildCreditsData } from "./creditOperationUtils";
 import { calculateCreditLimit } from "./CreditLimitCalculator";
 import { generatePurchaseMetadata } from "./PurchaseMetadataGenerator";
-import { PURCHASE_ID_PREFIXES, GLOBAL_TRANSACTION_COLLECTION } from "../core/CreditsConstants";
+import { PURCHASE_ID_PREFIXES, TRANSACTION_SUBCOLLECTION } from "../core/CreditsConstants";
 
 export async function initializeCreditsTransaction(
     _db: Firestore,
@@ -19,6 +19,20 @@ export async function initializeCreditsTransaction(
     userId: string
 ): Promise<InitializationResult> {
 
+    if (__DEV__) {
+        console.log('[CreditsInitializer] 🔵 initializeCreditsTransaction: START', {
+            userId,
+            purchaseId,
+            productId: metadata.productId,
+            source: metadata.source,
+            type: metadata.type,
+            isPremium: metadata.isPremium,
+            willRenew: metadata.willRenew,
+            storeTransactionId: metadata.storeTransactionId,
+            timestamp: new Date().toISOString(),
+        });
+    }
+
     if (!purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) && !purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL)) {
         throw new Error(`[CreditsInitializer] Only purchase and renewal operations can allocate credits. Received: ${purchaseId}`);
     }
@@ -32,6 +46,14 @@ export async function initializeCreditsTransaction(
         const existingData = getCreditDocumentOrDefault(creditsDoc, platform);
 
         if (existingData.processedPurchases.includes(purchaseId)) {
+            if (__DEV__) {
+                console.log('[CreditsInitializer] 🟡 Transaction already processed, skipping', {
+                    userId,
+                    purchaseId,
+                    existingCredits: existingData.credits,
+                    processedPurchasesCount: existingData.processedPurchases.length,
+                });
+            }
             return {
                 credits: existingData.credits,
                 alreadyProcessed: true,
@@ -39,26 +61,37 @@ export async function initializeCreditsTransaction(
             };
         }
 
-        // Global cross-user deduplication: prevent the same Apple/Google transaction
-        // from allocating credits under multiple Firebase UIDs.
+        // 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 globalRef = doc(_db, GLOBAL_TRANSACTION_COLLECTION, metadata.storeTransactionId);
-            const globalDoc = await transaction.get(globalRef);
-            if (globalDoc.exists()) {
-                const globalData = globalDoc.data();
-                if (globalData?.ownerUserId && globalData.ownerUserId !== userId) {
-                    console.warn(
-                        `[CreditsInitializer] Transaction ${metadata.storeTransactionId} already processed by user ${globalData.ownerUserId}, skipping for ${userId}`
-                    );
-                    return {
-                        credits: existingData.credits,
-                        alreadyProcessed: true,
-                        finalData: existingData
-                    };
+            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,
+                purchaseId,
+                existingCredits: existingData.credits,
+                productId: metadata.productId,
+            });
+        }
+
         const creditLimit = calculateCreditLimit(metadata.productId, config);
         const { purchaseHistory } = generatePurchaseMetadata({
             productId: metadata.productId,
@@ -88,17 +121,27 @@ export async function initializeCreditsTransaction(
 
         transaction.set(creditsRef, creditsData, { merge: true });
 
-        // Register transaction globally so other UIDs cannot claim the same purchase.
+        // Register transaction in user-specific subcollection to prevent duplicate processing.
         if (metadata.storeTransactionId) {
-            const globalRef = doc(_db, GLOBAL_TRANSACTION_COLLECTION, metadata.storeTransactionId);
-            transaction.set(globalRef, {
-                ownerUserId: userId,
+            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,
+                purchaseId,
+                previousCredits: existingData.credits,
+                newCredits,
+                creditLimit,
+                productId: metadata.productId,
+            });
+        }
+
         return {
             credits: newCredits,
             alreadyProcessed: false,

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

@@ -16,8 +16,9 @@ export const PROCESSED_PURCHASES_WINDOW = 50;
 export const MAX_SINGLE_DEDUCTION = 10000;
 
 /**
- * Global Firestore collection for cross-user transaction deduplication.
- * Prevents the same Apple/Google transaction from allocating credits
- * under multiple Firebase UIDs (e.g., anonymous + converted accounts).
+ * 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 GLOBAL_TRANSACTION_COLLECTION = 'processedTransactions';
+export const TRANSACTION_SUBCOLLECTION = 'processedTransactions';

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

@@ -7,7 +7,7 @@ import type { SubscriptionMetadata } from "../../../subscription/core/types/Subs
 import { toTimestamp } from "../../../../shared/utils/dateConverter";
 import { isPast } from "../../../../utils/dateUtils";
 import { getAppVersion, validatePlatform } from "../../../../utils/appUtils";
-import { GLOBAL_TRANSACTION_COLLECTION } from "../../core/CreditsConstants";
+import { TRANSACTION_SUBCOLLECTION } from "../../core/CreditsConstants";
 
 // Fix: was getDoc+setDoc (non-atomic) — now uses runTransaction so concurrent
 // initializeCreditsTransaction and deductCreditsOperation no longer see stale
@@ -67,17 +67,13 @@ export async function syncPremiumMetadata(
  * This handles edge cases like test store purchases, reinstalls, or failed initializations.
  * Returns true if a new document was created, false if one already existed.
  *
- * Cross-user guard: if storeTransactionId is provided and already registered
- * to a different user in the global processedTransactions collection, the recovery
- * document is NOT created (the subscription belongs to another UID).
- *
  * 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 global transaction check (below) prevents
- * duplicates across users, (3) even if two recovery docs are created, the credits document
+ * 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 global processedTransactions,
+ * would require a transaction spanning both the credits doc and transaction subcollection,
  * which adds complexity without meaningful benefit given the safeguards above.
  */
 export async function createRecoveryCreditsDocument(
@@ -94,24 +90,25 @@ export async function createRecoveryCreditsDocument(
   const existingDoc = await getDoc(ref);
   if (existingDoc.exists()) return false;
 
-  // Cross-user deduplication: if this transaction was already processed by another
-  // user, skip recovery to prevent double credit allocation across UIDs.
+  // 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 globalRef = doc(db, GLOBAL_TRANSACTION_COLLECTION, storeTransactionId);
-      const globalDoc = await getDoc(globalRef);
-      if (globalDoc.exists()) {
-        const globalData = globalDoc.data();
-        if (globalData?.ownerUserId && globalData.ownerUserId !== userId) {
-          console.warn(
-            `[CreditsWriter] Recovery skipped: transaction ${storeTransactionId} belongs to user ${globalData.ownerUserId}, not ${userId}`
+      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;
         }
+        return false;
       }
     } catch (error) {
-      // Non-fatal: if global check fails, still create recovery doc as safety net
-      console.warn('[CreditsWriter] Global transaction check failed during recovery:', 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);
+      }
     }
   }
 

package/src/domains/subscription/application/SubscriptionSyncProcessor.ts

@@ -26,52 +26,104 @@ export class SubscriptionSyncProcessor {
   // ─── Public API (replaces SubscriptionSyncService) ────────────────
 
   async handlePurchase(event: PurchaseCompletedEvent): Promise<void> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 PURCHASE START', {
+        userId: event.userId,
+        productId: event.productId,
+        source: event.source,
+        packageType: event.packageType,
+        timestamp: new Date().toISOString(),
+      });
+    }
     try {
       await this.processPurchase(event);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, {
         userId: event.userId,
         productId: event.productId,
       });
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log('[SubscriptionSyncProcessor] 🟢 PURCHASE SUCCESS', {
+          userId: event.userId,
+          productId: event.productId,
+          timestamp: new Date().toISOString(),
+        });
+      }
     } catch (error) {
-      console.error('[SubscriptionSyncProcessor] Purchase processing failed', {
+      console.error('[SubscriptionSyncProcessor] 🔴 PURCHASE FAILED', {
         userId: event.userId,
         productId: event.productId,
         error: error instanceof Error ? error.message : String(error),
+        timestamp: new Date().toISOString(),
       });
       throw error;
     }
   }
 
   async handleRenewal(event: RenewalDetectedEvent): Promise<void> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 RENEWAL START', {
+        userId: event.userId,
+        productId: event.productId,
+        newExpirationDate: event.newExpirationDate,
+        timestamp: new Date().toISOString(),
+      });
+    }
     try {
       await this.processRenewal(event);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, {
         userId: event.userId,
         productId: event.productId,
       });
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log('[SubscriptionSyncProcessor] 🟢 RENEWAL SUCCESS', {
+          userId: event.userId,
+          productId: event.productId,
+          timestamp: new Date().toISOString(),
+        });
+      }
     } catch (error) {
-      console.error('[SubscriptionSyncProcessor] Renewal processing failed', {
+      console.error('[SubscriptionSyncProcessor] 🔴 RENEWAL FAILED', {
         userId: event.userId,
         productId: event.productId,
         error: error instanceof Error ? error.message : String(error),
+        timestamp: new Date().toISOString(),
       });
       throw error;
     }
   }
 
   async handlePremiumStatusChanged(event: PremiumStatusChangedEvent): Promise<void> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 STATUS CHANGE START', {
+        userId: event.userId,
+        isPremium: event.isPremium,
+        productId: event.productId,
+        willRenew: event.willRenew,
+        expirationDate: event.expirationDate,
+        timestamp: new Date().toISOString(),
+      });
+    }
     try {
       await this.processStatusChange(event);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, {
         userId: event.userId,
         isPremium: event.isPremium,
       });
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log('[SubscriptionSyncProcessor] 🟢 STATUS CHANGE SUCCESS', {
+          userId: event.userId,
+          isPremium: event.isPremium,
+          productId: event.productId,
+          timestamp: new Date().toISOString(),
+        });
+      }
     } catch (error) {
-      console.error('[SubscriptionSyncProcessor] Status change processing failed', {
+      console.error('[SubscriptionSyncProcessor] 🔴 STATUS CHANGE FAILED', {
         userId: event.userId,
         isPremium: event.isPremium,
         productId: event.productId,
         error: error instanceof Error ? error.message : String(error),
+        timestamp: new Date().toISOString(),
       });
       throw error;
     }
@@ -96,6 +148,14 @@ export class SubscriptionSyncProcessor {
 
   private async processPurchase(event: PurchaseCompletedEvent): Promise<void> {
     this.purchaseInProgress = true;
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 processPurchase: Starting credit initialization', {
+        productId: event.productId,
+        source: event.source,
+        packageType: event.packageType,
+        activeEntitlements: Object.keys(event.customerInfo.entitlements.active),
+      });
+    }
     try {
       const revenueCatData = extractRevenueCatData(event.customerInfo, this.entitlementId);
       revenueCatData.packageType = event.packageType ?? null;
@@ -105,6 +165,15 @@ export class SubscriptionSyncProcessor {
 
       const creditsUserId = await this.getCreditsUserId(event.userId);
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log('[SubscriptionSyncProcessor] 🔵 processPurchase: Calling initializeCredits', {
+          creditsUserId,
+          purchaseId,
+          productId: event.productId,
+          revenueCatUserId: revenueCatData.revenueCatUserId,
+        });
+      }
+
       const result = await getCreditsRepository().initializeCredits(
         creditsUserId,
         purchaseId,
@@ -119,6 +188,13 @@ export class SubscriptionSyncProcessor {
       }
 
       this.emitCreditsUpdated(creditsUserId);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log('[SubscriptionSyncProcessor] 🟢 processPurchase: Credits initialized successfully', {
+          creditsUserId,
+          purchaseId,
+          credits: result.data?.credits,
+        });
+      }
     } finally {
       this.purchaseInProgress = false;
     }
@@ -198,6 +274,15 @@ export class SubscriptionSyncProcessor {
   private async syncPremiumStatus(userId: string, event: PremiumStatusChangedEvent): Promise<void> {
     const repo = getCreditsRepository();
 
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🔵 syncPremiumStatus: Starting', {
+        userId,
+        isPremium: event.isPremium,
+        productId: event.productId,
+        willRenew: event.willRenew,
+      });
+    }
+
     if (event.isPremium) {
       const created = await repo.ensurePremiumCreditsExist(
         userId,
@@ -208,7 +293,7 @@ export class SubscriptionSyncProcessor {
         event.storeTransactionId,
       );
       if (__DEV__ && created) {
-        console.log('[SubscriptionSyncProcessor] Recovery: created missing credits document for premium user', {
+        console.log('[SubscriptionSyncProcessor] 🟢 Recovery: created missing credits document for premium user', {
           userId,
           productId: event.productId,
         });
@@ -227,6 +312,14 @@ export class SubscriptionSyncProcessor {
       ownershipType: event.ownershipType ?? null,
     });
     this.emitCreditsUpdated(userId);
+
+    if (__DEV__) {
+      console.log('[SubscriptionSyncProcessor] 🟢 syncPremiumStatus: Completed', {
+        userId,
+        isPremium: event.isPremium,
+        productId: event.productId,
+      });
+    }
   }
 
   private emitCreditsUpdated(userId: string): void {

package/src/domains/subscription/infrastructure/services/purchase/PurchaseExecutor.ts

@@ -57,7 +57,7 @@ async function executeSubscriptionPurchase(
   const source = savedPurchase?.source;
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[PurchaseExecutor] executeSubscriptionPurchase:", {
+    console.log("[PurchaseExecutor] 🔵 executeSubscriptionPurchase: START", {
       userId,
       productId,
       isPremium,
@@ -65,13 +65,27 @@ async function executeSubscriptionPurchase(
       activeEntitlements: Object.keys(customerInfo.entitlements.active),
       source,
       packageType,
+      timestamp: new Date().toISOString(),
     });
   }
 
   try {
     await notifyPurchaseCompleted(config, userId, productId, customerInfo, source, packageType);
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[PurchaseExecutor] 🟢 executeSubscriptionPurchase: SUCCESS", {
+        userId,
+        productId,
+        isPremium,
+        timestamp: new Date().toISOString(),
+      });
+    }
   } catch (syncError) {
-    console.error('[PurchaseExecutor] Post-purchase sync failed, attempting recovery:', syncError);
+    console.error('[PurchaseExecutor] 🔴 Post-purchase sync failed, attempting recovery:', {
+      userId,
+      productId,
+      error: syncError instanceof Error ? syncError.message : String(syncError),
+      timestamp: new Date().toISOString(),
+    });
     await attemptRecovery(config, userId, customerInfo);
   } finally {
     if (savedPurchase) {