@burdenoff/microfe-movethewheels 2026.510.105

package/src/movethewheels/hooks/useFleet.ts

@@ -0,0 +1,778 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
+import type { Driver, DriverStatus, FleetFilter, Vehicle, VehicleStatus } from '../types';
+import { executeGraphQL } from '../utils/graphqlClient';
+
+interface UseFleetOptions {
+  filters?: FleetFilter;
+}
+
+interface UseFleetResult {
+  vehicles: Vehicle[];
+  drivers: Driver[];
+  totalVehicles: number;
+  totalDrivers: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+interface ApiVehicle {
+  id: string;
+  vehicleNumber: string;
+  type: string;
+  make?: string | null;
+  model?: string | null;
+  year?: number | null;
+  capacity?: Record<string, unknown> | null;
+  status: string;
+  currentLocation?: Record<string, unknown> | null;
+  fuelLevel?: number | null;
+  mileage?: number | null;
+  createdAt: string;
+  updatedAt?: string;
+}
+
+interface ApiDriver {
+  id: string;
+  userId?: string | null;
+  firstName: string;
+  lastName: string;
+  employeeId: string;
+  licenseNumber?: string | null;
+  licenseClass?: string | null;
+  licenseExpiry?: string | null;
+  status: string;
+  currentLocation?: Record<string, unknown> | null;
+  rating?: number | null;
+  vehicleId?: string | null;
+  createdAt: string;
+}
+
+const LIST_VEHICLES_QUERY = `
+  query ListVehicles($filter: VehicleFilterInput, $pagination: PaginationInput) {
+    vehicles(filter: $filter, pagination: $pagination) {
+      id
+      vehicleNumber
+      type
+      make
+      model
+      year
+      capacity
+      status
+      currentLocation
+      fuelLevel
+      mileage
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+const LIST_DRIVERS_QUERY = `
+  query ListDrivers($filter: DriverFilterInput, $pagination: PaginationInput) {
+    drivers(filter: $filter, pagination: $pagination) {
+      id
+      userId
+      firstName
+      lastName
+      employeeId
+      licenseNumber
+      licenseClass
+      licenseExpiry
+      status
+      currentLocation
+      rating
+      vehicleId
+      createdAt
+    }
+  }
+`;
+
+const GET_VEHICLE_QUERY = `
+  query GetVehicle($id: ID!) {
+    vehicle(id: $id) {
+      id
+      vehicleNumber
+      type
+      make
+      model
+      year
+      capacity
+      status
+      currentLocation
+      fuelLevel
+      mileage
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+const GET_DRIVER_QUERY = `
+  query GetDriver($id: ID!) {
+    driver(id: $id) {
+      id
+      userId
+      firstName
+      lastName
+      employeeId
+      licenseNumber
+      licenseClass
+      licenseExpiry
+      status
+      currentLocation
+      rating
+      vehicleId
+      createdAt
+    }
+  }
+`;
+
+const UPDATE_VEHICLE_STATUS_MUTATION = `
+  mutation UpdateVehicleStatus($id: ID!, $status: VehicleStatus!) {
+    updateVehicleStatus(id: $id, status: $status) {
+      id
+      vehicleNumber
+      type
+      make
+      model
+      year
+      capacity
+      status
+      currentLocation
+      fuelLevel
+      mileage
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+const ASSIGN_DRIVER_VEHICLE_MUTATION = `
+  mutation AssignDriverVehicle($id: ID!, $vehicleId: ID) {
+    assignDriverVehicle(id: $id, vehicleId: $vehicleId) {
+      id
+      userId
+      firstName
+      lastName
+      employeeId
+      licenseNumber
+      licenseClass
+      licenseExpiry
+      status
+      currentLocation
+      rating
+      vehicleId
+      createdAt
+    }
+  }
+`;
+
+const UPDATE_DRIVER_STATUS_MUTATION = `
+  mutation UpdateDriverStatus($id: ID!, $status: DriverStatus!) {
+    updateDriverStatus(id: $id, status: $status) {
+      id
+      userId
+      firstName
+      lastName
+      employeeId
+      licenseNumber
+      licenseClass
+      licenseExpiry
+      status
+      currentLocation
+      rating
+      vehicleId
+      createdAt
+    }
+  }
+`;
+
+const FLEET_STATS_QUERY = `
+  query GetFleetStats {
+    fleetStats {
+      totalVehicles
+      activeVehicles
+      inTransitVehicles
+      maintenanceVehicles
+      totalDrivers
+      availableDrivers
+      onDeliveryDrivers
+    }
+  }
+`;
+
+function mapVehicleStatus(status: string): VehicleStatus {
+  switch (status) {
+    case 'ACTIVE':
+      return 'available';
+    case 'IN_TRANSIT':
+      return 'assigned';
+    case 'MAINTENANCE':
+      return 'maintenance';
+    default:
+      return 'out_of_service';
+  }
+}
+
+function toApiVehicleStatus(status: VehicleStatus): string {
+  switch (status) {
+    case 'available':
+      return 'ACTIVE';
+    case 'assigned':
+      return 'IN_TRANSIT';
+    case 'maintenance':
+      return 'MAINTENANCE';
+    default:
+      return 'INACTIVE';
+  }
+}
+
+function mapDriverStatus(status: string): DriverStatus {
+  switch (status) {
+    case 'AVAILABLE':
+      return 'available';
+    case 'ON_DELIVERY':
+      return 'busy';
+    case 'ON_BREAK':
+      return 'on_break';
+    default:
+      return 'offline';
+  }
+}
+
+function toApiDriverStatus(status: DriverStatus): string {
+  switch (status) {
+    case 'available':
+      return 'AVAILABLE';
+    case 'busy':
+      return 'ON_DELIVERY';
+    case 'on_break':
+      return 'ON_BREAK';
+    default:
+      return 'OFF_DUTY';
+  }
+}
+
+function mapVehicle(vehicle: ApiVehicle): Vehicle {
+  return {
+    id: vehicle.id,
+    vehicleNumber: vehicle.vehicleNumber,
+    type: (vehicle.type?.toLowerCase() ?? 'van') as Vehicle['type'],
+    make: vehicle.make ?? '',
+    model: vehicle.model ?? '',
+    year: vehicle.year ?? new Date().getFullYear(),
+    capacity: {
+      weight: 0,
+      volume: 0,
+      ...(vehicle.capacity ?? {}),
+    },
+    status: mapVehicleStatus(vehicle.status),
+    driverId: undefined,
+    currentLocation: vehicle.currentLocation
+      ? {
+          latitude: Number((vehicle.currentLocation.latitude as number | undefined) ?? 0),
+          longitude: Number((vehicle.currentLocation.longitude as number | undefined) ?? 0),
+          address: (vehicle.currentLocation.address as string | undefined) ?? undefined,
+          timestamp: new Date(),
+        }
+      : undefined,
+    lastMaintenance: undefined,
+    nextMaintenance: undefined,
+    fuelLevel: vehicle.fuelLevel ?? undefined,
+    mileage: vehicle.mileage ?? undefined,
+    documents: [],
+    createdAt: new Date(vehicle.createdAt),
+  };
+}
+
+function mapDriver(driver: ApiDriver): Driver {
+  return {
+    id: driver.id,
+    userId: driver.userId ?? driver.id,
+    fullName: `${driver.firstName} ${driver.lastName}`.trim(),
+    employeeId: driver.employeeId,
+    licenseNumber: driver.licenseNumber ?? '',
+    licenseType: driver.licenseClass ?? 'standard',
+    licenseExpiry: driver.licenseExpiry ? new Date(driver.licenseExpiry) : new Date(),
+    vehicleIds: driver.vehicleId ? [driver.vehicleId] : [],
+    assignedVehicle: driver.vehicleId ?? undefined,
+    status: mapDriverStatus(driver.status),
+    currentLocation: driver.currentLocation
+      ? {
+          latitude: Number((driver.currentLocation.latitude as number | undefined) ?? 0),
+          longitude: Number((driver.currentLocation.longitude as number | undefined) ?? 0),
+          address: (driver.currentLocation.address as string | undefined) ?? undefined,
+          timestamp: new Date(),
+        }
+      : undefined,
+    joinDate: new Date(driver.createdAt),
+    baseSalary: 0,
+    completedOrders: 0,
+    todayOrders: 0,
+    specializations: [],
+    workingHours: {
+      startTime: '09:00',
+      endTime: '18:00',
+      workingDays: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
+      maxHoursPerDay: 8,
+      maxHoursPerWeek: 40,
+      currentHoursToday: 0,
+      currentHoursThisWeek: 0,
+    },
+    ratings: {
+      overall: driver.rating ?? 0,
+      punctuality: driver.rating ?? 0,
+      communication: driver.rating ?? 0,
+      carefulHandling: driver.rating ?? 0,
+      professionalism: driver.rating ?? 0,
+      onTimeDelivery: driver.rating ?? 0,
+      totalRatings: 0,
+    },
+    documents: [],
+    earnings: {
+      totalEarnings: 0,
+      weeklyEarnings: 0,
+      monthlyEarnings: 0,
+      pendingPayments: 0,
+      completedDeliveries: 0,
+      bonuses: 0,
+    },
+    compliance: {
+      hoursOfService: true,
+      documentation: true,
+      vehicleInspection: true,
+      lastUpdate: new Date(),
+    },
+    createdAt: new Date(driver.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 useFleet(options: UseFleetOptions = {}): UseFleetResult {
+  const { filters: rawFilters } = options;
+  // Stabilize filters reference for React Compiler memoization.
+  const filters = useMemo(
+    () => rawFilters,
+    [rawFilters?.driverId, rawFilters?.status, rawFilters?.vehicleType]
+  );
+  const graphQLOptions = useGraphqlOptions();
+  const [vehicles, setVehicles] = useState<Vehicle[]>([]);
+  const [drivers, setDrivers] = useState<Driver[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const [vehicleData, driverData] = await Promise.all([
+        executeGraphQL<{ vehicles: ApiVehicle[] }>(graphQLOptions, LIST_VEHICLES_QUERY, {
+          filter: {
+            type: filters?.vehicleType?.toUpperCase(),
+            status: filters?.status ? toApiVehicleStatus(filters.status) : undefined,
+          },
+          pagination: { limit: 200, offset: 0 },
+        }),
+        executeGraphQL<{ drivers: ApiDriver[] }>(graphQLOptions, LIST_DRIVERS_QUERY, {
+          filter: {
+            vehicleId: filters?.driverId,
+          },
+          pagination: { limit: 200, offset: 0 },
+        }),
+      ]);
+
+      setVehicles(vehicleData.vehicles.map(mapVehicle));
+      setDrivers(driverData.drivers.map(mapDriver));
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load fleet data'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [filters, graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return {
+    vehicles,
+    drivers,
+    totalVehicles: vehicles.length,
+    totalDrivers: drivers.length,
+    isLoading,
+    error,
+    refetch,
+  };
+}
+
+interface UseVehiclesResult {
+  vehicles: Vehicle[];
+  totalVehicles: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+  updateVehicleStatus: (id: string, status: VehicleStatus) => Promise<Vehicle>;
+  assignDriver: (vehicleId: string, driverId: string) => Promise<Vehicle>;
+}
+
+export function useVehicles(): UseVehiclesResult {
+  const graphQLOptions = useGraphqlOptions();
+  const [vehicles, setVehicles] = useState<Vehicle[]>([]);
+  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<{ vehicles: ApiVehicle[] }>(
+        graphQLOptions,
+        LIST_VEHICLES_QUERY,
+        {
+          pagination: { limit: 200, offset: 0 },
+        }
+      );
+      setVehicles(data.vehicles.map(mapVehicle));
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load vehicles'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  const updateVehicleStatus = useCallback(
+    async (id: string, status: VehicleStatus): Promise<Vehicle> => {
+      const data = await executeGraphQL<{ updateVehicleStatus: ApiVehicle }>(
+        graphQLOptions,
+        UPDATE_VEHICLE_STATUS_MUTATION,
+        {
+          id,
+          status: toApiVehicleStatus(status),
+        }
+      );
+      const updated = mapVehicle(data.updateVehicleStatus);
+      setVehicles((previous) => previous.map((item) => (item.id === id ? updated : item)));
+      return updated;
+    },
+    [graphQLOptions]
+  );
+
+  const assignDriver = useCallback(
+    async (vehicleId: string, driverId: string): Promise<Vehicle> => {
+      await executeGraphQL<{ assignDriverVehicle: ApiDriver }>(
+        graphQLOptions,
+        ASSIGN_DRIVER_VEHICLE_MUTATION,
+        {
+          id: driverId,
+          vehicleId,
+        }
+      );
+      const next = vehicles.find((item) => item.id === vehicleId);
+      if (!next) {
+        throw new Error('Vehicle not found');
+      }
+      const updated = { ...next, driverId, status: 'assigned' as VehicleStatus };
+      setVehicles((previous) => previous.map((item) => (item.id === vehicleId ? updated : item)));
+      return updated;
+    },
+    [graphQLOptions, vehicles]
+  );
+
+  return {
+    vehicles,
+    totalVehicles: vehicles.length,
+    isLoading,
+    error,
+    refetch,
+    updateVehicleStatus,
+    assignDriver,
+  };
+}
+
+export function useVehicle(vehicleId: string | undefined) {
+  const graphQLOptions = useGraphqlOptions();
+  const [vehicle, setVehicle] = useState<Vehicle | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    if (!vehicleId) {
+      setVehicle(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ vehicle: ApiVehicle | null }>(
+        graphQLOptions,
+        GET_VEHICLE_QUERY,
+        {
+          id: vehicleId,
+        }
+      );
+      setVehicle(data.vehicle ? mapVehicle(data.vehicle) : null);
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load vehicle'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, vehicleId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return { vehicle, isLoading, error, refetch };
+}
+
+interface UseDriversResult {
+  drivers: Driver[];
+  totalDrivers: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+  updateDriverStatus: (id: string, status: DriverStatus) => Promise<Driver>;
+  assignVehicle: (driverId: string, vehicleId: string) => Promise<Driver>;
+}
+
+export function useDrivers(): UseDriversResult {
+  const graphQLOptions = useGraphqlOptions();
+  const [drivers, setDrivers] = useState<Driver[]>([]);
+  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<{ drivers: ApiDriver[] }>(
+        graphQLOptions,
+        LIST_DRIVERS_QUERY,
+        {
+          pagination: { limit: 200, offset: 0 },
+        }
+      );
+      setDrivers(data.drivers.map(mapDriver));
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load drivers'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  const updateDriverStatus = useCallback(
+    async (id: string, status: DriverStatus): Promise<Driver> => {
+      const data = await executeGraphQL<{ updateDriverStatus: ApiDriver }>(
+        graphQLOptions,
+        UPDATE_DRIVER_STATUS_MUTATION,
+        {
+          id,
+          status: toApiDriverStatus(status),
+        }
+      );
+      const updated = mapDriver(data.updateDriverStatus);
+      setDrivers((previous) => previous.map((item) => (item.id === id ? updated : item)));
+      return updated;
+    },
+    [graphQLOptions]
+  );
+
+  const assignVehicle = useCallback(
+    async (driverId: string, vehicleId: string): Promise<Driver> => {
+      const data = await executeGraphQL<{ assignDriverVehicle: ApiDriver }>(
+        graphQLOptions,
+        ASSIGN_DRIVER_VEHICLE_MUTATION,
+        {
+          id: driverId,
+          vehicleId,
+        }
+      );
+      const updated = mapDriver(data.assignDriverVehicle);
+      setDrivers((previous) => previous.map((item) => (item.id === driverId ? updated : item)));
+      return updated;
+    },
+    [graphQLOptions]
+  );
+
+  return {
+    drivers,
+    totalDrivers: drivers.length,
+    isLoading,
+    error,
+    refetch,
+    updateDriverStatus,
+    assignVehicle,
+  };
+}
+
+export function useDriver(driverId: string | undefined) {
+  const graphQLOptions = useGraphqlOptions();
+  const [driver, setDriver] = useState<Driver | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    if (!driverId) {
+      setDriver(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ driver: ApiDriver | null }>(
+        graphQLOptions,
+        GET_DRIVER_QUERY,
+        {
+          id: driverId,
+        }
+      );
+      setDriver(data.driver ? mapDriver(data.driver) : null);
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load driver'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [driverId, graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return { driver, isLoading, error, refetch };
+}
+
+export function useFleetStats() {
+  const graphQLOptions = useGraphqlOptions();
+  const [stats, setStats] = useState({
+    totalVehicles: 0,
+    totalDrivers: 0,
+    vehiclesByStatus: {
+      available: 0,
+      assigned: 0,
+      maintenance: 0,
+      out_of_service: 0,
+    },
+    driversByStatus: {
+      available: 0,
+      busy: 0,
+      offline: 0,
+      on_break: 0,
+    },
+    avgFuelLevel: 0,
+    avgDriverRating: 0,
+    utilization: 0,
+  });
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    const load = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const data = await executeGraphQL<{
+          fleetStats: {
+            totalVehicles: number;
+            activeVehicles: number;
+            inTransitVehicles: number;
+            maintenanceVehicles: number;
+            totalDrivers: number;
+            availableDrivers: number;
+            onDeliveryDrivers: number;
+          };
+        }>(graphQLOptions, FLEET_STATS_QUERY);
+
+        setStats({
+          totalVehicles: data.fleetStats.totalVehicles,
+          totalDrivers: data.fleetStats.totalDrivers,
+          vehiclesByStatus: {
+            available: data.fleetStats.activeVehicles,
+            assigned: data.fleetStats.inTransitVehicles,
+            maintenance: data.fleetStats.maintenanceVehicles,
+            out_of_service: Math.max(
+              data.fleetStats.totalVehicles -
+                data.fleetStats.activeVehicles -
+                data.fleetStats.inTransitVehicles -
+                data.fleetStats.maintenanceVehicles,
+              0
+            ),
+          },
+          driversByStatus: {
+            available: data.fleetStats.availableDrivers,
+            busy: data.fleetStats.onDeliveryDrivers,
+            offline: Math.max(
+              data.fleetStats.totalDrivers -
+                data.fleetStats.availableDrivers -
+                data.fleetStats.onDeliveryDrivers,
+              0
+            ),
+            on_break: 0,
+          },
+          avgFuelLevel: 0,
+          avgDriverRating: 0,
+          utilization:
+            data.fleetStats.totalVehicles > 0
+              ? (data.fleetStats.activeVehicles / data.fleetStats.totalVehicles) * 100
+              : 0,
+        });
+      } catch (fetchError) {
+        setError(
+          fetchError instanceof Error ? fetchError : new Error('Failed to load fleet stats')
+        );
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    void load();
+  }, [graphQLOptions]);
+
+  return { stats, isLoading, error };
+}