@burdenoff/microfe-movethewheels 2026.920.2 → 2026.921.1

package/src/movethewheels/hooks/useOrders.ts

@@ -23,11 +23,7 @@ export type OrderWriteInput = Omit<Partial<Order>, 'scheduledDelivery'> & {
 interface UseOrdersResult {
   orders: Order[];
   totalOrders: number;
-  /**
-   * True when the most recent fetch returned a full page (rawCount === limit),
-   * i.e. there may be another page. Used for offset pagers where no grand
-   * total is available.
-   */
+  /** True when the most recent fetch has another server page. */
   hasMore: boolean;
   isLoading: boolean;
   error: Error | null;
@@ -42,7 +38,7 @@ interface UseOrdersResult {
 // The `order` domain was renamed to `delivery_jobs`/MtwDeliveryJob on 2026-07-07 (commit
 // 7e99ec5); `orderType` was dropped entirely in that rename with no replacement field, so it
 // is intentionally absent here — see BOFF-4505.
-interface ApiOrder {
+export interface ApiOrder {
   id: string;
   deliveryJobNumber: string;
   customerId: string;
@@ -111,6 +107,7 @@ const LIST_ORDERS_QUERY = `
     deliveryJobs(filter: $filter, pagination: $pagination) {
       ${DELIVERY_JOB_FIELDS}
     }
+    deliveryJobsCount(filter: $filter)
   }
 `;
 
@@ -266,7 +263,7 @@ function mapAddress(address: Record<string, unknown> | null | undefined): Order[
   } as Order['pickupAddress'];
 }
 
-function mapOrder(order: ApiOrder): Order {
+export function mapOrder(order: ApiOrder): Order {
   return {
     id: order.id,
     orderNumber: order.deliveryJobNumber,
@@ -324,6 +321,7 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
       rawFilters?.priority,
       rawFilters?.customerId,
       rawFilters?.driverId,
+      rawFilters?.search,
       rawFilters?.unassigned,
     ]
   );
@@ -331,6 +329,7 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
     useMoveTheWheels();
 
   const [orders, setOrders] = useState<Order[]>([]);
+  const [totalOrders, setTotalOrders] = useState(0);
   const [hasMore, setHasMore] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
@@ -353,6 +352,7 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
     try {
       const data = await executeGraphQL<{
         deliveryJobs: ApiOrder[];
+        deliveryJobsCount: number;
       }>(graphQLOptions, LIST_ORDERS_QUERY, {
         filter: {
           status: filters?.status ? toApiStatus(filters.status) : undefined,
@@ -361,17 +361,16 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
             : undefined,
           customerId: filters?.customerId,
           driverId: filters?.driverId,
+          unassigned: filters?.unassigned,
+          search: filters?.search,
         },
         pagination: { limit, offset },
       });
 
       const raw = data.deliveryJobs;
-      setHasMore(raw.length === limit);
-      let mapped = raw.map(mapOrder);
-      if (filters?.unassigned) {
-        mapped = mapped.filter((item) => !item.driverId);
-      }
-      setOrders(mapped);
+      setTotalOrders(data.deliveryJobsCount);
+      setHasMore(offset + raw.length < data.deliveryJobsCount);
+      setOrders(raw.map(mapOrder));
     } catch (fetchError) {
       setError(fetchError instanceof Error ? fetchError : new Error('Failed to load orders'));
     } finally {
@@ -481,7 +480,7 @@ export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
 
   return {
     orders,
-    totalOrders: orders.length,
+    totalOrders,
     hasMore,
     isLoading,
     error,

package/src/movethewheels/hooks/useRoutes.ts

@@ -7,6 +7,7 @@ interface UseRoutesOptions {
   driverId?: string;
   vehicleId?: string;
   status?: 'planned' | 'in_progress' | 'completed' | 'cancelled';
+  search?: string;
   limit?: number;
   offset?: number;
 }
@@ -14,7 +15,7 @@ interface UseRoutesOptions {
 interface UseRoutesResult {
   routes: Route[];
   totalRoutes: number;
-  /** True when the last fetch returned a full page (rawCount === limit). */
+  /** True when the last fetch has another server page. */
   hasMore: boolean;
   isLoading: boolean;
   error: Error | null;
@@ -63,6 +64,7 @@ const LIST_ROUTES_QUERY = `
       actualDuration
       createdAt
     }
+    routesCount(filter: $filter)
   }
 `;
 
@@ -253,9 +255,10 @@ function useGraphqlOptions() {
 }
 
 export function useRoutes(options: UseRoutesOptions = {}): UseRoutesResult {
-  const { driverId, vehicleId, status, limit = 500, offset = 0 } = options;
+  const { driverId, vehicleId, status, search, limit = 20, offset = 0 } = options;
   const graphQLOptions = useGraphqlOptions();
   const [routes, setRoutes] = useState<Route[]>([]);
+  const [totalRoutes, setTotalRoutes] = useState(0);
   const [hasMore, setHasMore] = useState(false);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
@@ -264,23 +267,28 @@ export function useRoutes(options: UseRoutesOptions = {}): UseRoutesResult {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ routes: ApiRoute[] }>(graphQLOptions, LIST_ROUTES_QUERY, {
+      const data = await executeGraphQL<{
+        routes: ApiRoute[];
+        routesCount: number;
+      }>(graphQLOptions, LIST_ROUTES_QUERY, {
         filter: {
           driverId,
           vehicleId,
           status: status ? toApiRouteStatus(status) : undefined,
+          search: search || undefined,
         },
         pagination: { limit, offset },
       });
 
-      setHasMore(data.routes.length === limit);
+      setTotalRoutes(data.routesCount);
+      setHasMore(offset + data.routes.length < data.routesCount);
       setRoutes(data.routes.map(mapRoute));
     } catch (fetchError) {
       setError(fetchError instanceof Error ? fetchError : new Error('Failed to load routes'));
     } finally {
       setIsLoading(false);
     }
-  }, [driverId, graphQLOptions, status, vehicleId, limit, offset]);
+  }, [driverId, graphQLOptions, search, status, vehicleId, limit, offset]);
 
   useEffect(() => {
     void load();
@@ -400,7 +408,7 @@ export function useRoutes(options: UseRoutesOptions = {}): UseRoutesResult {
 
   return {
     routes,
-    totalRoutes: routes.length,
+    totalRoutes,
     hasMore,
     isLoading,
     error,
@@ -455,26 +463,75 @@ export function useRoute(routeId: string | undefined) {
   };
 }
 
-export function useRouteStats() {
-  const { routes, isLoading, error } = useRoutes();
+const ROUTE_STATS_QUERY = `
+  query RouteStats {
+    routeStats {
+      total
+      totalDistance
+      totalDuration
+      completed
+      inProgress
+      planned
+      optimized
+    }
+  }
+`;
 
-  const stats = useMemo(() => {
-    const totalDistance = routes.reduce((sum, route) => sum + route.distance, 0);
-    const totalDuration = routes.reduce((sum, route) => sum + route.estimatedDuration, 0);
-    const totalRoutes = routes.length;
+export function useRouteStats() {
+  const graphQLOptions = useGraphqlOptions();
+  const [stats, setStats] = useState({
+    totalRoutes: 0,
+    totalDistance: 0,
+    totalDuration: 0,
+    avgDistance: 0,
+    avgDuration: 0,
+    completedRoutes: 0,
+    inProgressRoutes: 0,
+    plannedRoutes: 0,
+    optimizedRoutes: 0,
+  });
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
 
-    return {
-      totalRoutes,
-      totalDistance,
-      totalDuration,
-      avgDistance: totalRoutes > 0 ? totalDistance / totalRoutes : 0,
-      avgDuration: totalRoutes > 0 ? totalDuration / totalRoutes : 0,
-      completedRoutes: routes.filter((route) => route.status === 'completed').length,
-      inProgressRoutes: routes.filter((route) => route.status === 'in_progress').length,
-      plannedRoutes: routes.filter((route) => route.status === 'planned').length,
-      optimizedRoutes: routes.filter((route) => route.optimized).length,
+  useEffect(() => {
+    const load = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const data = await executeGraphQL<{
+          routeStats: {
+            total: number;
+            totalDistance: number;
+            totalDuration: number;
+            completed: number;
+            inProgress: number;
+            planned: number;
+            optimized: number;
+          };
+        }>(graphQLOptions, ROUTE_STATS_QUERY);
+        const routeStats = data.routeStats;
+        setStats({
+          totalRoutes: routeStats.total,
+          totalDistance: routeStats.totalDistance,
+          totalDuration: routeStats.totalDuration,
+          avgDistance: routeStats.total > 0 ? routeStats.totalDistance / routeStats.total : 0,
+          avgDuration: routeStats.total > 0 ? routeStats.totalDuration / routeStats.total : 0,
+          completedRoutes: routeStats.completed,
+          inProgressRoutes: routeStats.inProgress,
+          plannedRoutes: routeStats.planned,
+          optimizedRoutes: routeStats.optimized,
+        });
+      } catch (fetchError) {
+        setError(
+          fetchError instanceof Error ? fetchError : new Error('Failed to load route stats')
+        );
+      } finally {
+        setIsLoading(false);
+      }
     };
-  }, [routes]);
+
+    void load();
+  }, [graphQLOptions]);
 
   return { stats, isLoading, error };
 }

package/src/movethewheels/hooks/useTracking.ts

@@ -1,9 +1,18 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
-import type { Location, Tracking, TrackingAlert } from '../types';
+import type { Location, Order, Tracking, TrackingAlert, Driver, Vehicle } from '../types';
 import { executeGraphQL } from '../utils/graphqlClient';
-import { useDriver, useDrivers, useVehicle, useVehicles } from './useFleet';
-import { useOrder, useOrders } from './useOrders';
+import {
+  mapDriver,
+  mapVehicle,
+  type ApiDriver,
+  type ApiVehicle,
+  useDriver,
+  useVehicle,
+  useVehicles,
+  useDrivers,
+} from './useFleet';
+import { mapOrder, type ApiOrder, useOrder } from './useOrders';
 
 interface UseTrackingOptions {
   entityId?: string;
@@ -36,6 +45,23 @@ interface ApiShipment {
   trackingEvents?: ApiTrackingEvent[];
 }
 
+interface ApiActiveDelivery extends ApiShipment {
+  deliveryJob?:
+    | (ApiOrder & {
+        vehicle?: ApiVehicle | null;
+        driver?: ApiDriver | null;
+      })
+    | null;
+}
+
+interface LiveDelivery {
+  order: Order;
+  driver: Driver | null;
+  vehicle: Vehicle | null;
+  tracking: Tracking | null;
+  estimatedArrival: Date | undefined;
+}
+
 const SHIPMENTS_QUERY = `
   query ListShipments($filter: ShipmentFilterInput, $pagination: PaginationInput) {
     shipments(filter: $filter, pagination: $pagination) {
@@ -48,29 +74,9 @@ const SHIPMENTS_QUERY = `
   }
 `;
 
-const SHIPMENT_QUERY = `
-  query GetShipment($id: ID!) {
-    shipment(id: $id) {
-      id
-      shipmentNumber
-      deliveryJobId
-      status
-      estimatedDelivery
-      trackingEvents {
-        id
-        shipmentId
-        eventType
-        location
-        details
-        timestamp
-      }
-    }
-  }
-`;
-
 const DELIVERY_JOB_TRACKING_QUERY = `
-  query GetDeliveryJobTracking($deliveryJobId: ID!) {
-    deliveryJobTracking(deliveryJobId: $deliveryJobId) {
+  query GetDeliveryJobTracking($deliveryJobId: ID!, $pagination: PaginationInput) {
+    deliveryJobTracking(deliveryJobId: $deliveryJobId, pagination: $pagination) {
       id
       shipmentId
       eventType
@@ -82,13 +88,81 @@ const DELIVERY_JOB_TRACKING_QUERY = `
 `;
 
 const ACTIVE_DELIVERIES_QUERY = `
-  query GetActiveDeliveries {
-    activeDeliveries {
+  query GetActiveDeliveries($pagination: PaginationInput) {
+    activeDeliveries(pagination: $pagination) {
       id
       shipmentNumber
       deliveryJobId
       status
       estimatedDelivery
+      trackingEvents(pagination: { limit: 1, offset: 0 }) {
+        id
+        shipmentId
+        eventType
+        location
+        details
+        timestamp
+      }
+      deliveryJob {
+        id
+        deliveryJobNumber
+        customerId
+        status
+        priority
+        pickupAddress
+        deliveryAddress
+        cargoItems
+        pricing
+        trackingNumber
+        specialInstructions
+        scheduledDelivery
+        vehicleId
+        driverId
+        createdAt
+        updatedAt
+        customer {
+          name
+          email
+          phone
+          company
+        }
+        vehicle {
+          id
+          vehicleNumber
+          type
+          make
+          model
+          licensePlate
+          ownershipType
+          year
+          capacity
+          status
+          currentLocation
+          fuelLevel
+          mileage
+          lastServiceDate
+          nextServiceDueDate
+          nextServiceDueMileage
+          createdAt
+        }
+        driver {
+          id
+          userId
+          firstName
+          lastName
+          email
+          phone
+          employeeId
+          licenseNumber
+          licenseClass
+          licenseExpiry
+          status
+          currentLocation
+          rating
+          vehicleId
+          createdAt
+        }
+      }
     }
   }
 `;
@@ -157,14 +231,21 @@ export function useTracking(options: UseTrackingOptions = {}): UseTrackingResult
         graphQLOptions,
         SHIPMENTS_QUERY,
         {
-          pagination: { limit: 200, offset: 0 },
+          filter: entityId
+            ? {
+                ...(entityType === 'order' ? { deliveryJobId: entityId } : {}),
+                ...(entityType === 'vehicle' ? { vehicleId: entityId } : {}),
+                ...(entityType === 'driver' ? { driverId: entityId } : {}),
+              }
+            : undefined,
+          pagination: { limit: 50, offset: 0 },
         }
       );
 
       const mapped = data.shipments.map((shipment) => ({
         id: shipment.id,
-        entityId: shipment.deliveryJobId ?? shipment.id,
-        entityType: 'order' as const,
+        entityId: entityId ?? shipment.deliveryJobId ?? shipment.id,
+        entityType: entityType ?? 'order',
         currentLocation: {
           latitude: 0,
           longitude: 0,
@@ -180,13 +261,7 @@ export function useTracking(options: UseTrackingOptions = {}): UseTrackingResult
         lastUpdated: new Date(),
       }));
 
-      const filtered = mapped.filter((item) => {
-        if (entityId && item.entityId !== entityId) return false;
-        if (entityType && item.entityType !== entityType) return false;
-        return true;
-      });
-
-      setTracking(filtered);
+      setTracking(mapped);
     } catch (fetchError) {
       setError(
         fetchError instanceof Error ? fetchError : new Error('Failed to load tracking data')
@@ -229,9 +304,10 @@ export function useOrderTracking(orderId: string | undefined) {
         DELIVERY_JOB_TRACKING_QUERY,
         {
           deliveryJobId: orderId,
+          pagination: { limit: 1, offset: 0 },
         }
       );
-      const latest = data.deliveryJobTracking[data.deliveryJobTracking.length - 1];
+      const latest = data.deliveryJobTracking[0];
       setTracking(latest ? mapTrackingEventToTracking(latest, orderId) : null);
     } catch (fetchError) {
       setError(
@@ -291,18 +367,7 @@ export function useDriverTracking(driverId: string | undefined) {
 
 export function useLiveTracking() {
   const graphQLOptions = useGraphqlOptions();
-  const { orders } = useOrders();
-  const { vehicles } = useVehicles();
-  const { drivers } = useDrivers();
-  const [activeDeliveries, setActiveDeliveries] = useState<
-    Array<{
-      order: (typeof orders)[number];
-      driver: (typeof drivers)[number] | null;
-      vehicle: (typeof vehicles)[number] | null;
-      tracking: Tracking | null;
-      estimatedArrival: Date | undefined;
-    }>
-  >([]);
+  const [activeDeliveries, setActiveDeliveries] = useState<LiveDelivery[]>([]);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
@@ -310,64 +375,31 @@ export function useLiveTracking() {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ activeDeliveries: ApiShipment[] }>(
+      const data = await executeGraphQL<{ activeDeliveries: ApiActiveDelivery[] }>(
         graphQLOptions,
-        ACTIVE_DELIVERIES_QUERY
+        ACTIVE_DELIVERIES_QUERY,
+        { pagination: { limit: 100, offset: 0 } }
       );
 
-      const list = await Promise.all(
-        data.activeDeliveries.map(async (shipment) => {
-          const shipmentData = await executeGraphQL<{ shipment: ApiShipment | null }>(
-            graphQLOptions,
-            SHIPMENT_QUERY,
-            {
-              id: shipment.id,
-            }
-          );
-
-          const shipmentEvents = shipmentData.shipment?.trackingEvents ?? [];
-          const latestEvent = shipmentEvents[shipmentEvents.length - 1];
-          const order = orders.find((item) => item.id === shipment.deliveryJobId);
-          if (!order) {
-            return null;
-          }
-
-          const driver = order.driverId
-            ? (drivers.find(
-                (item) => item.id === order.driverId || item.userId === order.driverId
-              ) ?? null)
-            : null;
-          const vehicle = order.vehicleId
-            ? (vehicles.find((item) => item.id === order.vehicleId) ?? null)
-            : null;
+      const list = (data.activeDeliveries ?? [])
+        .map((shipment): LiveDelivery | null => {
+          const deliveryJob = shipment.deliveryJob;
+          if (!deliveryJob) return null;
 
+          const latestEvent = shipment.trackingEvents?.[0];
           return {
-            order,
-            driver,
-            vehicle,
-            tracking: latestEvent
-              ? mapTrackingEventToTracking(latestEvent, shipment.deliveryJobId ?? shipment.id)
-              : null,
+            order: mapOrder(deliveryJob),
+            driver: deliveryJob.driver ? mapDriver(deliveryJob.driver) : null,
+            vehicle: deliveryJob.vehicle ? mapVehicle(deliveryJob.vehicle) : null,
+            tracking: latestEvent ? mapTrackingEventToTracking(latestEvent, deliveryJob.id) : null,
             estimatedArrival: shipment.estimatedDelivery
               ? new Date(shipment.estimatedDelivery)
               : undefined,
           };
         })
-      );
+        .filter((item): item is LiveDelivery => item !== null);
 
-      setActiveDeliveries(
-        list.filter(
-          (
-            item
-          ): item is {
-            order: (typeof orders)[number];
-            driver: (typeof drivers)[number] | null;
-            vehicle: (typeof vehicles)[number] | null;
-            tracking: Tracking | null;
-            estimatedArrival: Date | undefined;
-          } => item !== null
-        )
-      );
+      setActiveDeliveries(list);
     } catch (fetchError) {
       setError(
         fetchError instanceof Error ? fetchError : new Error('Failed to load live tracking')
@@ -375,7 +407,7 @@ export function useLiveTracking() {
     } finally {
       setIsLoading(false);
     }
-  }, [drivers, graphQLOptions, orders, vehicles]);
+  }, [graphQLOptions]);
 
   useEffect(() => {
     void load();