@burdenoff/microfe-movethewheels 2026.822.1 → 2026.828.1

package/src/movethewheels/hooks/index.ts

@@ -12,9 +12,12 @@ export {
   useFleet,
   useVehicles,
   useVehicle,
+  useVehicleDrivers,
   useDrivers,
   useDriver,
+  useDriverStatusCounts,
   useFleetStats,
+  type DriverStatusCounts,
 } from './useFleet';
 
 // Inventory (Products & Warehouses)
@@ -22,9 +25,15 @@ export {
   useInventory,
   useProducts,
   useProduct,
+  useProductStockLevels,
   useWarehouses,
   useWarehouse,
   useInventoryStats,
+  useInventoryTransactions,
+  type InventoryStats,
+  type InventoryTransaction,
+  type InventoryTransactionType,
+  type ProductStockLevel,
 } from './useInventory';
 
 // Customers

package/src/movethewheels/hooks/useFleet.ts

@@ -46,6 +46,7 @@ interface ApiVehicle {
   make?: string | null;
   model?: string | null;
   licensePlate?: string | null;
+  ownershipType?: string | null;
   year?: number | null;
   capacity?: Record<string, unknown> | null;
   status: string;
@@ -83,6 +84,7 @@ const LIST_VEHICLES_QUERY = `
       make
       model
       licensePlate
+      ownershipType
       year
       capacity
       status
@@ -126,6 +128,7 @@ const GET_VEHICLE_QUERY = `
       make
       model
       licensePlate
+      ownershipType
       year
       capacity
       status
@@ -169,6 +172,7 @@ const UPDATE_VEHICLE_STATUS_MUTATION = `
       make
       model
       licensePlate
+      ownershipType
       year
       capacity
       status
@@ -234,6 +238,7 @@ const CREATE_VEHICLE_MUTATION = `
       make
       model
       licensePlate
+      ownershipType
       year
       capacity
       status
@@ -277,6 +282,7 @@ const UPDATE_VEHICLE_MUTATION = `
       make
       model
       licensePlate
+      ownershipType
       year
       capacity
       status
@@ -311,6 +317,21 @@ const UPDATE_DRIVER_MUTATION = `
   }
 `;
 
+/**
+ * `fleetStats` only breaks drivers down into available / on-delivery, so an
+ * "on break" or "off duty" tile derived from it is always wrong (on-break
+ * drivers get lumped into the off-duty remainder). `driversCount` takes the
+ * same DriverFilterInput as the list, so each roster tile can be counted
+ * exactly, workspace-wide, instead of inferred from a subtraction.
+ */
+const DRIVER_STATUS_COUNTS_QUERY = `
+  query GetDriverStatusCounts {
+    onBreak: driversCount(filter: { status: ON_BREAK })
+    offDuty: driversCount(filter: { status: OFF_DUTY })
+    inactive: driversCount(filter: { status: INACTIVE })
+  }
+`;
+
 const FLEET_STATS_QUERY = `
   query GetFleetStats {
     fleetStats {
@@ -386,6 +407,7 @@ function mapVehicle(vehicle: ApiVehicle): Vehicle {
     make: vehicle.make ?? '',
     model: vehicle.model ?? '',
     licensePlate: vehicle.licensePlate ?? '',
+    ownershipType: vehicle.ownershipType ?? undefined,
     year: vehicle.year ?? new Date().getFullYear(),
     capacity: {
       weight: 0,
@@ -805,8 +827,16 @@ interface UseDriversResult {
   assignVehicle: (driverId: string, vehicleId: string) => Promise<Driver>;
 }
 
-export function useDrivers(options: UseListOptions = {}): UseDriversResult {
-  const { limit = 200, offset = 0 } = options;
+interface UseDriversOptions extends UseListOptions {
+  /**
+   * Narrows the roster server-side via `DriverFilterInput.status` so the pager
+   * still counts whole result sets rather than filtering one fetched page.
+   */
+  status?: DriverStatus;
+}
+
+export function useDrivers(options: UseDriversOptions = {}): UseDriversResult {
+  const { limit = 200, offset = 0, status } = options;
   const graphQLOptions = useGraphqlOptions();
   const [drivers, setDrivers] = useState<Driver[]>([]);
   const [hasMore, setHasMore] = useState(false);
@@ -821,6 +851,7 @@ export function useDrivers(options: UseListOptions = {}): UseDriversResult {
         graphQLOptions,
         LIST_DRIVERS_QUERY,
         {
+          filter: status ? { status: toApiDriverStatus(status) } : undefined,
           pagination: { limit, offset },
         }
       );
@@ -831,7 +862,7 @@ export function useDrivers(options: UseListOptions = {}): UseDriversResult {
     } finally {
       setIsLoading(false);
     }
-  }, [graphQLOptions, limit, offset]);
+  }, [graphQLOptions, limit, offset, status]);
 
   useEffect(() => {
     void load();
@@ -928,6 +959,105 @@ export function useDriver(driverId: string | undefined) {
   return { driver, isLoading, error, refetch };
 }
 
+export interface DriverStatusCounts {
+  onBreak: number;
+  offDuty: number;
+  inactive: number;
+}
+
+/** Exact per-status driver counts for the roster tiles (see DRIVER_STATUS_COUNTS_QUERY). */
+export function useDriverStatusCounts() {
+  const graphQLOptions = useGraphqlOptions();
+  const [counts, setCounts] = useState<DriverStatusCounts>({
+    onBreak: 0,
+    offDuty: 0,
+    inactive: 0,
+  });
+  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<DriverStatusCounts>(
+        graphQLOptions,
+        DRIVER_STATUS_COUNTS_QUERY
+      );
+      setCounts({
+        onBreak: data.onBreak,
+        offDuty: data.offDuty,
+        inactive: data.inactive,
+      });
+    } catch (fetchError) {
+      setError(
+        fetchError instanceof Error ? fetchError : new Error('Failed to load driver status counts')
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return { counts, isLoading, error, refetch };
+}
+
+/**
+ * The driver(s) currently assigned to a vehicle, resolved server-side through
+ * `DriverFilterInput.vehicleId` (the same link `assignDriverVehicle` writes).
+ * A vehicle normally has one driver, but the filter returns a list, so the
+ * caller gets every assignment rather than a silently-picked first row.
+ */
+export function useVehicleDrivers(vehicleId: string | undefined) {
+  const graphQLOptions = useGraphqlOptions();
+  const [drivers, setDrivers] = useState<Driver[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const load = useCallback(async () => {
+    if (!vehicleId) {
+      setDrivers([]);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{ drivers: ApiDriver[] }>(
+        graphQLOptions,
+        LIST_DRIVERS_QUERY,
+        {
+          filter: { vehicleId },
+          pagination: { limit: 25, offset: 0 },
+        }
+      );
+      setDrivers(data.drivers.map(mapDriver));
+    } catch (fetchError) {
+      setError(
+        fetchError instanceof Error ? fetchError : new Error('Failed to load assigned driver')
+      );
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, vehicleId]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return { drivers, isLoading, error, refetch };
+}
+
 export function useFleetStats() {
   const graphQLOptions = useGraphqlOptions();
   const [stats, setStats] = useState({

package/src/movethewheels/hooks/useImportExport.ts

@@ -1,6 +1,4 @@
-import { useCallback, useMemo, useState } from 'react';
-import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
-import { executeGraphQL } from '../utils/graphqlClient';
+import { useCallback, useState } from 'react';
 
 export interface ImportExportResult {
   success: boolean;
@@ -8,26 +6,6 @@ export interface ImportExportResult {
   payload?: Record<string, unknown> | null;
 }
 
-const EXPORT_DATA_MUTATION = `
-  mutation MovethewheelsExportData($input: MovethewheelsExportDataInput!) {
-    exportData(input: $input) {
-      success
-      message
-      payload
-    }
-  }
-`;
-
-const IMPORT_DATA_MUTATION = `
-  mutation MovethewheelsImportData($input: MovethewheelsImportDataInput!) {
-    importData(input: $input) {
-      success
-      message
-      payload
-    }
-  }
-`;
-
 interface UseImportExportResult {
   exportData: (resource: string, format?: string) => Promise<ImportExportResult>;
   importData: (resource: string, payload: Record<string, unknown>) => Promise<ImportExportResult>;
@@ -35,66 +13,52 @@ interface UseImportExportResult {
   error: Error | null;
 }
 
+/**
+ * Import/export surface withdrawn from wspace-movethewheels-svc by migration
+ * 20260707000001_movethewheels_reuse_cleanup. The service now exposes
+ * `exportMtwEntities` (async job, returns MtwExportJob) but no import
+ * counterpart, so the old synchronous exportData/importData mutations are no
+ * longer resolvable. This hook keeps the same contract for consumers but
+ * rejects calls with a clear message until a replacement import/export flow is
+ * designed. The original operations are preserved in
+ * src/operations/wspace/movethewheels/mutations/marketplace-reports.withdrawn.graphql.
+ */
 export function useImportExport(): UseImportExportResult {
-  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
-    useMoveTheWheels();
   const [isBusy, setIsBusy] = useState(false);
   const [error, setError] = useState<Error | null>(null);
 
-  const graphQLOptions = useMemo(
-    () => ({
-      apiGatewayUrl,
-      authToken,
-      workspaceToken,
-      workspaceId,
-      tenantId,
-      actorId: currentUser?.id,
-    }),
-    [apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser?.id]
-  );
+  const withBusy = useCallback(async <T>(fn: () => Promise<T>): Promise<T> => {
+    setIsBusy(true);
+    setError(null);
+    try {
+      return await fn();
+    } catch (err) {
+      const normalized = err instanceof Error ? err : new Error('Import/export failed');
+      setError(normalized);
+      throw normalized;
+    } finally {
+      setIsBusy(false);
+    }
+  }, []);
 
   const exportData = useCallback(
-    async (resource: string, format?: string): Promise<ImportExportResult> => {
-      setIsBusy(true);
-      setError(null);
-      try {
-        const data = await executeGraphQL<{ exportData: ImportExportResult }>(
-          graphQLOptions,
-          EXPORT_DATA_MUTATION,
-          { input: { resource, format } }
+    async (resource: string, _format?: string): Promise<ImportExportResult> =>
+      withBusy(async () => {
+        throw new Error(
+          `Export for "${resource}" is not available: the import/export surface was withdrawn from the service.`
         );
-        return data.exportData;
-      } catch (fetchError) {
-        const normalized = fetchError instanceof Error ? fetchError : new Error('Export failed');
-        setError(normalized);
-        throw normalized;
-      } finally {
-        setIsBusy(false);
-      }
-    },
-    [graphQLOptions]
+      }),
+    [withBusy]
   );
 
   const importData = useCallback(
-    async (resource: string, payload: Record<string, unknown>): Promise<ImportExportResult> => {
-      setIsBusy(true);
-      setError(null);
-      try {
-        const data = await executeGraphQL<{ importData: ImportExportResult }>(
-          graphQLOptions,
-          IMPORT_DATA_MUTATION,
-          { input: { resource, payload } }
+    async (resource: string, _payload: Record<string, unknown>): Promise<ImportExportResult> =>
+      withBusy(async () => {
+        throw new Error(
+          `Import for "${resource}" is not available: the import surface was withdrawn from the service.`
         );
-        return data.importData;
-      } catch (fetchError) {
-        const normalized = fetchError instanceof Error ? fetchError : new Error('Import failed');
-        setError(normalized);
-        throw normalized;
-      } finally {
-        setIsBusy(false);
-      }
-    },
-    [graphQLOptions]
+      }),
+    [withBusy]
   );
 
   return { exportData, importData, isBusy, error };