@umituz/react-native-subscription 2.27.113 → 2.27.114

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.113",
+  "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,23 +1,16 @@
-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 { creditAllocationOrchestrator } from "./credit-strategies/CreditAllocationOrchestrator";
-import { getAppVersion, validatePlatform, isPast } from "../../../utils";
-import type { InitializeCreditsMetadata, InitializationResult } from "../../subscription/application/SubscriptionInitializerTypes";
 
 export async function initializeCreditsTransaction(
-    db: ReturnType<typeof getFirestore>,
+    db: Firestore,
     creditsRef: DocumentReference,
     config: CreditsConfig,
     purchaseId: string,
@@ -29,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: validatePlatform() 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 {
@@ -66,8 +35,6 @@ export async function initializeCreditsTransaction(
         }
 
         const creditLimit = CreditLimitCalculator.calculate(metadata.productId, config);
-
-        const platform = validatePlatform();
         const appVersion = getAppVersion();
 
         const { purchaseHistory } = PurchaseMetadataGenerator.generate({
@@ -79,85 +46,29 @@ export async function initializeCreditsTransaction(
             appVersion,
         }, existingData);
 
-        const isPremium = metadata.isPremium;
-
-        let isExpired = false;
-        if (metadata.expirationDate) {
-            isExpired = isPast(metadata.expirationDate);
-        }
-
-        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 = creditAllocationOrchestrator.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/CreditAllocationOrchestrator.ts

@@ -18,16 +18,11 @@ export class CreditAllocationOrchestrator {
      */
     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(`[CreditAllocationOrchestrator] Using strategy: ${strategy.constructor.name}`);
-        }
-
         return strategy.execute(params);
     }
 }

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/presentation/useCredits.ts

@@ -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/paywall/hooks/usePaywallActions.ts

@@ -60,9 +60,6 @@ export function usePaywallActions({
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       onPurchaseError?.(err);
-      if (__DEV__) {
-        console.error("[usePaywallActions] Purchase failed:", err);
-      }
     } finally {
       setIsLocalProcessing(false);
       endPurchase();

package/src/domains/subscription/application/SubscriptionSyncService.ts

@@ -15,24 +15,22 @@ export class SubscriptionSyncService {
   async handlePurchase(userId: string, productId: string, customerInfo: CustomerInfo, source?: PurchaseSource) {
     try {
       const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
-      const purchaseId = revenueCatData.originalTransactionId 
+      const purchaseId = revenueCatData.originalTransactionId
         ? `purchase_${revenueCatData.originalTransactionId}`
         : `purchase_${productId}_${Date.now()}`;
 
       await getCreditsRepository().initializeCredits(
-        userId, 
-        purchaseId, 
-        productId, 
-        source ?? PURCHASE_SOURCE.SETTINGS, // Default to settings if source unknown
+        userId,
+        purchaseId,
+        productId,
+        source ?? PURCHASE_SOURCE.SETTINGS,
         revenueCatData,
-        PURCHASE_TYPE.INITIAL // Default to INITIAL
+        PURCHASE_TYPE.INITIAL
       );
-      
-      // Notify listeners via Event Bus
+
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PURCHASE_COMPLETED, { userId, productId });
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionSyncService] Credits init failed:', error);
+    } catch {
     }
   }
 
@@ -40,23 +38,22 @@ export class SubscriptionSyncService {
     try {
       const revenueCatData = extractRevenueCatData(customerInfo, this.entitlementId);
       revenueCatData.expirationDate = newExpirationDate || revenueCatData.expirationDate;
-      const purchaseId = revenueCatData.originalTransactionId 
+      const purchaseId = revenueCatData.originalTransactionId
         ? `renewal_${revenueCatData.originalTransactionId}_${newExpirationDate}`
         : `renewal_${productId}_${Date.now()}`;
 
       await getCreditsRepository().initializeCredits(
-        userId, 
-        purchaseId, 
-        productId, 
-        PURCHASE_SOURCE.RENEWAL, 
+        userId,
+        purchaseId,
+        productId,
+        PURCHASE_SOURCE.RENEWAL,
         revenueCatData,
         PURCHASE_TYPE.RENEWAL
       );
-      
+
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.RENEWAL_DETECTED, { userId, productId });
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionSyncService] Renewal credits init failed:', error);
+    } catch {
     }
   }
 
@@ -123,8 +120,7 @@ export class SubscriptionSyncService {
       
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.CREDITS_UPDATED, userId);
       subscriptionEventBus.emit(SUBSCRIPTION_EVENTS.PREMIUM_STATUS_CHANGED, { userId, isPremium });
-    } catch (error) {
-      if (__DEV__) console.error('[SubscriptionSyncService] Premium status sync failed:', error);
+    } catch {
     }
   }
 }

package/src/domains/subscription/core/RevenueCatError.ts

@@ -3,54 +3,63 @@
  * Domain-specific error types for RevenueCat operations
  */
 
-export class RevenueCatError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "RevenueCatError";
-  }
+import { BaseError } from "../../../shared/utils/BaseError";
+
+export class RevenueCatError extends BaseError {
+    constructor(message: string, code: string = 'REVENUE_CAT_ERROR', cause?: Error) {
+        super(message, code, cause);
+        this.name = "RevenueCatError";
+    }
 }
 
 export class RevenueCatInitializationError extends RevenueCatError {
-  constructor(message = "RevenueCat service is not initialized") {
-    super(message);
-    this.name = "RevenueCatInitializationError";
-  }
+    constructor(message = "RevenueCat service is not initialized", cause?: Error) {
+        super(message, 'REVENUE_CAT_NOT_INITIALIZED', cause);
+        this.name = "RevenueCatInitializationError";
+    }
 }
 
 export class RevenueCatConfigurationError extends RevenueCatError {
-  constructor(message = "RevenueCat configuration is invalid") {
-    super(message);
-    this.name = "RevenueCatConfigurationError";
-  }
+    constructor(message = "RevenueCat configuration is invalid", cause?: Error) {
+        super(message, 'REVENUE_CAT_CONFIGURATION_ERROR', cause);
+        this.name = "RevenueCatConfigurationError";
+    }
 }
 
 export class RevenueCatPurchaseError extends RevenueCatError {
-  public productId: string | undefined;
+    public readonly productId: string | undefined;
+
+    constructor(message: string, productId?: string, cause?: Error) {
+        super(message, 'REVENUE_CAT_PURCHASE_ERROR', cause);
+        this.name = "RevenueCatPurchaseError";
+        this.productId = productId;
+    }
 
-  constructor(message: string, productId?: string) {
-    super(message);
-    this.name = "RevenueCatPurchaseError";
-    this.productId = productId;
-  }
+    override toJSON() {
+        return {
+            ...super.toJSON(),
+            productId: this.productId,
+        };
+    }
 }
 
 export class RevenueCatRestoreError extends RevenueCatError {
-  constructor(message = "Failed to restore purchases") {
-    super(message);
-    this.name = "RevenueCatRestoreError";
-  }
+    constructor(message = "Failed to restore purchases", cause?: Error) {
+        super(message, 'REVENUE_CAT_RESTORE_ERROR', cause);
+        this.name = "RevenueCatRestoreError";
+    }
 }
 
 export class RevenueCatNetworkError extends RevenueCatError {
-  constructor(message = "Network error during RevenueCat operation") {
-    super(message);
-    this.name = "RevenueCatNetworkError";
-  }
+    constructor(message = "Network error during RevenueCat operation", cause?: Error) {
+        super(message, 'REVENUE_CAT_NETWORK_ERROR', cause);
+        this.name = "RevenueCatNetworkError";
+    }
 }
 
 export class RevenueCatExpoGoError extends RevenueCatError {
-  constructor(message = "RevenueCat is not available in Expo Go. Use a development build or test store.") {
-    super(message);
-    this.name = "RevenueCatExpoGoError";
-  }
+    constructor(message = "RevenueCat is not available in Expo Go. Use a development build or test store.", cause?: Error) {
+        super(message, 'REVENUE_CAT_EXPO_GO_ERROR', cause);
+        this.name = "RevenueCatExpoGoError";
+    }
 }

package/src/domains/subscription/infrastructure/handlers/PackageHandler.ts

@@ -44,7 +44,6 @@ export class PackageHandler {
 
       return packages;
     } catch (error) {
-      // Re-throw with more detail
       throw new Error(
         `Failed to fetch subscription packages. ${
           error instanceof Error ? error.message : "Unknown error"