@mohasinac/appkit 4.41.17 → 4.42.0

package/dist/features/checkout/hooks/useCheckout.d.ts

@@ -1,9 +0,0 @@
-import type { CheckoutState, CheckoutStep, UserAddress, ShippingOption, PaymentGateway } from "../types";
-export declare function useCheckout(initial?: Partial<CheckoutState>): {
-    state: CheckoutState;
-    setStep: (step: CheckoutStep) => void;
-    setAddress: (address: UserAddress) => void;
-    setShipping: (option: ShippingOption) => void;
-    setPayment: (gateway: PaymentGateway) => void;
-    setCoupon: (code: string) => void;
-};

package/dist/features/checkout/hooks/useCheckout.js

@@ -1,24 +0,0 @@
-"use client";
-import { useState, useCallback } from "react";
-export function useCheckout(initial) {
-    const [state, setState] = useState({
-        step: "address",
-        ...initial,
-    });
-    const setStep = useCallback((step) => {
-        setState((s) => ({ ...s, step }));
-    }, []);
-    const setAddress = useCallback((address) => {
-        setState((s) => ({ ...s, address, step: "shipping" }));
-    }, []);
-    const setShipping = useCallback((option) => {
-        setState((s) => ({ ...s, shippingOption: option, step: "payment" }));
-    }, []);
-    const setPayment = useCallback((gateway) => {
-        setState((s) => ({ ...s, paymentGateway: gateway, step: "review" }));
-    }, []);
-    const setCoupon = useCallback((code) => {
-        setState((s) => ({ ...s, couponCode: code }));
-    }, []);
-    return { state, setStep, setAddress, setShipping, setPayment, setCoupon };
-}

package/dist/features/checkout/hooks/useCheckoutApi.d.ts

@@ -1,72 +0,0 @@
-export interface AddressListResponse<TAddress = any> {
-    data: TAddress[];
-}
-export interface CartApiResponse<TCart = any> {
-    cart: TCart;
-    itemCount: number;
-    subtotal: number;
-}
-export interface PlaceOrderResponse {
-    orderIds: string[];
-    total: number;
-    itemCount: number;
-    unavailableItems?: UnavailableItem[];
-}
-export interface UnavailableItem {
-    productId: string;
-    productTitle: string;
-    requestedQty: number;
-    availableQty: number;
-}
-export interface PreflightResponse {
-    available: any[];
-    unavailable: UnavailableItem[];
-}
-export interface CreatePaymentOrderResponse {
-    gatewayOrderId: string;
-    amount: number;
-    currency: string;
-    keyId: string;
-    platformFee?: number;
-}
-interface PlaceOrderPayload {
-    addressId: string;
-    paymentMethod: "cod" | "online" | "upi_manual";
-    notes?: string;
-    excludedProductIds?: string[];
-}
-interface CreatePaymentOrderPayload {
-    amount: number;
-    currency?: string;
-    receipt?: string;
-}
-interface VerifyPaymentPayload {
-    gateway_order_id: string;
-    gateway_payment_id: string;
-    gateway_signature: string;
-    addressId: string;
-    notes?: string;
-    excludedProductIds?: string[];
-}
-interface UseCheckoutOptions<TAddress = any, TCart = any> {
-    addressesEndpoint?: string;
-    cartEndpoint?: string;
-    preflightEndpoint?: string;
-    placeOrderEndpoint?: string;
-    paymentCreateOrderEndpoint?: string;
-    paymentVerifyEndpoint?: string;
-    onPlaceCodOrderSuccess?: (result: PlaceOrderResponse) => void;
-    onPlaceCodOrderError?: () => void;
-    enabled?: boolean;
-    initialAddresses?: TAddress[];
-    initialCart?: CartApiResponse<TCart>;
-}
-export declare function useCheckout<TAddress = any, TCart = any>(options?: UseCheckoutOptions<TAddress, TCart>): {
-    addressQuery: import("@tanstack/react-query").UseQueryResult<TAddress[], Error>;
-    cartQuery: import("@tanstack/react-query").UseQueryResult<CartApiResponse<TCart>, Error>;
-    preflightMutation: import("@tanstack/react-query").UseMutationResult<PreflightResponse, Error, string, unknown>;
-    placeCodOrderMutation: import("@tanstack/react-query").UseMutationResult<PlaceOrderResponse, Error, PlaceOrderPayload, unknown>;
-    createPaymentOrderMutation: import("@tanstack/react-query").UseMutationResult<CreatePaymentOrderResponse, Error, CreatePaymentOrderPayload, unknown>;
-    verifyPaymentMutation: import("@tanstack/react-query").UseMutationResult<PlaceOrderResponse, Error, VerifyPaymentPayload, unknown>;
-};
-export {};

package/dist/features/checkout/hooks/useCheckoutApi.js

@@ -1,47 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { apiClient } from "../../../http";
-import { useCheckoutReadQueries } from "../../cart";
-import { ACCOUNT_ENDPOINTS, CART_ENDPOINTS, CHECKOUT_ENDPOINTS, PAYMENT_ENDPOINTS, } from "../../../constants/api-endpoints";
-export function useCheckout(options) {
-    const queryClient = useQueryClient();
-    const { addressesEndpoint = ACCOUNT_ENDPOINTS.ADDRESSES, cartEndpoint = CART_ENDPOINTS.GET, preflightEndpoint = CHECKOUT_ENDPOINTS.PREFLIGHT, placeOrderEndpoint = CHECKOUT_ENDPOINTS.PLACE_ORDER, paymentCreateOrderEndpoint = PAYMENT_ENDPOINTS.CREATE_ORDER, paymentVerifyEndpoint = PAYMENT_ENDPOINTS.VERIFY, } = options ?? {};
-    const { addressQuery, cartQuery } = useCheckoutReadQueries({
-        addressesEndpoint,
-        cartEndpoint,
-        addressesQueryKey: ["addresses"],
-        cartQueryKey: ["cart"],
-        enabled: options?.enabled,
-        initialAddresses: options?.initialAddresses,
-        initialCart: options?.initialCart,
-    });
-    const preflightMutation = useMutation({
-        mutationFn: (addressId) => apiClient.post(preflightEndpoint, { addressId }),
-    });
-    const placeCodOrderMutation = useMutation({
-        mutationFn: (data) => apiClient.post(placeOrderEndpoint, data),
-        onSuccess: async (result) => {
-            await queryClient.invalidateQueries({ queryKey: ["cart"] });
-            await queryClient.invalidateQueries({ queryKey: ["orders"] });
-            options?.onPlaceCodOrderSuccess?.(result);
-        },
-        onError: options?.onPlaceCodOrderError,
-    });
-    const createPaymentOrderMutation = useMutation({
-        mutationFn: (data) => apiClient.post(paymentCreateOrderEndpoint, data),
-    });
-    const verifyPaymentMutation = useMutation({
-        mutationFn: (data) => apiClient.post(paymentVerifyEndpoint, data),
-        onSuccess: async () => {
-            await queryClient.invalidateQueries({ queryKey: ["cart"] });
-            await queryClient.invalidateQueries({ queryKey: ["orders"] });
-        },
-    });
-    return {
-        addressQuery,
-        cartQuery,
-        preflightMutation,
-        placeCodOrderMutation,
-        createPaymentOrderMutation,
-        verifyPaymentMutation,
-    };
-}

package/dist/features/checkout/hooks/usePaymentCheckout.d.ts

@@ -1,77 +0,0 @@
-import type { IClientPaymentGateway, OpenGatewayOptions } from "../../../contracts/client-payment-gateway";
-import type { PlaceOrderResponse } from "../hooks/useCheckoutApi";
-import { useCheckout as useCheckoutApi } from "../hooks/useCheckoutApi";
-import { usePaymentEvent, type UsePaymentEventOptions } from "../../payments/hooks/usePaymentEvent";
-import type { PaymentGateway } from "../../payments/schemas";
-export type PaymentCheckoutStep = "idle" | "preflight" | "creating_order" | "awaiting_payment" | "verifying" | "success" | "error" | "cancelled";
-export interface PaymentCheckoutState {
-    step: PaymentCheckoutStep;
-    error: string | null;
-    orderIds: string[] | null;
-    total: number | null;
-    itemCount: number | null;
-}
-export interface UsePaymentCheckoutOptions {
-    /** Payment gateway to use. Consumer registers the adapter via `registerClientPaymentGateway`. */
-    gateway: PaymentGateway;
-    /** Override the gateway adapter instance (skips registry lookup). */
-    gatewayAdapter?: IClientPaymentGateway;
-    /** Merchant display name for the payment modal. */
-    merchantName?: string;
-    /** Logo URL for the payment modal. */
-    logoUrl?: string;
-    /** Theme color for the payment modal. */
-    themeColor?: string;
-    /** Realtime event options for tracking payment completion via RTDB. */
-    realtimeEventOptions?: UsePaymentEventOptions;
-    /** Custom API endpoints (passed to useCheckoutApi). */
-    endpoints?: {
-        addresses?: string;
-        cart?: string;
-        preflight?: string;
-        placeOrder?: string;
-        paymentCreateOrder?: string;
-        paymentVerify?: string;
-    };
-    /** Called after successful order placement (COD or online). */
-    onSuccess?: (result: PlaceOrderResponse) => void;
-    /** Called on any checkout error. */
-    onError?: (error: Error) => void;
-    /** Called when user cancels payment modal. */
-    onCancel?: () => void;
-}
-export interface UsePaymentCheckoutReturn {
-    /** Current checkout step/state. */
-    state: PaymentCheckoutState;
-    /** Address and cart query results from useCheckoutApi. */
-    addressQuery: ReturnType<typeof useCheckoutApi>["addressQuery"];
-    cartQuery: ReturnType<typeof useCheckoutApi>["cartQuery"];
-    /** Run preflight stock check. */
-    preflight: (addressId: string) => Promise<boolean>;
-    /** Place a COD / UPI-manual order (no gateway interaction). */
-    placeCodOrder: (params: {
-        addressId: string;
-        paymentMethod: "cod" | "upi_manual";
-        notes?: string;
-        excludedProductIds?: string[];
-    }) => Promise<PlaceOrderResponse | null>;
-    /**
-     * Full online payment flow:
-     * 1. Create payment order on server
-     * 2. Open gateway modal
-     * 3. Verify payment on server
-     */
-    payOnline: (params: {
-        addressId: string;
-        amount: number;
-        currency?: string;
-        notes?: string;
-        excludedProductIds?: string[];
-        prefill?: OpenGatewayOptions["prefill"];
-    }) => Promise<PlaceOrderResponse | null>;
-    /** Payment event tracking (RTDB). */
-    paymentEvent: ReturnType<typeof usePaymentEvent>;
-    /** Reset checkout state back to idle. */
-    reset: () => void;
-}
-export declare function usePaymentCheckout(options: UsePaymentCheckoutOptions): UsePaymentCheckoutReturn;

package/dist/features/checkout/hooks/usePaymentCheckout.js

@@ -1,192 +0,0 @@
-"use client";
-import { normalizeError } from "../../../errors/normalize";
-import { useCallback, useRef, useState } from "react";
-import { getClientPaymentGateway } from "../../../contracts/client-payment-gateway";
-import { useCheckout as useCheckoutApi } from "../hooks/useCheckoutApi";
-import { usePaymentEvent, } from "../../payments/hooks/usePaymentEvent";
-// --- Helpers ---------------------------------------------------------------
-async function openGatewayStep(adapter, orderResponse, params) {
-    try {
-        await adapter.loadScript();
-        const response = await adapter.openPayment({
-            gatewayOrderId: orderResponse.gatewayOrderId,
-            publicKey: orderResponse.keyId,
-            amount: orderResponse.amount,
-            currency: orderResponse.currency,
-            merchantName: params.merchantName,
-            logoUrl: params.logoUrl,
-            prefill: params.prefill,
-            theme: params.themeColor ? { color: params.themeColor } : undefined,
-        });
-        return { response, cancelled: false, error: null };
-    }
-    catch (err) {
-        void normalizeError(err);
-        if (err instanceof Error && err.message.toLowerCase().includes("cancel")) {
-            return { response: null, cancelled: true, error: null };
-        }
-        return { response: null, cancelled: false, error: err instanceof Error ? err : new Error("Payment gateway error") };
-    }
-}
-// --- Hook ------------------------------------------------------------------
-const INITIAL_STATE = {
-    step: "idle",
-    error: null,
-    orderIds: null,
-    total: null,
-    itemCount: null,
-};
-export function usePaymentCheckout(options) {
-    const [state, setState] = useState(INITIAL_STATE);
-    const abortRef = useRef(false);
-    const { gateway, gatewayAdapter, merchantName, logoUrl, themeColor, endpoints, onSuccess, onError, onCancel, } = options;
-    const checkout = useCheckoutApi({
-        addressesEndpoint: endpoints?.addresses,
-        cartEndpoint: endpoints?.cart,
-        preflightEndpoint: endpoints?.preflight,
-        placeOrderEndpoint: endpoints?.placeOrder,
-        paymentCreateOrderEndpoint: endpoints?.paymentCreateOrder,
-        paymentVerifyEndpoint: endpoints?.paymentVerify,
-    });
-    const paymentEvent = usePaymentEvent(options.realtimeEventOptions);
-    const getAdapter = useCallback(() => {
-        return gatewayAdapter ?? getClientPaymentGateway(gateway);
-    }, [gateway, gatewayAdapter]);
-    const setError = useCallback((error) => {
-        setState((s) => ({ ...s, step: "error", error: error.message }));
-        onError?.(error);
-    }, [onError]);
-    const reset = useCallback(() => {
-        setState(INITIAL_STATE);
-        abortRef.current = false;
-        paymentEvent.reset();
-    }, [paymentEvent]);
-    const preflight = useCallback(async (addressId) => {
-        setState((s) => ({ ...s, step: "preflight", error: null }));
-        try {
-            const result = await checkout.preflightMutation.mutateAsync(addressId);
-            if (result.unavailable.length > 0) {
-                setState((s) => ({
-                    ...s,
-                    step: "error",
-                    error: `${result.unavailable.length} item(s) unavailable`,
-                }));
-                return false;
-            }
-            setState((s) => ({ ...s, step: "idle" }));
-            return true;
-        }
-        catch (err) {
-            void normalizeError(err);
-            setError(err instanceof Error ? err : new Error("Preflight check failed"));
-            return false;
-        }
-    }, [checkout.preflightMutation, setError]);
-    const placeCodOrder = useCallback(async (params) => {
-        setState((s) => ({ ...s, step: "verifying", error: null }));
-        try {
-            const result = await checkout.placeCodOrderMutation.mutateAsync({
-                addressId: params.addressId,
-                paymentMethod: params.paymentMethod,
-                notes: params.notes,
-                excludedProductIds: params.excludedProductIds,
-            });
-            setState({
-                step: "success",
-                error: null,
-                orderIds: result.orderIds,
-                total: result.total,
-                itemCount: result.itemCount,
-            });
-            onSuccess?.(result);
-            return result;
-        }
-        catch (err) {
-            void normalizeError(err);
-            setError(err instanceof Error ? err : new Error("Order placement failed"));
-            return null;
-        }
-    }, [checkout.placeCodOrderMutation, onSuccess, setError]);
-    const payOnline = useCallback(async (params) => {
-        abortRef.current = false;
-        // Step 1: Create payment order on server
-        setState((s) => ({ ...s, step: "creating_order", error: null }));
-        let orderResponse;
-        try {
-            orderResponse = await checkout.createPaymentOrderMutation.mutateAsync({
-                amount: params.amount,
-                currency: params.currency,
-            });
-        }
-        catch (err) {
-            void normalizeError(err);
-            setError(err instanceof Error
-                ? err
-                : new Error("Failed to create payment order"));
-            return null;
-        }
-        if (abortRef.current)
-            return null;
-        // Step 2: Open gateway modal
-        setState((s) => ({ ...s, step: "awaiting_payment" }));
-        const gatewayResult = await openGatewayStep(getAdapter(), orderResponse, { prefill: params.prefill, merchantName, logoUrl, themeColor });
-        if (gatewayResult.cancelled) {
-            setState((s) => ({ ...s, step: "cancelled", error: null }));
-            onCancel?.();
-            return null;
-        }
-        if (gatewayResult.error || !gatewayResult.response) {
-            setError(gatewayResult.error ?? new Error("Payment gateway error"));
-            return null;
-        }
-        const gatewayResponse = gatewayResult.response;
-        if (abortRef.current)
-            return null;
-        // Step 3: Verify payment on server
-        setState((s) => ({ ...s, step: "verifying" }));
-        try {
-            const result = await checkout.verifyPaymentMutation.mutateAsync({
-                gateway_order_id: gatewayResponse.gatewayOrderId,
-                gateway_payment_id: gatewayResponse.gatewayPaymentId,
-                gateway_signature: gatewayResponse.gatewaySignature ?? "",
-                addressId: params.addressId,
-                notes: params.notes,
-                excludedProductIds: params.excludedProductIds,
-            });
-            setState({
-                step: "success",
-                error: null,
-                orderIds: result.orderIds,
-                total: result.total,
-                itemCount: result.itemCount,
-            });
-            onSuccess?.(result);
-            return result;
-        }
-        catch (err) {
-            void normalizeError(err);
-            setError(err instanceof Error ? err : new Error("Payment verification failed"));
-            return null;
-        }
-    }, [
-        checkout.createPaymentOrderMutation,
-        checkout.verifyPaymentMutation,
-        getAdapter,
-        merchantName,
-        logoUrl,
-        themeColor,
-        onSuccess,
-        onCancel,
-        setError,
-    ]);
-    return {
-        state,
-        addressQuery: checkout.addressQuery,
-        cartQuery: checkout.cartQuery,
-        preflight,
-        placeCodOrder,
-        payOnline,
-        paymentEvent,
-        reset,
-    };
-}

package/dist/providers/payment-razorpay/index.d.ts

@@ -1,115 +0,0 @@
-/**
- * @mohasinac/payment-razorpay — Razorpay IPaymentProvider implementation
- *
- * Implements the @mohasinac/contracts IPaymentProvider interface.
- * Accepts credentials via constructor — no Firestore or DB dependency.
- *
- * @example
- * ```ts
- * import { RazorpayProvider } from "@mohasinac/payment-razorpay";
- * import { registerProviders } from "../../contracts";
- *
- * registerProviders({
- * payment: new RazorpayProvider({
- * keyId: process.env.RAZORPAY_KEY_ID!,
- * keySecret: process.env.RAZORPAY_KEY_SECRET!,
- * webhookSecret: process.env.RAZORPAY_WEBHOOK_SECRET,
- * }),
- * });
- * ```
- */
-import type { JsonValue } from "@mohasinac/appkit";
-import { IPaymentProvider } from "../../contracts";
-import type { PaymentOrder, PaymentCapture, Refund } from "../../contracts";
-export interface RazorpayConfig {
-    keyId: string;
-    keySecret: string;
-    webhookSecret?: string;
-}
-export declare class RazorpayProvider extends IPaymentProvider {
-    readonly name = "razorpay";
-    private readonly razorpay;
-    private readonly webhookSecret?;
-    constructor(config: RazorpayConfig);
-    createOrder(amount: number, currency?: string, metadata?: Record<string, JsonValue>): Promise<PaymentOrder>;
-    /**
-     * Verify Razorpay webhook signature (HMAC-SHA256 over raw body).
-     * Requires webhookSecret to be set in the constructor.
-     */
-    verifyWebhook(payload: string, signature: string): boolean;
-    capturePayment(paymentId: string): Promise<PaymentCapture>;
-    refund(paymentId: string, amount?: number): Promise<Refund>;
-    getOrder(orderId: string): Promise<PaymentOrder>;
-}
-/** Convert rupees (float) → paise (integer) for Razorpay amount field */
-export declare function rupeesToPaise(rupees: number): number;
-/** Convert paise (integer) → rupees (float) */
-export declare function paiseToRupees(paise: number): number;
-export interface RazorpayPaymentResult {
-    razorpay_order_id: string;
-    razorpay_payment_id: string;
-    razorpay_signature: string;
-}
-/**
- * Verify Razorpay payment signature.
- * Uses HMAC-SHA256 over `{orderId}|{paymentId}` with the key secret.
- */
-export declare function verifyPaymentSignature(params: RazorpayPaymentResult, keySecret: string): boolean;
-export interface RazorpayOrderOptions {
-    /** Amount in paise (smallest currency unit). E.g. ₹500 → 50000 */
-    amount: number;
-    currency?: string;
-    receipt?: string;
-    notes?: Record<string, string>;
-}
-export interface RazorpayOrder {
-    id: string;
-    entity: string;
-    amount: number;
-    amount_paid: number;
-    amount_due: number;
-    currency: string;
-    receipt: string | null;
-    status: string;
-    attempts: number;
-    created_at: number;
-}
-export interface RazorpayRefundResult {
-    id: string;
-    payment_id: string;
-    amount: number;
-    currency: string;
-    status: string;
-}
-/**
- * Create a Razorpay order. Credentials resolved from Firestore → env.
- * @deprecated Use `getProviders().payment.createOrder()` via `IPaymentProvider` instead.
- * @internal Will be removed in a future version.
- */
-export declare function createRazorpayOrder(opts: RazorpayOrderOptions): Promise<RazorpayOrder>;
-/**
- * Fetch an existing Razorpay order by ID.
- * @deprecated Use `getProviders().payment.getOrder()` via `IPaymentProvider` instead.
- * @internal Will be removed in a future version.
- */
-export declare function fetchRazorpayOrder(orderId: string): Promise<RazorpayOrder>;
-/**
- * Verify Razorpay payment signature — auto-resolves key secret.
- * Returns false if credentials are unavailable.
- * @deprecated Use `getProviders().payment.verifyWebhook()` via `IPaymentProvider` instead.
- * @internal Will be removed in a future version.
- */
-export declare function verifyPaymentSignatureWithKeys(params: RazorpayPaymentResult): Promise<boolean>;
-/**
- * Verify Razorpay webhook signature — auto-resolves webhook secret.
- * Uses HMAC-SHA256 over raw body.
- * @deprecated Use `getProviders().payment.verifyWebhook()` via `IPaymentProvider` instead.
- * @internal Will be removed in a future version.
- */
-export declare function verifyWebhookSignature(rawBody: string, receivedSignature: string): Promise<boolean>;
-/**
- * Create a full or partial refund for a Razorpay payment.
- * @deprecated Use `getProviders().payment.refund()` via `IPaymentProvider` instead.
- * @internal Will be removed in a future version.
- */
-export declare function createRazorpayRefund(paymentId: string, amountPaise?: number): Promise<RazorpayRefundResult>;