@umituz/react-native-subscription 2.22.7 → 2.22.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.22.7",
+  "version": "2.22.9",
   "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/domain/entities/Credits.ts

@@ -19,17 +19,34 @@ export type PurchaseSource =
 
 export type PurchaseType = "initial" | "renewal" | "upgrade" | "downgrade";
 
+export type SubscriptionStatus = "active" | "expired" | "canceled" | "free";
+
+/** Single Source of Truth for user subscription + credits data */
 export interface UserCredits {
+  // Core subscription
+  isPremium: boolean;
+  status: SubscriptionStatus;
+
+  // Dates
+  purchasedAt: Date | null;
+  expirationDate: Date | null;
+  lastUpdatedAt: Date | null;
+
+  // RevenueCat subscription details
+  willRenew: boolean;
+  productId?: string;
+  packageType?: "weekly" | "monthly" | "yearly" | "lifetime";
+  originalTransactionId?: string;
+
+  // Credits
   credits: number;
-  packageType?: "weekly" | "monthly" | "yearly";
   creditLimit?: number;
-  productId?: string;
+
+  // Metadata
   purchaseSource?: PurchaseSource;
   purchaseType?: PurchaseType;
   platform?: "ios" | "android";
   appVersion?: string;
-  purchasedAt: Date | null;
-  lastUpdatedAt: Date | null;
 }
 
 export interface CreditAllocation {

package/src/infrastructure/mappers/CreditsMapper.ts

@@ -1,27 +1,48 @@
-import type { UserCredits } from "../../domain/entities/Credits";
+import type { UserCredits, SubscriptionStatus } from "../../domain/entities/Credits";
 import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
 
+/** Maps Firestore document to domain entity */
 export class CreditsMapper {
-  static toEntity(snapData: UserCreditsDocumentRead): UserCredits {
+  static toEntity(doc: UserCreditsDocumentRead): UserCredits {
+    // Determine status from document or derive from isPremium/expirationDate
+    const status = doc.status ?? CreditsMapper.deriveStatus(doc);
+
     return {
-      credits: snapData.credits,
-      packageType: snapData.packageType,
-      creditLimit: snapData.creditLimit,
-      productId: snapData.productId,
-      purchaseSource: snapData.purchaseSource,
-      purchaseType: snapData.purchaseType,
-      platform: snapData.platform,
-      appVersion: snapData.appVersion,
-      purchasedAt: snapData.purchasedAt?.toDate?.() || null,
-      lastUpdatedAt: snapData.lastUpdatedAt?.toDate?.() || null,
+      // Core subscription
+      isPremium: doc.isPremium ?? false,
+      status,
+
+      // Dates
+      purchasedAt: doc.purchasedAt?.toDate?.() ?? null,
+      expirationDate: doc.expirationDate?.toDate?.() ?? null,
+      lastUpdatedAt: doc.lastUpdatedAt?.toDate?.() ?? null,
+
+      // RevenueCat details
+      willRenew: doc.willRenew ?? false,
+      productId: doc.productId,
+      packageType: doc.packageType,
+      originalTransactionId: doc.originalTransactionId,
+
+      // Credits
+      credits: doc.credits,
+      creditLimit: doc.creditLimit,
+
+      // Metadata
+      purchaseSource: doc.purchaseSource,
+      purchaseType: doc.purchaseType,
+      platform: doc.platform,
+      appVersion: doc.appVersion,
     };
   }
 
-  static toFirestore(data: Partial<UserCredits>): Record<string, any> {
-    return {
-      credits: data.credits,
-      // Timestamps are usually handled by serverTimestamp() in repos, 
-      // but we can map them if needed.
-    };
+  /** 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";
+    }
+    return "free";
   }
 }

package/src/infrastructure/models/UserCreditsDocument.ts

@@ -1,4 +1,3 @@
-
 export interface FirestoreTimestamp {
     toDate: () => Date;
 }
@@ -13,9 +12,11 @@ export type PurchaseSource =
 
 export type PurchaseType = "initial" | "renewal" | "upgrade" | "downgrade";
 
+export type SubscriptionDocStatus = "active" | "expired" | "canceled" | "free";
+
 export interface PurchaseMetadata {
   productId: string;
-  packageType: "weekly" | "monthly" | "yearly";
+  packageType: "weekly" | "monthly" | "yearly" | "lifetime";
   creditLimit: number;
   source: PurchaseSource;
   type: PurchaseType;
@@ -24,19 +25,33 @@ export interface PurchaseMetadata {
   timestamp: FirestoreTimestamp;
 }
 
-// Document structure when READING from Firestore
+/** Single Source of Truth for user subscription data */
 export interface UserCreditsDocumentRead {
+    // Core subscription status
+    isPremium?: boolean;
+    status?: SubscriptionDocStatus;
+
+    // Dates (all from RevenueCat)
+    purchasedAt?: FirestoreTimestamp;
+    expirationDate?: FirestoreTimestamp;
+    lastUpdatedAt?: FirestoreTimestamp;
+    lastPurchaseAt?: FirestoreTimestamp;
+
+    // RevenueCat subscription details
+    willRenew?: boolean;
+    productId?: string;
+    packageType?: "weekly" | "monthly" | "yearly" | "lifetime";
+    originalTransactionId?: string;
+
+    // Credits
     credits: number;
-    packageType?: "weekly" | "monthly" | "yearly";
     creditLimit?: number;
-    productId?: string;
+
+    // Metadata
     purchaseSource?: PurchaseSource;
     purchaseType?: PurchaseType;
     platform?: "ios" | "android";
     appVersion?: string;
-    purchasedAt?: FirestoreTimestamp;
-    lastUpdatedAt?: FirestoreTimestamp;
-    lastPurchaseAt?: FirestoreTimestamp;
     processedPurchases?: string[];
     purchaseHistory?: PurchaseMetadata[];
 }

package/src/infrastructure/repositories/CreditsRepository.ts

@@ -14,12 +14,20 @@ import { getCreditAllocation } from "../../utils/creditMapper";
 
 import { CreditsMapper } from "../mappers/CreditsMapper";
 
+/** RevenueCat subscription data to save (Single Source of Truth) */
+export interface RevenueCatData {
+  expirationDate?: string | null;
+  willRenew?: boolean;
+  originalTransactionId?: string;
+  isPremium?: boolean;
+}
+
 export class CreditsRepository extends BaseRepository {
   constructor(private config: CreditsConfig) { super(); }
 
   private getRef(db: Firestore, userId: string) {
-    return this.config.useUserSubcollection 
-      ? doc(db, "users", userId, "credits", "balance") 
+    return this.config.useUserSubcollection
+      ? doc(db, "users", userId, "credits", "balance")
       : doc(db, this.config.collectionName, userId);
   }
 
@@ -51,7 +59,8 @@ export class CreditsRepository extends BaseRepository {
     userId: string,
     purchaseId?: string,
     productId?: string,
-    source?: PurchaseSource
+    source?: PurchaseSource,
+    revenueCatData?: RevenueCatData
   ): Promise<CreditsResult> {
     const db = getFirestore();
     if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
@@ -70,6 +79,11 @@ export class CreditsRepository extends BaseRepository {
       const metadata: InitializeCreditsMetadata = {
         productId,
         source,
+        // RevenueCat data for Single Source of Truth
+        expirationDate: revenueCatData?.expirationDate,
+        willRenew: revenueCatData?.willRenew,
+        originalTransactionId: revenueCatData?.originalTransactionId,
+        isPremium: revenueCatData?.isPremium,
       };
 
       const res = await initializeCreditsTransaction(

package/src/infrastructure/services/CreditsInitializer.ts

@@ -3,6 +3,7 @@ import Constants from "expo-constants";
 import {
     runTransaction,
     serverTimestamp,
+    Timestamp,
     type Firestore,
     type FieldValue,
     type Transaction,
@@ -14,6 +15,7 @@ import type {
   PurchaseSource,
   PurchaseType,
   PurchaseMetadata,
+  SubscriptionDocStatus,
 } from "../models/UserCreditsDocument";
 import { detectPackageType } from "../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../utils/creditMapper";
@@ -22,10 +24,16 @@ interface InitializationResult {
     credits: number;
 }
 
+/** RevenueCat data to save to Firestore (Single Source of Truth) */
 export interface InitializeCreditsMetadata {
   productId?: string;
   source?: PurchaseSource;
   type?: PurchaseType;
+  // RevenueCat subscription data
+  expirationDate?: string | null;
+  willRenew?: boolean;
+  originalTransactionId?: string;
+  isPremium?: boolean;
 }
 
 export async function initializeCreditsTransaction(
@@ -114,17 +122,41 @@ export async function initializeCreditsTransaction(
           ? [...(existing?.purchaseHistory || []), purchaseMetadata].slice(-10)
           : existing?.purchaseHistory;
 
-        // Build credits data, excluding undefined values (Firestore doesn't accept undefined)
+        // Determine subscription status
+        const isPremium = metadata?.isPremium ?? true;
+        const status: SubscriptionDocStatus = isPremium ? "active" : "expired";
+
+        // Build credits data (Single Source of Truth)
         const creditsData: Record<string, unknown> = {
+            // Core subscription
+            isPremium,
+            status,
+
+            // Credits
             credits: newCredits,
             creditLimit,
+
+            // Dates
             purchasedAt,
             lastUpdatedAt: now,
             lastPurchaseAt: now,
+
+            // Tracking
             processedPurchases,
         };
 
-        // Only add optional fields if they have values
+        // RevenueCat subscription data
+        if (metadata?.expirationDate) {
+            creditsData.expirationDate = Timestamp.fromDate(new Date(metadata.expirationDate));
+        }
+        if (metadata?.willRenew !== undefined) {
+            creditsData.willRenew = metadata.willRenew;
+        }
+        if (metadata?.originalTransactionId) {
+            creditsData.originalTransactionId = metadata.originalTransactionId;
+        }
+
+        // Package info
         if (packageType && packageType !== "unknown") {
             creditsData.packageType = packageType;
         }
@@ -133,6 +165,8 @@ export async function initializeCreditsTransaction(
             creditsData.platform = platform;
             creditsData.appVersion = appVersion;
         }
+
+        // Purchase metadata
         if (metadata?.source) {
             creditsData.purchaseSource = metadata.source;
         }

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -3,10 +3,12 @@
  */
 
 import { Platform } from "react-native";
+import type { CustomerInfo } from "react-native-purchases";
 import type { CreditsConfig } from "../../domain/entities/Credits";
 import { configureCreditsRepository, getCreditsRepository } from "../repositories/CreditsRepositoryProvider";
 import { SubscriptionManager } from "../../revenuecat/infrastructure/managers/SubscriptionManager";
 import { configureAuthProvider } from "../../presentation/hooks/useAuthAwarePurchase";
+import type { RevenueCatData } from "../repositories/CreditsRepository";
 
 export interface FirebaseAuthLike {
   currentUser: { uid: string; isAnonymous: boolean } | null;
@@ -39,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);
@@ -61,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/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,173 +26,103 @@ 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 premiumEntitlement = customerInfo?.entitlements.active[entitlementId];
+  // All data from Firestore (Single Source of Truth)
+  const isPremium = credits?.isPremium ?? false;
+  const willRenew = credits?.willRenew ?? false;
 
-  // Premium status: use customerInfo directly as it updates in real-time via listener
-  // This is the source of truth, subscriptionActive is just a backup
-  const isPremium = !!premiumEntitlement || 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 (premiumEntitlement?.productIdentifier) {
-      const packageType = detectPackageType(premiumEntitlement.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, premiumEntitlement?.productIdentifier, creditLimit]);
-
-  // Get expiration date directly from RevenueCat (source of truth)
-  const entitlementExpirationDate = premiumEntitlement?.expirationDate ?? null;
-
-  // Prefer CustomerInfo expiration (real-time) over cached status
-  const expiresAtIso = entitlementExpirationDate || (statusExpirationDate
-    ? statusExpirationDate.toISOString()
-    : null);
-
-
-
-  const willRenew = premiumEntitlement?.willRenew || false;
-  const purchasedAtIso = convertPurchasedAt(credits?.purchasedAt);
+  }, [credits?.creditLimit, creditLimit]);
 
   // Formatted dates
-  const formattedExpirationDate = useMemo(
-    () => formatDate(expiresAtIso),
-    [expiresAtIso]
-  );
+  const formattedExpirationDate = useMemo(() => formatDate(expiresAtIso), [expiresAtIso]);
+  const formattedPurchaseDate = useMemo(() => formatDate(purchasedAtIso), [purchasedAtIso]);
 
-  const formattedPurchaseDate = useMemo(
-    () => formatDate(purchasedAtIso),
-    [purchasedAtIso]
-  );
+  // Days remaining
+  const daysRemaining = useMemo(() => calculateDaysRemaining(expiresAtIso), [expiresAtIso]);
 
-  // Days remaining calculation
-  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,
     showCredits: hasCredits,
     showUpgradePrompt: !isPremium && !hasCredits && !!upgradePrompt,
-    showExpirationDate: isPremium && !!expiresAtIso,
+    showExpirationDate: (isPremium || hasCredits) && !!expiresAtIso,
   }), [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,
+  ]);
 };