@burdenoff/microfe-movethewheels 2026.510.105

package/src/movethewheels/hooks/useRoutes.ts

@@ -0,0 +1,453 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
+import type { Route, RouteStop } from '../types';
+import { executeGraphQL } from '../utils/graphqlClient';
+
+interface UseRoutesOptions {
+  driverId?: string;
+  vehicleId?: string;
+  status?: 'planned' | 'in_progress' | 'completed' | 'cancelled';
+}
+
+interface UseRoutesResult {
+  routes: Route[];
+  totalRoutes: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+  createRoute: (route: Partial<Route>) => Promise<Route>;
+  updateRoute: (id: string, updates: Partial<Route>) => Promise<Route>;
+  deleteRoute: (id: string) => Promise<void>;
+  optimizeRoute: (routeId: string) => Promise<Route>;
+  updateStopStatus: (
+    routeId: string,
+    stopId: string,
+    status: RouteStop['status']
+  ) => Promise<Route>;
+}
+
+interface ApiRoute {
+  id: string;
+  name: string;
+  status: string;
+  shipmentId?: string | null;
+  vehicleId?: string | null;
+  driverId?: string | null;
+  waypoints?: unknown;
+  estimatedDistance?: number | null;
+  estimatedDuration?: number | null;
+  actualDistance?: number | null;
+  actualDuration?: number | null;
+  createdAt: string;
+}
+
+const LIST_ROUTES_QUERY = `
+  query ListRoutes($filter: RouteFilterInput, $pagination: PaginationInput) {
+    routes(filter: $filter, pagination: $pagination) {
+      id
+      name
+      status
+      shipmentId
+      vehicleId
+      driverId
+      waypoints
+      estimatedDistance
+      estimatedDuration
+      actualDistance
+      actualDuration
+      createdAt
+    }
+  }
+`;
+
+const GET_ROUTE_QUERY = `
+  query GetRoute($id: ID!) {
+    route(id: $id) {
+      id
+      name
+      status
+      shipmentId
+      vehicleId
+      driverId
+      waypoints
+      estimatedDistance
+      estimatedDuration
+      actualDistance
+      actualDuration
+      createdAt
+    }
+  }
+`;
+
+const CREATE_ROUTE_MUTATION = `
+  mutation CreateRoute($input: CreateRouteInput!) {
+    createRoute(input: $input) {
+      id
+      name
+      status
+      shipmentId
+      vehicleId
+      driverId
+      waypoints
+      estimatedDistance
+      estimatedDuration
+      actualDistance
+      actualDuration
+      createdAt
+    }
+  }
+`;
+
+const UPDATE_ROUTE_MUTATION = `
+  mutation UpdateRoute($id: ID!, $input: UpdateRouteInput!) {
+    updateRoute(id: $id, input: $input) {
+      id
+      name
+      status
+      shipmentId
+      vehicleId
+      driverId
+      waypoints
+      estimatedDistance
+      estimatedDuration
+      actualDistance
+      actualDuration
+      createdAt
+    }
+  }
+`;
+
+const DELETE_ROUTE_MUTATION = `
+  mutation DeleteRoute($id: ID!) {
+    deleteRoute(id: $id)
+  }
+`;
+
+const OPTIMIZE_ROUTE_MUTATION = `
+  mutation OptimizeRoute($id: ID!) {
+    optimizeRoute(id: $id) {
+      id
+      name
+      status
+      shipmentId
+      vehicleId
+      driverId
+      waypoints
+      estimatedDistance
+      estimatedDuration
+      actualDistance
+      actualDuration
+      createdAt
+    }
+  }
+`;
+
+function mapRouteStatus(status: string): Route['status'] {
+  switch (status) {
+    case 'IN_PROGRESS':
+      return 'in_progress';
+    case 'COMPLETED':
+      return 'completed';
+    case 'CANCELLED':
+      return 'cancelled';
+    default:
+      return 'planned';
+  }
+}
+
+function toApiRouteStatus(status: Route['status'] | undefined): string | undefined {
+  if (!status) return undefined;
+  switch (status) {
+    case 'in_progress':
+      return 'IN_PROGRESS';
+    case 'completed':
+      return 'COMPLETED';
+    case 'cancelled':
+      return 'CANCELLED';
+    default:
+      return 'PLANNED';
+  }
+}
+
+function mapWaypoints(waypoints: unknown): RouteStop[] {
+  if (!Array.isArray(waypoints)) return [];
+  return waypoints.map((point, index) => {
+    const item = (point ?? {}) as Record<string, unknown>;
+    return {
+      id: String(item.id ?? `stop-${index + 1}`),
+      orderId: String(item.orderId ?? ''),
+      sequence: Number(item.sequence ?? index + 1),
+      address: {
+        street: String(item.street ?? ''),
+        city: String(item.city ?? ''),
+        state: String(item.state ?? ''),
+        postalCode: String(item.postalCode ?? ''),
+        country: String(item.country ?? ''),
+        latitude: Number(item.latitude ?? 0),
+        longitude: Number(item.longitude ?? 0),
+      },
+      type: item.type === 'pickup' ? 'pickup' : 'delivery',
+      scheduledTime: item.scheduledTime ? new Date(String(item.scheduledTime)) : new Date(),
+      actualTime: item.actualTime ? new Date(String(item.actualTime)) : undefined,
+      duration: Number(item.duration ?? 0),
+      status: (item.status as RouteStop['status']) ?? 'pending',
+      notes: item.notes ? String(item.notes) : undefined,
+    };
+  });
+}
+
+function mapRoute(route: ApiRoute): Route {
+  return {
+    id: route.id,
+    name: route.name,
+    driverId: route.driverId ?? '',
+    vehicleId: route.vehicleId ?? '',
+    status: mapRouteStatus(route.status),
+    stops: mapWaypoints(route.waypoints),
+    distance: route.estimatedDistance ?? 0,
+    estimatedDuration: route.estimatedDuration ?? 0,
+    actualDuration: route.actualDuration ?? undefined,
+    startTime: undefined,
+    endTime: undefined,
+    optimized: false,
+    trafficConditions: [],
+    createdAt: new Date(route.createdAt),
+  };
+}
+
+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 useRoutes(options: UseRoutesOptions = {}): UseRoutesResult {
+  const { driverId, vehicleId, status } = options;
+  const graphQLOptions = useGraphqlOptions();
+  const [routes, setRoutes] = useState<Route[]>([]);
+  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<{ routes: ApiRoute[] }>(graphQLOptions, LIST_ROUTES_QUERY, {
+        filter: {
+          driverId,
+          vehicleId,
+          status: status ? toApiRouteStatus(status) : undefined,
+        },
+        pagination: { limit: 500, offset: 0 },
+      });
+
+      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]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  const createRoute = useCallback(
+    async (route: Partial<Route>): Promise<Route> => {
+      const data = await executeGraphQL<{ createRoute: ApiRoute }>(
+        graphQLOptions,
+        CREATE_ROUTE_MUTATION,
+        {
+          input: {
+            name: route.name ?? `Route ${new Date().toLocaleDateString()}`,
+            status: toApiRouteStatus(route.status),
+            shipmentId: undefined,
+            vehicleId: route.vehicleId,
+            driverId: route.driverId,
+            waypoints: route.stops ?? [],
+            estimatedDistance: route.distance ?? 0,
+            estimatedDuration: route.estimatedDuration ?? 0,
+            actualDistance: route.distance,
+            actualDuration: route.actualDuration,
+          },
+        }
+      );
+
+      const created = mapRoute(data.createRoute);
+      setRoutes((previous) => [created, ...previous]);
+      return created;
+    },
+    [graphQLOptions]
+  );
+
+  const updateRoute = useCallback(
+    async (id: string, updates: Partial<Route>): Promise<Route> => {
+      const data = await executeGraphQL<{ updateRoute: ApiRoute }>(
+        graphQLOptions,
+        UPDATE_ROUTE_MUTATION,
+        {
+          id,
+          input: {
+            name: updates.name,
+            status: toApiRouteStatus(updates.status),
+            shipmentId: undefined,
+            vehicleId: updates.vehicleId,
+            driverId: updates.driverId,
+            waypoints: updates.stops,
+            estimatedDistance: updates.distance,
+            estimatedDuration: updates.estimatedDuration,
+            actualDistance: updates.distance,
+            actualDuration: updates.actualDuration,
+          },
+        }
+      );
+
+      const updated = mapRoute(data.updateRoute);
+      setRoutes((previous) => previous.map((item) => (item.id === id ? updated : item)));
+      return updated;
+    },
+    [graphQLOptions]
+  );
+
+  const deleteRoute = useCallback(
+    async (id: string): Promise<void> => {
+      await executeGraphQL<{ deleteRoute: boolean }>(graphQLOptions, DELETE_ROUTE_MUTATION, { id });
+      setRoutes((previous) => previous.filter((item) => item.id !== id));
+    },
+    [graphQLOptions]
+  );
+
+  const optimizeRoute = useCallback(
+    async (routeId: string): Promise<Route> => {
+      const data = await executeGraphQL<{ optimizeRoute: ApiRoute }>(
+        graphQLOptions,
+        OPTIMIZE_ROUTE_MUTATION,
+        {
+          id: routeId,
+        }
+      );
+      const optimized = { ...mapRoute(data.optimizeRoute), optimized: true };
+      setRoutes((previous) => previous.map((item) => (item.id === routeId ? optimized : item)));
+      return optimized;
+    },
+    [graphQLOptions]
+  );
+
+  const updateStopStatus = useCallback(
+    async (routeId: string, stopId: string, stopStatus: RouteStop['status']): Promise<Route> => {
+      const route = routes.find((item) => item.id === routeId);
+      if (!route) {
+        throw new Error('Route not found');
+      }
+      const updatedStops = route.stops.map((stop) =>
+        stop.id === stopId
+          ? {
+              ...stop,
+              status: stopStatus,
+              actualTime: stopStatus === 'completed' ? new Date() : stop.actualTime,
+            }
+          : stop
+      );
+      return updateRoute(routeId, {
+        stops: updatedStops,
+        status: updatedStops.every((item) => item.status === 'completed')
+          ? 'completed'
+          : route.status,
+      });
+    },
+    [routes, updateRoute]
+  );
+
+  return {
+    routes,
+    totalRoutes: routes.length,
+    isLoading,
+    error,
+    refetch,
+    createRoute,
+    updateRoute,
+    deleteRoute,
+    optimizeRoute,
+    updateStopStatus,
+  };
+}
+
+export function useRoute(routeId: string | undefined) {
+  const graphQLOptions = useGraphqlOptions();
+  const [route, setRoute] = useState<Route | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    if (!routeId) {
+      setRoute(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ route: ApiRoute | null }>(
+        graphQLOptions,
+        GET_ROUTE_QUERY,
+        {
+          id: routeId,
+        }
+      );
+      setRoute(data.route ? mapRoute(data.route) : null);
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load route'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, routeId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  return {
+    route,
+    isLoading,
+    error,
+    refetch: () => void load(),
+  };
+}
+
+export function useRouteStats() {
+  const { routes, isLoading, error } = useRoutes();
+
+  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;
+
+    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,
+    };
+  }, [routes]);
+
+  return { stats, isLoading, error };
+}