@umituz/react-native-subscription 2.27.112 → 2.27.114

package/package.json

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

@@ -1,24 +1,16 @@
-import { Platform } from "react-native";
-import Constants from "expo-constants";
-import {
-  getFirestore,
-} from "@umituz/react-native-firebase";
-import {
-  runTransaction,
-  serverTimestamp,
-  type Transaction,
-  type DocumentReference,
-} from "firebase/firestore";
 import type { CreditsConfig } from "../core/Credits";
 import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
-import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
+import { getAppVersion, validatePlatform } from "../../../utils";
+import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
+import { runTransaction, type Transaction, type DocumentReference } from "firebase/firestore";
+import type { Firestore } from "firebase/firestore";
+import { getCreditDocumentOrDefault } from "./creditDocumentHelpers";
+import { calculateNewCredits, buildCreditsData, shouldSkipStatusSyncWrite } from "./creditOperationUtils";
 import { CreditLimitCalculator } from "./CreditLimitCalculator";
 import { PurchaseMetadataGenerator } from "./PurchaseMetadataGenerator";
-import { creditAllocationContext } from "./credit-strategies/CreditAllocationContext";
-import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
 
 export async function initializeCreditsTransaction(
-    db: ReturnType<typeof getFirestore>,
+    db: Firestore,
     creditsRef: DocumentReference,
     config: CreditsConfig,
     purchaseId: string,
@@ -30,33 +22,9 @@ export async function initializeCreditsTransaction(
 
     return runTransaction(db, async (transaction: Transaction) => {
         const creditsDoc = await transaction.get(creditsRef);
-        const now = serverTimestamp();
-        const existingData = creditsDoc.exists()
-            ? creditsDoc.data() as UserCreditsDocumentRead
-            : {
-                credits: 0,
-                creditLimit: 0,
-                isPremium: false,
-                status: "none",
-                processedPurchases: [],
-                purchaseHistory: [],
-                platform: Platform.OS as any,
-                lastUpdatedAt: now,
-                purchasedAt: now,
-                expirationDate: null,
-                lastPurchaseAt: null,
-                willRenew: false,
-                productId: null,
-                packageType: null,
-                originalTransactionId: null,
-                appVersion: null,
-                periodType: null,
-                isTrialing: false,
-                trialStartDate: null,
-                trialEndDate: null,
-                trialCredits: 0,
-                convertedFromTrial: false,
-            } as any;
+        const platform = validatePlatform();
+
+        const existingData = getCreditDocumentOrDefault(creditsDoc, platform);
 
         if (existingData.processedPurchases.includes(purchaseId)) {
             return {
@@ -67,16 +35,7 @@ export async function initializeCreditsTransaction(
         }
 
         const creditLimit = CreditLimitCalculator.calculate(metadata.productId, config);
-
-        const platform = Platform.OS;
-        if (platform !== "ios" && platform !== "android") {
-            throw new Error(`Invalid platform: ${platform}`);
-        }
-
-        const appVersion = Constants.expoConfig?.version;
-        if (!appVersion) {
-            throw new Error("appVersion is required in expoConfig");
-        }
+        const appVersion = getAppVersion();
 
         const { purchaseHistory } = PurchaseMetadataGenerator.generate({
             productId: metadata.productId,
@@ -87,85 +46,29 @@ export async function initializeCreditsTransaction(
             appVersion,
         }, existingData);
 
-        const isPremium = metadata.isPremium;
-
-        let isExpired = false;
-        if (metadata.expirationDate) {
-            isExpired = new Date(metadata.expirationDate).getTime() < Date.now();
-        }
-
-        const status = resolveSubscriptionStatus({
-            isPremium,
-            willRenew: metadata.willRenew ?? false,
-            isExpired,
-            periodType: metadata.periodType ?? undefined,
-        });
-
-        const isStatusSync = purchaseId.startsWith("status_sync_");
-        const isSubscriptionActive = isPremium && !isExpired;
-
-        const newCredits = creditAllocationContext.allocate({
-            status,
-            isStatusSync,
+        const newCredits = calculateNewCredits({
+            metadata,
             existingData,
             creditLimit,
-            isSubscriptionActive,
-            productId: metadata.productId,
+            purchaseId,
         });
 
-        const newProcessedPurchases = [...existingData.processedPurchases, purchaseId].slice(-50);
-
-        const creditsData: Record<string, any> = {
-            isPremium,
-            status,
-            credits: newCredits,
+        const creditsData = buildCreditsData({
+            existingData,
+            newCredits,
             creditLimit,
-            lastUpdatedAt: now,
-            processedPurchases: newProcessedPurchases,
-        };
-
-        if (purchaseHistory.length > 0) {
-            creditsData.purchaseHistory = purchaseHistory;
-        }
-
-        const isNewPurchaseOrRenewal = purchaseId.startsWith("purchase_")
-            || purchaseId.startsWith("renewal_");
-
-        if (isNewPurchaseOrRenewal) {
-            creditsData.lastPurchaseAt = now;
-        }
-
-        if (metadata.expirationDate) {
-            creditsData.expirationDate = serverTimestamp();
-        }
-
-        if (metadata.willRenew !== undefined) {
-            creditsData.willRenew = metadata.willRenew;
-        }
-
-        if (metadata.originalTransactionId) {
-            creditsData.originalTransactionId = metadata.originalTransactionId;
-        }
-
-        creditsData.productId = metadata.productId;
-        creditsData.platform = platform;
-
-        // Skip write if it's a status sync and data hasn't changed to save costs
-        if (isStatusSync && existingData) {
-            const hasChanged = 
-                existingData.isPremium !== creditsData.isPremium ||
-                existingData.status !== creditsData.status ||
-                existingData.credits !== creditsData.credits ||
-                existingData.creditLimit !== creditsData.creditLimit ||
-                existingData.productId !== creditsData.productId;
+            purchaseId,
+            metadata,
+            purchaseHistory,
+            platform,
+        });
 
-            if (!hasChanged) {
-                return {
-                    credits: existingData.credits,
-                    alreadyProcessed: true,
-                    finalData: existingData
-                };
-            }
+        if (shouldSkipStatusSyncWrite(purchaseId, existingData, creditsData)) {
+            return {
+                credits: existingData.credits,
+                alreadyProcessed: true,
+                finalData: existingData
+            };
         }
 
         transaction.set(creditsRef, creditsData, { merge: true });

package/src/domains/credits/application/credit-strategies/{CreditAllocationContext.ts → CreditAllocationOrchestrator.ts}

@@ -4,9 +4,9 @@ import { TrialCreditStrategy } from "./TrialCreditStrategy";
 import { StandardPurchaseCreditStrategy } from "./StandardPurchaseCreditStrategy";
 
 /**
- * Strategy Context to coordinate credit allocation logic using the Strategy Pattern.
+ * Orchestrator to coordinate credit allocation logic using the Strategy Pattern.
  */
-export class CreditAllocationContext {
+export class CreditAllocationOrchestrator {
     private strategies: ICreditStrategy[] = [
         new SyncCreditStrategy(),
         new TrialCreditStrategy(),
@@ -18,18 +18,13 @@ export class CreditAllocationContext {
      */
     allocate(params: CreditAllocationParams): number {
         const strategy = this.strategies.find(s => s.canHandle(params));
-        
+
         if (!strategy) {
-            // Should theoretically never happen due to StandardPurchaseCreditStrategy fallback
             return params.creditLimit;
         }
 
-        if (__DEV__) {
-            console.log(`[CreditAllocationContext] Using strategy: ${strategy.constructor.name}`);
-        }
-
         return strategy.execute(params);
     }
 }
 
-export const creditAllocationContext = new CreditAllocationContext();
+export const creditAllocationOrchestrator = new CreditAllocationOrchestrator();

package/src/domains/credits/application/creditDocumentHelpers.ts

@@ -0,0 +1,58 @@
+/**
+ * Credit Document Helpers
+ * Utilities for getting and creating credit documents
+ */
+
+import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
+import { serverTimestamp, type DocumentSnapshot } from "firebase/firestore";
+
+/**
+ * Get existing credit document or create default
+ */
+export function getCreditDocumentOrDefault(
+    creditsDoc: DocumentSnapshot,
+    platform: "ios" | "android"
+): UserCreditsDocumentRead {
+    if (creditsDoc.exists()) {
+        return creditsDoc.data() as UserCreditsDocumentRead;
+    }
+
+    const now = serverTimestamp();
+
+    return {
+        credits: 0,
+        creditLimit: 0,
+        isPremium: false,
+        status: "none",
+        processedPurchases: [],
+        purchaseHistory: [],
+        platform,
+        lastUpdatedAt: now,
+        purchasedAt: now,
+        expirationDate: null,
+        lastPurchaseAt: null,
+        willRenew: false,
+        productId: null,
+        packageType: null,
+        originalTransactionId: null,
+        appVersion: null,
+        periodType: null,
+        isTrialing: false,
+        trialStartDate: null,
+        trialEndDate: null,
+        trialCredits: 0,
+        convertedFromTrial: false,
+    } as any;
+}
+
+/**
+ * Add purchase ID to processed purchases list
+ * Maintains last 50 purchases
+ */
+export function addProcessedPurchase(
+    existing: string[],
+    purchaseId: string,
+    limit: number = 50
+): string[] {
+    return [...existing, purchaseId].slice(-limit);
+}

package/src/domains/credits/application/creditOperationUtils.ts

@@ -0,0 +1,154 @@
+/**
+ * Credit Operation Utilities
+ * Business logic for credit calculations and data building
+ */
+
+import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
+import { creditAllocationOrchestrator } from "./credit-strategies/CreditAllocationOrchestrator";
+import { isPast } from "../../../utils";
+import type { UserCreditsDocumentRead } from "../core/UserCreditsDocument";
+import type { InitializeCreditsMetadata } from "../../subscription/application/SubscriptionInitializerTypes";
+import { serverTimestamp } from "firebase/firestore";
+
+interface CalculateCreditsParams {
+    metadata: InitializeCreditsMetadata;
+    existingData: UserCreditsDocumentRead;
+    creditLimit: number;
+    purchaseId: string;
+}
+
+interface BuildCreditsDataParams {
+    existingData: UserCreditsDocumentRead;
+    newCredits: number;
+    creditLimit: number;
+    purchaseId: string;
+    metadata: InitializeCreditsMetadata;
+    purchaseHistory: any[];
+    platform: "ios" | "android";
+}
+
+/**
+ * Calculate new credits based on subscription status
+ */
+export function calculateNewCredits(params: CalculateCreditsParams): number {
+    const { metadata, existingData, creditLimit, purchaseId } = params;
+
+    const isPremium = metadata.isPremium;
+    const isExpired = metadata.expirationDate ? isPast(metadata.expirationDate) : false;
+
+    const status = resolveSubscriptionStatus({
+        isPremium,
+        willRenew: metadata.willRenew ?? false,
+        isExpired,
+        periodType: metadata.periodType ?? undefined,
+    });
+
+    const isStatusSync = purchaseId.startsWith("status_sync_");
+    const isSubscriptionActive = isPremium && !isExpired;
+
+    return creditAllocationOrchestrator.allocate({
+        status,
+        isStatusSync,
+        existingData,
+        creditLimit,
+        isSubscriptionActive,
+        productId: metadata.productId,
+    });
+}
+
+/**
+ * Build credits data object for Firestore update
+ */
+export function buildCreditsData(params: BuildCreditsDataParams): Record<string, any> {
+    const {
+        existingData,
+        newCredits,
+        creditLimit,
+        purchaseId,
+        metadata,
+        purchaseHistory,
+        platform,
+    } = params;
+
+    const isPremium = metadata.isPremium;
+    const isExpired = metadata.expirationDate ? isPast(metadata.expirationDate) : false;
+
+    const status = resolveSubscriptionStatus({
+        isPremium,
+        willRenew: metadata.willRenew ?? false,
+        isExpired,
+        periodType: metadata.periodType ?? undefined,
+    });
+
+    const newProcessedPurchases = addProcessedPurchase(existingData.processedPurchases, purchaseId);
+
+    const creditsData: Record<string, any> = {
+        isPremium,
+        status,
+        credits: newCredits,
+        creditLimit,
+        lastUpdatedAt: serverTimestamp(),
+        processedPurchases: newProcessedPurchases,
+    };
+
+    if (purchaseHistory.length > 0) {
+        creditsData.purchaseHistory = purchaseHistory;
+    }
+
+    const isNewPurchaseOrRenewal = purchaseId.startsWith("purchase_") || purchaseId.startsWith("renewal_");
+    if (isNewPurchaseOrRenewal) {
+        creditsData.lastPurchaseAt = serverTimestamp();
+    }
+
+    if (metadata.expirationDate) {
+        creditsData.expirationDate = serverTimestamp();
+    }
+
+    if (metadata.willRenew !== undefined) {
+        creditsData.willRenew = metadata.willRenew;
+    }
+
+    if (metadata.originalTransactionId) {
+        creditsData.originalTransactionId = metadata.originalTransactionId;
+    }
+
+    creditsData.productId = metadata.productId;
+    creditsData.platform = platform;
+
+    return creditsData;
+}
+
+/**
+ * Check if status sync write should be skipped (no changes)
+ */
+export function shouldSkipStatusSyncWrite(
+    purchaseId: string,
+    existingData: UserCreditsDocumentRead,
+    newCreditsData: Record<string, any>
+): boolean {
+    const isStatusSync = purchaseId.startsWith("status_sync_");
+
+    if (!isStatusSync) {
+        return false;
+    }
+
+    const hasChanged =
+        existingData.isPremium !== newCreditsData.isPremium ||
+        existingData.status !== newCreditsData.status ||
+        existingData.credits !== newCreditsData.credits ||
+        existingData.creditLimit !== newCreditsData.creditLimit ||
+        existingData.productId !== newCreditsData.productId;
+
+    return !hasChanged;
+}
+
+/**
+ * Add purchase ID to processed purchases list
+ */
+function addProcessedPurchase(
+    existing: string[],
+    purchaseId: string,
+    limit: number = 50
+): string[] {
+    return [...existing, purchaseId].slice(-limit);
+}

package/src/domains/credits/core/CreditsMapper.ts

@@ -3,17 +3,12 @@ import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionS
 import type { PeriodType, SubscriptionStatusType } from "../../subscription/core/SubscriptionConstants";
 import type { UserCreditsDocumentRead } from "./UserCreditsDocument";
 
+import { toSafeDate } from "../../../utils/dateUtils";
+
 /** Maps Firestore document to domain entity with expiration validation */
 export class CreditsMapper {
   static toEntity(doc: UserCreditsDocumentRead): UserCredits {
-    const safeDate = (ts: any): Date | null => {
-        if (!ts) return null;
-        if (typeof ts.toDate === "function") return ts.toDate();
-        if (ts instanceof Date) return ts;
-        return null;
-    };
-
-    const expirationDate = safeDate(doc.expirationDate);
+    const expirationDate = toSafeDate(doc.expirationDate);
     const periodType = doc.periodType;
 
     // Validate isPremium against expirationDate (real-time check)
@@ -25,10 +20,10 @@ export class CreditsMapper {
       status,
 
       // Dates
-      purchasedAt: safeDate(doc.purchasedAt) ?? new Date(),
+      purchasedAt: toSafeDate(doc.purchasedAt) ?? new Date(),
       expirationDate,
-      lastUpdatedAt: safeDate(doc.lastUpdatedAt) ?? new Date(),
-      lastPurchaseAt: safeDate(doc.lastPurchaseAt),
+      lastUpdatedAt: toSafeDate(doc.lastUpdatedAt) ?? new Date(),
+      lastPurchaseAt: toSafeDate(doc.lastPurchaseAt),
 
       // RevenueCat details
       willRenew: doc.willRenew,
@@ -39,8 +34,8 @@ export class CreditsMapper {
       // Trial fields
       periodType,
       isTrialing: doc.isTrialing,
-      trialStartDate: safeDate(doc.trialStartDate),
-      trialEndDate: safeDate(doc.trialEndDate),
+      trialStartDate: toSafeDate(doc.trialStartDate),
+      trialEndDate: toSafeDate(doc.trialEndDate),
       trialCredits: doc.trialCredits,
       convertedFromTrial: doc.convertedFromTrial,
 

package/src/domains/credits/infrastructure/{CreditsRepositoryProvider.ts → CreditsRepositoryManager.ts}

@@ -1,7 +1,7 @@
 /**
- * Credits Repository Provider
+ * Credits Repository Manager
  * Module-level singleton for credits repository configuration
- * Replaces Context API with a simpler, testable approach
+ * Provides a clean, testable approach for repository access
  */
 
 import type { CreditsConfig } from "../core/Credits";

package/src/domains/credits/presentation/useCredits.ts

@@ -14,7 +14,7 @@ import {
   getCreditsRepository,
   getCreditsConfig,
   isCreditsRepositoryConfigured,
-} from "../infrastructure/CreditsRepositoryProvider";
+} from "../infrastructure/CreditsRepositoryManager";
 import { calculateCreditPercentage, canAffordCost } from "../utils/creditCalculations";
 
 export const creditsQueryKeys = {
@@ -81,10 +81,9 @@ export const useCredits = (): UseCreditsResult => {
   // Observer Pattern: Listen for credit updates
   useEffect(() => {
     if (!userId) return;
-    
+
     const unsubscribe = subscriptionEventBus.on(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, (updatedUserId) => {
       if (updatedUserId === userId) {
-        if (__DEV__) console.log("[useCredits] Event received: CREDITS_UPDATED, refetching...");
         queryClient.invalidateQueries({ queryKey: creditsQueryKeys.user(userId) });
       }
     });

package/src/domains/credits/presentation/useDeductCredit.ts

@@ -6,7 +6,7 @@
 import { useCallback } from "react";
 import { useMutation, useQueryClient } from "@umituz/react-native-design-system";
 import type { UserCredits } from "../core/Credits";
-import { getCreditsRepository } from "../infrastructure/CreditsRepositoryProvider";
+import { getCreditsRepository } from "../infrastructure/CreditsRepositoryManager";
 import { creditsQueryKeys } from "./useCredits";
 import { calculateRemainingCredits } from "../utils/creditCalculations";
 
@@ -65,11 +65,11 @@ export const useDeductCredit = ({
         wasInsufficient: previousCredits.credits < cost
       };
     },
-    onError: (_err, _cost, context) => {
+    onError: (_err, _cost, mutationData) => {
       // Always restore previous credits on error to prevent UI desync
       // Use optional chaining to be safe
-      if (userId && context?.previousCredits && !context.skippedOptimistic) {
-         queryClient.setQueryData(creditsQueryKeys.user(userId), context.previousCredits);
+      if (userId && mutationData?.previousCredits && !mutationData.skippedOptimistic) {
+         queryClient.setQueryData(creditsQueryKeys.user(userId), mutationData.previousCredits);
       }
     },
     onSuccess: () => {

package/src/domains/paywall/components/PaywallContainer.types.ts

@@ -45,7 +45,7 @@ export interface PaywallContainerProps {
   /** Callback when purchase succeeds */
   readonly onPurchaseSuccess?: () => void;
   /** Callback when purchase fails */
-  readonly onPurchaseError?: (error: string) => void;
+  readonly onPurchaseError?: (error: Error | string) => void;
   /** Callback when auth is required (for anonymous users) */
   readonly onAuthRequired?: () => void;
   /** Visibility override */