@umituz/react-native-subscription 2.37.116 → 2.37.118

package/package.json

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

@@ -10,6 +10,12 @@ import {
 } from "./creditOperationUtils.types";
 import { PURCHASE_ID_PREFIXES, PROCESSED_PURCHASES_WINDOW } from "../core/CreditsConstants";
 
+// Helper to check if purchaseId is a purchase or renewal (used for setting lastPurchaseAt)
+function isPurchaseOrRenewal(purchaseId: string): boolean {
+  return purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) ||
+         purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL);
+}
+
 
 export function calculateNewCredits({ metadata, existingData, creditLimit }: CalculateCreditsParams): number {
   const isExpired = metadata.expirationDate ? isPast(metadata.expirationDate) : false;
@@ -48,9 +54,6 @@ export function buildCreditsData({
     periodType: metadata.periodType ?? undefined,
   });
 
-  const isPurchaseOrRenewal = purchaseId.startsWith(PURCHASE_ID_PREFIXES.PURCHASE) ||
-                              purchaseId.startsWith(PURCHASE_ID_PREFIXES.RENEWAL);
-
   const expirationTimestamp = metadata.expirationDate ? toTimestamp(metadata.expirationDate) : null;
   const canceledAtTimestamp = metadata.unsubscribeDetectedAt ? toTimestamp(metadata.unsubscribeDetectedAt) : null;
   const billingIssueTimestamp = metadata.billingIssueDetectedAt ? toTimestamp(metadata.billingIssueDetectedAt) : null;
@@ -65,7 +68,7 @@ export function buildCreditsData({
     productId,
     platform,
     ...(purchaseHistory.length > 0 && { purchaseHistory }),
-    ...(isPurchaseOrRenewal && { lastPurchaseAt: serverTimestamp() }),
+    ...(isPurchaseOrRenewal(purchaseId) && { lastPurchaseAt: serverTimestamp() }),
     ...(expirationTimestamp && { expirationDate: expirationTimestamp }),
     ...(metadata.willRenew !== undefined && { willRenew: metadata.willRenew }),
     ...(metadata.storeTransactionId && { storeTransactionId: metadata.storeTransactionId }),

package/src/domains/credits/infrastructure/operations/CreditsWriter.ts

@@ -70,6 +70,15 @@ export async function syncPremiumMetadata(
  * Cross-user guard: if storeTransactionId is provided and already registered
  * to a different user in the global processedTransactions collection, the recovery
  * document is NOT created (the subscription belongs to another UID).
+ *
+ * NOTE: This uses non-atomic check-then-act (getDoc + setDoc). In theory, two concurrent
+ * calls could both see no document and create duplicates. However, this is extremely rare
+ * in practice because: (1) createRecoveryCreditsDocument is called after a successful
+ * purchase which is already serialized, (2) the global transaction check (below) prevents
+ * duplicates across users, (3) even if two recovery docs are created, the credits document
+ * logic is idempotent (same purchaseId processed twice is no-op). Making this atomic
+ * would require a transaction spanning both the credits doc and global processedTransactions,
+ * which adds complexity without meaningful benefit given the safeguards above.
  */
 export async function createRecoveryCreditsDocument(
   ref: DocumentReference,

package/src/domains/credits/presentation/deduct-credit/types.ts

@@ -6,7 +6,6 @@ export interface UseDeductCreditParams {
 export interface UseDeductCreditResult {
   checkCredits: (cost?: number) => Promise<boolean>;
   deductCredit: (cost?: number) => Promise<boolean>;
-  deductCredits: (cost: number) => Promise<boolean>;
   refundCredits: (amount: number) => Promise<boolean>;
   isDeducting: boolean;
 }

package/src/domains/credits/presentation/deduct-credit/useDeductCredit.ts

@@ -45,10 +45,6 @@ export const useDeductCredit = ({
     }
   }, [onCreditsExhausted, userId]);
 
-  const deductCredits = useCallback(async (cost: number): Promise<boolean> => {
-    return await deductCredit(cost);
-  }, [deductCredit]);
-
   const checkCredits = useCallback(async (cost: number = 1): Promise<boolean> => {
     if (!userId) return false;
     return repository.hasCredits(userId, cost);
@@ -77,7 +73,6 @@ export const useDeductCredit = ({
   return {
     checkCredits,
     deductCredit,
-    deductCredits,
     refundCredits,
     isDeducting: mutation.isPending
   };

package/src/domains/credits/utils/creditCalculations.ts

@@ -0,0 +1,171 @@
+/**
+ * Credit calculation utilities
+ * All credit-related calculations consolidated in one place
+ */
+
+import type { CreditsConfig } from "../core/Credits";
+import { isValidNumber, isNonNegativeNumber } from "../../../shared/utils/validators";
+import { detectPackageType } from "../../../utils/packageTypeDetector";
+import { getCreditAllocation } from "../../../utils/creditMapper";
+import { resolveSubscriptionStatus } from "../../subscription/core/SubscriptionStatus";
+import { isPast } from "../../../utils/dateUtils";
+import type { CalculateCreditsParams } from "../application/creditOperationUtils.types";
+
+// ============================================================================
+// VALIDATION HELPERS
+// ============================================================================
+
+const isValidBalance = (balance: number | null | undefined): balance is number => {
+  return isValidNumber(balance) && isNonNegativeNumber(balance);
+};
+
+const isValidCost = (cost: number): boolean => {
+  return isValidNumber(cost) && isNonNegativeNumber(cost);
+};
+
+const isValidMaxCredits = (max: number): boolean => {
+  return isValidNumber(max) && max > 0;
+};
+
+// ============================================================================
+// CREDIT AMOUNT CALCULATIONS
+// ============================================================================
+
+/**
+ * Calculate remaining credits after a deduction
+ * Ensures result is never negative (minimum 0)
+ */
+export function calculateRemaining(current: number, cost: number): number {
+  return Math.max(0, current - cost);
+}
+
+/**
+ * Check if a balance can afford a cost
+ * Returns false if balance is invalid or insufficient
+ */
+export function canAffordAmount(
+  balance: number | null | undefined,
+  cost: number
+): boolean {
+  if (!isValidBalance(balance) || !isValidCost(cost)) return false;
+  return balance >= cost;
+}
+
+/**
+ * Calculate percentage of current vs max credits
+ * Returns 0 for invalid inputs, clamped between 0-100
+ */
+export function calculateSafePercentage(
+  current: number | null | undefined,
+  max: number
+): number {
+  if (!isValidNumber(current) || !isValidMaxCredits(max)) return 0;
+  const percentage = (current / max) * 100;
+  return Math.min(Math.max(percentage, 0), 100);
+}
+
+/**
+ * Calculate credit limit for a product ID
+ * Throws if product ID is missing or limit cannot be determined
+ */
+export function calculateCreditLimit(
+  productId: string | undefined,
+  config: CreditsConfig
+): number {
+  if (!productId) {
+    throw new Error(
+      "[CreditCalculations] Cannot calculate credit limit without productId"
+    );
+  }
+
+  // Check for explicit amount override
+  const explicitAmount = config.creditPackageAmounts?.[productId];
+  if (
+    explicitAmount !== undefined &&
+    explicitAmount !== null &&
+    typeof explicitAmount === "number"
+  ) {
+    return explicitAmount;
+  }
+
+  // Calculate from package type allocations
+  const packageType = detectPackageType(productId);
+  const dynamicLimit = getCreditAllocation(packageType, config.packageAllocations);
+
+  if (dynamicLimit === null || dynamicLimit === undefined) {
+    throw new Error(
+      `[CreditCalculations] Cannot determine credit limit for productId: ${productId}, packageType: ${packageType}`
+    );
+  }
+
+  return dynamicLimit;
+}
+
+/**
+ * Calculate new credit balance for a purchase/subscription
+ * Takes into account: current balance, subscription status, package type, credit limit
+ */
+export function calculateNewCredits(params: CalculateCreditsParams): number {
+  const { metadata, existingData, creditLimit } = params;
+
+  // Determine if subscription is expired
+  const isExpired = metadata.expirationDate
+    ? isPast(metadata.expirationDate)
+    : false;
+  const isPremium = metadata.isPremium;
+
+  // Resolve subscription status
+  const status = resolveSubscriptionStatus({
+    isPremium,
+    willRenew: metadata.willRenew ?? false,
+    isExpired,
+    periodType: metadata.periodType ?? undefined,
+  });
+
+  // Import orchestrator lazily to avoid circular dependency
+  const { creditAllocationOrchestrator } = require("../application/credit-strategies/CreditAllocationOrchestrator");
+
+  return creditAllocationOrchestrator.allocate({
+    status,
+    existingData,
+    creditLimit,
+    isSubscriptionActive: isPremium && !isExpired,
+    productId: metadata.productId ?? null,
+  });
+}
+
+// ============================================================================
+// LOAD STATUS CALCULATIONS
+// ============================================================================
+
+/**
+ * Calculate credits load status from query state
+ */
+export function deriveCreditsLoadStatus(
+  queryStatus: "pending" | "error" | "success",
+  queryEnabled: boolean
+): "idle" | "loading" | "error" | "ready" {
+  if (!queryEnabled) return "idle";
+  if (queryStatus === "pending") return "loading";
+  if (queryStatus === "error") return "error";
+  return "ready";
+}
+
+/**
+ * Derive credit-related computed values
+ */
+export interface DerivedCreditValues {
+  hasCredits: boolean;
+  creditsPercent: number;
+}
+
+export function deriveCreditValues(
+  credits: { credits?: number | null } | null,
+  creditLimit: number
+): DerivedCreditValues {
+  const creditAmount = credits?.credits ?? 0;
+  const has = creditAmount > 0;
+  const percent = calculateSafePercentage(creditAmount, creditLimit);
+
+  return { hasCredits: has, creditsPercent: percent };
+}

package/src/domains/subscription/infrastructure/services/purchase/PurchaseErrorHandler.ts

@@ -24,24 +24,24 @@ export async function handleAlreadyPurchasedError(
 ): Promise<PurchaseResult> {
   try {
     const restoreResult = await handleRestore(deps, userId);
-    if (restoreResult.success && restoreResult.customerInfo) {
-      if (restoreResult.isPremium) {
-        await notifyPurchaseCompleted(
-          deps.config,
-          userId,
-          pkg.product.identifier,
-          restoreResult.customerInfo,
-          getSavedPurchase()?.source
-        );
-      }
-      clearSavedPurchase();
-      return {
-        success: true,
-        isPremium: restoreResult.isPremium ?? false,
-        customerInfo: restoreResult.customerInfo,
-        productId: restoreResult.productId || pkg.product.identifier,
-      };
+    // restoreResult.success is always true here (handleRestore throws on error)
+    // and restoreResult.customerInfo is always present (RevenueCat guarantees it)
+    if (restoreResult.isPremium) {
+      await notifyPurchaseCompleted(
+        deps.config,
+        userId,
+        pkg.product.identifier,
+        restoreResult.customerInfo,
+        getSavedPurchase()?.source
+      );
     }
+    clearSavedPurchase();
+    return {
+      success: true,
+      isPremium: restoreResult.isPremium ?? false,
+      customerInfo: restoreResult.customerInfo,
+      productId: restoreResult.productId ?? pkg.product.identifier,
+    };
   } catch (_restoreError) {
     throw new RevenueCatPurchaseError(
       "You already own this subscription, but restore failed. Please try restoring purchases manually.",
@@ -49,12 +49,6 @@ export async function handleAlreadyPurchasedError(
       error instanceof Error ? error : undefined
     );
   }
-
-  throw new RevenueCatPurchaseError(
-    "You already own this subscription, but it could not be activated.",
-    pkg.product.identifier,
-    error instanceof Error ? error : undefined
-  );
 }
 
 export function handlePurchaseError(

package/src/domains/subscription/infrastructure/utils/PremiumStatusSyncer.ts

@@ -3,7 +3,6 @@ import type { RevenueCatConfig } from "../../../revenuecat/core/types";
 import type { PurchaseSource } from "../../core/SubscriptionConstants";
 import type { PackageType } from "../../../revenuecat/core/types";
 import { getPremiumEntitlement } from "../../../revenuecat/core/types";
-import type { PeriodType } from "../../core/SubscriptionConstants";
 
 export async function syncPremiumStatus(
     config: RevenueCatConfig,
@@ -38,8 +37,8 @@ export async function syncPremiumStatus(
                 productId: premiumEntitlement.productIdentifier,
                 expirationDate: premiumEntitlement.expirationDate ?? null,
                 willRenew: premiumEntitlement.willRenew,
-                periodType: premiumEntitlement.periodType as PeriodType | undefined,
-                storeTransactionId: subscription?.storeTransactionId ?? undefined,
+                periodType: premiumEntitlement.periodType,
+                storeTransactionId: subscription?.storeTransactionId ?? null,
                 unsubscribeDetectedAt: premiumEntitlement.unsubscribeDetectedAt ?? null,
                 billingIssueDetectedAt: premiumEntitlement.billingIssueDetectedAt ?? null,
                 store: premiumEntitlement.store ?? null,

package/src/utils/dateUtils.core.ts

@@ -2,12 +2,18 @@ export type DateLike = Date | string | number;
 
 export function isPast(date: DateLike): boolean {
   const d = new Date(date);
-  return d.getTime() < Date.now();
+  const time = d.getTime();
+  // Invalid dates (NaN) are not considered past - they're invalid
+  if (isNaN(time)) return false;
+  return time < Date.now();
 }
 
 export function isFuture(date: DateLike): boolean {
   const d = new Date(date);
-  return d.getTime() > Date.now();
+  const time = d.getTime();
+  // Invalid dates (NaN) are not considered future - they're invalid
+  if (isNaN(time)) return false;
+  return time > Date.now();
 }
 
 export function isNow(date: DateLike, marginMs: number = 1000): boolean {