@umituz/react-native-subscription 2.17.10 → 2.17.11

package/package.json

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

@@ -9,8 +9,25 @@ import type { SubscriptionPackageType } from "../../utils/packageTypeDetector";
 
 export type CreditType = "text" | "image";
 
+export type PurchaseSource =
+  | "onboarding"
+  | "settings"
+  | "upgrade_prompt"
+  | "home_screen"
+  | "feature_gate"
+  | "credits_exhausted";
+
+export type PurchaseType = "initial" | "renewal" | "upgrade" | "downgrade";
+
 export interface UserCredits {
   credits: number;
+  packageType?: "weekly" | "monthly" | "yearly";
+  creditLimit?: number;
+  productId?: string;
+  purchaseSource?: PurchaseSource;
+  purchaseType?: PurchaseType;
+  platform?: "ios" | "android";
+  appVersion?: string;
   purchasedAt: Date | null;
   lastUpdatedAt: Date | null;
 }

package/src/index.ts

@@ -17,6 +17,14 @@ export { SubscriptionService, initializeSubscriptionService } from "./infrastruc
 export { initializeSubscription, type SubscriptionInitConfig, type CreditPackageConfig } from "./infrastructure/services/SubscriptionInitializer";
 export { CreditsRepository, createCreditsRepository } from "./infrastructure/repositories/CreditsRepository";
 export { configureCreditsRepository, getCreditsRepository, getCreditsConfig, resetCreditsRepository, isCreditsRepositoryConfigured } from "./infrastructure/repositories/CreditsRepositoryProvider";
+export {
+  usePendingPurchaseStore,
+  type PendingPurchaseData,
+} from "./infrastructure/stores/PendingPurchaseStore";
+export {
+  usePendingPurchaseHandler,
+  type UsePendingPurchaseHandlerParams,
+} from "./presentation/hooks/usePendingPurchaseHandler";
 
 // Presentation Layer - Hooks
 export * from "./presentation/hooks";
@@ -30,7 +38,15 @@ export * from "./presentation/screens/SubscriptionDetailScreen";
 export * from "./presentation/types/SubscriptionDetailTypes";
 
 // Credits Domain
-export type { CreditType, UserCredits, CreditsConfig, CreditsResult, DeductCreditsResult } from "./domain/entities/Credits";
+export type {
+  CreditType,
+  UserCredits,
+  CreditsConfig,
+  CreditsResult,
+  DeductCreditsResult,
+  PurchaseSource,
+  PurchaseType,
+} from "./domain/entities/Credits";
 export { DEFAULT_CREDITS_CONFIG } from "./domain/entities/Credits";
 export { InsufficientCreditsError } from "./domain/errors/InsufficientCreditsError";
 

package/src/infrastructure/mappers/CreditsMapper.ts

@@ -5,6 +5,13 @@ export class CreditsMapper {
   static toEntity(snapData: UserCreditsDocumentRead): UserCredits {
     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,
     };

package/src/infrastructure/models/UserCreditsDocument.ts

@@ -3,11 +3,40 @@ export interface FirestoreTimestamp {
     toDate: () => Date;
 }
 
+export type PurchaseSource =
+  | "onboarding"
+  | "settings"
+  | "upgrade_prompt"
+  | "home_screen"
+  | "feature_gate"
+  | "credits_exhausted";
+
+export type PurchaseType = "initial" | "renewal" | "upgrade" | "downgrade";
+
+export interface PurchaseMetadata {
+  productId: string;
+  packageType: "weekly" | "monthly" | "yearly";
+  creditLimit: number;
+  source: PurchaseSource;
+  type: PurchaseType;
+  platform: "ios" | "android";
+  appVersion?: string;
+  timestamp: FirestoreTimestamp;
+}
+
 // Document structure when READING from Firestore
 export interface UserCreditsDocumentRead {
     credits: number;
+    packageType?: "weekly" | "monthly" | "yearly";
+    creditLimit?: number;
+    productId?: string;
+    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

@@ -5,8 +5,8 @@
 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";
-import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
-import { initializeCreditsTransaction } from "../services/CreditsInitializer";
+import type { UserCreditsDocumentRead, PurchaseSource } from "../models/UserCreditsDocument";
+import { initializeCreditsTransaction, type InitializeCreditsMetadata } from "../services/CreditsInitializer";
 import { detectPackageType } from "../../utils/packageTypeDetector";
 import { getCreditAllocation } from "../../utils/creditMapper";
 
@@ -32,7 +32,12 @@ export class CreditsRepository extends BaseRepository {
     } catch (e: any) { return { success: false, error: { message: e.message, code: "FETCH_ERR" } }; }
   }
 
-  async initializeCredits(userId: string, purchaseId?: string, productId?: string): Promise<CreditsResult> {
+  async initializeCredits(
+    userId: string,
+    purchaseId?: string,
+    productId?: string,
+    source?: PurchaseSource
+  ): Promise<CreditsResult> {
     const db = getFirestore();
     if (!db) return { success: false, error: { message: "No DB", code: "INIT_ERR" } };
     try {
@@ -46,7 +51,20 @@ export class CreditsRepository extends BaseRepository {
           if (dynamicLimit !== null) cfg = { ...cfg, creditLimit: dynamicLimit };
         }
       }
-      const res = await initializeCreditsTransaction(db, this.getRef(db, userId), cfg, purchaseId);
+
+      const metadata: InitializeCreditsMetadata = {
+        productId,
+        source,
+      };
+
+      const res = await initializeCreditsTransaction(
+        db,
+        this.getRef(db, userId),
+        cfg,
+        purchaseId,
+        metadata
+      );
+
       return {
         success: true,
         data: CreditsMapper.toEntity({

package/src/infrastructure/services/CreditsInitializer.ts

@@ -1,3 +1,5 @@
+import { Platform } from "react-native";
+import Constants from "expo-constants";
 import {
     runTransaction,
     serverTimestamp,
@@ -7,17 +9,31 @@ import {
     type DocumentReference,
 } from "firebase/firestore";
 import type { CreditsConfig } from "../../domain/entities/Credits";
-import type { UserCreditsDocumentRead } from "../models/UserCreditsDocument";
+import type {
+  UserCreditsDocumentRead,
+  PurchaseSource,
+  PurchaseType,
+  PurchaseMetadata,
+} from "../models/UserCreditsDocument";
+import { detectPackageType } from "../../utils/packageTypeDetector";
+import { getCreditAllocation } from "../../utils/creditMapper";
 
 interface InitializationResult {
     credits: number;
 }
 
+export interface InitializeCreditsMetadata {
+  productId?: string;
+  source?: PurchaseSource;
+  type?: PurchaseType;
+}
+
 export async function initializeCreditsTransaction(
     db: Firestore,
     creditsRef: DocumentReference,
     config: CreditsConfig,
-    purchaseId?: string
+    purchaseId?: string,
+    metadata?: InitializeCreditsMetadata
 ): Promise<InitializationResult> {
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
@@ -49,12 +65,68 @@ export async function initializeCreditsTransaction(
             processedPurchases = [...processedPurchases, purchaseId].slice(-10);
         }
 
+        // Detect package type and credit limit from productId
+        const productId = metadata?.productId;
+        const packageType = productId ? detectPackageType(productId) : undefined;
+        const allocation = packageType && packageType !== "unknown"
+          ? getCreditAllocation(packageType, config.packageAllocations)
+          : null;
+        const creditLimit = allocation || config.creditLimit;
+
+        // Platform and app version
+        const platform = Platform.OS as "ios" | "android";
+        const appVersion = Constants.expoConfig?.version;
+
+        // Determine purchase type
+        let purchaseType: PurchaseType = metadata?.type ?? "initial";
+        if (creditsDoc.exists()) {
+          const existing = creditsDoc.data() as UserCreditsDocumentRead;
+          if (existing.packageType && packageType !== "unknown") {
+            const oldLimit = existing.creditLimit || 0;
+            const newLimit = creditLimit;
+            if (newLimit > oldLimit) {
+              purchaseType = "upgrade";
+            } else if (newLimit < oldLimit) {
+              purchaseType = "downgrade";
+            } else if (purchaseId?.startsWith("renewal_")) {
+              purchaseType = "renewal";
+            }
+          }
+        }
+
+        // Create purchase metadata for history (only if productId and source exists and packageType detected)
+        const purchaseMetadata: PurchaseMetadata | undefined =
+          productId && metadata?.source && packageType && packageType !== "unknown" ? {
+            productId,
+            packageType,
+            creditLimit,
+            source: metadata.source,
+            type: purchaseType,
+            platform,
+            appVersion,
+            timestamp: now as any,
+          } : undefined;
+
+        // Update purchase history (keep last 10, only if metadata exists)
+        const existing = creditsDoc.exists() ? creditsDoc.data() as UserCreditsDocumentRead : null;
+        const purchaseHistory = purchaseMetadata
+          ? [...(existing?.purchaseHistory || []), purchaseMetadata].slice(-10)
+          : existing?.purchaseHistory;
+
         const creditsData = {
             credits: newCredits,
+            packageType: packageType !== "unknown" ? packageType : undefined,
+            creditLimit,
+            productId: productId || undefined,
+            purchaseSource: metadata?.source,
+            purchaseType: metadata?.type ? purchaseType : undefined,
+            platform: productId ? platform : undefined,
+            appVersion: productId ? appVersion : undefined,
             purchasedAt,
             lastUpdatedAt: now,
             lastPurchaseAt: now,
             processedPurchases,
+            purchaseHistory,
         };
 
         transaction.set(creditsRef, creditsData, { merge: true });

package/src/infrastructure/services/SubscriptionInitializer.ts

@@ -39,16 +39,26 @@ export const initializeSubscription = async (config: SubscriptionInitConfig): Pr
 
   configureCreditsRepository({ ...credits, creditPackageAmounts: creditPackages?.amounts });
 
-  const onPurchase = async (userId: string, productId: string) => {
+  const onPurchase = async (userId: string, productId: string, _customerInfo: unknown, source?: string) => {
     try {
-      await getCreditsRepository().initializeCredits(userId, `purchase_${productId}_${Date.now()}`, productId);
+      await getCreditsRepository().initializeCredits(
+        userId,
+        `purchase_${productId}_${Date.now()}`,
+        productId,
+        source as any
+      );
       onCreditsUpdated?.(userId);
     } catch { /* Silent */ }
   };
 
   const onRenewal = async (userId: string, productId: string, renewalId: string) => {
     try {
-      await getCreditsRepository().initializeCredits(userId, renewalId, productId);
+      await getCreditsRepository().initializeCredits(
+        userId,
+        renewalId,
+        productId,
+        undefined
+      );
       onCreditsUpdated?.(userId);
     } catch { /* Silent */ }
   };

package/src/infrastructure/stores/PendingPurchaseStore.ts

@@ -0,0 +1,56 @@
+/**
+ * Pending Purchase Store
+ * Manages pending purchase state for auth-required purchases
+ */
+
+import { createStore } from "@umituz/react-native-design-system";
+import type { PurchasesPackage } from "react-native-purchases";
+import type { PurchaseSource } from "../../domain/entities/Credits";
+
+export interface PendingPurchaseData {
+  package: PurchasesPackage;
+  source: PurchaseSource;
+  selectedAt: number;
+  metadata?: Record<string, unknown>;
+}
+
+interface PendingPurchaseState {
+  pending: PendingPurchaseData | null;
+}
+
+interface PendingPurchaseActions {
+  setPendingPurchase: (data: PendingPurchaseData) => void;
+  getPendingPurchase: () => PendingPurchaseData | null;
+  clearPendingPurchase: () => void;
+  hasPendingPurchase: () => boolean;
+}
+
+const initialState: PendingPurchaseState = {
+  pending: null,
+};
+
+export const usePendingPurchaseStore = createStore<
+  PendingPurchaseState,
+  PendingPurchaseActions
+>({
+  name: "pending-purchase-store",
+  initialState,
+  persist: false,
+  actions: (set, get) => ({
+    setPendingPurchase: (data: PendingPurchaseData) => {
+      set({ pending: data });
+    },
+
+    getPendingPurchase: () => {
+      return get().pending;
+    },
+
+    clearPendingPurchase: () => {
+      set({ pending: null });
+    },
+
+    hasPendingPurchase: () => {
+      return get().pending !== null;
+    },
+  }),
+});

package/src/presentation/hooks/useAuthAwarePurchase.ts

@@ -7,6 +7,10 @@
 import { useCallback } from "react";
 import type { PurchasesPackage } from "react-native-purchases";
 import { usePremium } from "./usePremium";
+import { usePendingPurchaseStore } from "../../infrastructure/stores/PendingPurchaseStore";
+import type { PurchaseSource } from "../../domain/entities/Credits";
+
+declare const __DEV__: boolean;
 
 export interface PurchaseAuthProvider {
     isAuthenticated: () => boolean;
@@ -24,16 +28,23 @@ export const configureAuthProvider = (provider: PurchaseAuthProvider): void => {
     globalAuthProvider = provider;
 };
 
+export interface UseAuthAwarePurchaseParams {
+  source?: PurchaseSource;
+}
+
 export interface UseAuthAwarePurchaseResult {
-    handlePurchase: (pkg: PurchasesPackage) => Promise<boolean>;
+    handlePurchase: (pkg: PurchasesPackage, source?: PurchaseSource) => Promise<boolean>;
     handleRestore: () => Promise<boolean>;
 }
 
-export const useAuthAwarePurchase = (): UseAuthAwarePurchaseResult => {
+export const useAuthAwarePurchase = (
+  params?: UseAuthAwarePurchaseParams
+): UseAuthAwarePurchaseResult => {
     const { purchasePackage, restorePurchase, closePaywall } = usePremium();
+    const { setPendingPurchase } = usePendingPurchaseStore();
 
     const handlePurchase = useCallback(
-        async (pkg: PurchasesPackage): Promise<boolean> => {
+        async (pkg: PurchasesPackage, source?: PurchaseSource): Promise<boolean> => {
             // SECURITY: Block purchase if auth provider not configured
             if (!globalAuthProvider) {
                 if (__DEV__) {
@@ -42,7 +53,6 @@ export const useAuthAwarePurchase = (): UseAuthAwarePurchaseResult => {
                         "Call configureAuthProvider() at app start. Purchase blocked for security.",
                     );
                 }
-                // Block purchase - never allow without auth provider
                 return false;
             }
 
@@ -50,9 +60,17 @@ export const useAuthAwarePurchase = (): UseAuthAwarePurchaseResult => {
             if (!globalAuthProvider.isAuthenticated()) {
                 if (__DEV__) {
                     console.log(
-                        "[useAuthAwarePurchase] User not authenticated, opening auth modal",
+                        "[useAuthAwarePurchase] User not authenticated, saving pending purchase and opening auth modal",
                     );
                 }
+
+                // Save pending purchase
+                setPendingPurchase({
+                  package: pkg,
+                  source: source || params?.source || "settings",
+                  selectedAt: Date.now(),
+                });
+
                 closePaywall();
                 globalAuthProvider.showAuthModal();
                 return false;
@@ -60,7 +78,7 @@ export const useAuthAwarePurchase = (): UseAuthAwarePurchaseResult => {
 
             return purchasePackage(pkg);
         },
-        [purchasePackage, closePaywall],
+        [purchasePackage, closePaywall, setPendingPurchase, params?.source],
     );
 
     const handleRestore = useCallback(async (): Promise<boolean> => {

package/src/presentation/hooks/usePendingPurchaseHandler.ts

@@ -0,0 +1,78 @@
+/**
+ * Pending Purchase Handler Hook
+ * Automatically executes pending purchase after successful authentication
+ */
+
+import { useEffect } from "react";
+import { usePendingPurchaseStore } from "../../infrastructure/stores/PendingPurchaseStore";
+import { usePremium } from "./usePremium";
+
+declare const __DEV__: boolean;
+
+export interface UsePendingPurchaseHandlerParams {
+  userId: string | undefined;
+  isAuthenticated: boolean;
+}
+
+/**
+ * Hook to handle pending purchases after authentication
+ * Call this in app root after auth initialization
+ */
+export const usePendingPurchaseHandler = ({
+  userId,
+  isAuthenticated,
+}: UsePendingPurchaseHandlerParams): void => {
+  const {
+    getPendingPurchase,
+    clearPendingPurchase,
+    hasPendingPurchase,
+  } = usePendingPurchaseStore();
+  const { purchasePackage } = usePremium();
+
+  useEffect(() => {
+    if (!isAuthenticated || !userId || !hasPendingPurchase()) {
+      return;
+    }
+
+    const executePendingPurchase = async () => {
+      const pending = getPendingPurchase();
+
+      if (!pending) {
+        return;
+      }
+
+      if (__DEV__) {
+        console.log(
+          "[usePendingPurchaseHandler] Executing pending purchase:",
+          {
+            packageId: pending.package.identifier,
+            source: pending.source,
+            selectedAt: new Date(pending.selectedAt).toISOString(),
+          }
+        );
+      }
+
+      try {
+        await purchasePackage(pending.package);
+      } catch (error) {
+        if (__DEV__) {
+          console.error(
+            "[usePendingPurchaseHandler] Failed to execute pending purchase:",
+            error
+          );
+        }
+      } finally {
+        clearPendingPurchase();
+      }
+    };
+
+    void executePendingPurchase();
+  }, [
+    isAuthenticated,
+    userId,
+    hasPendingPurchase,
+    getPendingPurchase,
+    clearPendingPurchase,
+    purchasePackage,
+  ]);
+};

package/src/presentation/hooks/useSubscriptionSettingsConfig.ts

@@ -66,12 +66,19 @@ export const useSubscriptionSettingsConfig = (
   const dynamicCreditLimit = useMemo(() => {
     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);
@@ -79,8 +86,9 @@ export const useSubscriptionSettingsConfig = (
       return closest;
     }
 
+    // 4. FINAL FALLBACK: Config'den al
     return creditLimit ?? config.creditLimit;
-  }, [premiumEntitlement?.productIdentifier, credits?.credits, creditLimit]);
+  }, [credits?.creditLimit, credits?.credits, premiumEntitlement?.productIdentifier, creditLimit]);
 
   // Get expiration date directly from RevenueCat (source of truth)
   const entitlementExpirationDate = premiumEntitlement?.expirationDate ?? null;

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

@@ -25,7 +25,8 @@ export interface RevenueCatConfig {
   onPurchaseCompleted?: (
     userId: string,
     productId: string,
-    customerInfo: CustomerInfo
+    customerInfo: CustomerInfo,
+    source?: string
   ) => Promise<void> | void;
   /** Callback for restore completion */
   onRestoreCompleted?: (

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

@@ -18,6 +18,7 @@ import {
     syncPremiumStatus,
     notifyPurchaseCompleted,
 } from "../utils/PremiumStatusSyncer";
+import { usePendingPurchaseStore } from "../../../infrastructure/stores/PendingPurchaseStore";
 
 export interface PurchaseHandlerDeps {
     config: RevenueCatConfig;
@@ -76,16 +77,24 @@ export async function handlePurchase(
             });
         }
 
+        // Get purchase source from pending purchase store
+        const pendingPurchaseStore = usePendingPurchaseStore.getState();
+        const pending = pendingPurchaseStore.getPendingPurchase();
+        const source = pending?.source;
+
         if (isConsumable) {
             if (__DEV__) {
-                console.log('[DEBUG PurchaseHandler] Consumable purchase SUCCESS');
+                console.log('[DEBUG PurchaseHandler] Consumable purchase SUCCESS', { source });
             }
             await notifyPurchaseCompleted(
                 deps.config,
                 userId,
                 pkg.product.identifier,
-                customerInfo
+                customerInfo,
+                source
             );
+            // Clear pending purchase after successful purchase
+            pendingPurchaseStore.clearPendingPurchase();
             return {
                 success: true,
                 isPremium: false,
@@ -103,20 +112,24 @@ export async function handlePurchase(
                 entitlementIdentifier,
                 isPremium,
                 allEntitlements: customerInfo.entitlements.active,
+                source,
             });
         }
 
         if (isPremium) {
             if (__DEV__) {
-                console.log('[DEBUG PurchaseHandler] Premium purchase SUCCESS');
+                console.log('[DEBUG PurchaseHandler] Premium purchase SUCCESS', { source });
             }
             await syncPremiumStatus(deps.config, userId, customerInfo);
             await notifyPurchaseCompleted(
                 deps.config,
                 userId,
                 pkg.product.identifier,
-                customerInfo
+                customerInfo,
+                source
             );
+            // Clear pending purchase after successful purchase
+            pendingPurchaseStore.clearPendingPurchase();
             return { success: true, isPremium: true, customerInfo };
         }
 
@@ -124,14 +137,17 @@ export async function handlePurchase(
         // Treat the purchase as successful for testing purposes
         if (deps.isUsingTestStore()) {
             if (__DEV__) {
-                console.log('[DEBUG PurchaseHandler] Test store purchase SUCCESS');
+                console.log('[DEBUG PurchaseHandler] Test store purchase SUCCESS', { source });
             }
             await notifyPurchaseCompleted(
                 deps.config,
                 userId,
                 pkg.product.identifier,
-                customerInfo
+                customerInfo,
+                source
             );
+            // Clear pending purchase after successful purchase
+            pendingPurchaseStore.clearPendingPurchase();
             return { success: true, isPremium: false, customerInfo };
         }
 

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

@@ -41,14 +41,15 @@ export async function notifyPurchaseCompleted(
     config: RevenueCatConfig,
     userId: string,
     productId: string,
-    customerInfo: CustomerInfo
+    customerInfo: CustomerInfo,
+    source?: string
 ): Promise<void> {
     if (!config.onPurchaseCompleted) {
         return;
     }
 
     try {
-        await config.onPurchaseCompleted(userId, productId, customerInfo);
+        await config.onPurchaseCompleted(userId, productId, customerInfo, source);
     } catch {
         // Silent error handling
     }