@burdenoff/microfe-movethewheels 2026.822.1 → 2026.827.1

package/src/movethewheels/hooks/useInventory.ts

@@ -51,9 +51,15 @@ interface UseInventoryResult {
   updateWarehouse: (id: string, input: CreateWarehouseInput) => Promise<Warehouse>;
 }
 
+// Wire shape of MtwInventoryItem (wspace-movethewheels-svc:
+// src/modules/inventory/schema/inventory.gql). The catalog domain was renamed
+// Product -> MtwCargoItem on 2026-07-07 (commit 7e99ec5): the root fields are
+// `cargoItems`/`cargoItem`/`createCargoItem`/`updateCargoItem` and the inventory
+// link column is `cargoItemId`. The MFE keeps its own `Product`/`Inventory.productId`
+// domain names; the rename is absorbed in the mappers below.
 interface ApiInventoryItem {
   id: string;
-  productId: string;
+  cargoItemId: string;
   warehouseId: string;
   onHand: number;
   available: number;
@@ -96,7 +102,7 @@ const LIST_INVENTORY_QUERY = `
   query ListInventoryItems($filter: InventoryFilterInput, $pagination: PaginationInput) {
     inventoryItems(filter: $filter, pagination: $pagination) {
       id
-      productId
+      cargoItemId
       warehouseId
       onHand
       available
@@ -110,8 +116,8 @@ const LIST_INVENTORY_QUERY = `
 `;
 
 const LIST_PRODUCTS_QUERY = `
-  query ListProducts($filter: ProductFilterInput, $pagination: PaginationInput) {
-    products(filter: $filter, pagination: $pagination) {
+  query ListCargoItems($filter: CargoItemFilterInput, $pagination: PaginationInput) {
+    cargoItems(filter: $filter, pagination: $pagination) {
       id
       sku
       name
@@ -146,8 +152,8 @@ const LIST_WAREHOUSES_QUERY = `
 `;
 
 const GET_PRODUCT_QUERY = `
-  query GetProduct($id: ID!) {
-    product(id: $id) {
+  query GetCargoItem($id: ID!) {
+    cargoItem(id: $id) {
       id
       sku
       name
@@ -190,12 +196,36 @@ const INVENTORY_STATS_QUERY = `
       totalDamaged
       lowStockCount
     }
+    cargoItemsCount
+    warehousesCount
+  }
+`;
+
+/**
+ * Stock ledger for the workspace, newest first (the service orders
+ * `inventoryTransactions` by `createdAt: desc`). `InventoryFilterInput` accepts
+ * `cargoItemId` / `warehouseId`, so the same query backs a per-item ledger.
+ */
+const LIST_INVENTORY_TRANSACTIONS_QUERY = `
+  query ListInventoryTransactions($filter: InventoryFilterInput, $pagination: PaginationInput) {
+    inventoryTransactions(filter: $filter, pagination: $pagination) {
+      id
+      transactionNumber
+      type
+      quantity
+      cargoItemId
+      warehouseId
+      notes
+      referenceType
+      referenceId
+      createdAt
+    }
   }
 `;
 
 const CREATE_PRODUCT_MUTATION = `
-  mutation CreateProduct($input: CreateProductInput!) {
-    createProduct(input: $input) {
+  mutation CreateCargoItem($input: CreateCargoItemInput!) {
+    createCargoItem(input: $input) {
       id
       sku
       name
@@ -215,8 +245,8 @@ const CREATE_PRODUCT_MUTATION = `
 `;
 
 const UPDATE_PRODUCT_MUTATION = `
-  mutation UpdateProduct($id: ID!, $input: UpdateProductInput!) {
-    updateProduct(id: $id, input: $input) {
+  mutation UpdateCargoItem($id: ID!, $input: UpdateCargoItemInput!) {
+    updateCargoItem(id: $id, input: $input) {
       id
       sku
       name
@@ -269,7 +299,7 @@ const ADJUST_INVENTORY_MUTATION = `
   mutation AdjustInventoryStock($input: AdjustInventoryStockInput!) {
     adjustInventoryStock(input: $input) {
       id
-      productId
+      cargoItemId
       warehouseId
       onHand
       available
@@ -355,7 +385,7 @@ function mapWarehouse(warehouse: ApiWarehouse): Warehouse {
 function mapInventory(item: ApiInventoryItem): Inventory {
   return {
     id: item.id,
-    productId: item.productId,
+    productId: item.cargoItemId,
     warehouseId: item.warehouseId,
     zoneId: '',
     quantity: item.onHand,
@@ -419,12 +449,12 @@ export function useInventory(options: UseInventoryOptions = {}): UseInventoryRes
           {
             filter: {
               warehouseId: filters?.warehouseId,
-              productId: filters?.productId,
+              cargoItemId: filters?.productId,
             },
             pagination: { limit: 500, offset: 0 },
           }
         ),
-        executeGraphQL<{ products: ApiProduct[] }>(graphQLOptions, LIST_PRODUCTS_QUERY, {
+        executeGraphQL<{ cargoItems: ApiProduct[] }>(graphQLOptions, LIST_PRODUCTS_QUERY, {
           pagination: { limit: 500, offset: 0 },
         }),
         executeGraphQL<{ warehouses: ApiWarehouse[] }>(graphQLOptions, LIST_WAREHOUSES_QUERY, {
@@ -438,7 +468,7 @@ export function useInventory(options: UseInventoryOptions = {}): UseInventoryRes
       }
 
       setInventory(nextInventory);
-      setProducts(productData.products.map(mapProduct));
+      setProducts(productData.cargoItems.map(mapProduct));
       setWarehouses(warehouseData.warehouses.map(mapWarehouse));
     } catch (fetchError) {
       setError(
@@ -515,7 +545,7 @@ export function useInventory(options: UseInventoryOptions = {}): UseInventoryRes
 
   const createProduct = useCallback(
     async (input: CreateProductInput): Promise<Product> => {
-      const data = await executeGraphQL<{ createProduct: ApiProduct }>(
+      const data = await executeGraphQL<{ createCargoItem: ApiProduct }>(
         graphQLOptions,
         CREATE_PRODUCT_MUTATION,
         {
@@ -528,7 +558,7 @@ export function useInventory(options: UseInventoryOptions = {}): UseInventoryRes
           },
         }
       );
-      const created = mapProduct(data.createProduct);
+      const created = mapProduct(data.createCargoItem);
       setProducts((previous) => [created, ...previous]);
       return created;
     },
@@ -559,7 +589,7 @@ export function useInventory(options: UseInventoryOptions = {}): UseInventoryRes
 
   const updateProduct = useCallback(
     async (id: string, input: CreateProductInput): Promise<Product> => {
-      const data = await executeGraphQL<{ updateProduct: ApiProduct }>(
+      const data = await executeGraphQL<{ updateCargoItem: ApiProduct }>(
         graphQLOptions,
         UPDATE_PRODUCT_MUTATION,
         {
@@ -573,7 +603,7 @@ export function useInventory(options: UseInventoryOptions = {}): UseInventoryRes
           },
         }
       );
-      const updated = mapProduct(data.updateProduct);
+      const updated = mapProduct(data.updateCargoItem);
       setProducts((previous) => previous.map((item) => (item.id === id ? updated : item)));
       return updated;
     },
@@ -637,15 +667,15 @@ export function useProducts(options: UseListOptions = {}) {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ products: ApiProduct[] }>(
+      const data = await executeGraphQL<{ cargoItems: ApiProduct[] }>(
         graphQLOptions,
         LIST_PRODUCTS_QUERY,
         {
           pagination: { limit, offset },
         }
       );
-      setHasMore(data.products.length === limit);
-      setProducts(data.products.map(mapProduct));
+      setHasMore(data.cargoItems.length === limit);
+      setProducts(data.cargoItems.map(mapProduct));
     } catch (fetchError) {
       setError(fetchError instanceof Error ? fetchError : new Error('Failed to load products'));
     } finally {
@@ -701,14 +731,14 @@ export function useProduct(productId: string | undefined) {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ product: ApiProduct | null }>(
+      const data = await executeGraphQL<{ cargoItem: ApiProduct | null }>(
         graphQLOptions,
         GET_PRODUCT_QUERY,
         {
           id: productId,
         }
       );
-      setProduct(data.product ? mapProduct(data.product) : null);
+      setProduct(data.cargoItem ? mapProduct(data.cargoItem) : null);
     } catch (fetchError) {
       setError(fetchError instanceof Error ? fetchError : new Error('Failed to load product'));
     } finally {
@@ -827,15 +857,39 @@ export function useWarehouse(warehouseId: string | undefined) {
   return { warehouse, isLoading, error, refetch: () => void load() };
 }
 
+export interface InventoryStats {
+  /** Units physically in the warehouses. */
+  totalOnHand: number;
+  /** Units free to promise on a new order. */
+  totalAvailable: number;
+  /** Units already committed to open orders. */
+  totalAllocated: number;
+  /** Units written off as damaged. */
+  totalDamaged: number;
+  /** Stock lines at or under their reorder point. */
+  lowStockCount: number;
+  /** Catalog size (`cargoItemsCount`), workspace-wide — not a page length. */
+  totalProducts: number;
+  /** Warehouse count (`warehousesCount`), workspace-wide. */
+  totalWarehouses: number;
+}
+
+/**
+ * Workspace-wide inventory aggregates, every figure served by the module:
+ * `inventoryStats` for the stock position, `cargoItemsCount`/`warehousesCount`
+ * for catalog and network size. There is no aggregate stock-value field on the
+ * subgraph, so no monetary total is reported here.
+ */
 export function useInventoryStats() {
   const graphQLOptions = useGraphqlOptions();
-  const [stats, setStats] = useState({
-    totalItems: 0,
-    lowStockItems: 0,
-    totalValue: 0,
+  const [stats, setStats] = useState<InventoryStats>({
+    totalOnHand: 0,
+    totalAvailable: 0,
+    totalAllocated: 0,
+    totalDamaged: 0,
+    lowStockCount: 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);
@@ -845,32 +899,26 @@ export function useInventoryStats() {
       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 },
-          }),
-        ]);
+        const data = await executeGraphQL<{
+          inventoryStats: {
+            totalOnHand: number;
+            totalAvailable: number;
+            totalAllocated: number;
+            totalDamaged: number;
+            lowStockCount: number;
+          };
+          cargoItemsCount: number;
+          warehousesCount: number;
+        }>(graphQLOptions, INVENTORY_STATS_QUERY);
 
         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,
-          })),
+          totalOnHand: data.inventoryStats.totalOnHand,
+          totalAvailable: data.inventoryStats.totalAvailable,
+          totalAllocated: data.inventoryStats.totalAllocated,
+          totalDamaged: data.inventoryStats.totalDamaged,
+          lowStockCount: data.inventoryStats.lowStockCount,
+          totalProducts: data.cargoItemsCount,
+          totalWarehouses: data.warehousesCount,
         });
       } catch (fetchError) {
         setError(
@@ -886,3 +934,213 @@ export function useInventoryStats() {
 
   return { stats, isLoading, error };
 }
+
+/**
+ * Per-warehouse stock for one catalog item. Uses the nested
+ * `MtwInventoryItem.warehouse` resolver so the warehouse name comes back with
+ * the row instead of being joined against a separately-paged warehouse list.
+ */
+const PRODUCT_STOCK_LEVELS_QUERY = `
+  query GetCargoItemStockLevels($cargoItemId: ID!) {
+    inventoryItems(filter: { cargoItemId: $cargoItemId }, pagination: { limit: 200, offset: 0 }) {
+      id
+      onHand
+      available
+      allocated
+      damaged
+      reorderPoint
+      warehouse {
+        id
+        name
+        code
+      }
+    }
+  }
+`;
+
+export interface ProductStockLevel {
+  inventoryItemId: string;
+  warehouseId: string;
+  warehouseName: string;
+  warehouseCode: string;
+  onHand: number;
+  available: number;
+  allocated: number;
+  damaged: number;
+  reorderPoint?: number;
+}
+
+interface ApiProductStockLevel {
+  id: string;
+  onHand: number;
+  available: number;
+  allocated: number;
+  damaged: number;
+  reorderPoint?: number | null;
+  warehouse?: { id: string; name: string; code: string } | null;
+}
+
+/** Where a catalog item is stocked, and how much of it is free to promise. */
+export function useProductStockLevels(productId: string | undefined) {
+  const graphQLOptions = useGraphqlOptions();
+  const [levels, setLevels] = useState<ProductStockLevel[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    if (!productId) {
+      setLevels([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ inventoryItems: ApiProductStockLevel[] }>(
+        graphQLOptions,
+        PRODUCT_STOCK_LEVELS_QUERY,
+        { cargoItemId: productId }
+      );
+      setLevels(
+        data.inventoryItems.map((item) => ({
+          inventoryItemId: item.id,
+          warehouseId: item.warehouse?.id ?? '',
+          warehouseName: item.warehouse?.name ?? 'Unknown warehouse',
+          warehouseCode: item.warehouse?.code ?? '',
+          onHand: item.onHand,
+          available: item.available,
+          allocated: item.allocated,
+          damaged: item.damaged,
+          reorderPoint: item.reorderPoint ?? undefined,
+        }))
+      );
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load stock levels'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, productId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return { levels, isLoading, error, refetch };
+}
+
+export type InventoryTransactionType = 'RECEIPT' | 'ISSUE' | 'TRANSFER' | 'ADJUSTMENT' | 'RETURN';
+
+export interface InventoryTransaction {
+  id: string;
+  transactionNumber: string;
+  type: InventoryTransactionType;
+  /** Signed by `type`: receipts/returns add stock, issues remove it. */
+  quantity: number;
+  productId: string;
+  warehouseId: string;
+  notes?: string;
+  referenceType?: string;
+  referenceId?: string;
+  createdAt: Date;
+}
+
+interface ApiInventoryTransaction {
+  id: string;
+  transactionNumber: string;
+  type: string;
+  quantity: number;
+  cargoItemId: string;
+  warehouseId: string;
+  notes?: string | null;
+  referenceType?: string | null;
+  referenceId?: string | null;
+  createdAt: string;
+}
+
+const TRANSACTION_TYPES: InventoryTransactionType[] = [
+  'RECEIPT',
+  'ISSUE',
+  'TRANSFER',
+  'ADJUSTMENT',
+  'RETURN',
+];
+
+/**
+ * The service returns `InventoryTransactionType` in upper snake case, but the
+ * value is normalised here rather than trusted, so an unexpected casing renders
+ * as ADJUSTMENT-neutral text instead of a broken label.
+ */
+function mapTransactionType(type: string): InventoryTransactionType {
+  const normalized = type.toUpperCase();
+  return (
+    TRANSACTION_TYPES.find((candidate) => candidate === normalized) ??
+    ('ADJUSTMENT' as InventoryTransactionType)
+  );
+}
+
+function mapTransaction(transaction: ApiInventoryTransaction): InventoryTransaction {
+  return {
+    id: transaction.id,
+    transactionNumber: transaction.transactionNumber,
+    type: mapTransactionType(transaction.type),
+    quantity: transaction.quantity,
+    productId: transaction.cargoItemId,
+    warehouseId: transaction.warehouseId,
+    notes: transaction.notes ?? undefined,
+    referenceType: transaction.referenceType ?? undefined,
+    referenceId: transaction.referenceId ?? undefined,
+    createdAt: new Date(transaction.createdAt),
+  };
+}
+
+interface UseInventoryTransactionsOptions {
+  limit?: number;
+  productId?: string;
+  warehouseId?: string;
+}
+
+/** Recent stock movements from `Query.inventoryTransactions` (newest first). */
+export function useInventoryTransactions(options: UseInventoryTransactionsOptions = {}) {
+  const { limit = 10, productId, warehouseId } = options;
+  const graphQLOptions = useGraphqlOptions();
+  const [transactions, setTransactions] = useState<InventoryTransaction[]>([]);
+  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<{ inventoryTransactions: ApiInventoryTransaction[] }>(
+        graphQLOptions,
+        LIST_INVENTORY_TRANSACTIONS_QUERY,
+        {
+          filter: productId || warehouseId ? { cargoItemId: productId, warehouseId } : undefined,
+          pagination: { limit, offset: 0 },
+        }
+      );
+      setTransactions(data.inventoryTransactions.map(mapTransaction));
+    } catch (fetchError) {
+      setError(
+        fetchError instanceof Error
+          ? fetchError
+          : new Error('Failed to load inventory transactions')
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, limit, productId, warehouseId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return { transactions, isLoading, error, refetch };
+}

package/src/movethewheels/hooks/useOrders.ts

@@ -9,6 +9,17 @@ interface UseOrdersOptions {
   offset?: number;
 }
 
+/**
+ * Write shape for create/update. Identical to `Partial<Order>` except that
+ * `scheduledDelivery` also accepts `null`: `UpdateDeliveryJobInput.scheduledDelivery`
+ * is nullable on the service, so an explicit `null` clears a previously booked
+ * slot, while `undefined` leaves it untouched. Without the distinction, clearing
+ * the field in the form would silently keep the old date.
+ */
+export type OrderWriteInput = Omit<Partial<Order>, 'scheduledDelivery'> & {
+  scheduledDelivery?: Date | null;
+};
+
 interface UseOrdersResult {
   orders: Order[];
   totalOrders: number;
@@ -21,8 +32,8 @@ interface UseOrdersResult {
   isLoading: boolean;
   error: Error | null;
   refetch: () => void;
-  createOrder: (order: Partial<Order>) => Promise<Order>;
-  updateOrder: (id: string, updates: Partial<Order>) => Promise<Order>;
+  createOrder: (order: OrderWriteInput) => Promise<Order>;
+  updateOrder: (id: string, updates: OrderWriteInput) => Promise<Order>;
   deleteOrder: (id: string) => Promise<void>;
   updateOrderStatus: (id: string, status: OrderStatus) => Promise<Order>;
 }
@@ -160,7 +171,13 @@ const DELETE_ORDER_MUTATION = `
   }
 `;
 
-function mapOrderStatus(status: string): OrderStatus {
+/**
+ * Normalises a service `DeliveryJobStatus` into the MFE's OrderStatus union.
+ * Exported so any surface rendering a raw job status badge normalises it the
+ * same way — the service casing is upper snake case and would miss the badge
+ * colour map otherwise.
+ */
+export function mapOrderStatus(status: string): OrderStatus {
   switch (status) {
     case 'PENDING':
       return 'pending';
@@ -183,7 +200,12 @@ function mapOrderStatus(status: string): OrderStatus {
   }
 }
 
-function mapOrderPriority(priority: string): 'low' | 'normal' | 'high' | 'urgent' {
+/**
+ * Normalises a service `DeliveryPriority` (LOW/MEDIUM/HIGH/URGENT/CRITICAL)
+ * into the four-level union PriorityBadge understands. MEDIUM and CRITICAL have
+ * no direct badge entry, so rendering the raw value would break the colour map.
+ */
+export function mapOrderPriority(priority: string): 'low' | 'normal' | 'high' | 'urgent' {
   switch (priority) {
     case 'LOW':
       return 'low';
@@ -366,7 +388,7 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
   }, [loadOrders]);
 
   const createOrder = useCallback(
-    async (orderData: Partial<Order>): Promise<Order> => {
+    async (orderData: OrderWriteInput): Promise<Order> => {
       const deliveryJobNumber =
         orderData.orderNumber ??
         `ORD-${new Date().getFullYear()}-${Date.now().toString().slice(-6)}`;
@@ -399,7 +421,7 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
   );
 
   const updateOrder = useCallback(
-    async (id: string, updates: Partial<Order>): Promise<Order> => {
+    async (id: string, updates: OrderWriteInput): Promise<Order> => {
       const data = await executeGraphQL<{
         updateDeliveryJob: ApiOrder;
       }>(graphQLOptions, UPDATE_ORDER_MUTATION, {
@@ -414,7 +436,9 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
           pricing: updates.pricing,
           specialInstructions: updates.specialInstructions,
           trackingNumber: updates.trackingNumber,
-          scheduledDelivery: updates.scheduledDelivery?.toISOString(),
+          // `null` clears the booked slot; `undefined` leaves it untouched.
+          scheduledDelivery:
+            updates.scheduledDelivery === null ? null : updates.scheduledDelivery?.toISOString(),
           vehicleId: updates.vehicleId,
           driverId: updates.driverId,
         },

package/src/movethewheels/hooks/useTracking.ts

@@ -30,7 +30,7 @@ interface ApiTrackingEvent {
 interface ApiShipment {
   id: string;
   shipmentNumber: string;
-  orderId: string;
+  deliveryJobId?: string | null;
   status: string;
   estimatedDelivery?: string | null;
   trackingEvents?: ApiTrackingEvent[];
@@ -41,7 +41,7 @@ const SHIPMENTS_QUERY = `
     shipments(filter: $filter, pagination: $pagination) {
       id
       shipmentNumber
-      orderId
+      deliveryJobId
       status
       estimatedDelivery
     }
@@ -53,7 +53,7 @@ const SHIPMENT_QUERY = `
     shipment(id: $id) {
       id
       shipmentNumber
-      orderId
+      deliveryJobId
       status
       estimatedDelivery
       trackingEvents {
@@ -68,9 +68,9 @@ const SHIPMENT_QUERY = `
   }
 `;
 
-const ORDER_TRACKING_QUERY = `
-  query GetOrderTracking($orderId: ID!) {
-    orderTracking(orderId: $orderId) {
+const DELIVERY_JOB_TRACKING_QUERY = `
+  query GetDeliveryJobTracking($deliveryJobId: ID!) {
+    deliveryJobTracking(deliveryJobId: $deliveryJobId) {
       id
       shipmentId
       eventType
@@ -86,7 +86,7 @@ const ACTIVE_DELIVERIES_QUERY = `
     activeDeliveries {
       id
       shipmentNumber
-      orderId
+      deliveryJobId
       status
       estimatedDelivery
     }
@@ -163,7 +163,7 @@ export function useTracking(options: UseTrackingOptions = {}): UseTrackingResult
 
       const mapped = data.shipments.map((shipment) => ({
         id: shipment.id,
-        entityId: shipment.orderId,
+        entityId: shipment.deliveryJobId ?? shipment.id,
         entityType: 'order' as const,
         currentLocation: {
           latitude: 0,
@@ -224,14 +224,14 @@ export function useOrderTracking(orderId: string | undefined) {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ orderTracking: ApiTrackingEvent[] }>(
+      const data = await executeGraphQL<{ deliveryJobTracking: ApiTrackingEvent[] }>(
         graphQLOptions,
-        ORDER_TRACKING_QUERY,
+        DELIVERY_JOB_TRACKING_QUERY,
         {
-          orderId,
+          deliveryJobId: orderId,
         }
       );
-      const latest = data.orderTracking[data.orderTracking.length - 1];
+      const latest = data.deliveryJobTracking[data.deliveryJobTracking.length - 1];
       setTracking(latest ? mapTrackingEventToTracking(latest, orderId) : null);
     } catch (fetchError) {
       setError(
@@ -327,7 +327,7 @@ export function useLiveTracking() {
 
           const shipmentEvents = shipmentData.shipment?.trackingEvents ?? [];
           const latestEvent = shipmentEvents[shipmentEvents.length - 1];
-          const order = orders.find((item) => item.id === shipment.orderId);
+          const order = orders.find((item) => item.id === shipment.deliveryJobId);
           if (!order) {
             return null;
           }
@@ -346,7 +346,7 @@ export function useLiveTracking() {
             driver,
             vehicle,
             tracking: latestEvent
-              ? mapTrackingEventToTracking(latestEvent, shipment.orderId)
+              ? mapTrackingEventToTracking(latestEvent, shipment.deliveryJobId ?? shipment.id)
               : null,
             estimatedArrival: shipment.estimatedDelivery
               ? new Date(shipment.estimatedDelivery)