@umituz/react-native-subscription 2.22.8 → 2.22.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.22.8",
+  "version": "2.22.10",
   "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/mappers/CreditsMapper.ts

@@ -1,20 +1,22 @@
 import type { UserCredits, SubscriptionStatus } from "../../domain/entities/Credits";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 
-/** Maps Firestore document to domain entity */
+/** Maps Firestore document to domain entity with expiration validation */
 export class CreditsMapper {
   static toEntity(doc: UserCreditsDocumentRead): UserCredits {
-    // Determine status from document or derive from isPremium/expirationDate
-    const status = doc.status ?? CreditsMapper.deriveStatus(doc);
+    const expirationDate = doc.expirationDate?.toDate?.() ?? null;
+
+    // Validate isPremium against expirationDate (real-time check)
+    const { isPremium, status } = CreditsMapper.validateSubscription(doc, expirationDate);
 
     return {
-      // Core subscription
-      isPremium: doc.isPremium ?? false,
+      // Core subscription (validated)
+      isPremium,
       status,
 
       // Dates
       purchasedAt: doc.purchasedAt?.toDate?.() ?? null,
-      expirationDate: doc.expirationDate?.toDate?.() ?? null,
+      expirationDate,
       lastUpdatedAt: doc.lastUpdatedAt?.toDate?.() ?? null,
 
       // RevenueCat details
@@ -35,14 +37,33 @@ export class CreditsMapper {
     };
   }
 
-  /** Derive status from isPremium and expirationDate for backward compatibility */
-  private static deriveStatus(doc: UserCreditsDocumentRead): SubscriptionStatus {
-    if (!doc.isPremium && !doc.expirationDate) return "free";
-    if (doc.isPremium) return "active";
-    if (doc.expirationDate) {
-      const expDate = doc.expirationDate.toDate?.();
-      if (expDate && expDate < new Date()) return "expired";
+  /** Validate subscription status against expirationDate */
+  private static validateSubscription(
+    doc: UserCreditsDocumentRead,
+    expirationDate: Date | null
+  ): { isPremium: boolean; status: SubscriptionStatus } {
+    const docIsPremium = doc.isPremium ?? false;
+
+    // No expiration date = lifetime or free
+    if (!expirationDate) {
+      return {
+        isPremium: docIsPremium,
+        status: docIsPremium ? "active" : "free",
+      };
+    }
+
+    // Check if subscription has expired
+    const isExpired = expirationDate < new Date();
+
+    if (isExpired) {
+      // Subscription expired - override document's isPremium
+      return { isPremium: false, status: "expired" };
     }
-    return "free";
+
+    // Subscription still active
+    return {
+      isPremium: docIsPremium,
+      status: docIsPremium ? "active" : "free",
+    };
   }
 }

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -129,6 +129,25 @@ export class CreditsRepository extends BaseRepository {
     const res = await this.getCredits(userId);
     return !!(res.success && res.data && res.data.credits >= cost);
   }
+
+  /** Sync expired subscription status to Firestore (background) */
+  async syncExpiredStatus(userId: string): Promise<void> {
+    const db = getFirestore();
+    if (!db) return;
+
+    try {
+      const ref = this.getRef(db, userId);
+      const { updateDoc } = await import("firebase/firestore");
+      await updateDoc(ref, {
+        isPremium: false,
+        status: "expired",
+        lastUpdatedAt: serverTimestamp(),
+      });
+      if (__DEV__) console.log("[CreditsRepository] Synced expired status for:", userId.slice(0, 8));
+    } catch (e) {
+      if (__DEV__) console.error("[CreditsRepository] Sync expired failed:", e);
+    }
+  }
 }
 
 export const createCreditsRepository = (c: CreditsConfig) => new CreditsRepository(c);

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -41,16 +41,31 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
 
   configureCreditsRepository({ ...credits, creditPackageAmounts: creditPackages?.amounts });
 
-  const onPurchase = async (userId: string, productId: string, _customerInfo: unknown, source?: string) => {
+  /** Extract RevenueCat data from CustomerInfo (Single Source of Truth) */
+  const extractRevenueCatData = (customerInfo: CustomerInfo, _productId: string): RevenueCatData => {
+    const entitlement = customerInfo.entitlements.active[entitlementId]
+      ?? customerInfo.entitlements.all[entitlementId];
+
+    return {
+      expirationDate: entitlement?.expirationDate ?? customerInfo.latestExpirationDate ?? null,
+      willRenew: entitlement?.willRenew ?? false,
+      originalTransactionId: entitlement?.originalPurchaseDate ?? undefined,
+      isPremium: Object.keys(customerInfo.entitlements.active).length > 0,
+    };
+  };
+
+  const onPurchase = async (userId: string, productId: string, customerInfo: CustomerInfo, source?: string) => {
     if (__DEV__) {
       console.log('[SubscriptionInitializer] onPurchase called:', { userId, productId, source });
     }
     try {
+      const revenueCatData = extractRevenueCatData(customerInfo, productId);
       const result = await getCreditsRepository().initializeCredits(
         userId,
         `purchase_${productId}_${Date.now()}`,
         productId,
-        source as any
+        source as any,
+        revenueCatData
       );
       if (__DEV__) {
         console.log('[SubscriptionInitializer] Credits initialized:', result);
@@ -63,16 +78,20 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
     }
   };
 
-  const onRenewal = async (userId: string, productId: string, _newExpirationDate: string, _customerInfo: unknown) => {
+  const onRenewal = async (userId: string, productId: string, newExpirationDate: string, customerInfo: CustomerInfo) => {
     if (__DEV__) {
       console.log('[SubscriptionInitializer] onRenewal called:', { userId, productId });
     }
     try {
+      const revenueCatData = extractRevenueCatData(customerInfo, productId);
+      // Update expiration date from renewal
+      revenueCatData.expirationDate = newExpirationDate || revenueCatData.expirationDate;
       const result = await getCreditsRepository().initializeCredits(
         userId,
         `renewal_${productId}_${Date.now()}`,
         productId,
-        "renewal" as any
+        "renewal" as any,
+        revenueCatData
       );
       if (__DEV__) {
         console.log('[SubscriptionInitializer] Credits reset on renewal:', result);

package/src/presentation/hooks/useCredits.ts

@@ -88,15 +88,22 @@ export const useCredits = ({
         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 });
+
+      // Background sync: If mapper detected expired status, sync to Firestore
+      if (result.data?.status === "expired") {
+        if (__DEV__) console.log("[useCredits] Detected expired subscription, syncing...");
+        repository.syncExpiredStatus(userId).catch(() => {});
+      }
+
+      if (__DEV__) console.log("[useCredits] Query success:", { hasData: !!result.data, credits: result.data?.credits, status: result.data?.status });
       return result.data || null;
     },
     enabled: queryEnabled,
     staleTime,
     gcTime,
-    refetchOnMount: true, // Refetch when component mounts
-    refetchOnWindowFocus: true, // Refetch when app becomes active
-    refetchOnReconnect: true, // Refetch when network reconnects
+    refetchOnMount: true,
+    refetchOnWindowFocus: true,
+    refetchOnReconnect: true,
   });
 
   const credits = data ?? null;

package/src/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -1,21 +1,16 @@
 /**
  * useSubscriptionSettingsConfig Hook
  * Returns ready-to-use config for settings screens
- * Package-driven: all logic handled internally
+ * Single Source of Truth: Firestore (credits document)
  */
 
 import { useMemo, useCallback } from "react";
 import { useCredits } from "./useCredits";
-import { useSubscriptionStatus } from "./useSubscriptionStatus";
-import { useCustomerInfo } from "../../revenuecat/presentation/hooks/useCustomerInfo";
 import { usePaywallVisibility } from "./usePaywallVisibility";
 import { calculateDaysRemaining } from "../../domain/entities/SubscriptionStatus";
-import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
-import { formatDate, convertPurchasedAt } from "../utils/subscriptionDateUtils";
+import { formatDate } from "../utils/subscriptionDateUtils";
 import { useCreditsArray, getSubscriptionStatusType } from "./useSubscriptionSettingsConfig.utils";
 import { getCreditsConfig } from "../../infrastructure/repositories/CreditsRepositoryProvider";
-import { detectPackageType } from "../../utils/packageTypeDetector";
-import { getCreditAllocation } from "../../utils/creditMapper";
 import type {
   SubscriptionSettingsConfig,
   SubscriptionStatusType,
@@ -31,105 +26,53 @@ export type {
 
 /**
  * Hook that returns ready-to-use subscription config for settings
- * All business logic handled internally
+ * Single Source of Truth: Firestore credits document
  */
 export const useSubscriptionSettingsConfig = (
   params: UseSubscriptionSettingsConfigParams
 ): SubscriptionSettingsConfig => {
-  const {
-    userId,
-    translations,
-    creditLimit,
-    upgradePrompt,
-  } = params;
+  const { userId, translations, creditLimit, upgradePrompt } = params;
 
-  // Internal hooks
+  // Single Source of Truth: Firestore credits document
   const { credits } = useCredits({ userId, enabled: !!userId });
-  const {
-    isPremium: subscriptionActive,
-    expirationDate: statusExpirationDate,
-  } = useSubscriptionStatus({
-    userId,
-    enabled: !!userId,
-  });
-  const { customerInfo } = useCustomerInfo();
   const { openPaywall } = usePaywallVisibility();
 
   const handleOpenPaywall = useCallback(() => {
     openPaywall("settings");
   }, [openPaywall]);
 
-  // RevenueCat entitlement info - dynamically using configured entitlementId
-  const entitlementId = SubscriptionManager.getEntitlementId() || "premium";
-  const activeEntitlement = customerInfo?.entitlements.active[entitlementId];
-  const allEntitlement = customerInfo?.entitlements.all[entitlementId];
+  // All data from Firestore (Single Source of Truth)
+  const isPremium = credits?.isPremium ?? false;
+  const willRenew = credits?.willRenew ?? false;
 
-  // Premium status: only active entitlements count as premium
-  const isPremium = !!activeEntitlement || subscriptionActive;
+  // Expiration date from Firestore
+  const expiresAtIso = credits?.expirationDate?.toISOString() ?? null;
 
+  // Purchase date from Firestore
+  const purchasedAtIso = credits?.purchasedAt?.toISOString() ?? null;
+
+  // Credit limit from Firestore or config fallback
   const dynamicCreditLimit = useMemo(() => {
+    if (credits?.creditLimit) return credits.creditLimit;
     const config = getCreditsConfig();
-
-    // 1. ÖNCE FIRESTORE'DAN OKU (Single Source of Truth)
-    if (credits?.creditLimit) {
-      return credits.creditLimit;
-    }
-
-    // 2. FALLBACK: RevenueCat'ten detect et
-    if (activeEntitlement?.productIdentifier) {
-      const packageType = detectPackageType(activeEntitlement.productIdentifier);
-      const allocation = getCreditAllocation(packageType, config.packageAllocations);
-      if (allocation !== null) return allocation;
-    }
-
-    // 3. LAST RESORT: Credit miktarına bakarak tahmin et
-    if (credits?.credits && config.packageAllocations) {
-      const currentCredits = credits.credits;
-      const allocations = Object.values(config.packageAllocations).map(a => a.credits);
-      const closest = allocations.find(a => a >= currentCredits) || Math.max(...allocations);
-      return closest;
-    }
-
-    // 4. FINAL FALLBACK: Config'den al
     return creditLimit ?? config.creditLimit;
-  }, [credits?.creditLimit, credits?.credits, activeEntitlement?.productIdentifier, creditLimit]);
-
-  // Get expiration date with fallback chain (supports expired subscriptions)
-  // 1. Active entitlement (current subscription)
-  // 2. All entitlements (includes expired subscriptions)
-  // 3. latestExpirationDate from CustomerInfo
-  // 4. Status from Firestore
-  const expiresAtIso = activeEntitlement?.expirationDate
-    ?? allEntitlement?.expirationDate
-    ?? customerInfo?.latestExpirationDate
-    ?? (statusExpirationDate ? statusExpirationDate.toISOString() : null);
-
-  const willRenew = activeEntitlement?.willRenew || false;
-  const purchasedAtIso = convertPurchasedAt(credits?.purchasedAt);
+  }, [credits?.creditLimit, creditLimit]);
 
   // Formatted dates
-  const formattedExpirationDate = useMemo(
-    () => formatDate(expiresAtIso),
-    [expiresAtIso]
-  );
-
-  const formattedPurchaseDate = useMemo(
-    () => formatDate(purchasedAtIso),
-    [purchasedAtIso]
-  );
+  const formattedExpirationDate = useMemo(() => formatDate(expiresAtIso), [expiresAtIso]);
+  const formattedPurchaseDate = useMemo(() => formatDate(purchasedAtIso), [purchasedAtIso]);
 
-  // Days remaining calculation
-  const daysRemaining = useMemo(
-    () => calculateDaysRemaining(expiresAtIso),
-    [expiresAtIso]
-  );
+  // Days remaining
+  const daysRemaining = useMemo(() => calculateDaysRemaining(expiresAtIso), [expiresAtIso]);
 
-  // Status type
-  const statusType: SubscriptionStatusType = getSubscriptionStatusType(isPremium);
+  // Status type from Firestore or derived
+  const statusType: SubscriptionStatusType = credits?.status
+    ? (credits.status as SubscriptionStatusType)
+    : getSubscriptionStatusType(isPremium);
 
   const creditsArray = useCreditsArray(credits, dynamicCreditLimit, translations);
 
-  // Centralized display flags - single source of truth for UI visibility
+  // Centralized display flags
   const hasCredits = creditsArray.length > 0;
   const display = useMemo(() => ({
     showHeader: isPremium || hasCredits,
@@ -139,63 +82,47 @@ export const useSubscriptionSettingsConfig = (
   }), [isPremium, hasCredits, upgradePrompt, expiresAtIso]);
 
   // Build config
-  const config = useMemo(
-    (): SubscriptionSettingsConfig => ({
-      enabled: true,
-      settingsItem: {
-        title: translations.title,
-        description: translations.description,
-        isPremium,
-        statusLabel: isPremium
-          ? translations.statusActive
-          : translations.statusFree,
-        icon: "diamond",
-        onPress: handleOpenPaywall,
-      },
-      sectionConfig: {
-        statusType,
-        isPremium,
-        display,
-        expirationDate: formattedExpirationDate,
-        purchaseDate: formattedPurchaseDate,
-        isLifetime: isPremium && !expiresAtIso,
-        daysRemaining,
-        willRenew,
-        credits: creditsArray,
-        translations: {
-          title: translations.title,
-          statusLabel: translations.statusLabel,
-          statusActive: translations.statusActive,
-          statusExpired: translations.statusExpired,
-          statusFree: translations.statusFree,
-          statusCanceled: translations.statusCanceled,
-          expiresLabel: translations.expiresLabel,
-          purchasedLabel: translations.purchasedLabel,
-          lifetimeLabel: translations.lifetimeLabel,
-          creditsTitle: translations.creditsTitle,
-          remainingLabel: translations.remainingLabel,
-          manageButton: translations.manageButton,
-          upgradeButton: translations.upgradeButton,
-        },
-        onUpgrade: handleOpenPaywall,
-        upgradePrompt,
-      },
-    }),
-    [
-      translations,
+  return useMemo((): SubscriptionSettingsConfig => ({
+    enabled: true,
+    settingsItem: {
+      title: translations.title,
+      description: translations.description,
       isPremium,
+      statusLabel: isPremium ? translations.statusActive : translations.statusFree,
+      icon: "diamond",
+      onPress: handleOpenPaywall,
+    },
+    sectionConfig: {
       statusType,
+      isPremium,
       display,
-      formattedExpirationDate,
-      formattedPurchaseDate,
-      expiresAtIso,
+      expirationDate: formattedExpirationDate,
+      purchaseDate: formattedPurchaseDate,
+      isLifetime: isPremium && !expiresAtIso,
       daysRemaining,
       willRenew,
-      creditsArray,
-      handleOpenPaywall,
+      credits: creditsArray,
+      translations: {
+        title: translations.title,
+        statusLabel: translations.statusLabel,
+        statusActive: translations.statusActive,
+        statusExpired: translations.statusExpired,
+        statusFree: translations.statusFree,
+        statusCanceled: translations.statusCanceled,
+        expiresLabel: translations.expiresLabel,
+        purchasedLabel: translations.purchasedLabel,
+        lifetimeLabel: translations.lifetimeLabel,
+        creditsTitle: translations.creditsTitle,
+        remainingLabel: translations.remainingLabel,
+        manageButton: translations.manageButton,
+        upgradeButton: translations.upgradeButton,
+      },
+      onUpgrade: handleOpenPaywall,
       upgradePrompt,
-    ]
-  );
-
-  return config;
+    },
+  }), [
+    translations, isPremium, statusType, display, formattedExpirationDate,
+    formattedPurchaseDate, expiresAtIso, daysRemaining, willRenew,
+    creditsArray, handleOpenPaywall, upgradePrompt,
+  ]);
 };