@umituz/react-native-subscription 2.37.103 → 2.37.105

package/package.json

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

@@ -2,19 +2,21 @@ import type { CreditsConfig } from "../core/Credits";
 import { getAppVersion, validatePlatform } from "../../../utils/appUtils";
 
 import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
-import { runTransaction, type Transaction, type DocumentReference, type Firestore } from "@umituz/react-native-firebase";
+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 } from "../core/CreditsConstants";
+import { PURCHASE_ID_PREFIXES, GLOBAL_TRANSACTION_COLLECTION } from "../core/CreditsConstants";
 
 export async function initializeCreditsTransaction(
     _db: Firestore,
     creditsRef: DocumentReference,
     config: CreditsConfig,
     purchaseId: string,
-    metadata: InitializeCreditsMetadata
+    metadata: InitializeCreditsMetadata,
+    userId: string
 ): Promise<InitializationResult> {
 
     if (!purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) && !purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL)) {
@@ -37,6 +39,26 @@ export async function initializeCreditsTransaction(
             };
         }
 
+        // Global cross-user deduplication: prevent the same Apple/Google transaction
+        // from allocating credits under multiple Firebase UIDs.
+        if (metadata.originalTransactionId) {
+            const globalRef = doc(_db, GLOBAL_TRANSACTION_COLLECTION, metadata.originalTransactionId);
+            const globalDoc = await transaction.get(globalRef);
+            if (globalDoc.exists()) {
+                const globalData = globalDoc.data();
+                if (globalData?.ownerUserId && globalData.ownerUserId !== userId) {
+                    console.warn(
+                        `[CreditsInitializer] Transaction ${metadata.originalTransactionId} already processed by user ${globalData.ownerUserId}, skipping for ${userId}`
+                    );
+                    return {
+                        credits: existingData.credits,
+                        alreadyProcessed: true,
+                        finalData: existingData
+                    };
+                }
+            }
+        }
+
         const creditLimit = calculateCreditLimit(metadata.productId, config);
         const { purchaseHistory } = generatePurchaseMetadata({
             productId: metadata.productId,
@@ -66,6 +88,17 @@ export async function initializeCreditsTransaction(
 
         transaction.set(creditsRef, creditsData, { merge: true });
 
+        // Register transaction globally so other UIDs cannot claim the same purchase.
+        if (metadata.originalTransactionId) {
+            const globalRef = doc(_db, GLOBAL_TRANSACTION_COLLECTION, metadata.originalTransactionId);
+            transaction.set(globalRef, {
+                ownerUserId: userId,
+                purchaseId,
+                productId: metadata.productId,
+                createdAt: serverTimestamp(),
+            });
+        }
+
         return {
             credits: newCredits,
             alreadyProcessed: false,

package/src/domains/credits/application/DeductCreditsCommand.ts

@@ -1,6 +1,6 @@
 import { runTransaction, serverTimestamp, type Transaction, type DocumentReference, type Firestore } from "@umituz/react-native-firebase";
 import type { DeductCreditsResult } from "../core/Credits";
-import { CREDIT_ERROR_CODES } from "../core/CreditsConstants";
+import { CREDIT_ERROR_CODES, MAX_SINGLE_DEDUCTION } from "../core/CreditsConstants";
 import { subscriptionEventBus, SUBSCRIPTION_EVENTS } from "../../../shared/infrastructure/SubscriptionEventBus";
 
 export async function deductCreditsOperation(
@@ -20,7 +20,6 @@ export async function deductCreditsOperation(
     };
   }
 
-  const MAX_SINGLE_DEDUCTION = 10000;
   if (cost <= 0 || !Number.isFinite(cost) || cost > MAX_SINGLE_DEDUCTION) {
     return {
       success: false,

package/src/domains/credits/application/PurchaseMetadataGenerator.ts

@@ -26,7 +26,10 @@ export function generatePurchaseMetadata(
   const packageType = detectPackageType(productId);
   let purchaseType: PurchaseType = type;
 
-  if (packageType !== PACKAGE_TYPE.UNKNOWN && creditLimit > existingData.creditLimit) {
+  const existingLimit = typeof existingData.creditLimit === 'number' && Number.isFinite(existingData.creditLimit)
+    ? existingData.creditLimit
+    : 0;
+  if (packageType !== PACKAGE_TYPE.UNKNOWN && creditLimit > existingLimit) {
     purchaseType = PURCHASE_TYPE.UPGRADE;
   }
 

package/src/domains/credits/application/creditDocumentHelpers.ts

@@ -7,7 +7,16 @@ export function getCreditDocumentOrDefault(
     platform: Platform
 ): UserCreditsDocumentRead {
     if (creditsDoc.exists()) {
-        return creditsDoc.data() as UserCreditsDocumentRead;
+        const raw = creditsDoc.data() as Record<string, unknown>;
+        // Ensure critical fields have safe defaults to prevent NaN/undefined propagation
+        return {
+            ...raw,
+            credits: typeof raw.credits === 'number' && Number.isFinite(raw.credits) ? raw.credits : 0,
+            creditLimit: typeof raw.creditLimit === 'number' && Number.isFinite(raw.creditLimit) ? raw.creditLimit : 0,
+            processedPurchases: Array.isArray(raw.processedPurchases) ? raw.processedPurchases : [],
+            purchaseHistory: Array.isArray(raw.purchaseHistory) ? raw.purchaseHistory : [],
+            isPremium: typeof raw.isPremium === 'boolean' ? raw.isPremium : false,
+        } as UserCreditsDocumentRead;
     }
 
     const now = serverTimestamp() as unknown as FirestoreTimestamp;

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

@@ -11,3 +11,13 @@ export const PURCHASE_ID_PREFIXES = {
 } as const;
 
 export const PROCESSED_PURCHASES_WINDOW = 50;
+
+/** Maximum credits that can be deducted in a single operation. */
+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).
+ */
+export const GLOBAL_TRANSACTION_COLLECTION = 'processedTransactions';

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

@@ -92,6 +92,7 @@ export class CreditsRepository extends BaseRepository {
     willRenew: boolean,
     expirationDate: string | null,
     periodType: string | null,
+    originalTransactionId?: string | null,
   ): Promise<boolean> {
     const db = requireFirestore();
     const creditLimit = calculateCreditLimit(productId, this.config);
@@ -102,6 +103,9 @@ export class CreditsRepository extends BaseRepository {
       willRenew,
       expirationDate,
       periodType,
+      db,
+      userId,
+      originalTransactionId,
     );
   }
 }

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

@@ -43,7 +43,7 @@ function isTransientError(error: unknown): boolean {
 }
 
 export async function initializeCreditsWithRetry(params: InitializeCreditsParams): Promise<CreditsResult> {
-  const { db, ref, config, purchaseId, productId, source, revenueCatData, type = PURCHASE_TYPE.INITIAL } = params;
+  const { db, ref, config, userId, purchaseId, productId, source, revenueCatData, type = PURCHASE_TYPE.INITIAL } = params;
 
   const creditLimit = calculateCreditLimit(productId, config);
   const cfg = { ...config, creditLimit };
@@ -72,7 +72,8 @@ export async function initializeCreditsWithRetry(params: InitializeCreditsParams
           ownershipType: revenueCatData.ownershipType,
           revenueCatUserId: revenueCatData.revenueCatUserId,
           type,
-        }
+        },
+        userId
       );
 
       return {

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

@@ -1,11 +1,12 @@
-import type { DocumentReference, Transaction } from "@umituz/react-native-firebase";
+import type { DocumentReference, Transaction, Firestore } from "@umituz/react-native-firebase";
 import { runTransaction, serverTimestamp } from "@umituz/react-native-firebase";
-import { getDoc, setDoc } from "firebase/firestore";
+import { doc, getDoc, setDoc } from "firebase/firestore";
 import { SUBSCRIPTION_STATUS } from "../../../subscription/core/SubscriptionConstants";
 import { resolveSubscriptionStatus } from "../../../subscription/core/SubscriptionStatus";
 import { toTimestamp } from "../../../../shared/utils/dateConverter";
 import { isPast } from "../../../../utils/dateUtils";
 import { getAppVersion, validatePlatform } from "../../../../utils/appUtils";
+import { GLOBAL_TRANSACTION_COLLECTION } from "../../core/CreditsConstants";
 
 // Fix: was getDoc+setDoc (non-atomic) — now uses runTransaction so concurrent
 // initializeCreditsTransaction and deductCreditsOperation no longer see stale
@@ -76,6 +77,10 @@ export async function syncPremiumMetadata(
  * Recovery: creates a credits document for premium users who don't have one.
  * 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 originalTransactionId 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).
  */
 export async function createRecoveryCreditsDocument(
   ref: DocumentReference,
@@ -84,9 +89,33 @@ export async function createRecoveryCreditsDocument(
   willRenew: boolean,
   expirationDate: string | null,
   periodType: string | null,
+  db?: Firestore,
+  userId?: string,
+  originalTransactionId?: string | null,
 ): Promise<boolean> {
-  const doc = await getDoc(ref);
-  if (doc.exists()) return false;
+  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.
+  if (db && userId && originalTransactionId) {
+    try {
+      const globalRef = doc(db, GLOBAL_TRANSACTION_COLLECTION, originalTransactionId);
+      const globalDoc = await getDoc(globalRef);
+      if (globalDoc.exists()) {
+        const globalData = globalDoc.data();
+        if (globalData?.ownerUserId && globalData.ownerUserId !== userId) {
+          console.warn(
+            `[CreditsWriter] Recovery skipped: transaction ${originalTransactionId} belongs to user ${globalData.ownerUserId}, not ${userId}`
+          );
+          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);
+    }
+  }
 
   const platform = validatePlatform();
   const appVersion = getAppVersion();

package/src/domains/revenuecat/core/types/RevenueCatConfig.ts

@@ -11,7 +11,8 @@ export interface RevenueCatConfig {
     productId?: string,
     expiresAt?: string,
     willRenew?: boolean,
-    periodType?: string
+    periodType?: string,
+    originalTransactionId?: string
   ) => Promise<void> | void;
   onPurchaseCompleted?: (
     userId: string,

package/src/domains/revenuecat/infrastructure/services/UserSwitchMutex.ts

@@ -18,8 +18,10 @@ class UserSwitchMutexImpl {
       }
       try {
         await this.activeSwitchPromise;
-      } catch (_ignored) {
-        // Intentional: waiting for active switch to complete without failing
+      } catch (error) {
+        // Previous switch failed — this is non-fatal for the current switch,
+        // but worth logging so the failure is visible in diagnostics.
+        console.warn('[UserSwitchMutex] Previous user switch failed:', error instanceof Error ? error.message : String(error));
       }
 
       const timeSinceLastSwitch = Date.now() - this.lastSwitchTime;

package/src/domains/revenuecat/infrastructure/services/userSwitchHandler.ts

@@ -5,11 +5,9 @@ import type { InitializerDeps } from "./RevenueCatInitializer.types";
 import { FAILED_INITIALIZATION_RESULT } from "./initializerConstants";
 import { UserSwitchMutex } from "./UserSwitchMutex";
 import { getPremiumEntitlement } from "../../core/types";
-import type { PeriodType } from "../../../subscription/core/SubscriptionConstants";
+import { ANONYMOUS_CACHE_KEY, type PeriodType } from "../../../subscription/core/SubscriptionConstants";
 import { requireFirestore } from "../../../../shared/infrastructure/firestore";
 
-const ANONYMOUS_CACHE_KEY = '__anonymous__';
-
 declare const __DEV__: boolean;
 
 function buildSuccessResult(deps: InitializerDeps, customerInfo: CustomerInfo, offerings: PurchasesOfferings | null): InitializeResult {
@@ -46,8 +44,9 @@ async function syncRevenueCatIdToProfile(firebaseUserId: string, revenueCatUserI
     const db = requireFirestore();
     const userRef = doc(db, "users", firebaseUserId);
     await setDoc(userRef, { revenueCatUserId }, { merge: true });
-  } catch {
+  } catch (error) {
     // Non-fatal: profile update failure should not block SDK initialization
+    console.warn('[UserSwitchHandler] Failed to sync RevenueCat ID to profile:', error instanceof Error ? error.message : String(error));
   }
 }
 
@@ -211,13 +210,17 @@ export async function handleInitialConfiguration(
         );
 
         if (premiumEntitlement) {
+          const subscription = customerInfo.subscriptionsByProductIdentifier?.[premiumEntitlement.productIdentifier];
+          const originalTransactionId = subscription?.storeTransactionId ?? undefined;
+
           await deps.config.onPremiumStatusChanged(
             normalizedUserId,
             true,
             premiumEntitlement.productIdentifier,
             premiumEntitlement.expirationDate ?? undefined,
             premiumEntitlement.willRenew,
-            premiumEntitlement.periodType as PeriodType | undefined
+            premiumEntitlement.periodType as PeriodType | undefined,
+            originalTransactionId
           );
         } else {
           await deps.config.onPremiumStatusChanged(
@@ -226,6 +229,7 @@ export async function handleInitialConfiguration(
             undefined,
             undefined,
             undefined,
+            undefined,
             undefined
           );
         }

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

@@ -27,14 +27,14 @@ export class SubscriptionSyncProcessor {
 
   private async getCreditsUserId(revenueCatUserId: string | null | undefined): Promise<string> {
     const trimmed = revenueCatUserId?.trim();
-    if (trimmed && trimmed.length > 0) {
+    if (trimmed && trimmed.length > 0 && trimmed !== 'undefined' && trimmed !== 'null') {
       return trimmed;
     }
 
     console.warn("[SubscriptionSyncProcessor] revenueCatUserId is empty/null, falling back to anonymousUserId");
     const anonymousId = await this.getAnonymousUserId();
     const trimmedAnonymous = anonymousId?.trim();
-    if (!trimmedAnonymous || trimmedAnonymous.length === 0) {
+    if (!trimmedAnonymous || trimmedAnonymous.length === 0 || trimmedAnonymous === 'undefined' || trimmedAnonymous === 'null') {
       throw new Error("[SubscriptionSyncProcessor] Cannot resolve credits userId: both revenueCatUserId and anonymousUserId are empty");
     }
     return trimmedAnonymous;
@@ -106,7 +106,8 @@ export class SubscriptionSyncProcessor {
     productId?: string,
     expiresAt?: string,
     willRenew?: boolean,
-    periodType?: PeriodType
+    periodType?: PeriodType,
+    originalTransactionId?: string
   ) {
     // If a purchase is in progress, skip metadata sync (purchase handler does it)
     // but still allow recovery to run — the purchase handler's credit initialization
@@ -123,7 +124,12 @@ export class SubscriptionSyncProcessor {
           productId,
           expiresAt ?? null,
           willRenew ?? false,
-          periodType ?? null
+          periodType ?? null,
+          undefined,
+          undefined,
+          undefined,
+          undefined,
+          originalTransactionId
         );
       }
       return;
@@ -157,7 +163,12 @@ export class SubscriptionSyncProcessor {
       productId,
       expiresAt ?? null,
       willRenew ?? false,
-      periodType ?? null
+      periodType ?? null,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      originalTransactionId
     );
   }
 }

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

@@ -49,10 +49,11 @@ export class SubscriptionSyncService {
     productId?: string,
     expiresAt?: string,
     willRenew?: boolean,
-    periodType?: PeriodType
+    periodType?: PeriodType,
+    originalTransactionId?: string
   ) {
     try {
-      await this.processor.processStatusChange(userId, isPremium, productId, expiresAt, willRenew, periodType);
+      await this.processor.processStatusChange(userId, isPremium, productId, expiresAt, willRenew, periodType, originalTransactionId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, { userId, isPremium });
     } catch (error) {
       console.error('[SubscriptionSyncService] Status change processing failed', {

package/src/domains/subscription/application/initializer/ServiceConfigurator.ts

@@ -48,10 +48,11 @@ export function configureServices(config: SubscriptionInitConfig, apiKey: string
         pId?: string,
         exp?: string,
         willR?: boolean,
-        pt?: string
+        pt?: string,
+        txnId?: string
       ) => {
         const validPeriodType = pt && Object.values(PERIOD_TYPE).includes(pt as PeriodType) ? pt as PeriodType : undefined;
-        return syncService.handlePremiumStatusChanged(u, isP, pId, exp, willR, validPeriodType);
+        return syncService.handlePremiumStatusChanged(u, isP, pId, exp, willR, validPeriodType, txnId);
       },
       onCreditsUpdated,
     },

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

@@ -17,12 +17,15 @@ export const handlePremiumStatusSync = async (
   unsubscribeDetectedAt?: string | null,
   billingIssueDetectedAt?: string | null,
   store?: string | null,
-  ownershipType?: string | null
+  ownershipType?: string | null,
+  originalTransactionId?: string
 ): Promise<void> => {
   const repo = getCreditsRepository();
 
   // Recovery: if premium user has no credits document, create one.
   // Handles edge cases like test store, reinstalls, or failed purchase initialization.
+  // The originalTransactionId is passed for cross-user deduplication: if this
+  // transaction was already processed by another UID, recovery is skipped.
   if (isPremium) {
     const created = await repo.ensurePremiumCreditsExist(
       userId,
@@ -30,6 +33,7 @@ export const handlePremiumStatusSync = async (
       willRenew,
       expiresAt,
       periodType,
+      originalTransactionId,
     );
     if (__DEV__ && created) {
       console.log('[handlePremiumStatusSync] Recovery: created missing credits document for premium user', { userId, productId });

package/src/domains/subscription/core/SubscriptionConstants.ts

@@ -57,3 +57,5 @@ export const PURCHASE_TYPE = {
 } as const;
 
 export type PurchaseType = (typeof PURCHASE_TYPE)[keyof typeof PURCHASE_TYPE];
+
+export const ANONYMOUS_CACHE_KEY = '__anonymous__';

package/src/domains/subscription/infrastructure/managers/SubscriptionManager.ts

@@ -9,8 +9,7 @@ import { checkPremiumStatusFromService } from "./premiumStatusChecker";
 import { getPackagesOperation, purchasePackageOperation, restoreOperation } from "./managerOperations";
 import { performServiceInitialization } from "./initializationHandler";
 import { initializationState } from "../state/initializationState";
-
-const ANONYMOUS_CACHE_KEY = '__anonymous__';
+import { ANONYMOUS_CACHE_KEY } from "../../core/SubscriptionConstants";
 
 class SubscriptionManagerImpl {
   private managerConfig: SubscriptionManagerConfig | null = null;

package/src/domains/subscription/infrastructure/utils/PremiumStatusSyncer.ts

@@ -28,16 +28,20 @@ export async function syncPremiumStatus(
 
     try {
         if (premiumEntitlement) {
+            const subscription = customerInfo.subscriptionsByProductIdentifier?.[premiumEntitlement.productIdentifier];
+            const originalTransactionId = subscription?.storeTransactionId ?? undefined;
+
             await config.onPremiumStatusChanged(
                 userId,
                 true,
                 premiumEntitlement.productIdentifier,
                 premiumEntitlement.expirationDate ?? undefined,
                 premiumEntitlement.willRenew,
-                premiumEntitlement.periodType as "NORMAL" | "INTRO" | undefined
+                premiumEntitlement.periodType as "NORMAL" | "INTRO" | undefined,
+                originalTransactionId
             );
         } else {
-            await config.onPremiumStatusChanged(userId, false, undefined, undefined, undefined, undefined);
+            await config.onPremiumStatusChanged(userId, false, undefined, undefined, undefined, undefined, undefined);
         }
         return { success: true };
     } catch (error) {

package/src/domains/subscription/presentation/screens/components/SubscriptionHeader.types.ts

@@ -25,6 +25,10 @@ export interface SubscriptionHeaderProps {
     latestPurchaseDateLabel?: string;
     billingIssuesLabel?: string;
     sandboxLabel?: string;
+    willRenewYes?: string;
+    willRenewNo?: string;
+    billingIssuesDetected?: string;
+    sandboxTestMode?: string;
   };
   // Additional RevenueCat subscription details
   willRenew?: boolean | null;

package/src/domains/subscription/presentation/screens/components/SubscriptionHeaderContent.tsx

@@ -67,7 +67,7 @@ export const SubscriptionHeaderContent: React.FC<SubscriptionHeaderContentProps>
     {willRenew !== null && willRenew !== undefined && translations.willRenewLabel && (
       <DetailRow
         label={translations.willRenewLabel}
-        value={willRenew ? "Yes" : "No"}
+        value={willRenew ? (translations.willRenewYes ?? "Yes") : (translations.willRenewNo ?? "No")}
         highlight={!willRenew}
         style={styles.row}
         labelStyle={styles.label}
@@ -113,7 +113,7 @@ export const SubscriptionHeaderContent: React.FC<SubscriptionHeaderContentProps>
     {billingIssuesDetected && translations.billingIssuesLabel && (
       <DetailRow
         label={translations.billingIssuesLabel}
-        value="Detected"
+        value={translations.billingIssuesDetected ?? "Detected"}
         highlight={true}
         style={styles.row}
         labelStyle={styles.label}
@@ -123,7 +123,7 @@ export const SubscriptionHeaderContent: React.FC<SubscriptionHeaderContentProps>
     {typeof __DEV__ !== 'undefined' && __DEV__ && isSandbox && translations.sandboxLabel && (
       <DetailRow
         label={translations.sandboxLabel}
-        value="Test Mode"
+        value={translations.sandboxTestMode ?? "Test Mode"}
         style={styles.row}
         labelStyle={styles.label}
         valueStyle={styles.value}