@umituz/react-native-subscription 2.37.10 → 2.37.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.37.10",
+  "version": "2.37.12",
   "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/creditOperationUtils.ts

@@ -77,6 +77,27 @@ export function buildCreditsData({
   };
 }
 
+/**
+ * Compare two Firestore Timestamp-like values by their underlying time.
+ * Handles Timestamp objects (with toMillis/seconds+nanoseconds), null, and undefined.
+ */
+function timestampsEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (a == null || b == null) return a == b;
+  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+    if ("toMillis" in a && "toMillis" in b &&
+        typeof (a as { toMillis: unknown }).toMillis === "function" &&
+        typeof (b as { toMillis: unknown }).toMillis === "function") {
+      return (a as { toMillis: () => number }).toMillis() === (b as { toMillis: () => number }).toMillis();
+    }
+    if ("seconds" in a && "seconds" in b && "nanoseconds" in a && "nanoseconds" in b) {
+      return (a as { seconds: number; nanoseconds: number }).seconds === (b as { seconds: number; nanoseconds: number }).seconds &&
+             (a as { seconds: number; nanoseconds: number }).nanoseconds === (b as { seconds: number; nanoseconds: number }).nanoseconds;
+    }
+  }
+  return false;
+}
+
 export function shouldSkipStatusSyncWrite(
   purchaseId: string,
   existingData: any,
@@ -92,7 +113,7 @@ export function shouldSkipStatusSyncWrite(
     existingData.creditLimit === newCreditsData.creditLimit &&
     existingData.productId === newCreditsData.productId &&
     existingData.willRenew === newCreditsData.willRenew &&
-    existingData.expirationDate === newCreditsData.expirationDate &&
-    existingData.canceledAt === newCreditsData.canceledAt &&
-    existingData.billingIssueDetectedAt === newCreditsData.billingIssueDetectedAt;
+    timestampsEqual(existingData.expirationDate, newCreditsData.expirationDate) &&
+    timestampsEqual(existingData.canceledAt, newCreditsData.canceledAt) &&
+    timestampsEqual(existingData.billingIssueDetectedAt, newCreditsData.billingIssueDetectedAt);
 }

package/src/domains/credits/presentation/deduct-credit/useDeductCredit.ts

@@ -1,4 +1,4 @@
-import { useCallback } from "react";
+import { useCallback, useRef } from "react";
 import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
 import { getCreditsRepository } from "../../infrastructure/CreditsRepositoryManager";
 import type { UseDeductCreditParams, UseDeductCreditResult } from "./types";
@@ -17,9 +17,13 @@ export const useDeductCredit = ({
     createDeductCreditMutationConfig(userId, repository, queryClient)
   );
 
+  // Use ref for stable reference to mutateAsync — avoids re-creating callbacks every render
+  const mutateAsyncRef = useRef(mutation.mutateAsync);
+  mutateAsyncRef.current = mutation.mutateAsync;
+
   const deductCredit = useCallback(async (cost: number = 1): Promise<boolean> => {
     try {
-      const res = await mutation.mutateAsync(cost);
+      const res = await mutateAsyncRef.current(cost);
       if (!res.success) {
         if (res.error?.code === "CREDITS_EXHAUSTED") {
           onCreditsExhausted?.();
@@ -35,7 +39,7 @@ export const useDeductCredit = ({
       });
       throw error;
     }
-  }, [mutation, onCreditsExhausted, userId]);
+  }, [onCreditsExhausted, userId]);
 
   const deductCredits = useCallback(async (cost: number): Promise<boolean> => {
     return await deductCredit(cost);

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

@@ -40,15 +40,19 @@ export class ConfigurationStateManager {
   completeConfiguration(success: boolean): void {
     this._isPurchasesConfigured = success;
 
-    // Cleanup promise state immediately (no setTimeout)
-    // If promise hasn't resolved yet, that's fine - it will still resolve via the callback
-    if (this._configurationPromise) {
-      this._configurationPromise = null;
-    }
+    // Note: Do NOT null _configurationPromise here.
+    // The promise is resolved externally via resolveConfig() in RevenueCatInitializer.
+    // Nulling it before resolution creates a race where concurrent callers
+    // see isConfiguring=false and start a duplicate SDK configuration.
+    // The promise is cleaned up in the next startConfiguration() or reset() call.
+    // We only clear the resolve function since it's no longer needed.
+    this._resolveConfiguration = null;
+  }
 
-    // Clear resolve function if it still exists
-    if (this._resolveConfiguration) {
-      this._resolveConfiguration = null;
+  /** Called after resolveConfig() to clean up the completed promise */
+  clearCompletedConfiguration(): void {
+    if (this._isPurchasesConfigured || !this._resolveConfiguration) {
+      this._configurationPromise = null;
     }
   }
 

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

@@ -72,5 +72,7 @@ export async function initializeSDK(
   const result = await handleInitialConfiguration(deps, userId, key);
   configState.completeConfiguration(result.success);
   resolveConfig(result);
+  // Clean up the resolved promise so future callers don't await a stale promise
+  configState.clearCompletedConfiguration();
   return result;
 }

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

@@ -37,7 +37,9 @@ export async function startBackgroundInitialization(config: SubscriptionInitConf
         await initializeInBackground(revenueCatUserId);
         lastUserId = revenueCatUserId;
       } catch (error) {
-        // Background re-initialization errors are non-critical, already logged by SubscriptionManager
+        // Don't update lastUserId on failure — allow retry on next auth state change
+        // with the same userId (e.g., network blip recovers)
+        lastUserId = undefined;
         console.error('[BackgroundInitializer] Reinitialization failed:', {
           userId: revenueCatUserId,
           error: error instanceof Error ? error.message : String(error)