@zezosoft/react-native-zezopay 1.0.3 → 1.0.4

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

@@ -1,323 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useAsync } from './useAsync';
-import {
-  ZezoPayClient,
-  type ICheckoutResult,
-  type PaymentProvider,
-  type IReadyPaymentProvider,
-  type ICheckoutPayload,
-  type BaseCheckoutInput,
-} from '../../http/api-sdk';
-import { Razorpay } from '../../Payments/Providers';
-import type {
-  HandlePayment,
-  ISummaryItem,
-  ZezoPayCallbacks,
-} from '../../types';
-import { Platform } from 'react-native';
-
-export const SUPPORTED_PROVIDERS: PaymentProvider[] = ['razorpay'];
-
-interface UseZezoPayParams {
-  publicKey: string;
-  user: { _id: string; name: string; email?: string; phone?: string };
-  subscriptionId?: string;
-  productId?: string;
-  cart?: ISummaryItem[];
-  paymentHandler?: HandlePayment;
-  callbacks?: ZezoPayCallbacks;
-}
-
-export const useZezoPay = ({
-  publicKey,
-  user,
-  subscriptionId,
-  productId,
-  cart: initialCart = [],
-  paymentHandler: customHandler,
-  callbacks,
-}: UseZezoPayParams) => {
-  if (!publicKey) throw new Error('publicKey is required');
-  if (!user?._id || !user?.name) throw new Error('User must have _id and name');
-
-  const client = useMemo(() => new ZezoPayClient({ publicKey }), [publicKey]);
-
-  // States
-  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('');
-
-  // Fetch available providers
-  const {
-    result: providers,
-    loading,
-    error: providersError,
-  } = useAsync(async () => {
-    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
-  useEffect(() => {
-    if (providers?.length && !provider)
-      setProvider(providers?.[0]?.provider as PaymentProvider);
-  }, [providers, provider]);
-
-  // 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]);
-
-  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 defaultHandler: HandlePayment = useCallback(
-    async ({
-      provider: checkoutProvider,
-      subscriptionId: subId,
-      digitalProductId: prodId,
-      userInfo,
-    }) => {
-      if (!checkoutProvider || !SUPPORTED_PROVIDERS.includes(checkoutProvider))
-        throw new Error(`Invalid provider: ${checkoutProvider}`);
-
-      const basePayload: BaseCheckoutInput = {
-        provider: checkoutProvider,
-        userId: userInfo._id,
-        metadata: { userInfo, ...(cartItems.length && { summary: cartItems }) },
-        ...(coupon && { coupon_code: coupon }),
-      };
-
-      let payload: ICheckoutPayload;
-      if (subId)
-        payload = {
-          ...basePayload,
-          type: 'subscription',
-          subscriptionId: subId,
-        };
-      else if (prodId)
-        payload = {
-          ...basePayload,
-          type: 'digital-product',
-          digitalProductId: prodId,
-        };
-      else {
-        if (rawAmount <= 0) throw new Error('Amount must be greater than zero');
-        payload = { ...basePayload, type: 'normal', price: rawAmount };
-      }
-
-      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;
-    },
-    [coupon, client.payments, cartItems, rawAmount]
-  );
-
-  const executePayment = customHandler || defaultHandler;
-
-  // Razorpay payment processor
-  const processPayment = useCallback(
-    async (order: ICheckoutResult) => {
-      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 {
-        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
-            )
-          );
-
-        setCoupon(code);
-      } catch (err: any) {
-        setError(err?.message || 'Coupon verification failed');
-      } finally {
-        setCouponLoading(false);
-      }
-    },
-    [client.payments, user._id]
-  );
-
-  // 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('');
-    setLoadingPayment(true);
-
-    try {
-      const order = await executePayment({
-        provider,
-        subscriptionId,
-        digitalProductId: productId,
-        userInfo: user,
-        metadata: {
-          userInfo: user,
-          ...(cartItems.length && { summary: cartItems }),
-        },
-      });
-      if (!order) throw new Error('No order data returned');
-      await processPayment(order);
-    } catch (err: any) {
-      setError(err.message || 'Payment failed');
-      callbacks?.onError?.(err);
-    } finally {
-      setLoadingPayment(false);
-    }
-  }, [
-    loadingPayment,
-    provider,
-    cartItems,
-    totalAmount,
-    executePayment,
-    subscriptionId,
-    productId,
-    user,
-    processPayment,
-    callbacks,
-  ]);
-
-  return {
-    provider,
-    setProvider,
-    cartItems,
-    setCartItems,
-    totalAmount,
-    coupon,
-    setCoupon,
-    couponLoading,
-    removeCoupon,
-    loadingPayment,
-    success,
-    error,
-    providers: providers || [],
-    loading,
-    providersError,
-    removeItem,
-    payNow,
-    applyCoupon,
-  };
-};

package/src/ZezoPay/utils/index.ts

@@ -1,16 +0,0 @@
-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

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