@zezosoft/react-native-zezopay 1.0.0

package/src/ZezoPay/utils/hooks/useZezoPay.ts

@@ -0,0 +1,325 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useAsync } from './useAsync';
+import {
+  ZezoPayClient,
+  type ICheckoutResult,
+  type ISummaryItem,
+  type PaymentProvider,
+  type ZezoPayCallbacks,
+  type HandlePayment,
+  type IReadyPaymentProvider,
+  type ICheckoutPayload,
+  type BaseCheckoutInput,
+} from '@zezosoft/zezopay-client';
+import { Platform } from 'react-native';
+import { Razorpay } from '../../Payments/Providers';
+
+export const allowedProviders: PaymentProvider[] = ['razorpay'];
+
+/**
+ * Parameters for the useZezoPay hook
+ * @interface UseZezoPayParams
+ */
+interface UseZezoPayParams {
+  publicKey: string;
+  userInfo: { _id: string; name: string; email?: string; phone?: string };
+  subscriptionId?: string;
+  digitalProductId?: string;
+  summaryItems?: ISummaryItem[];
+  handlePayment?: HandlePayment;
+  callback?: ZezoPayCallbacks;
+}
+
+/**
+ * Custom hook to handle payments with ZezoPay SDK.
+ * Manages payment providers, summary items, and checkout process.
+ * @param params - Configuration for the ZezoPay client
+ * @returns Object with payment state and methods
+ */
+export const useZezoPay = ({
+  publicKey,
+  userInfo,
+  subscriptionId,
+  digitalProductId,
+  summaryItems: initialItems = [],
+  handlePayment,
+  callback,
+}: UseZezoPayParams) => {
+  // Input validation
+  if (!publicKey) throw new Error('publicKey is required');
+  if (!userInfo?._id || !userInfo?.name)
+    throw new Error('userInfo must include _id and name');
+
+  // SDK client
+  const zezopay = useMemo(
+    () =>
+      new ZezoPayClient({
+        publicKey,
+        platform: Platform.OS === 'ios' ? 'ios' : 'android',
+      }),
+    [publicKey]
+  );
+
+  // States
+  const [selectedPayment, setSelectedPayment] =
+    useState<PaymentProvider | null>(null);
+  const [summaryItems, setSummaryItems] =
+    useState<ISummaryItem[]>(initialItems);
+  const [voucherCode, setVoucherCode] = useState('');
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [isSuccess, setIsSuccess] = useState(false);
+  const [error, setError] = useState('');
+
+  // Load payment providers
+  const {
+    result: providers,
+    loading,
+    error: providerError,
+  } = useAsync(async () => {
+    try {
+      const data = (await zezopay.payments.providers())?.data || [];
+      const filtered = data.filter((p: IReadyPaymentProvider) =>
+        allowedProviders.includes(p.provider as PaymentProvider)
+      );
+      if (!filtered.length) {
+        throw new Error('No supported payment providers available');
+      }
+      return filtered;
+    } catch (err) {
+      console.warn('Failed to load payment providers:', err);
+      throw new Error('Could not fetch payment providers');
+    }
+  }, [publicKey]);
+
+  // Auto-select first provider
+  useEffect(() => {
+    if (providers?.length && !selectedPayment) {
+      setSelectedPayment(providers[0]?.provider as PaymentProvider);
+    }
+  }, [providers, selectedPayment]);
+
+  // Total price calculation
+  const totalPrice = useMemo(() => {
+    if (!summaryItems.length) return 0;
+    return Number(
+      summaryItems
+        .reduce((sum, item) => {
+          let price = item.price || 0;
+          if (item.discount) {
+            if (typeof item.discount === 'number') {
+              price = (price * (100 - item.discount)) / 100;
+            } else if (item.discount.type === 'percentage') {
+              price = (price * (100 - item.discount.amount)) / 100;
+            } else if (item.discount.type === 'fixed') {
+              price = Math.max(0, price - item.discount.amount); // Prevent negative prices
+            }
+          }
+          return sum + price;
+        }, 0)
+        .toFixed(2)
+    );
+  }, [summaryItems]);
+
+  // Remove item from summary
+  const removeItem = useCallback((id: string | number) => {
+    setSummaryItems((prev) => prev.filter((item) => item.id !== id));
+  }, []);
+
+  // Default checkout handler
+  const defaultHandlePayment: HandlePayment = useCallback(
+    async ({
+      provider,
+      subscriptionId: subId,
+      digitalProductId: dpId,
+      userInfo: paymentUserInfo,
+    }) => {
+      if (!provider || !allowedProviders.includes(provider)) {
+        throw new Error(`Invalid payment provider: ${provider || 'none'}`);
+      }
+
+      // Common payload properties
+      const basePayload: BaseCheckoutInput = {
+        provider,
+        userId: paymentUserInfo._id,
+        metadata: { userInfo: paymentUserInfo },
+        ...(voucherCode && { coupon_code: voucherCode }), // Include coupon_code if provided
+      };
+
+      // Construct payload based on type
+      let payload: ICheckoutPayload;
+
+      if (subId) {
+        payload = {
+          ...basePayload,
+          type: 'subscription',
+          subscriptionId: subId,
+        };
+      } else if (dpId) {
+        payload = {
+          ...basePayload,
+          type: 'digital-product',
+          digitalProductId: dpId,
+        };
+      } else {
+        if (totalPrice <= 0) {
+          throw new Error(
+            'Price must be greater than zero for normal payments'
+          );
+        }
+        payload = { ...basePayload, type: 'normal', price: totalPrice };
+      }
+
+      try {
+        const result = await zezopay.payments.checkout(payload);
+        if (result.status !== 200) {
+          throw new Error(`Checkout failed with status: ${result.status}`);
+        }
+        return result.data;
+      } catch (err) {
+        console.warn('Checkout error:', err);
+        throw new Error('Failed to initiate checkout');
+      }
+    },
+    [voucherCode, totalPrice, zezopay.payments]
+  );
+
+  const paymentFn = handlePayment || defaultHandlePayment;
+
+  // Payment handler
+  const paymentHandler = useCallback(
+    async (order: ICheckoutResult) => {
+      if (!selectedPayment) {
+        throw new Error('No payment provider selected');
+      }
+      if (!order?.orderId || !order?.price || !order?.currency) {
+        throw new Error(
+          'Invalid order details: missing orderId, price, or currency'
+        );
+      }
+
+      try {
+        if (selectedPayment === 'razorpay') {
+          const razorpay = new Razorpay();
+          await razorpay.open({
+            amount: order.price * 100,
+            currency: order.currency,
+            order_id: order.orderId,
+            publicKey: order.publicKey || publicKey, // Fallback to publicKey
+            handler(response) {
+              if (response.razorpay_payment_id) {
+                callback?.onSuccess?.({
+                  status: 'success',
+                  order_id: response.razorpay_order_id,
+                  signature: response.razorpay_signature,
+                  payment_id: response.razorpay_payment_id,
+                });
+                setIsSuccess(true);
+                setError('');
+              } else {
+                const err = new Error('Payment failed: No payment ID received');
+                setError(err.message);
+                callback?.onFailure?.(err);
+              }
+            },
+            OnError(err) {
+              const errorMessage =
+                err?.description ||
+                err?.message ||
+                err?.details?.error?.description ||
+                'Payment failed unexpectedly';
+
+              setError(errorMessage);
+              callback?.onError?.(err);
+              callback?.onFailure?.(err);
+            },
+            prefill: {
+              user_email: userInfo.email,
+              user_name: userInfo.name,
+              user_phone: userInfo.phone,
+            },
+          });
+        } else {
+          throw new Error(`Unsupported payment provider: ${selectedPayment}`);
+        }
+      } catch (err) {
+        console.warn('Payment handler error:', err);
+        throw err;
+      }
+    },
+    [selectedPayment, userInfo, callback, publicKey]
+  );
+
+  // Handle pay now
+  const handlePayNow = useCallback(async () => {
+    if (isProcessing) return; // Prevent multiple submissions
+    if (!selectedPayment) {
+      setError('Please select a payment provider');
+      return;
+    }
+    if (!summaryItems.length) {
+      setError('Cart is empty. Add items to proceed.');
+      return;
+    }
+    if (totalPrice <= 0) {
+      setError('Total price must be greater than zero');
+      return;
+    }
+
+    setError('');
+    setIsProcessing(true); // ✅ Set processing to true at the start
+
+    try {
+      const order = await paymentFn({
+        provider: selectedPayment,
+        subscriptionId,
+        digitalProductId,
+        userInfo,
+      });
+
+      if (!order) {
+        const err = new Error('No order data returned from checkout');
+        setError(err.message);
+        callback?.onFailure?.(err);
+        return;
+      }
+
+      await paymentHandler(order);
+    } catch (err: any) {
+      const errorMessage = err.message || 'Payment failed unexpectedly';
+      setError(errorMessage);
+      callback?.onFailure?.(err);
+      console.warn('Payment error:', err);
+    } finally {
+      setIsProcessing(false); // ✅ Reset processing state
+    }
+  }, [
+    isProcessing,
+    selectedPayment,
+    summaryItems,
+    totalPrice,
+    paymentFn,
+    subscriptionId,
+    digitalProductId,
+    userInfo,
+    paymentHandler,
+    callback,
+  ]);
+
+  return {
+    selectedPayment,
+    setSelectedPayment,
+    summaryItems,
+    setSummaryItems,
+    totalPrice,
+    voucherCode,
+    setVoucherCode,
+    isProcessing,
+    isSuccess,
+    error,
+    providers: providers || [],
+    loading,
+    providerError,
+    removeItem,
+    handlePayNow,
+  };
+};

package/src/ZezoPay/utils/index.ts

@@ -0,0 +1,16 @@
+export function formatCurrency({
+  amount,
+  currency = 'INR',
+  minimumFractionDigits = 2,
+}: {
+  amount: number;
+  currency?: string;
+  minimumFractionDigits?: number;
+}): string {
+  return new Intl.NumberFormat('en-IN', {
+    style: 'currency',
+    currency,
+    minimumFractionDigits,
+    maximumFractionDigits: 2,
+  }).format(amount);
+}

package/src/index.tsx

@@ -0,0 +1 @@
+export * from './ZezoPay';