@classytic/commerce-sdk 0.1.0

package/dist/chunk-IXMWZJLV.js

@@ -0,0 +1,616 @@
+import { purchaseApi } from './chunk-6RYGA6MF.js';
+import { transferApi } from './chunk-FA7QFJ2G.js';
+import { requestApi } from './chunk-QO5AGZFP.js';
+import { movementApi } from './chunk-SZYWG5IB.js';
+import { adjustmentApi } from './chunk-R5Z7NYLH.js';
+import { supplierApi } from './chunk-WUOQK7BO.js';
+import { stockApi } from './chunk-KZIGRIQG.js';
+import { posApi } from './chunk-66OQAZSL.js';
+import { createCrudHooks } from './chunk-B6MPVOV7.js';
+import { getToastHandler } from './chunk-U3XT35GZ.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { useMemo } from 'react';
+
+// src/inventory/api/index.ts
+var inventoryApis = {
+  stock: () => import('./stock-OOUW57VQ.js').then((m) => m.stockApi),
+  purchase: () => import('./purchase-24BGT2HA.js').then((m) => m.purchaseApi),
+  transfer: () => import('./transfer-7SYSH3RG.js').then((m) => m.transferApi),
+  request: () => import('./request-652PS6VR.js').then((m) => m.requestApi),
+  movement: () => import('./movement-7MV3ADY5.js').then((m) => m.movementApi),
+  adjustment: () => import('./adjustment-DTSLM7AN.js').then((m) => m.adjustmentApi),
+  supplier: () => import('./supplier-OC6JAWV6.js').then((m) => m.supplierApi)
+};
+var INVENTORY_KEYS = {
+  all: ["inventory"],
+  products: (branchId) => [...INVENTORY_KEYS.all, "products", branchId],
+  productsList: (branchId, params) => [...INVENTORY_KEYS.products(branchId), params],
+  lookup: (code, branchId) => [...INVENTORY_KEYS.all, "lookup", code, branchId]
+};
+function useInventory(token, branchId, filters = {}, options = {}) {
+  const queryKey = INVENTORY_KEYS.productsList(branchId, filters);
+  const { data, isLoading, isFetching, error, refetch } = useQuery({
+    queryKey,
+    queryFn: () => posApi.getProducts({
+      token,
+      branchId,
+      category: filters.category,
+      search: filters.search,
+      inStockOnly: filters.inStockOnly,
+      lowStockOnly: filters.lowStockOnly,
+      after: filters.after,
+      limit: filters.limit || 50,
+      sort: filters.sort || "name"
+    }),
+    enabled: !!token && options.enabled !== false,
+    staleTime: 30 * 1e3,
+    // 30 seconds - inventory changes frequently
+    refetchOnWindowFocus: true
+  });
+  return {
+    items: data?.docs || [],
+    summary: data?.summary || { totalItems: 0, totalQuantity: 0, lowStockCount: 0, outOfStockCount: 0 },
+    branch: data?.branch || { _id: "", code: "", name: "" },
+    hasMore: data?.hasMore || false,
+    nextCursor: data?.next || null,
+    isLoading,
+    isFetching,
+    error,
+    refetch
+  };
+}
+function useInventoryLookup(token, code, branchId, options = {}) {
+  return useQuery({
+    queryKey: INVENTORY_KEYS.lookup(code, branchId),
+    queryFn: () => posApi.lookup({ token, code, branchId }),
+    enabled: !!token && !!code && code.length >= 2 && options.enabled !== false,
+    staleTime: 10 * 1e3,
+    // 10 seconds
+    retry: false
+  });
+}
+function useStockActions(token) {
+  const queryClient = useQueryClient();
+  const toast = getToastHandler();
+  const invalidateStockQueries = (branchId) => {
+    queryClient.invalidateQueries({
+      queryKey: INVENTORY_KEYS.products(branchId)
+    });
+    queryClient.invalidateQueries({
+      queryKey: ["pos", "products", branchId]
+    });
+  };
+  const adjustMutation = useMutation({
+    mutationFn: (data) => adjustmentApi.create({ token, data }),
+    onSuccess: (_, variables) => {
+      invalidateStockQueries(variables.branchId);
+      toast.success("Stock adjusted successfully");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to adjust stock");
+    }
+  });
+  const setStockMutation = useMutation({
+    mutationFn: ({
+      productId,
+      quantity,
+      branchId,
+      variantSku,
+      notes
+    }) => adjustmentApi.create({
+      token,
+      data: {
+        productId,
+        quantity,
+        branchId,
+        variantSku,
+        mode: "set",
+        notes
+      }
+    }),
+    onSuccess: (_, variables) => {
+      invalidateStockQueries(variables.branchId);
+      toast.success("Stock level updated");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to update stock");
+    }
+  });
+  const bulkAdjustMutation = useMutation({
+    mutationFn: (data) => adjustmentApi.create({
+      token,
+      data: {
+        adjustments: data.adjustments,
+        branchId: data.branchId,
+        reason: data.reason
+      }
+    }),
+    onSuccess: (_, variables) => {
+      invalidateStockQueries(variables.branchId);
+      toast.success("Bulk adjustment completed");
+    },
+    onError: (error) => {
+      toast.error(error.message || "Failed to bulk adjust stock");
+    }
+  });
+  return {
+    // Adjust stock (add/remove/set)
+    adjust: adjustMutation.mutateAsync,
+    isAdjusting: adjustMutation.isPending,
+    // Set stock directly
+    setStock: setStockMutation.mutateAsync,
+    isSettingStock: setStockMutation.isPending,
+    // Bulk operations
+    bulkAdjust: bulkAdjustMutation.mutateAsync,
+    isBulkAdjusting: bulkAdjustMutation.isPending,
+    // Combined loading state
+    isLoading: adjustMutation.isPending || setStockMutation.isPending || bulkAdjustMutation.isPending
+  };
+}
+function getStockStatus(quantity, lowThreshold = 10) {
+  if (quantity === 0) return "out";
+  if (quantity <= lowThreshold) return "low";
+  return "ok";
+}
+function getStockStatusBadge(status) {
+  switch (status) {
+    case "out":
+      return { variant: "destructive", label: "Out of Stock" };
+    case "low":
+      return { variant: "warning", label: "Low Stock" };
+    case "ok":
+      return { variant: "success", label: "In Stock" };
+  }
+}
+
+// src/inventory/hooks/stock.ts
+var stockHooks = createCrudHooks({
+  api: stockApi,
+  entityKey: "stock",
+  singular: "Stock Entry",
+  plural: "Stock Entries",
+  defaults: {
+    staleTime: 2 * 60 * 1e3
+    // 2 minutes
+  }
+});
+var {
+  KEYS: STOCK_KEYS,
+  useList: useStock,
+  useDetail: useStockDetail,
+  useActions: useStockActions2,
+  useNavigation: useStockNavigation
+} = stockHooks;
+var purchaseHooks = createCrudHooks({
+  api: purchaseApi,
+  entityKey: "purchases",
+  singular: "Purchase",
+  plural: "Purchases"
+});
+var {
+  KEYS: PURCHASE_KEYS,
+  useList: usePurchases,
+  useDetail: usePurchaseDetail,
+  useActions: usePurchaseActions,
+  useNavigation: usePurchaseNavigation
+} = purchaseHooks;
+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) => {
+      const response = await purchaseApi.receive({ token, id });
+      return response.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 }) => {
+      const response = await purchaseApi.pay({ token, id, amount, method, reference });
+      return response.data;
+    },
+    onSuccess: () => {
+      invalidateAll();
+      toast.success("Payment recorded");
+    },
+    onError: (err) => {
+      toast.error(err.message || "Failed to record payment");
+    }
+  });
+  const cancel = useMutation({
+    mutationFn: async ({ id, reason }) => {
+      const response = await purchaseApi.cancel({ token, id, reason });
+      return response.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
+  };
+}
+var transferHooks = createCrudHooks({
+  api: transferApi,
+  entityKey: "transfers",
+  singular: "Transfer",
+  plural: "Transfers"
+});
+var {
+  KEYS: TRANSFER_KEYS,
+  useList: useTransfers,
+  useDetail: useTransferDetail,
+  useActions: useTransferActions,
+  useNavigation: useTransferNavigation
+} = transferHooks;
+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) => {
+      const response = await transferApi.approve({ token, id });
+      return response.data;
+    },
+    onSuccess: () => {
+      invalidateAll();
+      toast.success("Transfer approved");
+    },
+    onError: (err) => {
+      toast.error(err.message || "Failed to approve transfer");
+    }
+  });
+  const dispatchMutation = useMutation({
+    mutationFn: async ({ id, data }) => {
+      const response = await transferApi.dispatch({ token, id, data });
+      return response.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) => {
+      const response = await transferApi.markInTransit({ token, id });
+      return response.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 }) => {
+      const response = await transferApi.receive({ token, id, data });
+      return response.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 }) => {
+      const response = await transferApi.cancel({ token, id, reason });
+      return response.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
+  };
+}
+var TRANSFER_STATS_KEYS = {
+  all: ["transfers", "stats"],
+  byBranch: (branchId) => ["transfers", "stats", 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,
+    // 30 seconds
+    select: (data) => data?.data
+  });
+}
+
+// src/inventory/hooks/adjustment.ts
+var adjustmentHooks = createCrudHooks({
+  api: adjustmentApi,
+  entityKey: "adjustments",
+  singular: "Adjustment",
+  plural: "Adjustments"
+});
+var {
+  KEYS: ADJUSTMENT_KEYS,
+  useList: useAdjustments,
+  useDetail: useAdjustmentDetail,
+  useActions: useAdjustmentActions,
+  useNavigation: useAdjustmentNavigation
+} = adjustmentHooks;
+var MOVEMENT_KEYS = {
+  all: ["inventory", "movements"],
+  list: (params) => [...MOVEMENT_KEYS.all, "list", params],
+  lowStock: (params) => [...MOVEMENT_KEYS.all, "low-stock", params]
+};
+function useMovements(token, params, options = {}) {
+  const { data, isLoading, isFetching, error, refetch } = useQuery({
+    queryKey: MOVEMENT_KEYS.list(params),
+    queryFn: () => movementApi.list({ token, params }),
+    enabled: !!token && options.enabled !== false,
+    staleTime: options.staleTime ?? 15 * 1e3
+    // 15 seconds
+  });
+  const movements = useMemo(() => {
+    if (!data) return [];
+    return data.docs || data.data || [];
+  }, [data]);
+  const pagination = useMemo(() => {
+    if (!data) return null;
+    const d = data;
+    if (d.page === void 0) return null;
+    return {
+      page: d.page || 1,
+      limit: d.limit || 20,
+      total: d.total || 0,
+      pages: d.pages || 1,
+      hasNext: d.hasNext || false,
+      hasPrev: d.hasPrev || false
+    };
+  }, [data]);
+  return {
+    movements,
+    pagination,
+    isLoading,
+    isFetching,
+    error,
+    refetch
+  };
+}
+function useLowStock(token, params, options = {}) {
+  return useQuery({
+    queryKey: MOVEMENT_KEYS.lowStock(params),
+    queryFn: () => movementApi.lowStock({ token, params }),
+    enabled: !!token && options.enabled !== false,
+    staleTime: options.staleTime ?? 60 * 1e3
+    // 1 minute
+  });
+}
+function getStockChangeInvalidationKeys() {
+  return [
+    ["inventory"],
+    // All inventory product queries
+    MOVEMENT_KEYS.all
+    // Audit trail (new movements created)
+  ];
+}
+var REQUEST_KEYS = {
+  all: ["inventory", "requests"],
+  list: (params) => [...REQUEST_KEYS.all, "list", params],
+  pending: () => [...REQUEST_KEYS.all, "pending"],
+  detail: (id) => [...REQUEST_KEYS.all, "detail", id]
+};
+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
+  });
+  const requests = useMemo(() => {
+    if (!data) return [];
+    return data.docs || data.data || [];
+  }, [data]);
+  return {
+    requests,
+    isLoading,
+    isFetching,
+    error,
+    refetch
+  };
+}
+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
+  });
+  const requests = useMemo(() => {
+    if (!data) return [];
+    return data.docs || data.data || [];
+  }, [data]);
+  return {
+    requests,
+    isLoading,
+    isFetching,
+    error,
+    refetch
+  };
+}
+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
+  });
+}
+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_challan"
+    }),
+    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) => {
+      const result = await createMutation.mutateAsync(data);
+      return result.data;
+    },
+    isCreating: createMutation.isPending,
+    approve: async (params) => {
+      const result = await approveMutation.mutateAsync(params);
+      return result.data;
+    },
+    isApproving: approveMutation.isPending,
+    reject: async (params) => {
+      const result = await rejectMutation.mutateAsync(params);
+      return result.data;
+    },
+    isRejecting: rejectMutation.isPending,
+    fulfill: async (params) => {
+      const result = await fulfillMutation.mutateAsync(params);
+      return result.data;
+    },
+    isFulfilling: fulfillMutation.isPending,
+    cancel: async (params) => {
+      const result = await cancelMutation.mutateAsync(params);
+      return result.data;
+    },
+    isCancelling: cancelMutation.isPending,
+    isLoading: createMutation.isPending || approveMutation.isPending || rejectMutation.isPending || fulfillMutation.isPending || cancelMutation.isPending
+  };
+}
+function getTransferStateInvalidationKeys() {
+  return [
+    TRANSFER_KEYS.all,
+    // Transfer list and details
+    REQUEST_KEYS.all
+    // If transfer was from request fulfillment
+  ];
+}
+
+// src/inventory/hooks/supplier.ts
+var supplierHooks = createCrudHooks({
+  api: supplierApi,
+  entityKey: "suppliers",
+  singular: "Supplier",
+  plural: "Suppliers"
+});
+var {
+  KEYS: SUPPLIER_KEYS,
+  useList: useSuppliers,
+  useDetail: useSupplierDetail,
+  useActions: useSupplierActions,
+  useNavigation: useSupplierNavigation
+} = supplierHooks;
+
+export { ADJUSTMENT_KEYS, INVENTORY_KEYS, MOVEMENT_KEYS, PURCHASE_KEYS, REQUEST_KEYS, STOCK_KEYS, SUPPLIER_KEYS, TRANSFER_KEYS, TRANSFER_STATS_KEYS, adjustmentHooks, getStockChangeInvalidationKeys, getStockStatus, getStockStatusBadge, getTransferStateInvalidationKeys, inventoryApis, purchaseHooks, stockHooks, supplierHooks, transferHooks, useAdjustmentActions, useAdjustmentDetail, useAdjustmentNavigation, useAdjustments, useInventory, useInventoryLookup, useLowStock, useMovements, usePendingStockRequests, usePurchaseActions, usePurchaseDetail, usePurchaseNavigation, usePurchaseStateActions, usePurchases, useStock, useStockActions, useStockDetail, useStockNavigation, useStockRequestActions, useStockRequestDetail, useStockRequests, useSupplierActions, useSupplierDetail, useSupplierNavigation, useSuppliers, useTransferActions, useTransferDetail, useTransferNavigation, useTransferStateActions, useTransferStats, useTransfers };
+//# sourceMappingURL=chunk-IXMWZJLV.js.map
+//# sourceMappingURL=chunk-IXMWZJLV.js.map