@umituz/react-native-subscription 2.22.3 → 2.22.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.22.3",
+  "version": "2.22.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/repositories/CreditsRepository.ts

@@ -2,6 +2,8 @@
  * Credits Repository
  */
 
+declare const __DEV__: boolean;
+
 import { doc, getDoc, runTransaction, serverTimestamp, type Firestore, type Transaction } from "firebase/firestore";
 import { BaseRepository, getFirestore } from "@umituz/react-native-firebase";
 import type { CreditsConfig, CreditsResult, DeductCreditsResult } from "../../domain/entities/Credits";
@@ -23,13 +25,26 @@ export class CreditsRepository extends BaseRepository {
 
   async getCredits(userId: string): Promise<CreditsResult> {
     const db = getFirestore();
-    if (!db) return { success: false, error: { message: "No DB", code: "DB_ERR" } };
+    if (!db) {
+      if (__DEV__) console.log("[CreditsRepository] No Firestore instance");
+      return { success: false, error: { message: "No DB", code: "DB_ERR" } };
+    }
     try {
-      const snap = await getDoc(this.getRef(db, userId));
-      if (!snap.exists()) return { success: true, data: undefined };
+      const ref = this.getRef(db, userId);
+      if (__DEV__) console.log("[CreditsRepository] Fetching credits:", { userId: userId.slice(0, 8), path: ref.path });
+      const snap = await getDoc(ref);
+      if (!snap.exists()) {
+        if (__DEV__) console.log("[CreditsRepository] No credits document found");
+        return { success: true, data: undefined };
+      }
       const d = snap.data() as UserCreditsDocumentRead;
-      return { success: true, data: CreditsMapper.toEntity(d) };
-    } catch (e: any) { return { success: false, error: { message: e.message, code: "FETCH_ERR" } }; }
+      const entity = CreditsMapper.toEntity(d);
+      if (__DEV__) console.log("[CreditsRepository] Credits fetched:", { credits: entity.credits, limit: entity.creditLimit });
+      return { success: true, data: entity };
+    } catch (e: any) {
+      if (__DEV__) console.error("[CreditsRepository] Fetch error:", e.message);
+      return { success: false, error: { message: e.message, code: "FETCH_ERR" } };
+    }
   }
 
   async initializeCredits(

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -61,8 +61,30 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
     }
   };
 
+  const onRenewal = async (userId: string, productId: string, _newExpirationDate: string, _customerInfo: unknown) => {
+    if (__DEV__) {
+      console.log('[SubscriptionInitializer] onRenewal called:', { userId, productId });
+    }
+    try {
+      const result = await getCreditsRepository().initializeCredits(
+        userId,
+        `renewal_${productId}_${Date.now()}`,
+        productId,
+        "renewal" as any
+      );
+      if (__DEV__) {
+        console.log('[SubscriptionInitializer] Credits reset on renewal:', result);
+      }
+      onCreditsUpdated?.(userId);
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[SubscriptionInitializer] Renewal credits init failed:', error);
+      }
+    }
+  };
+
   SubscriptionManager.configure({
-    config: { apiKey: key, testStoreKey, entitlementIdentifier: entitlementId, consumableProductIdentifiers: [creditPackages?.identifierPattern || "credit"], onPurchaseCompleted: onPurchase, onCreditsUpdated },
+    config: { apiKey: key, testStoreKey, entitlementIdentifier: entitlementId, consumableProductIdentifiers: [creditPackages?.identifierPattern || "credit"], onPurchaseCompleted: onPurchase, onRenewalDetected: onRenewal, onCreditsUpdated },
     apiKey: key, getAnonymousUserId
   });
 

package/src/presentation/hooks/useCredits.ts

@@ -5,6 +5,8 @@
  * Generic and reusable - uses config from module-level provider.
  */
 
+declare const __DEV__: boolean;
+
 import { useQuery } from "@tanstack/react-query";
 import { useCallback, useMemo } from "react";
 import type { UserCredits } from "../../domain/entities/Credits";
@@ -61,18 +63,35 @@ export const useCredits = ({
   const staleTime = cache?.staleTime ?? DEFAULT_STALE_TIME;
   const gcTime = cache?.gcTime ?? DEFAULT_GC_TIME;
 
+  const queryEnabled = enabled && !!userId && isConfigured;
+
+  if (__DEV__) {
+    console.log("[useCredits] Query state:", {
+      userId: userId?.slice(0, 8),
+      enabled,
+      isConfigured,
+      queryEnabled,
+    });
+  }
+
   const { data, isLoading, error, refetch } = useQuery({
     queryKey: creditsQueryKeys.user(userId ?? ""),
     queryFn: async () => {
-      if (!userId || !isConfigured) return null;
+      if (!userId || !isConfigured) {
+        if (__DEV__) console.log("[useCredits] Query skipped:", { hasUserId: !!userId, isConfigured });
+        return null;
+      }
+      if (__DEV__) console.log("[useCredits] Executing queryFn for userId:", userId.slice(0, 8));
       const repository = getCreditsRepository();
       const result = await repository.getCredits(userId);
       if (!result.success) {
+        if (__DEV__) console.error("[useCredits] Query failed:", result.error?.message);
         throw new Error(result.error?.message || "Failed to fetch credits");
       }
+      if (__DEV__) console.log("[useCredits] Query success:", { hasData: !!result.data, credits: result.data?.credits });
       return result.data || null;
     },
-    enabled: enabled && !!userId && isConfigured,
+    enabled: queryEnabled,
     staleTime,
     gcTime,
     refetchOnMount: true, // Refetch when component mounts

package/src/revenuecat/domain/value-objects/RevenueCatConfig.ts

@@ -34,6 +34,13 @@ export interface RevenueCatConfig {
     isPremium: boolean,
     customerInfo: CustomerInfo
   ) => Promise<void> | void;
+  /** Callback when subscription renewal is detected */
+  onRenewalDetected?: (
+    userId: string,
+    productId: string,
+    newExpirationDate: string,
+    customerInfo: CustomerInfo
+  ) => Promise<void> | void;
   /** Callback after credits are successfully updated (for cache invalidation) */
   onCreditsUpdated?: (userId: string) => void;
 }

package/src/revenuecat/infrastructure/services/CustomerInfoListenerManager.ts

@@ -1,6 +1,6 @@
 /**
  * Customer Info Listener Manager
- * Handles RevenueCat customer info update listeners
+ * Handles RevenueCat customer info update listeners with renewal detection
  */
 
 import Purchases, {
@@ -9,10 +9,21 @@ import Purchases, {
 } from "react-native-purchases";
 import type { RevenueCatConfig } from "../../domain/value-objects/RevenueCatConfig";
 import { syncPremiumStatus } from "../utils/PremiumStatusSyncer";
+import {
+    detectRenewal,
+    updateRenewalState,
+    type RenewalState,
+} from "../utils/RenewalDetector";
+
+declare const __DEV__: boolean;
 
 export class CustomerInfoListenerManager {
     private listener: CustomerInfoUpdateListener | null = null;
     private currentUserId: string | null = null;
+    private renewalState: RenewalState = {
+        previousExpirationDate: null,
+        previousProductId: null,
+    };
 
     setUserId(userId: string): void {
         this.currentUserId = userId;
@@ -20,6 +31,10 @@ export class CustomerInfoListenerManager {
 
     clearUserId(): void {
         this.currentUserId = null;
+        this.renewalState = {
+            previousExpirationDate: null,
+            previousProductId: null,
+        };
     }
 
     setupListener(config: RevenueCatConfig): void {
@@ -30,6 +45,37 @@ export class CustomerInfoListenerManager {
                 return;
             }
 
+            const renewalResult = detectRenewal(
+                this.renewalState,
+                customerInfo,
+                config.entitlementIdentifier
+            );
+
+            if (renewalResult.isRenewal && config.onRenewalDetected) {
+                if (__DEV__) {
+                    console.log("[CustomerInfoListener] Renewal detected:", {
+                        userId: this.currentUserId,
+                        productId: renewalResult.productId,
+                        newExpiration: renewalResult.newExpirationDate,
+                    });
+                }
+
+                try {
+                    await config.onRenewalDetected(
+                        this.currentUserId,
+                        renewalResult.productId!,
+                        renewalResult.newExpirationDate!,
+                        customerInfo
+                    );
+                } catch (error) {
+                    if (__DEV__) {
+                        console.error("[CustomerInfoListener] Renewal callback failed:", error);
+                    }
+                }
+            }
+
+            this.renewalState = updateRenewalState(this.renewalState, renewalResult);
+
             syncPremiumStatus(config, this.currentUserId, customerInfo);
         };
 

package/src/revenuecat/infrastructure/utils/RenewalDetector.ts

@@ -0,0 +1,83 @@
+/**
+ * Renewal Detector
+ * Detects subscription renewals by tracking expiration date changes
+ * Best Practice: Compare expiration dates to detect renewal events
+ */
+
+import type { CustomerInfo } from "react-native-purchases";
+
+export interface RenewalState {
+  previousExpirationDate: string | null;
+  previousProductId: string | null;
+}
+
+export interface RenewalDetectionResult {
+  isRenewal: boolean;
+  productId: string | null;
+  newExpirationDate: string | null;
+}
+
+/**
+ * Detects if a subscription renewal occurred
+ *
+ * Best Practice (RevenueCat):
+ * - Track previous expiration date
+ * - If new expiration > previous → Renewal detected
+ * - Reset credits on renewal (industry standard)
+ *
+ * @param state Previous state (expiration date, product ID)
+ * @param customerInfo Current CustomerInfo from RevenueCat
+ * @param entitlementId Entitlement identifier to check
+ * @returns Renewal detection result
+ */
+export function detectRenewal(
+  state: RenewalState,
+  customerInfo: CustomerInfo,
+  entitlementId: string
+): RenewalDetectionResult {
+  const entitlement = customerInfo.entitlements.active[entitlementId];
+
+  if (!entitlement) {
+    return {
+      isRenewal: false,
+      productId: null,
+      newExpirationDate: null,
+    };
+  }
+
+  const newExpirationDate = entitlement.expirationDate;
+  const productId = entitlement.productIdentifier;
+
+  if (!newExpirationDate || !state.previousExpirationDate) {
+    return {
+      isRenewal: false,
+      productId,
+      newExpirationDate,
+    };
+  }
+
+  const newExpiration = new Date(newExpirationDate);
+  const previousExpiration = new Date(state.previousExpirationDate);
+
+  const isRenewal = newExpiration > previousExpiration &&
+                    productId === state.previousProductId;
+
+  return {
+    isRenewal,
+    productId,
+    newExpirationDate,
+  };
+}
+
+/**
+ * Updates renewal state after detection
+ */
+export function updateRenewalState(
+  _state: RenewalState,
+  result: RenewalDetectionResult
+): RenewalState {
+  return {
+    previousExpirationDate: result.newExpirationDate,
+    previousProductId: result.productId,
+  };
+}