@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/inventory/hooks/request.js

@@ -0,0 +1,218 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { requestApi } from "../api/request.js";
+import { TRANSFER_KEYS } from "./transfer.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+//#region src/inventory/hooks/request.ts
+/**
+* Stock Request Hooks
+*
+* React hooks for stock request operations.
+*/
+const REQUEST_KEYS = {
+	all: ["inventory", "requests"],
+	list: (params) => [
+		...REQUEST_KEYS.all,
+		"list",
+		params
+	],
+	pending: () => [...REQUEST_KEYS.all, "pending"],
+	detail: (id) => [
+		...REQUEST_KEYS.all,
+		"detail",
+		id
+	]
+};
+/**
+* Fetch stock requests
+*
+* @param token - Auth token
+* @param params - Query parameters (status, branchId, etc.)
+* @param options - Query options
+*/
+function useStockRequests(token, params, options = {}) {
+	const { data, isLoading, isFetching, error, refetch } = useQuery({
+		queryKey: REQUEST_KEYS.list(params),
+		queryFn: () => requestApi.list({
+			token,
+			params
+		}),
+		enabled: !!token && options.enabled !== false,
+		staleTime: options.staleTime ?? 15 * 1e3
+	});
+	return {
+		requests: useMemo(() => {
+			if (!data) return [];
+			return data.docs || data.data || [];
+		}, [data]),
+		isLoading,
+		isFetching,
+		error,
+		refetch
+	};
+}
+/**
+* Fetch pending stock requests
+*
+* @param token - Auth token
+* @param options - Query options
+*/
+function usePendingStockRequests(token, options = {}) {
+	const { data, isLoading, isFetching, error, refetch } = useQuery({
+		queryKey: REQUEST_KEYS.pending(),
+		queryFn: () => requestApi.listPending({ token }),
+		enabled: !!token && options.enabled !== false,
+		staleTime: options.staleTime ?? 15 * 1e3
+	});
+	return {
+		requests: useMemo(() => {
+			if (!data) return [];
+			return data.docs || data.data || [];
+		}, [data]),
+		isLoading,
+		isFetching,
+		error,
+		refetch
+	};
+}
+/**
+* Stock request detail
+*
+* @param token - Auth token
+* @param id - Request ID
+* @param options - Query options
+*/
+function useStockRequestDetail(token, id, options = {}) {
+	return useQuery({
+		queryKey: REQUEST_KEYS.detail(id || ""),
+		queryFn: () => requestApi.getById({
+			token,
+			id
+		}),
+		enabled: !!token && !!id && options.enabled !== false,
+		staleTime: options.staleTime ?? 30 * 1e3
+	});
+}
+/**
+* Stock request actions (create, approve, reject, fulfill, cancel)
+*
+* @param token - Auth token
+*
+* @example
+* ```tsx
+* function RequestActions({ request }) {
+*   const { approve, reject, fulfill, isLoading } = useStockRequestActions(token);
+*
+*   return (
+*     <>
+*       <Button onClick={() => approve({ id: request._id })}>Approve</Button>
+*       <Button onClick={() => reject({ id: request._id, reason: 'Out of stock' })}>Reject</Button>
+*     </>
+*   );
+* }
+* ```
+*/
+function useStockRequestActions(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const createMutation = useMutation({
+		mutationFn: (data) => requestApi.create({
+			token,
+			data
+		}),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: REQUEST_KEYS.all });
+			toast.success("Stock request created");
+		},
+		onError: (err) => toast.error(err.message || "Failed to create request")
+	});
+	const approveMutation = useMutation({
+		mutationFn: ({ id, items, reviewNotes }) => requestApi.approve({
+			token,
+			id,
+			items,
+			reviewNotes
+		}),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: REQUEST_KEYS.all });
+			toast.success("Request approved");
+		},
+		onError: (err) => toast.error(err.message || "Failed to approve request")
+	});
+	const rejectMutation = useMutation({
+		mutationFn: ({ id, reason }) => requestApi.reject({
+			token,
+			id,
+			reason
+		}),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: REQUEST_KEYS.all });
+			toast.success("Request rejected");
+		},
+		onError: (err) => toast.error(err.message || "Failed to reject request")
+	});
+	const fulfillMutation = useMutation({
+		mutationFn: ({ id, remarks, items, transport }) => requestApi.fulfill({
+			token,
+			id,
+			remarks,
+			items,
+			transport,
+			documentType: "delivery_note"
+		}),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: REQUEST_KEYS.all });
+			queryClient.invalidateQueries({ queryKey: TRANSFER_KEYS.all });
+			toast.success("Request fulfilled (transfer created)");
+		},
+		onError: (err) => toast.error(err.message || "Failed to fulfill request")
+	});
+	const cancelMutation = useMutation({
+		mutationFn: ({ id, reason }) => requestApi.cancel({
+			token,
+			id,
+			reason
+		}),
+		onSuccess: () => {
+			queryClient.invalidateQueries({ queryKey: REQUEST_KEYS.all });
+			toast.success("Request cancelled");
+		},
+		onError: (err) => toast.error(err.message || "Failed to cancel request")
+	});
+	return {
+		create: async (data) => {
+			return (await createMutation.mutateAsync(data)).data;
+		},
+		isCreating: createMutation.isPending,
+		approve: async (params) => {
+			return (await approveMutation.mutateAsync(params)).data;
+		},
+		isApproving: approveMutation.isPending,
+		reject: async (params) => {
+			return (await rejectMutation.mutateAsync(params)).data;
+		},
+		isRejecting: rejectMutation.isPending,
+		fulfill: async (params) => {
+			return (await fulfillMutation.mutateAsync(params)).data;
+		},
+		isFulfilling: fulfillMutation.isPending,
+		cancel: async (params) => {
+			return (await cancelMutation.mutateAsync(params)).data;
+		},
+		isCancelling: cancelMutation.isPending,
+		isLoading: createMutation.isPending || approveMutation.isPending || rejectMutation.isPending || fulfillMutation.isPending || cancelMutation.isPending
+	};
+}
+/**
+* Get all keys that should be invalidated when a transfer state changes.
+* Use for: approve, dispatch, receive, cancel.
+*/
+function getTransferStateInvalidationKeys() {
+	return [TRANSFER_KEYS.all, REQUEST_KEYS.all];
+}
+
+//#endregion
+export { REQUEST_KEYS, getTransferStateInvalidationKeys, usePendingStockRequests, useStockRequestActions, useStockRequestDetail, useStockRequests };

package/dist/inventory/hooks/reservation.d.ts

@@ -0,0 +1,25 @@
+import { CreateReservationPayload, Reservation } from "../api/reservation.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import * as _classytic_arc_next_api0 from "@classytic/arc-next/api";
+
+//#region src/inventory/hooks/reservation.d.ts
+declare const RESERVATION_KEYS: {
+  all: readonly ["reservations"];
+};
+/**
+ * Reservation mutations — reserve, release, consume
+ */
+declare function useReservationActions(token: string): {
+  reserve: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<Reservation>, Error, CreateReservationPayload, unknown>;
+  release: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<Reservation>, Error, string, unknown>;
+  consume: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<Reservation>, Error, {
+    id: string;
+    quantity: number;
+  }, unknown>;
+  isReserving: boolean;
+  isReleasing: boolean;
+  isConsuming: boolean;
+  isLoading: boolean;
+};
+//#endregion
+export { RESERVATION_KEYS, useReservationActions };

package/dist/inventory/hooks/reservation.js

@@ -0,0 +1,56 @@
+"use client";
+
+import { reservationApi } from "../api/reservation.js";
+import { AVAILABILITY_KEYS } from "./availability.js";
+import { INVENTORY_KEYS } from "./inventory.js";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/reservation.ts
+/**
+* Reservation Hooks — Flow-native stock reservations
+*/
+const RESERVATION_KEYS = { all: ["reservations"] };
+/**
+* Reservation mutations — reserve, release, consume
+*/
+function useReservationActions(token) {
+	const queryClient = useQueryClient();
+	const invalidate = () => {
+		queryClient.invalidateQueries({ queryKey: AVAILABILITY_KEYS.all });
+		queryClient.invalidateQueries({ queryKey: INVENTORY_KEYS.all });
+	};
+	const reserve = useMutation({
+		mutationFn: (data) => reservationApi.create({
+			token,
+			data
+		}),
+		onSuccess: invalidate
+	});
+	const release = useMutation({
+		mutationFn: (id) => reservationApi.release({
+			token,
+			id
+		}),
+		onSuccess: invalidate
+	});
+	const consume = useMutation({
+		mutationFn: ({ id, quantity }) => reservationApi.consume({
+			token,
+			id,
+			quantity
+		}),
+		onSuccess: invalidate
+	});
+	return {
+		reserve,
+		release,
+		consume,
+		isReserving: reserve.isPending,
+		isReleasing: release.isPending,
+		isConsuming: consume.isPending,
+		isLoading: reserve.isPending || release.isPending || consume.isPending
+	};
+}
+
+//#endregion
+export { RESERVATION_KEYS, useReservationActions };

package/dist/inventory/hooks/scan.d.ts

@@ -0,0 +1,14 @@
+import { ScanResolution } from "../api/scan.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import * as _classytic_arc_next_api0 from "@classytic/arc-next/api";
+
+//#region src/inventory/hooks/scan.d.ts
+declare const SCAN_KEYS: {
+  all: readonly ["scan"];
+};
+/**
+ * Resolve a barcode/SKU/lot/serial scan token
+ */
+declare function useScanResolve(token: string): _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<ScanResolution>, Error, string, unknown>;
+//#endregion
+export { SCAN_KEYS, useScanResolve };

package/dist/inventory/hooks/scan.js

@@ -0,0 +1,22 @@
+"use client";
+
+import { scanApi } from "../api/scan.js";
+import { useMutation } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/scan.ts
+/**
+* Scan Hooks — Flow-native barcode/token resolution
+*/
+const SCAN_KEYS = { all: ["scan"] };
+/**
+* Resolve a barcode/SKU/lot/serial scan token
+*/
+function useScanResolve(token) {
+	return useMutation({ mutationFn: (scanToken) => scanApi.resolve({
+		token,
+		scanToken
+	}) });
+}
+
+//#endregion
+export { SCAN_KEYS, useScanResolve };

package/dist/inventory/hooks/supplier.d.ts

@@ -0,0 +1,24 @@
+import { Supplier, SupplierCreatePayload, SupplierUpdatePayload } from "../types/supplier.js";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/inventory/hooks/supplier.d.ts
+/**
+ * Supplier hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useSuppliers: List suppliers with filtering/pagination
+ * - useSupplierDetail: Get single supplier
+ * - useSupplierActions: Create, update, delete mutations
+ * - useSupplierNavigation: Navigation between suppliers
+ */
+declare const supplierHooks: _classytic_arc_next0.CrudHooksReturn<Supplier, SupplierCreatePayload, SupplierUpdatePayload>;
+declare const SUPPLIER_KEYS: _classytic_arc_next_query0.QueryKeys, useSuppliers: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Supplier> | undefined): _classytic_arc_next_query0.ListQueryResult<Supplier>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Supplier> | undefined): _classytic_arc_next_query0.ListQueryResult<Supplier>;
+  }, useSupplierDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Supplier> | undefined): _classytic_arc_next_query0.DetailQueryResult<Supplier>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Supplier> | undefined): _classytic_arc_next_query0.DetailQueryResult<Supplier>;
+  }, useSupplierActions: () => _classytic_arc_next0.CrudActions<Supplier, SupplierCreatePayload, SupplierUpdatePayload>, useSupplierNavigation: () => _classytic_arc_next0.NavigateFn<Supplier>;
+//#endregion
+export { SUPPLIER_KEYS, supplierHooks, useSupplierActions, useSupplierDetail, useSupplierNavigation, useSuppliers };

package/dist/inventory/hooks/supplier.js

@@ -0,0 +1,30 @@
+"use client";
+
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { supplierApi } from "../api/supplier.js";
+
+//#region src/inventory/hooks/supplier.ts
+/**
+* Supplier Hooks
+*
+* React hooks for supplier CRUD operations using the factory pattern.
+*/
+/**
+* Supplier hooks using createCrudHooks factory
+*
+* Provides:
+* - useSuppliers: List suppliers with filtering/pagination
+* - useSupplierDetail: Get single supplier
+* - useSupplierActions: Create, update, delete mutations
+* - useSupplierNavigation: Navigation between suppliers
+*/
+const supplierHooks = createCrudHooks({
+	api: supplierApi,
+	entityKey: "suppliers",
+	singular: "Supplier",
+	plural: "Suppliers"
+});
+const { KEYS: SUPPLIER_KEYS, useList: useSuppliers, useDetail: useSupplierDetail, useActions: useSupplierActions, useNavigation: useSupplierNavigation } = supplierHooks;
+
+//#endregion
+export { SUPPLIER_KEYS, supplierHooks, useSupplierActions, useSupplierDetail, useSupplierNavigation, useSuppliers };

package/dist/inventory/hooks/trace.d.ts

@@ -0,0 +1,19 @@
+import { RecallResult, TraceResult } from "../api/trace.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import * as _classytic_arc_next_api0 from "@classytic/arc-next/api";
+
+//#region src/inventory/hooks/trace.d.ts
+declare const TRACE_KEYS: {
+  all: readonly ["trace"];
+  lot: (lotId: string) => readonly ["trace", "lot", string];
+  serial: (serialCode: string, skuRef: string) => readonly ["trace", "serial", string, string];
+};
+declare function useLotTrace(token: string, lotId: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<TraceResult, Error>;
+declare function useSerialTrace(token: string, serialCode: string, skuRef: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<TraceResult, Error>;
+declare function useRecallAnalysis(token: string): _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<RecallResult>, Error, string, unknown>;
+//#endregion
+export { TRACE_KEYS, useLotTrace, useRecallAnalysis, useSerialTrace };

package/dist/inventory/hooks/trace.js

@@ -0,0 +1,55 @@
+"use client";
+
+import { traceApi } from "../api/trace.js";
+import { useMutation, useQuery } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/trace.ts
+/**
+* Traceability Hooks (Enterprise)
+*/
+const TRACE_KEYS = {
+	all: ["trace"],
+	lot: (lotId) => [
+		...TRACE_KEYS.all,
+		"lot",
+		lotId
+	],
+	serial: (serialCode, skuRef) => [
+		...TRACE_KEYS.all,
+		"serial",
+		serialCode,
+		skuRef
+	]
+};
+function useLotTrace(token, lotId, options = {}) {
+	return useQuery({
+		queryKey: TRACE_KEYS.lot(lotId),
+		queryFn: () => traceApi.traceLot({
+			token,
+			lotId
+		}),
+		enabled: options.enabled !== false && !!token && !!lotId,
+		select: (res) => res.data
+	});
+}
+function useSerialTrace(token, serialCode, skuRef, options = {}) {
+	return useQuery({
+		queryKey: TRACE_KEYS.serial(serialCode, skuRef),
+		queryFn: () => traceApi.traceSerial({
+			token,
+			serialCode,
+			skuRef
+		}),
+		enabled: options.enabled !== false && !!token && !!serialCode && !!skuRef,
+		select: (res) => res.data
+	});
+}
+function useRecallAnalysis(token) {
+	return useMutation({ mutationFn: (lotId) => traceApi.recall({
+		token,
+		lotId
+	}) });
+}
+
+//#endregion
+export { TRACE_KEYS, useLotTrace, useRecallAnalysis, useSerialTrace };

package/dist/inventory/hooks/transfer.d.ts

@@ -0,0 +1,90 @@
+import { CreateTransferPayload, DispatchTransferPayload, InventoryTransfer, ReceiveTransferPayload, Transfer, TransferStats, UpdateTransferPayload } from "../types/inventory.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/inventory/hooks/transfer.d.ts
+/**
+ * Transfer hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useTransfers: List transfers with filtering/pagination
+ * - useTransferDetail: Get single transfer
+ * - useTransferActions: Create, update, delete mutations (basic CRUD)
+ * - useTransferNavigation: Navigation between transfers
+ */
+declare const transferHooks: _classytic_arc_next0.CrudHooksReturn<InventoryTransfer, CreateTransferPayload, UpdateTransferPayload>;
+declare const TRANSFER_KEYS: _classytic_arc_next_query0.QueryKeys, useTransfers: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<InventoryTransfer> | undefined): _classytic_arc_next_query0.ListQueryResult<InventoryTransfer>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<InventoryTransfer> | undefined): _classytic_arc_next_query0.ListQueryResult<InventoryTransfer>;
+  }, useTransferDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<InventoryTransfer> | undefined): _classytic_arc_next_query0.DetailQueryResult<InventoryTransfer>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<InventoryTransfer> | undefined): _classytic_arc_next_query0.DetailQueryResult<InventoryTransfer>;
+  }, useTransferActions: () => _classytic_arc_next0.CrudActions<InventoryTransfer, CreateTransferPayload, UpdateTransferPayload>, useTransferNavigation: () => _classytic_arc_next0.NavigateFn<InventoryTransfer>;
+interface UseTransferStateActionsReturn {
+  approve: (id: string) => Promise<Transfer>;
+  isApproving: boolean;
+  dispatch: (params: {
+    id: string;
+    data?: DispatchTransferPayload;
+  }) => Promise<Transfer>;
+  isDispatching: boolean;
+  inTransit: (id: string) => Promise<Transfer>;
+  isMarkingInTransit: boolean;
+  receive: (params: {
+    id: string;
+    data?: ReceiveTransferPayload;
+  }) => Promise<Transfer>;
+  isReceiving: boolean;
+  cancel: (params: {
+    id: string;
+    reason?: string;
+  }) => Promise<Transfer>;
+  isCancelling: boolean;
+  isLoading: boolean;
+}
+/**
+ * Hook for transfer state actions (approve, dispatch, inTransit, receive, cancel)
+ *
+ * @param token - Auth token
+ * @returns Transfer state action functions
+ *
+ * @example
+ * ```tsx
+ * const { approve, dispatch, receive, cancel, isApproving } = useTransferStateActions(token);
+ *
+ * // Approve a transfer
+ * await approve(transferId);
+ *
+ * // Dispatch with transport details
+ * await dispatch({ id: transferId, data: { transport: { vehicleNumber: 'ABC123' } } });
+ *
+ * // Receive a transfer
+ * await receive({ id: transferId, data: {} });
+ *
+ * // Cancel transfer
+ * await cancel({ id: transferId, reason: 'Duplicate entry' });
+ * ```
+ */
+declare function useTransferStateActions(token: string): UseTransferStateActionsReturn;
+declare const TRANSFER_STATS_KEYS: {
+  all: readonly ["transfers", "stats"];
+  byBranch: (branchId?: string) => readonly ["transfers", "stats", string | undefined];
+};
+/**
+ * Hook to fetch transfer statistics
+ *
+ * @param token - Auth token
+ * @param branchId - Optional branch filter
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: stats, isLoading } = useTransferStats(token, branchId);
+ * ```
+ */
+declare function useTransferStats(token: string, branchId?: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<TransferStats, Error>;
+//#endregion
+export { TRANSFER_KEYS, TRANSFER_STATS_KEYS, UseTransferStateActionsReturn, transferHooks, useTransferActions, useTransferDetail, useTransferNavigation, useTransferStateActions, useTransferStats, useTransfers };