@burdenoff/microfe-movethewheels 2026.510.105

package/src/movethewheels/hooks/useInventory.ts

@@ -0,0 +1,632 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
+import type { Inventory, InventoryFilter, Product, Warehouse } from '../types';
+import { executeGraphQL } from '../utils/graphqlClient';
+
+interface UseInventoryOptions {
+  filters?: InventoryFilter;
+}
+
+interface UseInventoryResult {
+  inventory: Inventory[];
+  products: Product[];
+  warehouses: Warehouse[];
+  totalItems: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+  updateStock: (inventoryId: string, quantity: number, reason: string) => Promise<Inventory>;
+  transferStock: (
+    fromWarehouseId: string,
+    toWarehouseId: string,
+    productId: string,
+    quantity: number
+  ) => Promise<void>;
+}
+
+interface ApiInventoryItem {
+  id: string;
+  productId: string;
+  warehouseId: string;
+  onHand: number;
+  available: number;
+  allocated: number;
+  damaged: number;
+  reorderPoint?: number | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface ApiProduct {
+  id: string;
+  sku: string;
+  name: string;
+  description?: string | null;
+  category?: string | null;
+  brand?: string | null;
+  dimensions?: Record<string, unknown> | null;
+  weight?: number | null;
+  value?: number | null;
+  hazardous: boolean;
+  fragile: boolean;
+  temperatureControlled: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface ApiWarehouse {
+  id: string;
+  name: string;
+  code: string;
+  type: string;
+  address: Record<string, unknown>;
+  totalCapacity?: number | null;
+  usedCapacity?: number | null;
+  createdAt: string;
+}
+
+const LIST_INVENTORY_QUERY = `
+  query ListInventoryItems($filter: InventoryFilterInput, $pagination: PaginationInput) {
+    inventoryItems(filter: $filter, pagination: $pagination) {
+      id
+      productId
+      warehouseId
+      onHand
+      available
+      allocated
+      damaged
+      reorderPoint
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+const LIST_PRODUCTS_QUERY = `
+  query ListProducts($filter: ProductFilterInput, $pagination: PaginationInput) {
+    products(filter: $filter, pagination: $pagination) {
+      id
+      sku
+      name
+      description
+      category
+      brand
+      dimensions
+      weight
+      value
+      hazardous
+      fragile
+      temperatureControlled
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+const LIST_WAREHOUSES_QUERY = `
+  query ListWarehouses($filter: WarehouseFilterInput, $pagination: PaginationInput) {
+    warehouses(filter: $filter, pagination: $pagination) {
+      id
+      name
+      code
+      type
+      address
+      totalCapacity
+      usedCapacity
+      createdAt
+    }
+  }
+`;
+
+const GET_PRODUCT_QUERY = `
+  query GetProduct($id: ID!) {
+    product(id: $id) {
+      id
+      sku
+      name
+      description
+      category
+      brand
+      dimensions
+      weight
+      value
+      hazardous
+      fragile
+      temperatureControlled
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+const GET_WAREHOUSE_QUERY = `
+  query GetWarehouse($id: ID!) {
+    warehouse(id: $id) {
+      id
+      name
+      code
+      type
+      address
+      totalCapacity
+      usedCapacity
+      createdAt
+    }
+  }
+`;
+
+const INVENTORY_STATS_QUERY = `
+  query GetInventoryStats {
+    inventoryStats {
+      totalOnHand
+      totalAvailable
+      totalAllocated
+      totalDamaged
+      lowStockCount
+    }
+  }
+`;
+
+const ADJUST_INVENTORY_MUTATION = `
+  mutation AdjustInventoryStock($input: AdjustInventoryStockInput!) {
+    adjustInventoryStock(input: $input) {
+      id
+      productId
+      warehouseId
+      onHand
+      available
+      allocated
+      damaged
+      reorderPoint
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+function mapProduct(product: ApiProduct): Product {
+  return {
+    id: product.id,
+    sku: product.sku,
+    name: product.name,
+    description: product.description ?? '',
+    category: product.category ?? 'general',
+    brand: product.brand ?? undefined,
+    dimensions: {
+      length: 0,
+      width: 0,
+      height: 0,
+      unit: 'cm',
+      ...(product.dimensions ?? {}),
+    } as Product['dimensions'],
+    weight: product.weight ?? 0,
+    value: product.value ?? 0,
+    barcode: undefined,
+    images: [],
+    attributes: [],
+    hazardous: product.hazardous,
+    temperatureControlled: product.temperatureControlled,
+    fragile: product.fragile,
+    createdAt: new Date(product.createdAt),
+    updatedAt: new Date(product.updatedAt),
+  };
+}
+
+function mapWarehouse(warehouse: ApiWarehouse): Warehouse {
+  const totalSpace = warehouse.totalCapacity ?? 0;
+  const usedSpace = warehouse.usedCapacity ?? 0;
+  return {
+    id: warehouse.id,
+    name: warehouse.name,
+    code: warehouse.code,
+    address: {
+      street: '',
+      city: '',
+      state: '',
+      postalCode: '',
+      country: '',
+      ...(warehouse.address ?? {}),
+    },
+    type: (warehouse.type?.toLowerCase() ?? 'distribution') as Warehouse['type'],
+    capacity: {
+      totalSpace,
+      usedSpace,
+      totalPallets: 0,
+      usedPallets: 0,
+      specialAreas: [],
+    },
+    operatingHours: {},
+    contacts: [],
+    zones: [],
+    equipment: [],
+    staff: [],
+    metrics: {
+      throughput: 0,
+      accuracy: 0,
+      productivity: 0,
+      utilization: totalSpace > 0 ? (usedSpace / totalSpace) * 100 : 0,
+      ordersFulfilled: 0,
+      averageProcessingTime: 0,
+      lastUpdated: new Date(),
+    },
+    isActive: true,
+    createdAt: new Date(warehouse.createdAt),
+  };
+}
+
+function mapInventory(item: ApiInventoryItem): Inventory {
+  return {
+    id: item.id,
+    productId: item.productId,
+    warehouseId: item.warehouseId,
+    zoneId: '',
+    quantity: item.onHand,
+    reservedQuantity: item.allocated,
+    availableQuantity: item.available,
+    reorderLevel: item.reorderPoint ?? 0,
+    maxLevel: Math.max(item.onHand * 2, item.available),
+    lastRestocked: new Date(item.updatedAt),
+    location: {
+      aisle: '',
+      shelf: '',
+      position: '',
+      level: 0,
+    },
+    movements: [],
+    createdAt: new Date(item.createdAt),
+    updatedAt: new Date(item.updatedAt),
+  };
+}
+
+function useGraphqlOptions() {
+  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
+    useMoveTheWheels();
+  return useMemo(
+    () => ({
+      apiGatewayUrl,
+      authToken,
+      workspaceToken,
+      workspaceId,
+      tenantId,
+      actorId: currentUser?.id,
+    }),
+    [apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser?.id]
+  );
+}
+
+export function useInventory(options: UseInventoryOptions = {}): UseInventoryResult {
+  const { filters: rawFilters } = options;
+  // Stabilize filters reference for React Compiler memoization.
+  const filters = useMemo(
+    () => rawFilters,
+    [rawFilters?.lowStock, rawFilters?.productId, rawFilters?.warehouseId]
+  );
+  const graphQLOptions = useGraphqlOptions();
+  const [inventory, setInventory] = useState<Inventory[]>([]);
+  const [products, setProducts] = useState<Product[]>([]);
+  const [warehouses, setWarehouses] = useState<Warehouse[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const [inventoryData, productData, warehouseData] = await Promise.all([
+        executeGraphQL<{ inventoryItems: ApiInventoryItem[] }>(
+          graphQLOptions,
+          LIST_INVENTORY_QUERY,
+          {
+            filter: {
+              warehouseId: filters?.warehouseId,
+              productId: filters?.productId,
+            },
+            pagination: { limit: 500, offset: 0 },
+          }
+        ),
+        executeGraphQL<{ products: ApiProduct[] }>(graphQLOptions, LIST_PRODUCTS_QUERY, {
+          pagination: { limit: 500, offset: 0 },
+        }),
+        executeGraphQL<{ warehouses: ApiWarehouse[] }>(graphQLOptions, LIST_WAREHOUSES_QUERY, {
+          pagination: { limit: 500, offset: 0 },
+        }),
+      ]);
+
+      let nextInventory = inventoryData.inventoryItems.map(mapInventory);
+      if (filters?.lowStock) {
+        nextInventory = nextInventory.filter((item) => item.availableQuantity <= item.reorderLevel);
+      }
+
+      setInventory(nextInventory);
+      setProducts(productData.products.map(mapProduct));
+      setWarehouses(warehouseData.warehouses.map(mapWarehouse));
+    } catch (fetchError) {
+      setError(
+        fetchError instanceof Error ? fetchError : new Error('Failed to load inventory data')
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, [filters, graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  const updateStock = useCallback(
+    async (inventoryId: string, quantity: number, _reason: string): Promise<Inventory> => {
+      const current = inventory.find((item) => item.id === inventoryId);
+      if (!current) {
+        throw new Error('Inventory item not found');
+      }
+
+      const data = await executeGraphQL<{ adjustInventoryStock: ApiInventoryItem }>(
+        graphQLOptions,
+        ADJUST_INVENTORY_MUTATION,
+        {
+          input: {
+            id: inventoryId,
+            onHand: current.quantity + quantity,
+            available: current.availableQuantity + quantity,
+            allocated: current.reservedQuantity,
+            damaged: 0,
+          },
+        }
+      );
+
+      const updated = mapInventory(data.adjustInventoryStock);
+      setInventory((previous) =>
+        previous.map((item) => (item.id === inventoryId ? updated : item))
+      );
+      return updated;
+    },
+    [graphQLOptions, inventory]
+  );
+
+  const transferStock = useCallback(
+    async (
+      fromWarehouseId: string,
+      toWarehouseId: string,
+      productId: string,
+      quantity: number
+    ): Promise<void> => {
+      const source = inventory.find(
+        (item) => item.warehouseId === fromWarehouseId && item.productId === productId
+      );
+      if (!source) {
+        throw new Error('Source inventory not found');
+      }
+
+      await updateStock(source.id, -Math.abs(quantity), 'transfer out');
+
+      const destination = inventory.find(
+        (item) => item.warehouseId === toWarehouseId && item.productId === productId
+      );
+      if (destination) {
+        await updateStock(destination.id, Math.abs(quantity), 'transfer in');
+      }
+    },
+    [inventory, updateStock]
+  );
+
+  return {
+    inventory,
+    products,
+    warehouses,
+    totalItems: inventory.length,
+    isLoading,
+    error,
+    refetch,
+    updateStock,
+    transferStock,
+  };
+}
+
+export function useProducts() {
+  const graphQLOptions = useGraphqlOptions();
+  const [products, setProducts] = useState<Product[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ products: ApiProduct[] }>(
+        graphQLOptions,
+        LIST_PRODUCTS_QUERY,
+        {
+          pagination: { limit: 500, offset: 0 },
+        }
+      );
+      setProducts(data.products.map(mapProduct));
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load products'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  return {
+    products,
+    totalProducts: products.length,
+    isLoading,
+    error,
+    refetch: () => void load(),
+  };
+}
+
+export function useProduct(productId: string | undefined) {
+  const graphQLOptions = useGraphqlOptions();
+  const [product, setProduct] = useState<Product | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    if (!productId) {
+      setProduct(null);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ product: ApiProduct | null }>(
+        graphQLOptions,
+        GET_PRODUCT_QUERY,
+        {
+          id: productId,
+        }
+      );
+      setProduct(data.product ? mapProduct(data.product) : null);
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load product'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, productId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  return { product, isLoading, error, refetch: () => void load() };
+}
+
+export function useWarehouses() {
+  const graphQLOptions = useGraphqlOptions();
+  const [warehouses, setWarehouses] = useState<Warehouse[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ warehouses: ApiWarehouse[] }>(
+        graphQLOptions,
+        LIST_WAREHOUSES_QUERY,
+        {
+          pagination: { limit: 500, offset: 0 },
+        }
+      );
+      setWarehouses(data.warehouses.map(mapWarehouse));
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load warehouses'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  return {
+    warehouses,
+    totalWarehouses: warehouses.length,
+    isLoading,
+    error,
+    refetch: () => void load(),
+  };
+}
+
+export function useWarehouse(warehouseId: string | undefined) {
+  const graphQLOptions = useGraphqlOptions();
+  const [warehouse, setWarehouse] = useState<Warehouse | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    if (!warehouseId) {
+      setWarehouse(null);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ warehouse: ApiWarehouse | null }>(
+        graphQLOptions,
+        GET_WAREHOUSE_QUERY,
+        { id: warehouseId }
+      );
+      setWarehouse(data.warehouse ? mapWarehouse(data.warehouse) : null);
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load warehouse'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, warehouseId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  return { warehouse, isLoading, error, refetch: () => void load() };
+}
+
+export function useInventoryStats() {
+  const graphQLOptions = useGraphqlOptions();
+  const [stats, setStats] = useState({
+    totalItems: 0,
+    lowStockItems: 0,
+    totalValue: 0,
+    totalProducts: 0,
+    totalWarehouses: 0,
+    warehouseUtilization: [] as Array<{ id: string; name: string; utilization: number }>,
+  });
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const load = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const [inventoryStats, warehouses] = await Promise.all([
+          executeGraphQL<{
+            inventoryStats: {
+              totalOnHand: number;
+              lowStockCount: number;
+            };
+          }>(graphQLOptions, INVENTORY_STATS_QUERY),
+          executeGraphQL<{ warehouses: ApiWarehouse[] }>(graphQLOptions, LIST_WAREHOUSES_QUERY, {
+            pagination: { limit: 500, offset: 0 },
+          }),
+        ]);
+
+        setStats({
+          totalItems: inventoryStats.inventoryStats.totalOnHand,
+          lowStockItems: inventoryStats.inventoryStats.lowStockCount,
+          totalValue: 0,
+          totalProducts: 0,
+          totalWarehouses: warehouses.warehouses.length,
+          warehouseUtilization: warehouses.warehouses.map((warehouse) => ({
+            id: warehouse.id,
+            name: warehouse.name,
+            utilization:
+              (warehouse.totalCapacity ?? 0) > 0
+                ? ((warehouse.usedCapacity ?? 0) / (warehouse.totalCapacity ?? 1)) * 100
+                : 0,
+          })),
+        });
+      } catch (fetchError) {
+        setError(
+          fetchError instanceof Error ? fetchError : new Error('Failed to load inventory stats')
+        );
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    void load();
+  }, [graphQLOptions]);
+
+  return { stats, isLoading, error };
+}