@burdenoff/microfe-movethewheels 2026.924.2 → 2026.925.2

package/src/movethewheels/hooks/useTracking.ts

@@ -41,10 +41,23 @@ interface ApiShipment {
   shipmentNumber: string;
   deliveryJobId?: string | null;
   status: string;
+  trackingNumber?: string | null;
   estimatedDelivery?: string | null;
   trackingEvents?: ApiTrackingEvent[];
 }
 
+interface LookupDeliveryJob {
+  id: string;
+  deliveryJobNumber: string;
+  trackingNumber?: string | null;
+}
+
+interface LookupShipment {
+  shipmentNumber: string;
+  deliveryJobId?: string | null;
+  trackingNumber?: string | null;
+}
+
 interface ApiActiveDelivery extends ApiShipment {
   deliveryJob?:
     | (ApiOrder & {
@@ -69,11 +82,30 @@ const SHIPMENTS_QUERY = `
       shipmentNumber
       deliveryJobId
       status
+      trackingNumber
       estimatedDelivery
     }
   }
 `;
 
+const LOOKUP_DELIVERY_JOB_QUERY = `
+  query LookupDeliveryJob($id: ID!) {
+    deliveryJob(id: $id) {
+      id
+    }
+  }
+`;
+
+const LOOKUP_DELIVERY_JOBS_QUERY = `
+  query LookupDeliveryJobs($filter: DeliveryJobFilterInput, $pagination: PaginationInput) {
+    deliveryJobs(filter: $filter, pagination: $pagination) {
+      id
+      deliveryJobNumber
+      trackingNumber
+    }
+  }
+`;
+
 const DELIVERY_JOB_TRACKING_QUERY = `
   query GetDeliveryJobTracking($deliveryJobId: ID!, $pagination: PaginationInput) {
     deliveryJobTracking(deliveryJobId: $deliveryJobId, pagination: $pagination) {
@@ -86,7 +118,6 @@ const DELIVERY_JOB_TRACKING_QUERY = `
     }
   }
 `;
-
 const ACTIVE_DELIVERIES_QUERY = `
   query GetActiveDeliveries($pagination: PaginationInput) {
     activeDeliveries(pagination: $pagination) {
@@ -178,25 +209,37 @@ const TRACKING_ALERTS_QUERY = `
   }
 `;
 
-function mapTrackingEventToTracking(event: ApiTrackingEvent, entityId: string): Tracking {
-  const location = {
+function mapTrackingEventToLocation(event: ApiTrackingEvent): Location {
+  return {
     latitude: Number((event.location?.latitude as number | undefined) ?? 0),
     longitude: Number((event.location?.longitude as number | undefined) ?? 0),
     address: (event.location?.address as string | undefined) ?? undefined,
     timestamp: new Date(event.timestamp),
   };
+}
+
+function mapTrackingEventsToTracking(
+  events: ApiTrackingEvent[],
+  entityId: string
+): Tracking | null {
+  const latest = events[0];
+  if (!latest) return null;
+
+  const locationHistory = events.map(mapTrackingEventToLocation);
+  const currentLocation = locationHistory[0];
+  if (!currentLocation) return null;
 
   return {
-    id: event.id,
+    id: latest.id,
     entityId,
     entityType: 'order',
-    currentLocation: location,
-    locationHistory: [location],
-    status: event.eventType.toLowerCase(),
+    currentLocation,
+    locationHistory,
+    status: latest.eventType.toLowerCase(),
     estimatedArrival: undefined,
-    nextCheckpoint: event.details ?? undefined,
+    nextCheckpoint: latest.details ?? undefined,
     alerts: [],
-    lastUpdated: new Date(event.timestamp),
+    lastUpdated: new Date(latest.timestamp),
   };
 }
 
@@ -216,8 +259,26 @@ function useGraphqlOptions() {
   );
 }
 
+const TRACKING_POLL_INTERVAL_MS = 30_000;
+
+function useVisibleTrackingPolling(load: () => void | Promise<void>, enabled: boolean): void {
+  useEffect(() => {
+    if (!enabled || typeof document === 'undefined') return;
+
+    const refreshWhenVisible = () => {
+      if (document.visibilityState === 'visible') void load();
+    };
+    const intervalId = window.setInterval(refreshWhenVisible, TRACKING_POLL_INTERVAL_MS);
+    document.addEventListener('visibilitychange', refreshWhenVisible);
+    return () => {
+      window.clearInterval(intervalId);
+      document.removeEventListener('visibilitychange', refreshWhenVisible);
+    };
+  }, [enabled, load]);
+}
+
 export function useTracking(options: UseTrackingOptions = {}): UseTrackingResult {
-  const { entityId, entityType } = options;
+  const { entityId, entityType, realtime = false } = options;
   const graphQLOptions = useGraphqlOptions();
   const [tracking, setTracking] = useState<Tracking[]>([]);
   const [isLoading, setIsLoading] = useState(false);
@@ -274,6 +335,7 @@ export function useTracking(options: UseTrackingOptions = {}): UseTrackingResult
   useEffect(() => {
     void load();
   }, [load]);
+  useVisibleTrackingPolling(load, realtime);
 
   return {
     tracking,
@@ -283,46 +345,165 @@ export function useTracking(options: UseTrackingOptions = {}): UseTrackingResult
   };
 }
 
-export function useOrderTracking(orderId: string | undefined) {
+async function resolveTrackingOrderId(
+  graphQLOptions: ReturnType<typeof useGraphqlOptions>,
+  rawLookup: string
+): Promise<string | null> {
+  const lookup = rawLookup.trim();
+  const direct = await executeGraphQL<{ deliveryJob: { id: string } | null }>(
+    graphQLOptions,
+    LOOKUP_DELIVERY_JOB_QUERY,
+    { id: lookup }
+  );
+  if (direct.deliveryJob?.id) return direct.deliveryJob.id;
+
+  const jobs = await executeGraphQL<{ deliveryJobs: LookupDeliveryJob[] }>(
+    graphQLOptions,
+    LOOKUP_DELIVERY_JOBS_QUERY,
+    {
+      filter: { search: lookup },
+      pagination: { limit: 50, offset: 0 },
+    }
+  );
+  const normalizedLookup = lookup.toLocaleLowerCase();
+  const matchingJobs = jobs.deliveryJobs.filter((job) =>
+    [job.id, job.deliveryJobNumber, job.trackingNumber]
+      .filter((value): value is string => Boolean(value))
+      .some((value) => value.toLocaleLowerCase() === normalizedLookup)
+  );
+  if (matchingJobs.length > 1) {
+    throw new Error('Multiple deliveries match that reference. Enter the full tracking number.');
+  }
+  if (matchingJobs[0]) return matchingJobs[0].id;
+
+  const shipments = await executeGraphQL<{ shipments: LookupShipment[] }>(
+    graphQLOptions,
+    SHIPMENTS_QUERY,
+    {
+      filter: { search: lookup },
+      pagination: { limit: 50, offset: 0 },
+    }
+  );
+  const matchingShipments = shipments.shipments.filter((shipment) =>
+    [shipment.trackingNumber, shipment.shipmentNumber]
+      .filter((value): value is string => Boolean(value))
+      .some((value) => value.toLocaleLowerCase() === normalizedLookup)
+  );
+  const matchingJobIds = [
+    ...new Set(
+      matchingShipments
+        .map((shipment) => shipment.deliveryJobId)
+        .filter((value): value is string => Boolean(value))
+    ),
+  ];
+  if (matchingJobIds.length > 1) {
+    throw new Error('Multiple shipments match that reference. Enter the full tracking number.');
+  }
+  return matchingJobIds[0] ?? null;
+}
+
+export function useOrderTracking(orderLookup: string | undefined) {
   const graphQLOptions = useGraphqlOptions();
-  const { order } = useOrder(orderId);
+  const [resolvedOrderId, setResolvedOrderId] = useState<string | undefined>();
+  const [lookupLoading, setLookupLoading] = useState(false);
+  const [lookupError, setLookupError] = useState<Error | null>(null);
+  const [lookupVersion, setLookupVersion] = useState(0);
+  const {
+    order,
+    isLoading: orderLoading,
+    error: orderError,
+    refetch: refetchOrder,
+  } = useOrder(resolvedOrderId);
   const [tracking, setTracking] = useState<Tracking | null>(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
+  const [trackingLoading, setTrackingLoading] = useState(false);
+  const [trackingError, setTrackingError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    const lookup = orderLookup?.trim() ?? '';
+
+    setResolvedOrderId(undefined);
+    setTracking(null);
+    setLookupError(null);
+    if (!lookup) {
+      setLookupLoading(false);
+      return () => {
+        cancelled = true;
+      };
+    }
+
+    setLookupLoading(true);
+    void resolveTrackingOrderId(graphQLOptions, lookup)
+      .then((id) => {
+        if (!cancelled) setResolvedOrderId(id ?? undefined);
+      })
+      .catch((fetchError: unknown) => {
+        if (!cancelled) {
+          setLookupError(
+            fetchError instanceof Error ? fetchError : new Error('Failed to find the delivery')
+          );
+        }
+      })
+      .finally(() => {
+        if (!cancelled) setLookupLoading(false);
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [graphQLOptions, lookupVersion, orderLookup]);
 
   const load = useCallback(async () => {
-    if (!orderId) {
+    if (!resolvedOrderId) {
       setTracking(null);
+      setTrackingLoading(false);
       return;
     }
 
-    setIsLoading(true);
-    setError(null);
+    setTrackingLoading(true);
+    setTrackingError(null);
     try {
       const data = await executeGraphQL<{ deliveryJobTracking: ApiTrackingEvent[] }>(
         graphQLOptions,
         DELIVERY_JOB_TRACKING_QUERY,
         {
-          deliveryJobId: orderId,
-          pagination: { limit: 1, offset: 0 },
+          deliveryJobId: resolvedOrderId,
+          pagination: { limit: 50, offset: 0 },
         }
       );
-      const latest = data.deliveryJobTracking[0];
-      setTracking(latest ? mapTrackingEventToTracking(latest, orderId) : null);
+      const events = [...data.deliveryJobTracking].sort(
+        (first, second) => Date.parse(second.timestamp) - Date.parse(first.timestamp)
+      );
+      setTracking(mapTrackingEventsToTracking(events, resolvedOrderId));
     } catch (fetchError) {
-      setError(
+      setTrackingError(
         fetchError instanceof Error ? fetchError : new Error('Failed to load order tracking')
       );
     } finally {
-      setIsLoading(false);
+      setTrackingLoading(false);
     }
-  }, [graphQLOptions, orderId]);
+  }, [graphQLOptions, resolvedOrderId]);
 
   useEffect(() => {
     void load();
   }, [load]);
+  useVisibleTrackingPolling(load, Boolean(resolvedOrderId));
+
+  const refetch = () => {
+    setLookupVersion((version) => version + 1);
+    if (resolvedOrderId) {
+      void refetchOrder();
+      void load();
+    }
+  };
 
-  return { tracking, order, isLoading, error, refetch: () => void load() };
+  return {
+    tracking,
+    order: resolvedOrderId ? order : null,
+    isLoading: lookupLoading || orderLoading || trackingLoading,
+    error: lookupError ?? (resolvedOrderId ? (orderError ?? trackingError) : null),
+    refetch,
+  };
 }
 
 export function useVehicleTracking(vehicleId: string | undefined) {
@@ -386,12 +567,11 @@ export function useLiveTracking() {
           const deliveryJob = shipment.deliveryJob;
           if (!deliveryJob) return null;
 
-          const latestEvent = shipment.trackingEvents?.[0];
           return {
             order: mapOrder(deliveryJob),
             driver: deliveryJob.driver ? mapDriver(deliveryJob.driver) : null,
             vehicle: deliveryJob.vehicle ? mapVehicle(deliveryJob.vehicle) : null,
-            tracking: latestEvent ? mapTrackingEventToTracking(latestEvent, deliveryJob.id) : null,
+            tracking: mapTrackingEventsToTracking(shipment.trackingEvents ?? [], deliveryJob.id),
             estimatedArrival: shipment.estimatedDelivery
               ? new Date(shipment.estimatedDelivery)
               : undefined,
@@ -412,6 +592,7 @@ export function useLiveTracking() {
   useEffect(() => {
     void load();
   }, [load]);
+  useVisibleTrackingPolling(load, true);
 
   return { activeDeliveries, isLoading, error, refetch: () => void load() };
 }