@classytic/commerce-sdk 0.1.2 → 0.2.1

package/dist/inventory/hooks/transfer.js

@@ -0,0 +1,197 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { transferApi } from "../api/transfer.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/transfer.ts
+/**
+* Transfer Hooks
+*
+* React hooks for inventory transfer (challan) operations using the factory pattern.
+*/
+/**
+* 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
+*/
+const transferHooks = createCrudHooks({
+	api: transferApi,
+	entityKey: "transfers",
+	singular: "Transfer",
+	plural: "Transfers"
+});
+const { KEYS: TRANSFER_KEYS, useList: useTransfers, useDetail: useTransferDetail, useActions: useTransferActions, useNavigation: useTransferNavigation } = transferHooks;
+/**
+* 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' });
+* ```
+*/
+function useTransferStateActions(token) {
+	const queryClient = useQueryClient();
+	const toast = getToastHandler();
+	const invalidateAll = () => {
+		queryClient.invalidateQueries({ queryKey: TRANSFER_KEYS.all });
+		queryClient.invalidateQueries({ queryKey: ["inventory"] });
+		queryClient.invalidateQueries({ queryKey: ["stock"] });
+	};
+	const approveMutation = useMutation({
+		mutationFn: async (id) => {
+			return (await transferApi.approve({
+				token,
+				id
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Transfer approved");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to approve transfer");
+		}
+	});
+	const dispatchMutation = useMutation({
+		mutationFn: async ({ id, data }) => {
+			return (await transferApi.dispatch({
+				token,
+				id,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Transfer dispatched - stock deducted");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to dispatch transfer");
+		}
+	});
+	const inTransitMutation = useMutation({
+		mutationFn: async (id) => {
+			return (await transferApi.markInTransit({
+				token,
+				id
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Transfer marked in transit");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to mark transfer in transit");
+		}
+	});
+	const receiveMutation = useMutation({
+		mutationFn: async ({ id, data }) => {
+			return (await transferApi.receive({
+				token,
+				id,
+				data
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Transfer received - stock added");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to receive transfer");
+		}
+	});
+	const cancelMutation = useMutation({
+		mutationFn: async ({ id, reason }) => {
+			return (await transferApi.cancel({
+				token,
+				id,
+				reason
+			})).data;
+		},
+		onSuccess: () => {
+			invalidateAll();
+			toast.success("Transfer cancelled");
+		},
+		onError: (err) => {
+			toast.error(err.message || "Failed to cancel transfer");
+		}
+	});
+	return {
+		approve: async (id) => {
+			return approveMutation.mutateAsync(id);
+		},
+		isApproving: approveMutation.isPending,
+		dispatch: async (params) => {
+			return dispatchMutation.mutateAsync(params);
+		},
+		isDispatching: dispatchMutation.isPending,
+		inTransit: async (id) => {
+			return inTransitMutation.mutateAsync(id);
+		},
+		isMarkingInTransit: inTransitMutation.isPending,
+		receive: async (params) => {
+			return receiveMutation.mutateAsync(params);
+		},
+		isReceiving: receiveMutation.isPending,
+		cancel: async (params) => {
+			return cancelMutation.mutateAsync(params);
+		},
+		isCancelling: cancelMutation.isPending,
+		isLoading: approveMutation.isPending || dispatchMutation.isPending || inTransitMutation.isPending || receiveMutation.isPending || cancelMutation.isPending
+	};
+}
+const TRANSFER_STATS_KEYS = {
+	all: ["transfers", "stats"],
+	byBranch: (branchId) => [
+		"transfers",
+		"stats",
+		branchId
+	]
+};
+/**
+* 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);
+* ```
+*/
+function useTransferStats(token, branchId, options = {}) {
+	return useQuery({
+		queryKey: TRANSFER_STATS_KEYS.byBranch(branchId),
+		queryFn: () => transferApi.stats({
+			token,
+			params: branchId ? { branchId } : {}
+		}),
+		enabled: !!token && options.enabled !== false,
+		staleTime: 30 * 1e3,
+		select: (data) => data?.data
+	});
+}
+
+//#endregion
+export { TRANSFER_KEYS, TRANSFER_STATS_KEYS, transferHooks, useTransferActions, useTransferDetail, useTransferNavigation, useTransferStateActions, useTransferStats, useTransfers };

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

@@ -0,0 +1,87 @@
+import { AuditCountLine, AuditReconcileResult, AuditSession, AuditVarianceReport, BulkCreateLocationPayload, CreateAuditPayload, CreateLocationPayload, CreateNodePayload, UpdateLocationPayload, UpdateNodePayload, WarehouseLayout, WarehouseLocation, WarehouseNode } from "../types/warehouse.js";
+import { Availability } from "../api/availability.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/warehouse.d.ts
+declare const NODE_KEYS: {
+  all: readonly ["warehouse-nodes"];
+  list: () => readonly ["warehouse-nodes", "list"];
+  detail: (id: string) => readonly ["warehouse-nodes", string];
+};
+declare const LOCATION_KEYS: {
+  all: readonly ["warehouse-locations"];
+  list: (nodeId: string) => readonly ["warehouse-locations", "list", string];
+  layout: (nodeId: string) => readonly ["warehouse-locations", "layout", string];
+  detail: (id: string) => readonly ["warehouse-locations", string];
+  stock: (id: string) => readonly ["warehouse-locations", string, "stock"];
+};
+declare const AUDIT_KEYS: {
+  all: readonly ["stock-audits"];
+  list: (status?: string) => readonly ["stock-audits", "list", string | undefined];
+  detail: (id: string) => readonly ["stock-audits", string];
+  variance: (id: string) => readonly ["stock-audits", string, "variance"];
+};
+declare function useWarehouses(token: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<WarehouseNode[], Error>;
+declare function useWarehouseDetail(token: string, id: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<WarehouseNode, Error>;
+declare function useWarehouseActions(token: string): {
+  create: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<WarehouseNode>, Error, CreateNodePayload, unknown>;
+  update: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<WarehouseNode>, Error, {
+    id: string;
+    data: UpdateNodePayload;
+  }, unknown>;
+};
+declare function useLocations(token: string, nodeId: string, options?: {
+  enabled?: boolean;
+  type?: string;
+  parentLocationId?: string;
+}): _tanstack_react_query0.UseQueryResult<WarehouseLocation[], Error>;
+declare function useWarehouseLayout(token: string, nodeId: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<WarehouseLayout, Error>;
+declare function useLocationDetail(token: string, id: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<WarehouseLocation, Error>;
+declare function useLocationStock(token: string, id: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<Availability, Error>;
+declare function useLocationActions(token: string): {
+  create: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<WarehouseLocation>, Error, CreateLocationPayload, unknown>;
+  bulkCreate: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<{
+    created: number;
+    locations: WarehouseLocation[];
+  }>, Error, BulkCreateLocationPayload, unknown>;
+  update: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<WarehouseLocation>, Error, {
+    id: string;
+    data: UpdateLocationPayload;
+  }, unknown>;
+};
+declare function useAudits(token: string, status?: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<AuditSession[], Error>;
+declare function useAuditDetail(token: string, id: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<AuditSession, Error>;
+declare function useAuditVariance(token: string, id: string, options?: {
+  enabled?: boolean;
+}): _tanstack_react_query0.UseQueryResult<AuditVarianceReport, Error>;
+declare function useAuditActions(token: string): {
+  create: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<AuditSession>, Error, CreateAuditPayload, unknown>;
+  submitLines: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<unknown>, Error, {
+    id: string;
+    lines: AuditCountLine[];
+  }, unknown>;
+  reconcile: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<AuditReconcileResult>, Error, {
+    id: string;
+    autoApproveThreshold?: number;
+  }, unknown>;
+  postMoves: _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<{
+    posted: boolean;
+  }>, Error, string, unknown>;
+};
+//#endregion
+export { AUDIT_KEYS, LOCATION_KEYS, NODE_KEYS, useAuditActions, useAuditDetail, useAuditVariance, useAudits, useLocationActions, useLocationDetail, useLocationStock, useLocations, useWarehouseActions, useWarehouseDetail, useWarehouseLayout, useWarehouses };

package/dist/inventory/hooks/warehouse.js

@@ -0,0 +1,240 @@
+"use client";
+
+import { auditApi, locationApi, nodeApi } from "../api/warehouse.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/inventory/hooks/warehouse.ts
+/**
+* Warehouse Hooks — Node, Location, Audit
+*
+* TanStack Query hooks for warehouse management.
+*/
+const NODE_KEYS = {
+	all: ["warehouse-nodes"],
+	list: () => [...NODE_KEYS.all, "list"],
+	detail: (id) => [...NODE_KEYS.all, id]
+};
+const LOCATION_KEYS = {
+	all: ["warehouse-locations"],
+	list: (nodeId) => [
+		...LOCATION_KEYS.all,
+		"list",
+		nodeId
+	],
+	layout: (nodeId) => [
+		...LOCATION_KEYS.all,
+		"layout",
+		nodeId
+	],
+	detail: (id) => [...LOCATION_KEYS.all, id],
+	stock: (id) => [
+		...LOCATION_KEYS.all,
+		id,
+		"stock"
+	]
+};
+const AUDIT_KEYS = {
+	all: ["stock-audits"],
+	list: (status) => [
+		...AUDIT_KEYS.all,
+		"list",
+		status
+	],
+	detail: (id) => [...AUDIT_KEYS.all, id],
+	variance: (id) => [
+		...AUDIT_KEYS.all,
+		id,
+		"variance"
+	]
+};
+function useWarehouses(token, options = {}) {
+	return useQuery({
+		queryKey: NODE_KEYS.list(),
+		queryFn: () => nodeApi.list({ token }),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useWarehouseDetail(token, id, options = {}) {
+	return useQuery({
+		queryKey: NODE_KEYS.detail(id),
+		queryFn: () => nodeApi.getById({
+			token,
+			id
+		}),
+		enabled: options.enabled !== false && !!token && !!id,
+		select: (res) => res.data
+	});
+}
+function useWarehouseActions(token) {
+	const qc = useQueryClient();
+	return {
+		create: useMutation({
+			mutationFn: (data) => nodeApi.create({
+				token,
+				data
+			}),
+			onSuccess: () => qc.invalidateQueries({ queryKey: NODE_KEYS.all })
+		}),
+		update: useMutation({
+			mutationFn: ({ id, data }) => nodeApi.update({
+				token,
+				id,
+				data
+			}),
+			onSuccess: () => qc.invalidateQueries({ queryKey: NODE_KEYS.all })
+		})
+	};
+}
+function useLocations(token, nodeId, options = {}) {
+	return useQuery({
+		queryKey: LOCATION_KEYS.list(nodeId),
+		queryFn: () => locationApi.list({
+			token,
+			nodeId,
+			type: options.type,
+			parentLocationId: options.parentLocationId
+		}),
+		enabled: options.enabled !== false && !!token && !!nodeId,
+		select: (res) => res.data
+	});
+}
+function useWarehouseLayout(token, nodeId, options = {}) {
+	return useQuery({
+		queryKey: LOCATION_KEYS.layout(nodeId),
+		queryFn: () => locationApi.getLayout({
+			token,
+			nodeId
+		}),
+		enabled: options.enabled !== false && !!token && !!nodeId,
+		select: (res) => res.data
+	});
+}
+function useLocationDetail(token, id, options = {}) {
+	return useQuery({
+		queryKey: LOCATION_KEYS.detail(id),
+		queryFn: () => locationApi.getById({
+			token,
+			id
+		}),
+		enabled: options.enabled !== false && !!token && !!id,
+		select: (res) => res.data
+	});
+}
+function useLocationStock(token, id, options = {}) {
+	return useQuery({
+		queryKey: LOCATION_KEYS.stock(id),
+		queryFn: () => locationApi.getStock({
+			token,
+			id
+		}),
+		enabled: options.enabled !== false && !!token && !!id,
+		select: (res) => res.data
+	});
+}
+function useLocationActions(token) {
+	const qc = useQueryClient();
+	return {
+		create: useMutation({
+			mutationFn: (data) => locationApi.create({
+				token,
+				data
+			}),
+			onSuccess: () => qc.invalidateQueries({ queryKey: LOCATION_KEYS.all })
+		}),
+		bulkCreate: useMutation({
+			mutationFn: (data) => locationApi.bulkCreate({
+				token,
+				data
+			}),
+			onSuccess: () => qc.invalidateQueries({ queryKey: LOCATION_KEYS.all })
+		}),
+		update: useMutation({
+			mutationFn: ({ id, data }) => locationApi.update({
+				token,
+				id,
+				data
+			}),
+			onSuccess: () => qc.invalidateQueries({ queryKey: LOCATION_KEYS.all })
+		})
+	};
+}
+function useAudits(token, status, options = {}) {
+	return useQuery({
+		queryKey: AUDIT_KEYS.list(status),
+		queryFn: () => auditApi.list({
+			token,
+			status
+		}),
+		enabled: options.enabled !== false && !!token,
+		select: (res) => res.data
+	});
+}
+function useAuditDetail(token, id, options = {}) {
+	return useQuery({
+		queryKey: AUDIT_KEYS.detail(id),
+		queryFn: () => auditApi.getById({
+			token,
+			id
+		}),
+		enabled: options.enabled !== false && !!token && !!id,
+		select: (res) => res.data
+	});
+}
+function useAuditVariance(token, id, options = {}) {
+	return useQuery({
+		queryKey: AUDIT_KEYS.variance(id),
+		queryFn: () => auditApi.getVariance({
+			token,
+			id
+		}),
+		enabled: options.enabled !== false && !!token && !!id,
+		select: (res) => res.data
+	});
+}
+function useAuditActions(token) {
+	const qc = useQueryClient();
+	return {
+		create: useMutation({
+			mutationFn: (data) => auditApi.create({
+				token,
+				data
+			}),
+			onSuccess: () => qc.invalidateQueries({ queryKey: AUDIT_KEYS.all })
+		}),
+		submitLines: useMutation({
+			mutationFn: ({ id, lines }) => auditApi.submitLines({
+				token,
+				id,
+				lines
+			}),
+			onSuccess: (_data, vars) => {
+				qc.invalidateQueries({ queryKey: AUDIT_KEYS.detail(vars.id) });
+			}
+		}),
+		reconcile: useMutation({
+			mutationFn: ({ id, autoApproveThreshold }) => auditApi.reconcile({
+				token,
+				id,
+				autoApproveThreshold
+			}),
+			onSuccess: (_data, vars) => {
+				qc.invalidateQueries({ queryKey: AUDIT_KEYS.detail(vars.id) });
+				qc.invalidateQueries({ queryKey: AUDIT_KEYS.variance(vars.id) });
+			}
+		}),
+		postMoves: useMutation({
+			mutationFn: (id) => auditApi.postMoves({
+				token,
+				id
+			}),
+			onSuccess: () => {
+				qc.invalidateQueries({ queryKey: AUDIT_KEYS.all });
+				qc.invalidateQueries({ queryKey: ["availability"] });
+			}
+		})
+	};
+}
+
+//#endregion
+export { AUDIT_KEYS, LOCATION_KEYS, NODE_KEYS, useAuditActions, useAuditDetail, useAuditVariance, useAudits, useLocationActions, useLocationDetail, useLocationStock, useLocations, useWarehouseActions, useWarehouseDetail, useWarehouseLayout, useWarehouses };