@mohasinac/appkit 2.3.0 → 2.3.2

package/dist/features/orders/schemas/firestore.js

@@ -0,0 +1,96 @@
+/**
+ * Orders Firestore Document Types & Constants
+ */
+import { generateOrderId } from "../../../utils/id-generators";
+/** Runtime-accessible shipping method values — use instead of bare string literals. */
+export const ShippingMethodValues = {
+    CUSTOM: "custom",
+    SHIPROCKET: "shiprocket",
+};
+/** Runtime-accessible order status values — use instead of bare string literals. */
+export const OrderStatusValues = {
+    PENDING: "pending",
+    CONFIRMED: "confirmed",
+    PROCESSING: "processing",
+    SHIPPED: "shipped",
+    DELIVERED: "delivered",
+    CANCELLED: "cancelled",
+    REFUNDED: "refunded",
+    RETURN_REQUESTED: "return_requested",
+    RETURNED: "returned",
+};
+/** Runtime-accessible payment status values — use instead of bare string literals. */
+export const PaymentStatusValues = {
+    PENDING: "pending",
+    PROCESSING: "processing",
+    PAID: "paid",
+    FAILED: "failed",
+    REFUNDED: "refunded",
+    PARTIAL_REFUND: "partial_refund",
+};
+/** Runtime-accessible payment method values — use instead of bare string literals. */
+export const PaymentMethodValues = {
+    COD: "cod",
+    ONLINE: "online",
+    UPI_MANUAL: "upi_manual",
+    RAZORPAY: "razorpay",
+};
+/** Runtime-accessible refund status values — use instead of bare string literals. */
+export const RefundStatusValues = {
+    PENDING: "pending",
+    PROCESSING: "processing",
+    COMPLETED: "completed",
+    REJECTED: "rejected",
+};
+export const ORDER_COLLECTION = "orders";
+export const ORDER_INDEXED_FIELDS = [
+    "userId",
+    "productId",
+    "sellerId",
+    "status",
+    "paymentStatus",
+    "payoutStatus",
+    "shippingMethod",
+    "orderDate",
+    "createdAt",
+];
+export const DEFAULT_ORDER_DATA = {
+    status: "pending",
+    paymentStatus: "pending",
+    quantity: 1,
+};
+export const ORDER_PUBLIC_FIELDS = [
+    "id",
+    "productId",
+    "productTitle",
+    "quantity",
+    "unitPrice",
+    "totalPrice",
+    "currency",
+    "status",
+    "paymentStatus",
+    "shippingAddress",
+    "trackingNumber",
+    "notes",
+    "orderDate",
+    "shippingDate",
+    "deliveryDate",
+    "createdAt",
+];
+export const ORDER_UPDATABLE_FIELDS = ["notes", "shippingAddress"];
+export const orderQueryHelpers = {
+    byUser: (userId) => ["userId", "==", userId],
+    bySeller: (sellerId) => ["sellerId", "==", sellerId],
+    byProduct: (productId) => ["productId", "==", productId],
+    byStatus: (status) => ["status", "==", status],
+    byPaymentStatus: (status) => ["paymentStatus", "==", status],
+    confirmed: () => ["status", "==", "confirmed"],
+    pending: () => ["status", "==", "pending"],
+    shipped: () => ["status", "==", "shipped"],
+    delivered: () => ["status", "==", "delivered"],
+    paid: () => ["paymentStatus", "==", "paid"],
+    recentOrders: (date) => ["orderDate", ">=", date],
+};
+export function createOrderId(productCount, date) {
+    return generateOrderId({ productCount, date });
+}

package/dist/features/orders/schemas/index.d.ts

@@ -0,0 +1,217 @@
+export * from "./firestore";
+import { z } from "zod";
+export declare const orderStatusSchema: z.ZodEnum<["pending", "confirmed", "processing", "shipped", "delivered", "cancelled", "refunded", "return_requested", "returned"]>;
+export declare const orderItemSchema: z.ZodObject<{
+    productId: z.ZodString;
+    title: z.ZodString;
+    image: z.ZodOptional<z.ZodString>;
+    price: z.ZodNumber;
+    quantity: z.ZodNumber;
+    currency: z.ZodOptional<z.ZodString>;
+    sellerId: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    productId: string;
+    price: number;
+    quantity: number;
+    image?: string | undefined;
+    sellerId?: string | undefined;
+    currency?: string | undefined;
+    attributes?: Record<string, string> | undefined;
+}, {
+    title: string;
+    productId: string;
+    price: number;
+    quantity: number;
+    image?: string | undefined;
+    sellerId?: string | undefined;
+    currency?: string | undefined;
+    attributes?: Record<string, string> | undefined;
+}>;
+export declare const orderTimelineSchema: z.ZodObject<{
+    status: z.ZodEnum<["pending", "confirmed", "processing", "shipped", "delivered", "cancelled", "refunded", "return_requested", "returned"]>;
+    message: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodString;
+    actor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+    timestamp: string;
+    message?: string | undefined;
+    actor?: string | undefined;
+}, {
+    status: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+    timestamp: string;
+    message?: string | undefined;
+    actor?: string | undefined;
+}>;
+/**
+ * Base Zod schema for an order.
+ * Apps can extend this to add their own fields:
+ *
+ * @example
+ * import { orderSchema } from "@mohasinac/feat-orders";
+ *
+ * const myOrderSchema = orderSchema.extend({
+ *   giftMessage: z.string().optional(),
+ *   loyaltyPointsEarned: z.number().optional(),
+ * });
+ * type MyOrder = z.infer<typeof myOrderSchema>;
+ */
+export declare const orderSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        productId: z.ZodString;
+        title: z.ZodString;
+        image: z.ZodOptional<z.ZodString>;
+        price: z.ZodNumber;
+        quantity: z.ZodNumber;
+        currency: z.ZodOptional<z.ZodString>;
+        sellerId: z.ZodOptional<z.ZodString>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        productId: string;
+        price: number;
+        quantity: number;
+        image?: string | undefined;
+        sellerId?: string | undefined;
+        currency?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    }, {
+        title: string;
+        productId: string;
+        price: number;
+        quantity: number;
+        image?: string | undefined;
+        sellerId?: string | undefined;
+        currency?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    }>, "many">;
+    address: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    orderStatus: z.ZodEnum<["pending", "confirmed", "processing", "shipped", "delivered", "cancelled", "refunded", "return_requested", "returned"]>;
+    paymentStatus: z.ZodString;
+    paymentGateway: z.ZodOptional<z.ZodString>;
+    subtotal: z.ZodNumber;
+    shippingCost: z.ZodOptional<z.ZodNumber>;
+    discount: z.ZodOptional<z.ZodNumber>;
+    tax: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodNumber;
+    currency: z.ZodString;
+    couponCode: z.ZodOptional<z.ZodString>;
+    trackingNumber: z.ZodOptional<z.ZodString>;
+    shippingCarrier: z.ZodOptional<z.ZodString>;
+    notes: z.ZodOptional<z.ZodString>;
+    timeline: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<["pending", "confirmed", "processing", "shipped", "delivered", "cancelled", "refunded", "return_requested", "returned"]>;
+        message: z.ZodOptional<z.ZodString>;
+        timestamp: z.ZodString;
+        actor: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+        timestamp: string;
+        message?: string | undefined;
+        actor?: string | undefined;
+    }, {
+        status: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+        timestamp: string;
+        message?: string | undefined;
+        actor?: string | undefined;
+    }>, "many">>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    address: Record<string, unknown>;
+    items: {
+        title: string;
+        productId: string;
+        price: number;
+        quantity: number;
+        image?: string | undefined;
+        sellerId?: string | undefined;
+        currency?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    }[];
+    currency: string;
+    total: number;
+    userId: string;
+    subtotal: number;
+    paymentStatus: string;
+    orderStatus: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    notes?: string | undefined;
+    tax?: number | undefined;
+    trackingNumber?: string | undefined;
+    shippingCarrier?: string | undefined;
+    paymentGateway?: string | undefined;
+    shippingCost?: number | undefined;
+    discount?: number | undefined;
+    couponCode?: string | undefined;
+    timeline?: {
+        status: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+        timestamp: string;
+        message?: string | undefined;
+        actor?: string | undefined;
+    }[] | undefined;
+}, {
+    id: string;
+    address: Record<string, unknown>;
+    items: {
+        title: string;
+        productId: string;
+        price: number;
+        quantity: number;
+        image?: string | undefined;
+        sellerId?: string | undefined;
+        currency?: string | undefined;
+        attributes?: Record<string, string> | undefined;
+    }[];
+    currency: string;
+    total: number;
+    userId: string;
+    subtotal: number;
+    paymentStatus: string;
+    orderStatus: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    notes?: string | undefined;
+    tax?: number | undefined;
+    trackingNumber?: string | undefined;
+    shippingCarrier?: string | undefined;
+    paymentGateway?: string | undefined;
+    shippingCost?: number | undefined;
+    discount?: number | undefined;
+    couponCode?: string | undefined;
+    timeline?: {
+        status: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested";
+        timestamp: string;
+        message?: string | undefined;
+        actor?: string | undefined;
+    }[] | undefined;
+}>;
+/** Base schema for list-query parameters. */
+export declare const orderListParamsSchema: z.ZodObject<{
+    userId: z.ZodOptional<z.ZodString>;
+    orderStatus: z.ZodOptional<z.ZodEnum<["pending", "confirmed", "processing", "shipped", "delivered", "cancelled", "refunded", "return_requested", "returned"]>>;
+    paymentStatus: z.ZodOptional<z.ZodString>;
+    sort: z.ZodOptional<z.ZodString>;
+    page: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    sort?: string | undefined;
+    page?: number | undefined;
+    perPage?: number | undefined;
+    userId?: string | undefined;
+    paymentStatus?: string | undefined;
+    orderStatus?: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested" | undefined;
+}, {
+    sort?: string | undefined;
+    page?: number | undefined;
+    perPage?: number | undefined;
+    userId?: string | undefined;
+    paymentStatus?: string | undefined;
+    orderStatus?: "pending" | "processing" | "refunded" | "confirmed" | "shipped" | "delivered" | "cancelled" | "returned" | "return_requested" | undefined;
+}>;

package/dist/features/orders/schemas/index.js

@@ -0,0 +1,76 @@
+export * from "./firestore";
+import { z } from "zod";
+// --- Sub-schemas --------------------------------------------------------------
+export const orderStatusSchema = z.enum([
+    "pending",
+    "confirmed",
+    "processing",
+    "shipped",
+    "delivered",
+    "cancelled",
+    "refunded",
+    "return_requested",
+    "returned",
+]);
+export const orderItemSchema = z.object({
+    productId: z.string(),
+    title: z.string(),
+    image: z.string().optional(),
+    price: z.number(),
+    quantity: z.number(),
+    currency: z.string().optional(),
+    sellerId: z.string().optional(),
+    attributes: z.record(z.string()).optional(),
+});
+export const orderTimelineSchema = z.object({
+    status: orderStatusSchema,
+    message: z.string().optional(),
+    timestamp: z.string(),
+    actor: z.string().optional(),
+});
+// --- Base item schema ---------------------------------------------------------
+/**
+ * Base Zod schema for an order.
+ * Apps can extend this to add their own fields:
+ *
+ * @example
+ * import { orderSchema } from "@mohasinac/feat-orders";
+ *
+ * const myOrderSchema = orderSchema.extend({
+ *   giftMessage: z.string().optional(),
+ *   loyaltyPointsEarned: z.number().optional(),
+ * });
+ * type MyOrder = z.infer<typeof myOrderSchema>;
+ */
+export const orderSchema = z.object({
+    id: z.string(),
+    userId: z.string(),
+    items: z.array(orderItemSchema),
+    // address shape is intentionally open to allow extending apps
+    address: z.record(z.unknown()),
+    orderStatus: orderStatusSchema,
+    paymentStatus: z.string(),
+    paymentGateway: z.string().optional(),
+    subtotal: z.number(),
+    shippingCost: z.number().optional(),
+    discount: z.number().optional(),
+    tax: z.number().optional(),
+    total: z.number(),
+    currency: z.string(),
+    couponCode: z.string().optional(),
+    trackingNumber: z.string().optional(),
+    shippingCarrier: z.string().optional(),
+    notes: z.string().optional(),
+    timeline: z.array(orderTimelineSchema).optional(),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+});
+/** Base schema for list-query parameters. */
+export const orderListParamsSchema = z.object({
+    userId: z.string().optional(),
+    orderStatus: orderStatusSchema.optional(),
+    paymentStatus: z.string().optional(),
+    sort: z.string().optional(),
+    page: z.coerce.number().optional(),
+    perPage: z.coerce.number().optional(),
+});

package/dist/features/orders/server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @mohasinac/appkit/features/orders/server
+ *
+ * Server-only entry point for order repositories.
+ */
+export * from "./actions";
+export { OrderRepository, OrdersRepository, orderRepository, } from "./repository/orders.repository";
+export { GET as getOrderTrackingHandler } from "./api/track/[trackingId]/route";

package/dist/features/orders/server.js

@@ -0,0 +1,9 @@
+/**
+ * @mohasinac/appkit/features/orders/server
+ *
+ * Server-only entry point for order repositories.
+ */
+export * from "./actions";
+export { OrderRepository, OrdersRepository, orderRepository, } from "./repository/orders.repository";
+// API route handler — re-export for consumer app router stubs
+export { GET as getOrderTrackingHandler } from "./api/track/[trackingId]/route";

package/dist/features/orders/types/index.d.ts

@@ -0,0 +1,69 @@
+import { type PaymentGateway, PaymentGatewayValues } from "../../payments/schemas";
+export { type PaymentGateway, PaymentGatewayValues };
+export type PaymentStatus = "pending" | "processing" | "paid" | "failed" | "refunded" | "partial_refund";
+export interface UserAddress {
+    id: string;
+    label?: string;
+    line1: string;
+    line2?: string;
+    city: string;
+    state: string;
+    postalCode: string;
+    country: string;
+    isDefault?: boolean;
+    phone?: string;
+}
+export type OrderStatus = "pending" | "confirmed" | "processing" | "shipped" | "delivered" | "cancelled" | "refunded" | "return_requested" | "returned";
+export interface OrderItem {
+    productId: string;
+    title: string;
+    image?: string;
+    price: number;
+    quantity: number;
+    currency?: string;
+    sellerId?: string;
+    attributes?: Record<string, string>;
+}
+export interface OrderTimeline {
+    status: OrderStatus;
+    message?: string;
+    timestamp: string;
+    actor?: string;
+}
+export interface Order {
+    id: string;
+    userId: string;
+    items: OrderItem[];
+    address: UserAddress;
+    orderStatus: OrderStatus;
+    paymentStatus: PaymentStatus;
+    paymentGateway?: PaymentGateway;
+    subtotal: number;
+    shippingCost?: number;
+    discount?: number;
+    tax?: number;
+    total: number;
+    currency: string;
+    couponCode?: string;
+    trackingNumber?: string;
+    shippingCarrier?: string;
+    notes?: string;
+    timeline?: OrderTimeline[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export interface OrderListResponse {
+    items: Order[];
+    total: number;
+    page: number;
+    perPage: number;
+    totalPages: number;
+}
+export interface OrderListParams {
+    userId?: string;
+    orderStatus?: OrderStatus;
+    paymentStatus?: PaymentStatus;
+    sort?: string;
+    page?: number;
+    perPage?: number;
+}

package/dist/features/orders/types/index.js

@@ -0,0 +1,2 @@
+import { PaymentGatewayValues, } from "../../payments/schemas";
+export { PaymentGatewayValues };

package/dist/features/orders/utils/order-splitter.d.ts

@@ -0,0 +1,14 @@
+export type OrderType = "standard" | "preorder" | "auction" | "offer";
+export interface OrderGroup<T> {
+    items: T[];
+    orderType: OrderType;
+}
+export declare function splitCartIntoOrderGroups<T extends {
+    item: {
+        itemId: string;
+        sellerId?: string;
+        isAuction?: boolean;
+        isPreOrder?: boolean;
+        isOffer?: boolean;
+    };
+}>(checks: T[]): OrderGroup<T>[];

package/dist/features/orders/utils/order-splitter.js

@@ -0,0 +1,29 @@
+export function splitCartIntoOrderGroups(checks) {
+    const groups = new Map();
+    for (const check of checks) {
+        const { item } = check;
+        let key;
+        let orderType;
+        if (item.isAuction) {
+            key = `auction:${item.itemId}`;
+            orderType = "auction";
+        }
+        else if (item.isOffer) {
+            key = `offer:${item.itemId}`;
+            orderType = "offer";
+        }
+        else if (item.isPreOrder) {
+            key = `preorder:${item.sellerId ?? "unknown"}`;
+            orderType = "preorder";
+        }
+        else {
+            key = `standard:${item.sellerId ?? "unknown"}`;
+            orderType = "standard";
+        }
+        if (!groups.has(key)) {
+            groups.set(key, { items: [], orderType });
+        }
+        groups.get(key).items.push(check);
+    }
+    return Array.from(groups.values());
+}

package/dist/features/payments/columns/index.d.ts

@@ -0,0 +1,17 @@
+import type { TableColumn, ColumnExtensionOpts } from "../../../contracts";
+import type { PaymentRecord } from "../types";
+/**
+ * Default admin columns for payment records.
+ * Use `buildPaymentColumns()` to customise via overrides / extras / omit.
+ */
+export declare const paymentAdminColumns: TableColumn<PaymentRecord>[];
+/**
+ * Factory that returns columns for the payments admin table.
+ *
+ * @example
+ * const cols = buildPaymentColumns<MyPaymentRecord>({
+ *   extras: [{ key: "bankReference", header: "Bank Ref", render: (p) => p.bankReference }],
+ *   omit: ["gateway"],
+ * });
+ */
+export declare function buildPaymentColumns<T extends PaymentRecord = PaymentRecord>(opts?: ColumnExtensionOpts<T>): TableColumn<T>[];

package/dist/features/payments/columns/index.js

@@ -0,0 +1,45 @@
+import { buildColumns, renderCurrencyCompact } from "../../../ui/columns";
+/**
+ * Default admin columns for payment records.
+ * Use `buildPaymentColumns()` to customise via overrides / extras / omit.
+ */
+export const paymentAdminColumns = [
+    {
+        key: "orderId",
+        header: "Order ID",
+        sortable: false,
+    },
+    {
+        key: "gateway",
+        header: "Gateway",
+        sortable: false,
+    },
+    {
+        key: "amount",
+        header: "Amount",
+        sortable: true,
+        render: (item) => renderCurrencyCompact(item.amount, item.currency),
+    },
+    {
+        key: "status",
+        header: "Status",
+        sortable: false,
+    },
+    {
+        key: "createdAt",
+        header: "Date",
+        sortable: true,
+    },
+];
+/**
+ * Factory that returns columns for the payments admin table.
+ *
+ * @example
+ * const cols = buildPaymentColumns<MyPaymentRecord>({
+ *   extras: [{ key: "bankReference", header: "Bank Ref", render: (p) => p.bankReference }],
+ *   omit: ["gateway"],
+ * });
+ */
+export function buildPaymentColumns(opts) {
+    return buildColumns(paymentAdminColumns, opts);
+}

package/dist/features/payments/hooks/usePaymentEvent.d.ts

@@ -0,0 +1,17 @@
+import type { IClientRealtimeProvider } from "../../../contracts/client-realtime";
+import { RealtimeEventStatus, type RealtimeEventMessages } from "../../../react";
+export type { RealtimeEventStatus as PaymentEventStatus };
+export interface UsePaymentEventReturn {
+    status: RealtimeEventStatus;
+    error: string | null;
+    orderIds: string[] | null;
+    subscribe: (eventId: string, customToken: string) => void;
+    reset: () => void;
+}
+export interface UsePaymentEventOptions {
+    rtdbPath?: string;
+    timeoutMs?: number;
+    messages?: RealtimeEventMessages;
+    realtimeProvider?: IClientRealtimeProvider;
+}
+export declare function usePaymentEvent(options?: UsePaymentEventOptions): UsePaymentEventReturn;

package/dist/features/payments/hooks/usePaymentEvent.js

@@ -0,0 +1,25 @@
+import { logger } from "../../../core/Logger";
+import { RealtimeEventType, useRealtimeEvent, } from "../../../react";
+const PAYMENT_EVENT_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_RTDB_PATH = "payment_events";
+function extractOrderIds(raw) {
+    return raw.orderIds ?? null;
+}
+export function usePaymentEvent(options) {
+    const { status, error, data: orderIds, subscribe, reset, } = useRealtimeEvent({
+        type: RealtimeEventType.PAYMENT,
+        rtdbPath: options?.rtdbPath ?? DEFAULT_RTDB_PATH,
+        realtimeProvider: options?.realtimeProvider,
+        timeoutMs: options?.timeoutMs ?? PAYMENT_EVENT_TIMEOUT_MS,
+        onLogError: (message, err) => logger.error(message, err),
+        extractData: extractOrderIds,
+        messages: {
+            tokenFailure: "Failed to initialize payment tracking.",
+            connectionLost: "Payment tracking connection was lost.",
+            timedOut: "Payment tracking timed out.",
+            failure: "Payment was not completed.",
+            ...(options?.messages ?? {}),
+        },
+    });
+    return { status, error, orderIds, subscribe, reset };
+}

package/dist/features/payments/hooks/usePayments.d.ts

@@ -0,0 +1,10 @@
+import type { PaymentSettings } from "../types";
+export declare function usePaymentSettings(opts?: {
+    initialData?: PaymentSettings;
+    enabled?: boolean;
+    endpoint?: string;
+}): {
+    settings: PaymentSettings | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};

package/dist/features/payments/hooks/usePayments.js

@@ -0,0 +1,18 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
+export function usePaymentSettings(opts) {
+    const endpoint = opts?.endpoint ?? ADMIN_ENDPOINTS.PAYMENTS_SETTINGS;
+    const query = useQuery({
+        queryKey: ["payment-settings"],
+        queryFn: () => apiClient.get(endpoint),
+        initialData: opts?.initialData,
+        enabled: opts?.enabled,
+        staleTime: 10 * 60 * 1000,
+    });
+    return {
+        settings: query.data,
+        isLoading: query.isLoading,
+        error: query.error,
+    };
+}

package/dist/features/payments/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./schemas";
+export * from "./columns";
+export * from "./hooks/usePayments";
+export * from "./hooks/usePaymentEvent";
+export { manifest } from "./manifest";