@umituz/react-native-subscription 2.27.141 → 2.27.142

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-subscription",
-  "version": "2.27.141",
+  "version": "2.27.142",
   "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/paywall/components/PaywallContainer.tsx

@@ -1,19 +1,12 @@
-/**
- * PaywallContainer Component
- * Uses centralized pending purchase state - no local auth handling
- * Apple Guideline 3.1.2 compliant trial display
- */
-
-import React, { useMemo, useEffect } from "react";
+import React, { useMemo } from "react";
 import { usePaywallVisibility } from "../../subscription/presentation/usePaywallVisibility";
 import { useSubscriptionPackages } from "../../subscription/infrastructure/hooks/useSubscriptionPackages";
 import { useRevenueCatTrialEligibility } from "../../subscription/infrastructure/hooks/useRevenueCatTrialEligibility";
 import { createCreditAmountsFromPackages } from "../../../utils/creditMapper";
 import { PaywallModal } from "./PaywallModal";
-import type { TrialEligibilityInfo } from "./PaywallModal.types";
-
 import { usePaywallActions } from "../hooks/usePaywallActions";
 import { useAuthAwarePurchase } from "../../subscription/presentation/useAuthAwarePurchase";
+import { useTrialEligibilityCheck } from "../hooks/useTrialEligibilityCheck";
 import type { PaywallContainerProps } from "./PaywallContainer.types";
 
 export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
@@ -59,62 +52,13 @@ export const PaywallContainer: React.FC<PaywallContainerProps> = (props) => {
     onClose: handleClose,
   });
 
-  // Check trial eligibility only if trialConfig is enabled
-  // Use ref to track if we've already checked for these packages to avoid redundant calls
-  const checkedPackagesRef = React.useRef<string[]>([]);
-
-  useEffect(() => {
-    if (!trialConfig?.enabled) return;
-    if (packages.length === 0) return;
-    if (isLoading) return; // Wait for packages to fully load
-
-    // Get current package identifiers
-    const currentPackageIds = packages.map((pkg) => pkg.product.identifier);
-    const sortedIds = [...currentPackageIds].sort().join(",");
-
-    // Skip if we've already checked these exact packages
-    if (checkedPackagesRef.current.join(",") === sortedIds) {
-      return;
-    }
-
-    // Update ref
-    checkedPackagesRef.current = currentPackageIds;
-
-    // Get all actual product IDs from packages
-    const allProductIds = packages.map((pkg) => pkg.product.identifier);
-
-    // If eligibleProductIds are provided, filter to matching packages (partial match)
-    // e.g., "yearly" matches "futureus.yearly"
-    let productIdsToCheck: string[];
-    if (trialConfig.eligibleProductIds?.length) {
-      productIdsToCheck = allProductIds.filter((actualId) =>
-        trialConfig.eligibleProductIds?.some((configId) =>
-          actualId.toLowerCase().includes(configId.toLowerCase())
-        )
-      );
-    } else {
-      productIdsToCheck = allProductIds;
-    }
-
-    if (productIdsToCheck.length > 0) {
-      checkEligibility(productIdsToCheck);
-    }
-  }, [packages, isLoading, checkEligibility, trialConfig?.enabled, trialConfig?.eligibleProductIds]);
-
-  // Convert eligibility map to format expected by PaywallModal
-  // Only process if trial is enabled
-  const trialEligibility = useMemo((): Record<string, TrialEligibilityInfo> => {
-    if (!trialConfig?.enabled) return {};
-
-    const result: Record<string, TrialEligibilityInfo> = {};
-    for (const [productId, info] of Object.entries(eligibilityMap)) {
-      result[productId] = {
-        eligible: info.eligible,
-        durationDays: trialConfig.durationDays ?? info.trialDurationDays ?? 7,
-      };
-    }
-    return result;
-  }, [eligibilityMap, trialConfig?.enabled, trialConfig?.durationDays]);
+  const trialEligibility = useTrialEligibilityCheck({
+    packages,
+    isLoading,
+    eligibilityMap,
+    checkEligibility,
+    trialConfig,
+  });
 
   // Compute credit amounts from packageAllocations if not provided directly
   const creditAmounts = useMemo(() => {

package/src/domains/paywall/hooks/useTrialEligibilityCheck.ts

@@ -0,0 +1,65 @@
+import { useEffect, useRef, useMemo } from "react";
+import type { PurchasesPackage } from "react-native-purchases";
+import type { TrialEligibilityInfo } from "../components/PaywallModal.types";
+import type { PaywallContainerProps } from "../components/PaywallContainer.types";
+
+interface UseTrialEligibilityCheckParams {
+  packages: PurchasesPackage[];
+  isLoading: boolean;
+  eligibilityMap: Record<string, { eligible: boolean; trialDurationDays?: number }>;
+  checkEligibility: (productIds: string[]) => void;
+  trialConfig: PaywallContainerProps["trialConfig"];
+}
+
+export const useTrialEligibilityCheck = ({
+  packages,
+  isLoading,
+  eligibilityMap,
+  checkEligibility,
+  trialConfig,
+}: UseTrialEligibilityCheckParams) => {
+  const checkedPackagesRef = useRef<string[]>([]);
+
+  useEffect(() => {
+    if (!trialConfig?.enabled || packages.length === 0 || isLoading) return;
+
+    const currentPackageIds = packages.map((pkg) => pkg.product.identifier);
+    const sortedIds = [...currentPackageIds].sort().join(",");
+
+    if (checkedPackagesRef.current.join(",") === sortedIds) return;
+
+    checkedPackagesRef.current = currentPackageIds;
+
+    const allProductIds = packages.map((pkg) => pkg.product.identifier);
+
+    let productIdsToCheck: string[];
+    if (trialConfig.eligibleProductIds?.length) {
+      productIdsToCheck = allProductIds.filter((actualId) =>
+        trialConfig.eligibleProductIds?.some((configId) =>
+          actualId.toLowerCase().includes(configId.toLowerCase())
+        )
+      );
+    } else {
+      productIdsToCheck = allProductIds;
+    }
+
+    if (productIdsToCheck.length > 0) {
+      checkEligibility(productIdsToCheck);
+    }
+  }, [packages, isLoading, checkEligibility, trialConfig?.enabled, trialConfig?.eligibleProductIds]);
+
+  const trialEligibility = useMemo((): Record<string, TrialEligibilityInfo> => {
+    if (!trialConfig?.enabled) return {};
+
+    const result: Record<string, TrialEligibilityInfo> = {};
+    for (const [productId, info] of Object.entries(eligibilityMap)) {
+      result[productId] = {
+        eligible: info.eligible,
+        durationDays: trialConfig.durationDays ?? info.trialDurationDays ?? 7,
+      };
+    }
+    return result;
+  }, [eligibilityMap, trialConfig?.enabled, trialConfig?.durationDays]);
+
+  return trialEligibility;
+};

package/src/domains/wallet/domain/errors/WalletError.ts

@@ -1,141 +1,17 @@
-/**
- * Wallet Error
- *
- * Custom error classes for wallet and payment operations.
- * Follows the same pattern as SubscriptionError.
- */
-
-import { WALLET_ERROR_MESSAGES } from "./WalletErrorMessages";
-
-export type WalletErrorCategory =
-  | "PAYMENT"
-  | "VALIDATION"
-  | "INFRASTRUCTURE"
-  | "BUSINESS";
-
-export abstract class WalletError extends Error {
-  abstract readonly code: string;
-  abstract readonly userMessage: string;
-  abstract readonly category: WalletErrorCategory;
-
-  constructor(
-    message: string,
-    public readonly cause?: Error
-  ) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      userMessage: this.userMessage,
-      category: this.category,
-      message: this.message,
-      cause: this.cause?.message,
-    };
-  }
-}
-
-export class PaymentValidationError extends WalletError {
-  readonly code = "PAYMENT_VALIDATION_ERROR";
-  readonly category = "PAYMENT" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.PAYMENT_VALIDATION_FAILED;
-
-  constructor(message: string, cause?: Error) {
-    super(message, cause);
-  }
-}
-
-export class PaymentProviderError extends WalletError {
-  readonly code = "PAYMENT_PROVIDER_ERROR";
-  readonly category = "PAYMENT" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.PAYMENT_PROVIDER_ERROR;
-
-  constructor(message: string, cause?: Error) {
-    super(message, cause);
-  }
-}
-
-export class DuplicatePaymentError extends WalletError {
-  readonly code = "DUPLICATE_PAYMENT";
-  readonly category = "PAYMENT" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.DUPLICATE_PAYMENT;
-}
-
-export class UserValidationError extends WalletError {
-  readonly code = "USER_VALIDATION_ERROR";
-  readonly category = "VALIDATION" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.USER_VALIDATION_FAILED;
-}
-
-export class PackageValidationError extends WalletError {
-  readonly code = "PACKAGE_VALIDATION_ERROR";
-  readonly category = "VALIDATION" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.PACKAGE_VALIDATION_FAILED;
-}
-
-export class ReceiptValidationError extends WalletError {
-  readonly code = "RECEIPT_VALIDATION_ERROR";
-  readonly category = "VALIDATION" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.RECEIPT_VALIDATION_FAILED;
-}
-
-export class TransactionError extends WalletError {
-  readonly code = "TRANSACTION_ERROR";
-  readonly category = "INFRASTRUCTURE" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.TRANSACTION_FAILED;
-
-  constructor(message: string, cause?: Error) {
-    super(message, cause);
-  }
-}
-
-export class NetworkError extends WalletError {
-  readonly code = "NETWORK_ERROR";
-  readonly category = "INFRASTRUCTURE" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.NETWORK_ERROR;
-
-  constructor(message: string, cause?: Error) {
-    super(message, cause);
-  }
-}
-
-export class CreditLimitError extends WalletError {
-  readonly code = "CREDIT_LIMIT_ERROR";
-  readonly category = "BUSINESS" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.CREDIT_LIMIT_EXCEEDED;
-}
-
-export class RefundError extends WalletError {
-  readonly code = "REFUND_ERROR";
-  readonly category = "BUSINESS" as const;
-  readonly userMessage = WALLET_ERROR_MESSAGES.REFUND_FAILED;
-
-  constructor(message: string, cause?: Error) {
-    super(message, cause);
-  }
-}
-
-export function handleWalletError(error: unknown): WalletError {
-  if (error instanceof WalletError) {
-    return error;
-  }
-
-  if (error instanceof Error) {
-    const message = error.message.toLowerCase();
-
-    if (message.includes("network") || message.includes("timeout")) {
-      return new NetworkError(error.message, error);
-    }
-
-    if (message.includes("permission") || message.includes("unauthorized")) {
-      return new UserValidationError("Authentication failed");
-    }
-
-    return new TransactionError(error.message, error);
-  }
-
-  return new TransactionError("Unexpected error occurred");
-}
+export type { WalletErrorCategory } from "./WalletError.types";
+export { WalletError } from "./WalletError.types";
+
+export {
+  PaymentValidationError,
+  PaymentProviderError,
+  DuplicatePaymentError,
+  UserValidationError,
+  PackageValidationError,
+  ReceiptValidationError,
+  TransactionError,
+  NetworkError,
+  CreditLimitError,
+  RefundError,
+} from "./WalletErrorClasses";
+
+export { handleWalletError } from "./WalletErrorFactory";

package/src/domains/wallet/domain/errors/WalletError.types.ts

@@ -0,0 +1,30 @@
+export type WalletErrorCategory =
+  | "PAYMENT"
+  | "VALIDATION"
+  | "INFRASTRUCTURE"
+  | "BUSINESS";
+
+export abstract class WalletError extends Error {
+  abstract readonly code: string;
+  abstract readonly userMessage: string;
+  abstract readonly category: WalletErrorCategory;
+
+  constructor(
+    message: string,
+    public readonly cause?: Error
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      userMessage: this.userMessage,
+      category: this.category,
+      message: this.message,
+      cause: this.cause?.message,
+    };
+  }
+}

package/src/domains/wallet/domain/errors/WalletErrorClasses.ts

@@ -0,0 +1,82 @@
+import { WalletError } from "./WalletError.types";
+import { WALLET_ERROR_MESSAGES } from "./WalletErrorMessages";
+
+export class PaymentValidationError extends WalletError {
+  readonly code = "PAYMENT_VALIDATION_ERROR";
+  readonly category = "PAYMENT" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.PAYMENT_VALIDATION_FAILED;
+
+  constructor(message: string, cause?: Error) {
+    super(message, cause);
+  }
+}
+
+export class PaymentProviderError extends WalletError {
+  readonly code = "PAYMENT_PROVIDER_ERROR";
+  readonly category = "PAYMENT" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.PAYMENT_PROVIDER_ERROR;
+
+  constructor(message: string, cause?: Error) {
+    super(message, cause);
+  }
+}
+
+export class DuplicatePaymentError extends WalletError {
+  readonly code = "DUPLICATE_PAYMENT";
+  readonly category = "PAYMENT" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.DUPLICATE_PAYMENT;
+}
+
+export class UserValidationError extends WalletError {
+  readonly code = "USER_VALIDATION_ERROR";
+  readonly category = "VALIDATION" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.USER_VALIDATION_FAILED;
+}
+
+export class PackageValidationError extends WalletError {
+  readonly code = "PACKAGE_VALIDATION_ERROR";
+  readonly category = "VALIDATION" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.PACKAGE_VALIDATION_FAILED;
+}
+
+export class ReceiptValidationError extends WalletError {
+  readonly code = "RECEIPT_VALIDATION_ERROR";
+  readonly category = "VALIDATION" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.RECEIPT_VALIDATION_FAILED;
+}
+
+export class TransactionError extends WalletError {
+  readonly code = "TRANSACTION_ERROR";
+  readonly category = "INFRASTRUCTURE" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.TRANSACTION_FAILED;
+
+  constructor(message: string, cause?: Error) {
+    super(message, cause);
+  }
+}
+
+export class NetworkError extends WalletError {
+  readonly code = "NETWORK_ERROR";
+  readonly category = "INFRASTRUCTURE" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.NETWORK_ERROR;
+
+  constructor(message: string, cause?: Error) {
+    super(message, cause);
+  }
+}
+
+export class CreditLimitError extends WalletError {
+  readonly code = "CREDIT_LIMIT_ERROR";
+  readonly category = "BUSINESS" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.CREDIT_LIMIT_EXCEEDED;
+}
+
+export class RefundError extends WalletError {
+  readonly code = "REFUND_ERROR";
+  readonly category = "BUSINESS" as const;
+  readonly userMessage = WALLET_ERROR_MESSAGES.REFUND_FAILED;
+
+  constructor(message: string, cause?: Error) {
+    super(message, cause);
+  }
+}

package/src/domains/wallet/domain/errors/WalletErrorFactory.ts

@@ -0,0 +1,24 @@
+import { WalletError } from "./WalletError.types";
+import { NetworkError, UserValidationError, TransactionError } from "./WalletErrorClasses";
+
+export const handleWalletError = (error: unknown): WalletError => {
+  if (error instanceof WalletError) {
+    return error;
+  }
+
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+
+    if (message.includes("network") || message.includes("timeout")) {
+      return new NetworkError(error.message, error);
+    }
+
+    if (message.includes("permission") || message.includes("unauthorized")) {
+      return new UserValidationError("Authentication failed");
+    }
+
+    return new TransactionError(error.message, error);
+  }
+
+  return new TransactionError("Unexpected error occurred");
+};