@zezosoft/react-native-zezopay 1.0.2 → 1.0.3

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

@@ -3,318 +3,321 @@ 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';
+} from '../../http/api-sdk';
 import { Razorpay } from '../../Payments/Providers';
+import type {
+  HandlePayment,
+  ISummaryItem,
+  ZezoPayCallbacks,
+} from '../../types';
+import { Platform } from 'react-native';
 
-export const allowedProviders: PaymentProvider[] = ['razorpay'];
+export const SUPPORTED_PROVIDERS: PaymentProvider[] = ['razorpay'];
 
-/**
- * Parameters for the useZezoPay hook
- * @interface UseZezoPayParams
- */
 interface UseZezoPayParams {
   publicKey: string;
-  userInfo: { _id: string; name: string; email?: string; phone?: string };
+  user: { _id: string; name: string; email?: string; phone?: string };
   subscriptionId?: string;
-  digitalProductId?: string;
-  summaryItems?: ISummaryItem[];
-  handlePayment?: HandlePayment;
-  callback?: ZezoPayCallbacks;
+  productId?: string;
+  cart?: ISummaryItem[];
+  paymentHandler?: HandlePayment;
+  callbacks?: 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,
+  user,
   subscriptionId,
-  digitalProductId,
-  summaryItems: initialItems = [],
-  handlePayment,
-  callback,
+  productId,
+  cart: initialCart = [],
+  paymentHandler: customHandler,
+  callbacks,
 }: 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');
+  if (!user?._id || !user?.name) throw new Error('User must have _id and name');
 
-  // SDK client
-  const zezopay = useMemo(
-    () =>
-      new ZezoPayClient({
-        publicKey,
-        platform: Platform.OS === 'ios' ? 'ios' : 'android',
-      }),
-    [publicKey]
-  );
+  const client = useMemo(() => new ZezoPayClient({ publicKey }), [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 [provider, setProvider] = useState<PaymentProvider | null>(null);
+  const [cartItems, setCartItems] = useState<ISummaryItem[]>(initialCart);
+  const [coupon, setCoupon] = useState('');
+  const [loadingPayment, setLoadingPayment] = useState(false);
+  const [couponLoading, setCouponLoading] = useState(false); // ✅ coupon loading
+  const [success, setSuccess] = useState(false);
   const [error, setError] = useState('');
 
-  // Load payment providers
+  // Fetch available providers
   const {
     result: providers,
     loading,
-    error: providerError,
+    error: providersError,
   } = 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) {
-      throw err;
-    }
+    const data =
+      (
+        await client.payments.providers({
+          platform: Platform.OS as 'ios' | 'android',
+        })
+      )?.data || [];
+    const supported = data.filter((p: IReadyPaymentProvider) =>
+      SUPPORTED_PROVIDERS.includes(p.provider as PaymentProvider)
+    );
+    if (!supported.length)
+      throw new Error('No supported payment providers available');
+    return supported;
   }, [publicKey]);
 
-  // Auto-select first provider
+  // Auto select first provider
   useEffect(() => {
-    if (providers?.length && !selectedPayment) {
-      setSelectedPayment(providers[0]?.provider as PaymentProvider);
-    }
-  }, [providers, selectedPayment]);
+    if (providers?.length && !provider)
+      setProvider(providers?.[0]?.provider as PaymentProvider);
+  }, [providers, provider]);
 
-  // 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]);
+  // Cart totals
+  const totalAmount = useMemo(() => {
+    return cartItems.reduce((sum, item) => {
+      let price = item.price || 0;
+      if (item.discount) {
+        if (typeof item.discount === 'number')
+          price *= (100 - item.discount) / 100;
+        else if (item.discount.type === 'percentage')
+          price *= (100 - item.discount.amount) / 100;
+        else if (item.discount.type === 'fixed')
+          price = Math.max(0, price - item.discount.amount);
+      }
+      return sum + price;
+    }, 0);
+  }, [cartItems]);
 
-  // Remove item from summary
-  const removeItem = useCallback((id: string | number) => {
-    setSummaryItems((prev) => prev.filter((item) => item.id !== id));
-  }, []);
+  const rawAmount = useMemo(
+    () => cartItems.reduce((sum, item) => sum + (item.price || 0), 0),
+    [cartItems]
+  );
+
+  const removeItem = useCallback(
+    (id: string | number) =>
+      setCartItems((prev) => prev.filter((item) => item.id !== id)),
+    []
+  );
 
   // Default checkout handler
-  const defaultHandlePayment: HandlePayment = useCallback(
+  const defaultHandler: HandlePayment = useCallback(
     async ({
-      provider,
+      provider: checkoutProvider,
       subscriptionId: subId,
-      digitalProductId: dpId,
-      userInfo: paymentUserInfo,
+      digitalProductId: prodId,
+      userInfo,
     }) => {
-      if (!provider || !allowedProviders.includes(provider)) {
-        throw new Error(`Invalid payment provider: ${provider || 'none'}`);
-      }
+      if (!checkoutProvider || !SUPPORTED_PROVIDERS.includes(checkoutProvider))
+        throw new Error(`Invalid provider: ${checkoutProvider}`);
 
-      // Common payload properties
       const basePayload: BaseCheckoutInput = {
-        provider,
-        userId: paymentUserInfo._id,
-        metadata: { userInfo: paymentUserInfo },
-        ...(voucherCode && { coupon_code: voucherCode }), // Include coupon_code if provided
+        provider: checkoutProvider,
+        userId: userInfo._id,
+        metadata: { userInfo, ...(cartItems.length && { summary: cartItems }) },
+        ...(coupon && { coupon_code: coupon }),
       };
 
-      // Construct payload based on type
       let payload: ICheckoutPayload;
-
-      if (subId) {
+      if (subId)
         payload = {
           ...basePayload,
           type: 'subscription',
           subscriptionId: subId,
         };
-      } else if (dpId) {
+      else if (prodId)
         payload = {
           ...basePayload,
           type: 'digital-product',
-          digitalProductId: dpId,
+          digitalProductId: prodId,
         };
-      } else {
-        if (totalPrice <= 0) {
-          throw new Error(
-            'Price must be greater than zero for normal payments'
-          );
-        }
-        payload = { ...basePayload, type: 'normal', price: totalPrice };
+      else {
+        if (rawAmount <= 0) throw new Error('Amount must be greater than zero');
+        payload = { ...basePayload, type: 'normal', price: rawAmount };
       }
 
-      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) {
-        throw err;
-      }
+      const result = await client.payments.checkout({
+        ...payload,
+        ...(coupon && { coupon_code: coupon }),
+      });
+      if (result.status !== 200)
+        throw new Error(`Checkout failed with status ${result.status}`);
+      return result.data;
     },
-    [voucherCode, totalPrice, zezopay.payments]
+    [coupon, client.payments, cartItems, rawAmount]
   );
 
-  const paymentFn = handlePayment || defaultHandlePayment;
+  const executePayment = customHandler || defaultHandler;
 
-  // Payment handler
-  const paymentHandler = useCallback(
+  // Razorpay payment processor
+  const processPayment = 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'
-        );
-      }
+      if (!provider) throw new Error('No payment provider selected');
+      if (!order?.orderId || !order?.price || !order?.currency)
+        throw new Error('Invalid order');
+
+      if (provider === 'razorpay') {
+        const razorpay = new Razorpay();
+        await razorpay.open({
+          amount: order.price * 100,
+          currency: order.currency,
+          order_id: order.orderId,
+          publicKey: order.publicKey || publicKey,
+          handler(response) {
+            if (response.razorpay_payment_id) {
+              callbacks?.onSuccess?.({
+                status: 'success',
+                order_id: response.razorpay_order_id,
+                signature: response.razorpay_signature,
+                payment_id: response.razorpay_payment_id,
+              });
+              setSuccess(true);
+              setError('');
+            } else {
+              const err = new Error('Payment failed: missing payment ID');
+              setError(err.message);
+              callbacks?.onFailure?.(err);
+            }
+          },
+          OnError(err) {
+            const msg =
+              err?.description ||
+              err?.message ||
+              err?.details?.error?.description ||
+              'Payment failed';
+            setError(msg);
+            callbacks?.onFailure?.(err);
+          },
+          prefill: {
+            user_email: user.email,
+            user_name: user.name,
+            user_phone: user.phone,
+          },
+        });
+      } else throw new Error(`Unsupported provider: ${provider}`);
+    },
+    [provider, user, callbacks, publicKey]
+  );
+
+  // Apply coupon
+  const applyCoupon = useCallback(
+    async (code: string) => {
+      if (!code) return;
+      setCouponLoading(true);
+      setError('');
 
       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';
+        const res = await client.payments.verifyCoupon({
+          userId: user._id,
+          code,
+        });
+        const data = res?.data?.data;
+
+        if (!data || res.status !== 200)
+          return setError(res?.data?.message || 'Invalid or expired coupon');
+
+        if (data.type === 'percentage')
+          setCartItems((prev) =>
+            prev.map((item) => ({
+              ...item,
+              discount: { type: 'percentage', amount: data.discount },
+            }))
+          );
+        else if (data.type === 'amount')
+          setCartItems((prev) =>
+            prev.map((item, i) =>
+              i === 0
+                ? {
+                    ...item,
+                    discount: { type: 'fixed', amount: data.discount },
+                  }
+                : item
+            )
+          );
 
-              setError(errorMessage);
-              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) {
-        throw err;
+        setCoupon(code);
+      } catch (err: any) {
+        setError(err?.message || 'Coupon verification failed');
+      } finally {
+        setCouponLoading(false);
       }
     },
-    [selectedPayment, userInfo, callback, publicKey]
+    [client.payments, user._id]
   );
 
-  // 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;
-    }
+  // Remove coupon
+  const removeCoupon = useCallback(() => {
+    setCoupon('');
+    setCartItems((prev) =>
+      prev.map((item) => ({ ...item, discount: undefined }))
+    );
+    setError('');
+  }, []);
+
+  // Pay now
+  const payNow = useCallback(async () => {
+    if (loadingPayment) return;
+    if (!provider) return setError('Select a payment provider');
+    if (!cartItems.length) return setError('Cart is empty');
+    if (totalAmount <= 0) return setError('Amount must be greater than zero');
 
     setError('');
-    setIsProcessing(true); // ✅ Set processing to true at the start
+    setLoadingPayment(true);
 
     try {
-      const order = await paymentFn({
-        provider: selectedPayment,
+      const order = await executePayment({
+        provider,
         subscriptionId,
-        digitalProductId,
-        userInfo,
+        digitalProductId: productId,
+        userInfo: user,
+        metadata: {
+          userInfo: user,
+          ...(cartItems.length && { summary: cartItems }),
+        },
       });
-
-      if (!order) {
-        const err = new Error('No order data returned from checkout');
-        setError(err.message);
-        callback?.onError?.(err);
-        return;
-      }
-
-      await paymentHandler(order);
+      if (!order) throw new Error('No order data returned');
+      await processPayment(order);
     } catch (err: any) {
-      const errorMessage = err.message || 'Payment failed unexpectedly';
-      setError(errorMessage);
-      callback?.onError?.(err);
+      setError(err.message || 'Payment failed');
+      callbacks?.onError?.(err);
     } finally {
-      setIsProcessing(false);
+      setLoadingPayment(false);
     }
   }, [
-    isProcessing,
-    selectedPayment,
-    summaryItems,
-    totalPrice,
-    paymentFn,
+    loadingPayment,
+    provider,
+    cartItems,
+    totalAmount,
+    executePayment,
     subscriptionId,
-    digitalProductId,
-    userInfo,
-    paymentHandler,
-    callback,
+    productId,
+    user,
+    processPayment,
+    callbacks,
   ]);
 
   return {
-    selectedPayment,
-    setSelectedPayment,
-    summaryItems,
-    setSummaryItems,
-    totalPrice,
-    voucherCode,
-    setVoucherCode,
-    isProcessing,
-    isSuccess,
+    provider,
+    setProvider,
+    cartItems,
+    setCartItems,
+    totalAmount,
+    coupon,
+    setCoupon,
+    couponLoading,
+    removeCoupon,
+    loadingPayment,
+    success,
     error,
     providers: providers || [],
     loading,
-    providerError,
+    providersError,
     removeItem,
-    handlePayNow,
+    payNow,
+    applyCoupon,
   };
 };