@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/inventory/hooks/procurement.js

@@ -0,0 +1,87 @@
+"use client";
+
+import { procurementApi } from "../api/procurement.js";
+import { AVAILABILITY_KEYS } from "./availability.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/procurement.ts
+/**
+* Procurement Order Hooks (Standard+)
+*/
+const PROCUREMENT_KEYS = {
+	all: ["procurement"],
+	list: (status) => [
+		...PROCUREMENT_KEYS.all,
+		"list",
+		status
+	],
+	detail: (id) => [...PROCUREMENT_KEYS.all, id]
+};
+function useProcurementOrders(token, status, options = {}) {
+	return useQuery({
+		queryKey: PROCUREMENT_KEYS.list(status),
+		queryFn: () => procurementApi.list({
+			token,
+			status
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useProcurementDetail(token, id, options = {}) {
+	return useQuery({
+		queryKey: PROCUREMENT_KEYS.detail(id),
+		queryFn: () => procurementApi.getById({
+			token,
+			id
+		}),
+		enabled: options.enabled !== false && !!token && !!id,
+		select: (res) => res.data
+	});
+}
+function useProcurementActions(token) {
+	const qc = useQueryClient();
+	const invalidate = () => {
+		qc.invalidateQueries({ queryKey: PROCUREMENT_KEYS.all });
+		qc.invalidateQueries({ queryKey: AVAILABILITY_KEYS.all });
+	};
+	const create = useMutation({
+		mutationFn: (data) => procurementApi.create({
+			token,
+			data
+		}),
+		onSuccess: invalidate
+	});
+	const approve = useMutation({
+		mutationFn: (id) => procurementApi.approve({
+			token,
+			id
+		}),
+		onSuccess: invalidate
+	});
+	const receive = useMutation({
+		mutationFn: ({ id, data }) => procurementApi.receive({
+			token,
+			id,
+			data
+		}),
+		onSuccess: invalidate
+	});
+	const cancel = useMutation({
+		mutationFn: (id) => procurementApi.cancel({
+			token,
+			id
+		}),
+		onSuccess: invalidate
+	});
+	return {
+		create,
+		approve,
+		receive,
+		cancel,
+		isLoading: create.isPending || approve.isPending || receive.isPending || cancel.isPending
+	};
+}
+
+//#endregion
+export { PROCUREMENT_KEYS, useProcurementActions, useProcurementDetail, useProcurementOrders };

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

@@ -0,0 +1,63 @@
+import { CreatePurchasePayload, Purchase, UpdatePurchasePayload } from "../types/inventory.js";
+import { useMutation } 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/purchase.d.ts
+/**
+ * Purchase hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - usePurchases: List purchases with filtering/pagination
+ * - usePurchaseDetail: Get single purchase
+ * - usePurchaseActions: Create, update, delete mutations (basic CRUD)
+ * - usePurchaseNavigation: Navigation between purchases
+ */
+declare const purchaseHooks: _classytic_arc_next0.CrudHooksReturn<Purchase, CreatePurchasePayload, UpdatePurchasePayload>;
+declare const PURCHASE_KEYS: _classytic_arc_next_query0.QueryKeys, usePurchases: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Purchase> | undefined): _classytic_arc_next_query0.ListQueryResult<Purchase>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Purchase> | undefined): _classytic_arc_next_query0.ListQueryResult<Purchase>;
+  }, usePurchaseDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Purchase> | undefined): _classytic_arc_next_query0.DetailQueryResult<Purchase>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Purchase> | undefined): _classytic_arc_next_query0.DetailQueryResult<Purchase>;
+  }, usePurchaseActions: () => _classytic_arc_next0.CrudActions<Purchase, CreatePurchasePayload, UpdatePurchasePayload>, usePurchaseNavigation: () => _classytic_arc_next0.NavigateFn<Purchase>;
+interface UsePurchaseStateActionsReturn {
+  receive: ReturnType<typeof useMutation<Purchase, Error, string>>;
+  pay: ReturnType<typeof useMutation<Purchase, Error, {
+    id: string;
+    amount: number;
+    method: string;
+    reference?: string;
+  }>>;
+  cancel: ReturnType<typeof useMutation<Purchase, Error, {
+    id: string;
+    reason?: string;
+  }>>;
+  isReceiving: boolean;
+  isPaying: boolean;
+  isCancelling: boolean;
+  isLoading: boolean;
+}
+/**
+ * Hook for purchase state actions (receive, pay, cancel)
+ *
+ * @param token - Auth token
+ * @returns Purchase state action mutations
+ *
+ * @example
+ * ```tsx
+ * const { receive, pay, cancel, isReceiving } = usePurchaseStateActions(token);
+ *
+ * // Receive a purchase (adds stock)
+ * await receive.mutateAsync(purchaseId);
+ *
+ * // Record payment
+ * await pay.mutateAsync({ id: purchaseId, amount: 1000, method: 'cash' });
+ *
+ * // Cancel purchase
+ * await cancel.mutateAsync({ id: purchaseId, reason: 'Duplicate entry' });
+ * ```
+ */
+declare function usePurchaseStateActions(token: string): UsePurchaseStateActionsReturn;
+//#endregion
+export { PURCHASE_KEYS, UsePurchaseStateActionsReturn, purchaseHooks, usePurchaseActions, usePurchaseDetail, usePurchaseNavigation, usePurchaseStateActions, usePurchases };

package/dist/inventory/hooks/purchase.js

@@ -0,0 +1,119 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { purchaseApi } from "../api/purchase.js";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/purchase.ts
+/**
+* Purchase Hooks
+*
+* React hooks for purchase CRUD operations using the factory pattern.
+*/
+/**
+* Purchase hooks using createCrudHooks factory
+*
+* Provides:
+* - usePurchases: List purchases with filtering/pagination
+* - usePurchaseDetail: Get single purchase
+* - usePurchaseActions: Create, update, delete mutations (basic CRUD)
+* - usePurchaseNavigation: Navigation between purchases
+*/
+const purchaseHooks = createCrudHooks({
+	api: purchaseApi,
+	entityKey: "purchases",
+	singular: "Purchase",
+	plural: "Purchases"
+});
+const { KEYS: PURCHASE_KEYS, useList: usePurchases, useDetail: usePurchaseDetail, useActions: usePurchaseActions, useNavigation: usePurchaseNavigation } = purchaseHooks;
+/**
+* Hook for purchase state actions (receive, pay, cancel)
+*
+* @param token - Auth token
+* @returns Purchase state action mutations
+*
+* @example
+* ```tsx
+* const { receive, pay, cancel, isReceiving } = usePurchaseStateActions(token);
+*
+* // Receive a purchase (adds stock)
+* await receive.mutateAsync(purchaseId);
+*
+* // Record payment
+* await pay.mutateAsync({ id: purchaseId, amount: 1000, method: 'cash' });
+*
+* // Cancel purchase
+* await cancel.mutateAsync({ id: purchaseId, reason: 'Duplicate entry' });
+* ```
+*/
+function usePurchaseStateActions(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const invalidateAll = () => {
+		queryClient.invalidateQueries({ queryKey: PURCHASE_KEYS.all });
+		queryClient.invalidateQueries({ queryKey: ["inventory"] });
+		queryClient.invalidateQueries({ queryKey: ["stock"] });
+	};
+	const receive = useMutation({
+		mutationFn: async (id) => {
+			return (await purchaseApi.receive({
+				token,
+				id
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Purchase received - stock added");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to receive purchase");
+		}
+	});
+	const pay = useMutation({
+		mutationFn: async ({ id, amount, method, reference }) => {
+			return (await purchaseApi.pay({
+				token,
+				id,
+				amount,
+				method,
+				reference
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Payment recorded");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to record payment");
+		}
+	});
+	const cancel = useMutation({
+		mutationFn: async ({ id, reason }) => {
+			return (await purchaseApi.cancel({
+				token,
+				id,
+				reason
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Purchase cancelled");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to cancel purchase");
+		}
+	});
+	return {
+		receive,
+		pay,
+		cancel,
+		isReceiving: receive.isPending,
+		isPaying: pay.isPending,
+		isCancelling: cancel.isPending,
+		isLoading: receive.isPending || pay.isPending || cancel.isPending
+	};
+}
+
+//#endregion
+export { PURCHASE_KEYS, purchaseHooks, usePurchaseActions, usePurchaseDetail, usePurchaseNavigation, usePurchaseStateActions, usePurchases };

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

@@ -0,0 +1,34 @@
+import { CreateRulePayload, EvaluateResult, ReplenishmentRule, UpdateRulePayload } from "../api/replenishment.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/replenishment.d.ts
+declare const REPLENISHMENT_KEYS: {
+  all: readonly ["replenishment"];
+  list: (scopeId?: string) => readonly ["replenishment", "list", string | undefined];
+  detail: (id: string) => readonly ["replenishment", string];
+};
+declare function useReplenishmentRules(token: string, scopeId?: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<ReplenishmentRule[], Error>;
+declare function useReplenishmentRuleDetail(token: string, id: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<ReplenishmentRule, Error>;
+declare function useReplenishmentActions(token: string): {
+  create: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<ReplenishmentRule>, Error, CreateRulePayload, unknown>;
+  update: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<ReplenishmentRule>, Error, {
+    id: string;
+    data: UpdateRulePayload;
+  }, unknown>;
+  remove: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<{
+    deleted: boolean;
+  }>, Error, string, unknown>;
+  evaluate: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<EvaluateResult>, Error, {
+    skuRef?: string;
+    nodeId?: string;
+    dryRun?: boolean;
+  }, unknown>;
+  isLoading: boolean;
+};
+//#endregion
+export { REPLENISHMENT_KEYS, useReplenishmentActions, useReplenishmentRuleDetail, useReplenishmentRules };

package/dist/inventory/hooks/replenishment.js

@@ -0,0 +1,87 @@
+"use client";
+
+import { replenishmentApi } from "../api/replenishment.js";
+import { PROCUREMENT_KEYS } from "./procurement.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/replenishment.ts
+/**
+* Replenishment Rules Hooks (Standard+)
+*/
+const REPLENISHMENT_KEYS = {
+	all: ["replenishment"],
+	list: (scopeId) => [
+		...REPLENISHMENT_KEYS.all,
+		"list",
+		scopeId
+	],
+	detail: (id) => [...REPLENISHMENT_KEYS.all, id]
+};
+function useReplenishmentRules(token, scopeId, options = {}) {
+	return useQuery({
+		queryKey: REPLENISHMENT_KEYS.list(scopeId),
+		queryFn: () => replenishmentApi.list({
+			token,
+			scopeId
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useReplenishmentRuleDetail(token, id, options = {}) {
+	return useQuery({
+		queryKey: REPLENISHMENT_KEYS.detail(id),
+		queryFn: () => replenishmentApi.getById({
+			token,
+			id
+		}),
+		enabled: options.enabled !== false && !!token && !!id,
+		select: (res) => res.data
+	});
+}
+function useReplenishmentActions(token) {
+	const qc = useQueryClient();
+	const invalidate = () => qc.invalidateQueries({ queryKey: REPLENISHMENT_KEYS.all });
+	const create = useMutation({
+		mutationFn: (data) => replenishmentApi.create({
+			token,
+			data
+		}),
+		onSuccess: invalidate
+	});
+	const update = useMutation({
+		mutationFn: ({ id, data }) => replenishmentApi.update({
+			token,
+			id,
+			data
+		}),
+		onSuccess: invalidate
+	});
+	const remove = useMutation({
+		mutationFn: (id) => replenishmentApi.deleteRule({
+			token,
+			id
+		}),
+		onSuccess: invalidate
+	});
+	const evaluate = useMutation({
+		mutationFn: (params) => replenishmentApi.evaluate({
+			token,
+			...params
+		}),
+		onSuccess: () => {
+			invalidate();
+			qc.invalidateQueries({ queryKey: PROCUREMENT_KEYS.all });
+		}
+	});
+	return {
+		create,
+		update,
+		remove,
+		evaluate,
+		isLoading: create.isPending || update.isPending || remove.isPending || evaluate.isPending
+	};
+}
+
+//#endregion
+export { REPLENISHMENT_KEYS, useReplenishmentActions, useReplenishmentRuleDetail, useReplenishmentRules };

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

@@ -0,0 +1,37 @@
+import { AgingReport, AvailabilityMatrix, HealthMetrics, TurnoverReport } from "../api/report.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/inventory/hooks/report.d.ts
+declare const REPORT_KEYS: {
+  all: readonly ["inventory-reports"];
+  aging: (nodeId?: string) => readonly ["inventory-reports", "aging", string | undefined];
+  turnover: (nodeId?: string) => readonly ["inventory-reports", "turnover", string | undefined];
+  availability: (nodeId?: string) => readonly ["inventory-reports", "availability", string | undefined];
+  health: (nodeId?: string) => readonly ["inventory-reports", "health", string | undefined];
+};
+declare function useStockAging(token: string, params?: {
+  nodeId?: string;
+  skuRef?: string;
+  buckets?: string;
+}, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<AgingReport, Error>;
+declare function useStockTurnover(token: string, params?: {
+  nodeId?: string;
+  skuRef?: string;
+  startDate?: string;
+  endDate?: string;
+}, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<TurnoverReport, Error>;
+declare function useAvailabilityMatrix(token: string, params?: {
+  nodeId?: string;
+  skuRefs?: string;
+}, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<AvailabilityMatrix, Error>;
+declare function useStockHealth(token: string, nodeId?: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<HealthMetrics, Error>;
+//#endregion
+export { REPORT_KEYS, useAvailabilityMatrix, useStockAging, useStockHealth, useStockTurnover };

package/dist/inventory/hooks/report.js

@@ -0,0 +1,79 @@
+"use client";
+
+import { reportApi } from "../api/report.js";
+import { useQuery } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/report.ts
+/**
+* Inventory Report Hooks (Enterprise)
+*/
+const REPORT_KEYS = {
+	all: ["inventory-reports"],
+	aging: (nodeId) => [
+		...REPORT_KEYS.all,
+		"aging",
+		nodeId
+	],
+	turnover: (nodeId) => [
+		...REPORT_KEYS.all,
+		"turnover",
+		nodeId
+	],
+	availability: (nodeId) => [
+		...REPORT_KEYS.all,
+		"availability",
+		nodeId
+	],
+	health: (nodeId) => [
+		...REPORT_KEYS.all,
+		"health",
+		nodeId
+	]
+};
+function useStockAging(token, params = {}, options = {}) {
+	return useQuery({
+		queryKey: REPORT_KEYS.aging(params.nodeId),
+		queryFn: () => reportApi.aging({
+			token,
+			...params
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useStockTurnover(token, params = {}, options = {}) {
+	return useQuery({
+		queryKey: REPORT_KEYS.turnover(params.nodeId),
+		queryFn: () => reportApi.turnover({
+			token,
+			...params
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useAvailabilityMatrix(token, params = {}, options = {}) {
+	return useQuery({
+		queryKey: REPORT_KEYS.availability(params.nodeId),
+		queryFn: () => reportApi.availability({
+			token,
+			...params
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useStockHealth(token, nodeId, options = {}) {
+	return useQuery({
+		queryKey: REPORT_KEYS.health(nodeId),
+		queryFn: () => reportApi.health({
+			token,
+			nodeId
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+
+//#endregion
+export { REPORT_KEYS, useAvailabilityMatrix, useStockAging, useStockHealth, useStockTurnover };

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

@@ -0,0 +1,113 @@
+import { ApiResponse } from "../../core/api-factory.js";
+import { CreateStockRequestPayload, StockRequest } from "../types/inventory.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+
+//#region src/inventory/hooks/request.d.ts
+declare const REQUEST_KEYS: {
+  all: readonly ["inventory", "requests"];
+  list: (params?: Record<string, unknown>) => readonly ["inventory", "requests", "list", Record<string, unknown> | undefined];
+  pending: () => readonly ["inventory", "requests", "pending"];
+  detail: (id: string) => readonly ["inventory", "requests", "detail", string];
+};
+interface QueryOptions {
+  enabled?: boolean;
+  staleTime?: number;
+}
+interface UseStockRequestsReturn {
+  requests: StockRequest[];
+  isLoading: boolean;
+  isFetching: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+interface UseStockRequestActionsReturn {
+  create: (data: CreateStockRequestPayload) => Promise<StockRequest>;
+  isCreating: boolean;
+  approve: (params: {
+    id: string;
+    items?: {
+      productId: string;
+      variantSku?: string;
+      quantityApproved: number;
+    }[];
+    reviewNotes?: string;
+  }) => Promise<StockRequest>;
+  isApproving: boolean;
+  reject: (params: {
+    id: string;
+    reason: string;
+  }) => Promise<StockRequest>;
+  isRejecting: boolean;
+  fulfill: (params: {
+    id: string;
+    remarks?: string;
+    items?: {
+      productId: string;
+      variantSku?: string;
+      quantity: number;
+      cartonNumber?: string;
+    }[];
+    transport?: {
+      vehicleNumber?: string;
+      driverName?: string;
+      driverPhone?: string;
+    };
+  }) => Promise<StockRequest>;
+  isFulfilling: boolean;
+  cancel: (params: {
+    id: string;
+    reason?: string;
+  }) => Promise<StockRequest>;
+  isCancelling: boolean;
+  isLoading: boolean;
+}
+/**
+ * Fetch stock requests
+ *
+ * @param token - Auth token
+ * @param params - Query parameters (status, branchId, etc.)
+ * @param options - Query options
+ */
+declare function useStockRequests(token: string, params?: Record<string, unknown>, options?: QueryOptions): UseStockRequestsReturn;
+/**
+ * Fetch pending stock requests
+ *
+ * @param token - Auth token
+ * @param options - Query options
+ */
+declare function usePendingStockRequests(token: string, options?: QueryOptions): UseStockRequestsReturn;
+/**
+ * Stock request detail
+ *
+ * @param token - Auth token
+ * @param id - Request ID
+ * @param options - Query options
+ */
+declare function useStockRequestDetail(token: string, id: string | null, options?: QueryOptions): _tanstack_react_query0.UseQueryResult<ApiResponse<StockRequest>, Error>;
+/**
+ * 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>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useStockRequestActions(token: string): UseStockRequestActionsReturn;
+/**
+ * Get all keys that should be invalidated when a transfer state changes.
+ * Use for: approve, dispatch, receive, cancel.
+ */
+declare function getTransferStateInvalidationKeys(): (string[] | readonly ["inventory", "requests"])[];
+//#endregion
+export { REQUEST_KEYS, UseStockRequestActionsReturn, UseStockRequestsReturn, getTransferStateInvalidationKeys, usePendingStockRequests, useStockRequestActions, useStockRequestDetail, useStockRequests };