@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/logistics/hooks/logistics.d.ts

@@ -0,0 +1,252 @@
+import { OrderShipping, ShippingStatus } from "../../sales/types/order.js";
+import { CancelShipmentResult, CreateShipmentPayload, PickupStore, ProviderCharges, ProviderName, TrackingResult } from "../types/logistics.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/logistics/hooks/logistics.d.ts
+declare const LOGISTICS_KEYS: {
+  all: readonly ["logistics"];
+  pickupStores: (provider?: string) => readonly ["logistics", "pickup-stores", string | undefined];
+  shipment: (id: string) => readonly ["logistics", "shipment", string];
+  tracking: (id: string) => readonly ["logistics", "tracking", string];
+  charge: (params: {
+    deliveryAreaId: number;
+    amount: number;
+    weight?: number;
+  }) => readonly ["logistics", "charge", {
+    deliveryAreaId: number;
+    amount: number;
+    weight?: number;
+  }];
+  config: () => readonly ["logistics", "config"];
+};
+interface QueryOptions {
+  enabled?: boolean;
+  staleTime?: number;
+  refetchInterval?: number | false;
+}
+interface ChargeParams {
+  deliveryAreaId: number;
+  pickupAreaId?: number;
+  amount: number;
+  weight?: number;
+  provider?: ProviderName;
+}
+interface UseDeliveryChargeParams {
+  deliveryAreaId: number | null | undefined;
+  amount: number;
+  weight?: number;
+  enabled?: boolean;
+}
+interface UseDeliveryChargeReturn {
+  charges: ProviderCharges | null;
+  deliveryCharge: number;
+  codCharge: number;
+  totalCharge: number;
+  isLoading: boolean;
+  isFetching: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+interface UseLogisticsActionsReturn {
+  createShipment: (params: {
+    orderId: string;
+    data: CreateShipmentPayload;
+  }) => Promise<OrderShipping | undefined>;
+  isCreatingShipment: boolean;
+  cancelShipment: (params: {
+    shipmentId: string;
+    reason?: string;
+  }) => Promise<CancelShipmentResult | undefined>;
+  isCancellingShipment: boolean;
+  updateShipmentStatus: (params: {
+    shipmentId: string;
+    data: UpdateShipmentStatusParams;
+  }) => Promise<OrderShipping | undefined>;
+  isUpdatingStatus: boolean;
+  isLoading: boolean;
+}
+interface UpdateShipmentStatusParams {
+  status: ShippingStatus | string;
+  note?: string;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * Fetch pickup stores from logistics provider
+ *
+ * @param token - Auth token (admin required)
+ * @param provider - Optional provider filter
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function PickupStoreSelect() {
+ *   const { data: stores, isLoading } = usePickupStores(token);
+ *
+ *   return (
+ *     <Select>
+ *       {stores?.map(store => (
+ *         <SelectItem key={store.id} value={store.id.toString()}>
+ *           {store.name} - {store.areaName}
+ *         </SelectItem>
+ *       ))}
+ *     </Select>
+ *   );
+ * }
+ * ```
+ */
+declare function usePickupStores(token: string, provider?: string, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<PickupStore[], Error>;
+/**
+ * Calculate delivery charge via provider API
+ *
+ * @param token - Auth token (optional for public)
+ * @param params - Charge calculation parameters
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: charges } = useDeliveryChargeCalculation(token, {
+ *   deliveryAreaId: 1206,
+ *   amount: isCOD ? cartTotal : 0,
+ * });
+ * ```
+ */
+declare function useDeliveryChargeCalculation(token: string | null, params: ChargeParams | null, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<ProviderCharges, Error>;
+/**
+ * Convenience hook for delivery charge with extracted values
+ *
+ * @param params - Delivery charge parameters
+ *
+ * @example
+ * ```tsx
+ * function CheckoutDelivery({ areaId, subtotal, isCOD }) {
+ *   const { deliveryCharge, isLoading } = useDeliveryCharge({
+ *     deliveryAreaId: areaId,
+ *     amount: isCOD ? subtotal : 0,
+ *   });
+ *
+ *   return (
+ *     <p>Delivery: {isLoading ? "..." : `৳${deliveryCharge}`}</p>
+ *   );
+ * }
+ * ```
+ */
+declare function useDeliveryCharge({
+  deliveryAreaId,
+  amount,
+  weight,
+  enabled
+}: UseDeliveryChargeParams): UseDeliveryChargeReturn;
+/**
+ * Get shipping info by order ID
+ *
+ * @param token - Auth token
+ * @param orderId - Order ID
+ * @param options - Query options
+ */
+declare function useShipment(token: string, orderId: string | null, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<OrderShipping, Error>;
+/**
+ * Track shipment - fetches latest status from provider
+ *
+ * @param token - Auth token
+ * @param shipmentId - Order ID or tracking number
+ * @param options - Query options (supports refetchInterval for auto-refresh)
+ *
+ * @example
+ * ```tsx
+ * function ShipmentTracker({ shipmentId }) {
+ *   const { data, isLoading } = useTrackShipment(token, shipmentId, {
+ *     refetchInterval: 5 * 60 * 1000, // Auto-refresh every 5 minutes
+ *   });
+ *
+ *   return (
+ *     <Timeline events={data?.tracking?.timeline || []} />
+ *   );
+ * }
+ * ```
+ */
+declare function useTrackShipment(token: string, shipmentId: string | null, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<TrackingResult, Error>;
+/**
+ * Create shipment mutation
+ *
+ * @param token - Auth token
+ *
+ * @example
+ * ```tsx
+ * function CreateShipmentButton({ order }) {
+ *   const { mutate, isPending } = useCreateShipment(token);
+ *
+ *   return (
+ *     <Button
+ *       onClick={() =>
+ *         mutate({
+ *           orderId: order._id,
+ *           data: { provider: "redx", useProviderApi: true },
+ *         })
+ *       }
+ *       disabled={isPending}
+ *     >
+ *       Create Shipment
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCreateShipment(token: string): _tanstack_react_query0.UseMutationResult<OrderShipping | undefined, Error, {
+  orderId: string;
+  data: CreateShipmentPayload;
+}, unknown>;
+/**
+ * Cancel shipment mutation
+ *
+ * @param token - Auth token
+ */
+declare function useCancelShipment(token: string): _tanstack_react_query0.UseMutationResult<CancelShipmentResult | undefined, Error, {
+  shipmentId: string;
+  reason?: string;
+}, unknown>;
+/**
+ * Update shipment status mutation
+ *
+ * @param token - Auth token
+ */
+declare function useUpdateShipmentStatus(token: string): _tanstack_react_query0.UseMutationResult<OrderShipping | undefined, Error, {
+  shipmentId: string;
+  data: UpdateShipmentStatusParams;
+}, unknown>;
+/**
+ * Combined hook for all logistics mutations
+ *
+ * @param token - Auth token
+ *
+ * @example
+ * ```tsx
+ * function ShipmentActions({ order }) {
+ *   const {
+ *     createShipment,
+ *     cancelShipment,
+ *     isLoading,
+ *   } = useLogisticsActions(token);
+ *
+ *   return (
+ *     <>
+ *       <Button
+ *         onClick={() =>
+ *           createShipment({
+ *             orderId: order._id,
+ *             data: { provider: "redx", useProviderApi: true },
+ *           })
+ *         }
+ *       >
+ *         Create Shipment
+ *       </Button>
+ *       <Button onClick={() => cancelShipment({ shipmentId: order._id })}>
+ *         Cancel
+ *       </Button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useLogisticsActions(token: string): UseLogisticsActionsReturn;
+//#endregion
+export { LOGISTICS_KEYS, UseDeliveryChargeReturn, UseLogisticsActionsReturn, useCancelShipment, useCreateShipment, useDeliveryCharge, useDeliveryChargeCalculation, useLogisticsActions, usePickupStores, useShipment, useTrackShipment, useUpdateShipmentStatus };

package/dist/logistics/hooks/logistics.js

@@ -0,0 +1,370 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { logisticsApi } from "../api/logistics.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/logistics/hooks/logistics.ts
+const LOGISTICS_KEYS = {
+	all: ["logistics"],
+	pickupStores: (provider) => [
+		...LOGISTICS_KEYS.all,
+		"pickup-stores",
+		provider
+	],
+	shipment: (id) => [
+		...LOGISTICS_KEYS.all,
+		"shipment",
+		id
+	],
+	tracking: (id) => [
+		...LOGISTICS_KEYS.all,
+		"tracking",
+		id
+	],
+	charge: (params) => [
+		...LOGISTICS_KEYS.all,
+		"charge",
+		params
+	],
+	config: () => [...LOGISTICS_KEYS.all, "config"]
+};
+/**
+* Fetch pickup stores from logistics provider
+*
+* @param token - Auth token (admin required)
+* @param provider - Optional provider filter
+* @param options - Query options
+*
+* @example
+* ```tsx
+* function PickupStoreSelect() {
+*   const { data: stores, isLoading } = usePickupStores(token);
+*
+*   return (
+*     <Select>
+*       {stores?.map(store => (
+*         <SelectItem key={store.id} value={store.id.toString()}>
+*           {store.name} - {store.areaName}
+*         </SelectItem>
+*       ))}
+*     </Select>
+*   );
+* }
+* ```
+*/
+function usePickupStores(token, provider, options = {}) {
+	return useQuery({
+		queryKey: LOGISTICS_KEYS.pickupStores(provider),
+		queryFn: async () => {
+			return (await logisticsApi.getPickupStores({
+				token,
+				provider
+			})).data || [];
+		},
+		enabled: options.enabled !== false && !!token,
+		staleTime: options.staleTime ?? 300 * 1e3
+	});
+}
+/**
+* Calculate delivery charge via provider API
+*
+* @param token - Auth token (optional for public)
+* @param params - Charge calculation parameters
+* @param options - Query options
+*
+* @example
+* ```tsx
+* const { data: charges } = useDeliveryChargeCalculation(token, {
+*   deliveryAreaId: 1206,
+*   amount: isCOD ? cartTotal : 0,
+* });
+* ```
+*/
+function useDeliveryChargeCalculation(token, params, options = {}) {
+	const hasValidParams = !!params?.deliveryAreaId && params?.amount !== void 0;
+	return useQuery({
+		queryKey: LOGISTICS_KEYS.charge(params ? {
+			deliveryAreaId: params.deliveryAreaId,
+			amount: params.amount,
+			weight: params.weight
+		} : {
+			deliveryAreaId: 0,
+			amount: 0
+		}),
+		queryFn: async () => {
+			if (!params) throw new Error("Params required");
+			const response = await logisticsApi.calculateCharge({
+				deliveryAreaId: params.deliveryAreaId,
+				pickupAreaId: params.pickupAreaId,
+				amount: params.amount,
+				weight: params.weight,
+				provider: params.provider
+			});
+			if (!response.data) throw new Error("No charge data returned");
+			return response.data;
+		},
+		enabled: options.enabled !== false && hasValidParams,
+		staleTime: options.staleTime ?? 60 * 1e3
+	});
+}
+/**
+* Convenience hook for delivery charge with extracted values
+*
+* @param params - Delivery charge parameters
+*
+* @example
+* ```tsx
+* function CheckoutDelivery({ areaId, subtotal, isCOD }) {
+*   const { deliveryCharge, isLoading } = useDeliveryCharge({
+*     deliveryAreaId: areaId,
+*     amount: isCOD ? subtotal : 0,
+*   });
+*
+*   return (
+*     <p>Delivery: {isLoading ? "..." : `৳${deliveryCharge}`}</p>
+*   );
+* }
+* ```
+*/
+function useDeliveryCharge({ deliveryAreaId, amount, weight = 500, enabled = true }) {
+	const { data, isLoading, isFetching, error, refetch } = useQuery({
+		queryKey: LOGISTICS_KEYS.charge({
+			deliveryAreaId: deliveryAreaId || 0,
+			amount,
+			weight
+		}),
+		queryFn: async () => {
+			if (!deliveryAreaId) return null;
+			return (await logisticsApi.calculateCharge({
+				deliveryAreaId,
+				amount,
+				weight
+			})).data || null;
+		},
+		enabled: enabled && !!deliveryAreaId,
+		staleTime: 300 * 1e3,
+		gcTime: 600 * 1e3,
+		retry: 1
+	});
+	return {
+		charges: data || null,
+		deliveryCharge: data?.deliveryCharge ?? 0,
+		codCharge: data?.codCharge ?? 0,
+		totalCharge: data?.totalCharge ?? 0,
+		isLoading,
+		isFetching,
+		error,
+		refetch
+	};
+}
+/**
+* Get shipping info by order ID
+*
+* @param token - Auth token
+* @param orderId - Order ID
+* @param options - Query options
+*/
+function useShipment(token, orderId, options = {}) {
+	return useQuery({
+		queryKey: LOGISTICS_KEYS.shipment(orderId || ""),
+		queryFn: async () => {
+			if (!orderId) throw new Error("Order ID required");
+			const response = await logisticsApi.getShipment({
+				token,
+				id: orderId
+			});
+			if (!response.data) throw new Error("Shipping info not found");
+			return response.data;
+		},
+		enabled: options.enabled !== false && !!token && !!orderId,
+		staleTime: options.staleTime ?? 30 * 1e3
+	});
+}
+/**
+* Track shipment - fetches latest status from provider
+*
+* @param token - Auth token
+* @param shipmentId - Order ID or tracking number
+* @param options - Query options (supports refetchInterval for auto-refresh)
+*
+* @example
+* ```tsx
+* function ShipmentTracker({ shipmentId }) {
+*   const { data, isLoading } = useTrackShipment(token, shipmentId, {
+*     refetchInterval: 5 * 60 * 1000, // Auto-refresh every 5 minutes
+*   });
+*
+*   return (
+*     <Timeline events={data?.tracking?.timeline || []} />
+*   );
+* }
+* ```
+*/
+function useTrackShipment(token, shipmentId, options = {}) {
+	return useQuery({
+		queryKey: LOGISTICS_KEYS.tracking(shipmentId || ""),
+		queryFn: async () => {
+			if (!shipmentId) throw new Error("Order ID or tracking number required");
+			const response = await logisticsApi.trackShipment({
+				token,
+				id: shipmentId
+			});
+			if (!response.data) throw new Error("Tracking data not found");
+			return response.data;
+		},
+		enabled: options.enabled !== false && !!token && !!shipmentId,
+		staleTime: options.staleTime ?? 60 * 1e3,
+		refetchInterval: options.refetchInterval ?? 300 * 1e3
+	});
+}
+/**
+* Create shipment mutation
+*
+* @param token - Auth token
+*
+* @example
+* ```tsx
+* function CreateShipmentButton({ order }) {
+*   const { mutate, isPending } = useCreateShipment(token);
+*
+*   return (
+*     <Button
+*       onClick={() =>
+*         mutate({
+*           orderId: order._id,
+*           data: { provider: "redx", useProviderApi: true },
+*         })
+*       }
+*       disabled={isPending}
+*     >
+*       Create Shipment
+*     </Button>
+*   );
+* }
+* ```
+*/
+function useCreateShipment(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	return useMutation({
+		mutationFn: async ({ orderId, data }) => {
+			return (await logisticsApi.createShipment({
+				token,
+				orderId,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			toast.success("Shipment created successfully");
+			queryClient.invalidateQueries({ queryKey: ["orders"] });
+			queryClient.invalidateQueries({ queryKey: LOGISTICS_KEYS.all });
+		},
+		onError: (error) => {
+			toast.error(error.message || "Failed to create shipment");
+		}
+	});
+}
+/**
+* Cancel shipment mutation
+*
+* @param token - Auth token
+*/
+function useCancelShipment(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	return useMutation({
+		mutationFn: async ({ shipmentId, reason }) => {
+			return (await logisticsApi.cancelShipment({
+				token,
+				id: shipmentId,
+				data: { reason }
+			})).data;
+		},
+		onSuccess: () => {
+			toast.success("Shipment cancelled");
+			queryClient.invalidateQueries({ queryKey: ["orders"] });
+			queryClient.invalidateQueries({ queryKey: LOGISTICS_KEYS.all });
+		},
+		onError: (error) => {
+			toast.error(error.message || "Failed to cancel shipment");
+		}
+	});
+}
+/**
+* Update shipment status mutation
+*
+* @param token - Auth token
+*/
+function useUpdateShipmentStatus(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	return useMutation({
+		mutationFn: async ({ shipmentId, data }) => {
+			return (await logisticsApi.updateShipmentStatus({
+				token,
+				id: shipmentId,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			toast.success("Shipment status updated");
+			queryClient.invalidateQueries({ queryKey: ["orders"] });
+			queryClient.invalidateQueries({ queryKey: LOGISTICS_KEYS.all });
+		},
+		onError: (error) => {
+			toast.error(error.message || "Failed to update status");
+		}
+	});
+}
+/**
+* Combined hook for all logistics mutations
+*
+* @param token - Auth token
+*
+* @example
+* ```tsx
+* function ShipmentActions({ order }) {
+*   const {
+*     createShipment,
+*     cancelShipment,
+*     isLoading,
+*   } = useLogisticsActions(token);
+*
+*   return (
+*     <>
+*       <Button
+*         onClick={() =>
+*           createShipment({
+*             orderId: order._id,
+*             data: { provider: "redx", useProviderApi: true },
+*           })
+*         }
+*       >
+*         Create Shipment
+*       </Button>
+*       <Button onClick={() => cancelShipment({ shipmentId: order._id })}>
+*         Cancel
+*       </Button>
+*     </>
+*   );
+* }
+* ```
+*/
+function useLogisticsActions(token) {
+	const createShipmentMutation = useCreateShipment(token);
+	const cancelShipmentMutation = useCancelShipment(token);
+	const updateStatusMutation = useUpdateShipmentStatus(token);
+	return {
+		createShipment: createShipmentMutation.mutateAsync,
+		isCreatingShipment: createShipmentMutation.isPending,
+		cancelShipment: cancelShipmentMutation.mutateAsync,
+		isCancellingShipment: cancelShipmentMutation.isPending,
+		updateShipmentStatus: updateStatusMutation.mutateAsync,
+		isUpdatingStatus: updateStatusMutation.isPending,
+		isLoading: createShipmentMutation.isPending || cancelShipmentMutation.isPending || updateStatusMutation.isPending
+	};
+}
+
+//#endregion
+export { LOGISTICS_KEYS, useCancelShipment, useCreateShipment, useDeliveryCharge, useDeliveryChargeCalculation, useLogisticsActions, usePickupStores, useShipment, useTrackShipment, useUpdateShipmentStatus };