@burdenoff/microfe-movethewheels 2026.510.105

package/src/movethewheels/hooks/index.ts

@@ -0,0 +1,55 @@
+/**
+ * MoveTheWheels Hooks
+ *
+ * All custom hooks for data access and operations.
+ */
+
+// Orders
+export { useOrders, useOrder, useOrderStats } from './useOrders';
+
+// Fleet (Vehicles & Drivers)
+export {
+  useFleet,
+  useVehicles,
+  useVehicle,
+  useDrivers,
+  useDriver,
+  useFleetStats,
+} from './useFleet';
+
+// Inventory (Products & Warehouses)
+export {
+  useInventory,
+  useProducts,
+  useProduct,
+  useWarehouses,
+  useWarehouse,
+  useInventoryStats,
+} from './useInventory';
+
+// Customers
+export { useCustomers, useCustomer, useCustomerStats } from './useCustomers';
+
+// Routes
+export { useRoutes, useRoute, useRouteStats } from './useRoutes';
+
+// Analytics
+export {
+  useAnalytics,
+  useDashboardMetrics,
+  useRevenueAnalytics,
+  useOrderAnalytics,
+  useFleetAnalytics,
+  usePerformanceAnalytics,
+} from './useAnalytics';
+
+// Tracking
+export {
+  useTracking,
+  useOrderTracking,
+  useVehicleTracking,
+  useDriverTracking,
+  useLiveTracking,
+  useTrackingAlerts,
+  useGeofence,
+} from './useTracking';

package/src/movethewheels/hooks/useAnalytics.ts

@@ -0,0 +1,476 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
+import type { Analytics } from '../types';
+import { executeGraphQL } from '../utils/graphqlClient';
+
+interface UseAnalyticsOptions {
+  dateRange?: {
+    from: Date;
+    to: Date;
+  };
+}
+
+interface UseAnalyticsResult {
+  analytics: Analytics;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+const ANALYTICS_QUERY = `
+  query GetMovethewheelsAnalytics {
+    analytics {
+      orderTrend {
+        label
+        value
+      }
+      deliveryTrend {
+        label
+        value
+      }
+      revenueTrend {
+        label
+        value
+      }
+    }
+    dashboardMetrics {
+      totalOrders
+      activeDeliveries
+      availableDrivers
+      activeVehicles
+      lowStockItems
+      totalRevenue
+    }
+    fleetStats {
+      totalVehicles
+      activeVehicles
+      maintenanceVehicles
+    }
+  }
+`;
+
+const DASHBOARD_QUERY = `
+  query GetDashboardMetrics {
+    dashboardMetrics {
+      totalOrders
+      activeDeliveries
+      availableDrivers
+      activeVehicles
+      lowStockItems
+      totalRevenue
+    }
+    orderStats {
+      total
+      pending
+      inTransit
+      delivered
+      cancelled
+      failed
+    }
+    fleetStats {
+      totalVehicles
+      activeVehicles
+      maintenanceVehicles
+      totalDrivers
+      availableDrivers
+      onDeliveryDrivers
+    }
+    financeMetrics {
+      revenue {
+        totalRevenue
+        averageOrderValue
+      }
+    }
+  }
+`;
+
+const ORDER_ANALYTICS_QUERY = `
+  query GetOrderAnalytics {
+    orderStats {
+      pending
+      inTransit
+      delivered
+      cancelled
+      failed
+    }
+    analytics {
+      orderTrend {
+        label
+        value
+      }
+    }
+  }
+`;
+
+function emptyAnalytics(): Analytics {
+  return {
+    overview: {
+      totalOrders: 0,
+      totalRevenue: 0,
+      activeVehicles: 0,
+      onTimeDeliveryRate: 0,
+      customerSatisfaction: 0,
+    },
+    trends: {
+      dailyOrders: [],
+      revenue: [],
+    },
+    fleet: {
+      utilization: 0,
+      totalVehicles: 0,
+      activeVehicles: 0,
+      maintenanceVehicles: 0,
+      outOfServiceVehicles: 0,
+      fuelEfficiency: 0,
+    },
+    performance: {
+      onTimePickup: 0,
+      onTimeDelivery: 0,
+      damagedItems: 0,
+      customerComplaints: 0,
+      driverRatings: 0,
+    },
+  };
+}
+
+export function useAnalytics(_options: UseAnalyticsOptions = {}): UseAnalyticsResult {
+  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
+    useMoveTheWheels();
+  const [analytics, setAnalytics] = useState<Analytics>(emptyAnalytics());
+  const [isLoading, setIsLoading] = 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 load = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{
+        analytics: {
+          orderTrend: Array<{ label: string; value: number }>;
+          revenueTrend: Array<{ label: string; value: number }>;
+        };
+        dashboardMetrics: {
+          totalOrders: number;
+          totalRevenue: number;
+          activeVehicles: number;
+        };
+        fleetStats: {
+          totalVehicles: number;
+          activeVehicles: number;
+          maintenanceVehicles: number;
+        };
+      }>(graphQLOptions, ANALYTICS_QUERY);
+
+      setAnalytics({
+        overview: {
+          totalOrders: data.dashboardMetrics.totalOrders,
+          totalRevenue: data.dashboardMetrics.totalRevenue,
+          activeVehicles: data.dashboardMetrics.activeVehicles,
+          onTimeDeliveryRate: 0,
+          customerSatisfaction: 0,
+        },
+        trends: {
+          dailyOrders: data.analytics.orderTrend.map((item) => ({
+            date: item.label,
+            orders: Math.round(item.value),
+          })),
+          revenue: data.analytics.revenueTrend.map((item) => ({
+            month: item.label,
+            revenue: item.value,
+          })),
+        },
+        fleet: {
+          utilization:
+            data.fleetStats.totalVehicles > 0
+              ? (data.fleetStats.activeVehicles / data.fleetStats.totalVehicles) * 100
+              : 0,
+          totalVehicles: data.fleetStats.totalVehicles,
+          activeVehicles: data.fleetStats.activeVehicles,
+          maintenanceVehicles: data.fleetStats.maintenanceVehicles,
+          outOfServiceVehicles: Math.max(
+            data.fleetStats.totalVehicles -
+              data.fleetStats.activeVehicles -
+              data.fleetStats.maintenanceVehicles,
+            0
+          ),
+          fuelEfficiency: 0,
+        },
+        performance: {
+          onTimePickup: 0,
+          onTimeDelivery: 0,
+          damagedItems: 0,
+          customerComplaints: 0,
+          driverRatings: 0,
+        },
+      });
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load analytics'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions]);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  const refetch = useCallback(() => {
+    void load();
+  }, [load]);
+
+  return { analytics, isLoading, error, refetch };
+}
+
+export function useDashboardMetrics() {
+  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
+    useMoveTheWheels();
+  const [metrics, setMetrics] = useState({
+    orders: {
+      total: 0,
+      pending: 0,
+      inTransit: 0,
+      delivered: 0,
+      today: 0,
+    },
+    fleet: {
+      totalVehicles: 0,
+      activeVehicles: 0,
+      totalDrivers: 0,
+      availableDrivers: 0,
+    },
+    revenue: {
+      total: 0,
+      avgOrderValue: 0,
+      currency: 'USD',
+    },
+    performance: {
+      onTimeDeliveryRate: 0,
+      avgDriverRating: 0,
+    },
+  });
+  const [isLoading, setIsLoading] = 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]
+  );
+
+  useEffect(() => {
+    const load = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const data = await executeGraphQL<{
+          orderStats: {
+            total: number;
+            pending: number;
+            inTransit: number;
+            delivered: number;
+          };
+          fleetStats: {
+            totalVehicles: number;
+            activeVehicles: number;
+            totalDrivers: number;
+            availableDrivers: number;
+          };
+          financeMetrics: {
+            revenue: {
+              totalRevenue: number;
+              averageOrderValue: number;
+            };
+          };
+        }>(graphQLOptions, DASHBOARD_QUERY);
+
+        setMetrics({
+          orders: {
+            total: data.orderStats.total,
+            pending: data.orderStats.pending,
+            inTransit: data.orderStats.inTransit,
+            delivered: data.orderStats.delivered,
+            today: 0,
+          },
+          fleet: {
+            totalVehicles: data.fleetStats.totalVehicles,
+            activeVehicles: data.fleetStats.activeVehicles,
+            totalDrivers: data.fleetStats.totalDrivers,
+            availableDrivers: data.fleetStats.availableDrivers,
+          },
+          revenue: {
+            total: data.financeMetrics.revenue.totalRevenue,
+            avgOrderValue: data.financeMetrics.revenue.averageOrderValue,
+            currency: 'USD',
+          },
+          performance: {
+            onTimeDeliveryRate: 0,
+            avgDriverRating: 0,
+          },
+        });
+      } catch (fetchError) {
+        setError(
+          fetchError instanceof Error ? fetchError : new Error('Failed to load dashboard metrics')
+        );
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    void load();
+  }, [graphQLOptions]);
+
+  return { metrics, isLoading, error };
+}
+
+export function useRevenueAnalytics(period: 'daily' | 'weekly' | 'monthly' = 'monthly') {
+  const { analytics, isLoading, error } = useAnalytics();
+
+  const revenueData = useMemo(() => {
+    if (period === 'daily') {
+      return analytics.trends.dailyOrders.map((item) => ({
+        label: item.date,
+        value: item.orders,
+      }));
+    }
+
+    return analytics.trends.revenue.map((item) => ({
+      label: item.month,
+      value: item.revenue,
+    }));
+  }, [analytics.trends.dailyOrders, analytics.trends.revenue, period]);
+
+  return { revenueData, isLoading, error };
+}
+
+export function useOrderAnalytics() {
+  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
+    useMoveTheWheels();
+  const [orderData, setOrderData] = useState({
+    byStatus: [] as Array<{ status: string; count: number }>,
+    byType: [] as Array<{ type: string; count: number }>,
+    byPriority: [] as Array<{ priority: string; count: number }>,
+    trends: [] as Array<{ date: string; orders: number }>,
+  });
+  const [isLoading, setIsLoading] = 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]
+  );
+
+  useEffect(() => {
+    const load = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const data = await executeGraphQL<{
+          orderStats: {
+            pending: number;
+            inTransit: number;
+            delivered: number;
+            cancelled: number;
+            failed: number;
+          };
+          analytics: {
+            orderTrend: Array<{ label: string; value: number }>;
+          };
+        }>(graphQLOptions, ORDER_ANALYTICS_QUERY);
+
+        setOrderData({
+          byStatus: [
+            { status: 'pending', count: data.orderStats.pending },
+            { status: 'in_transit', count: data.orderStats.inTransit },
+            { status: 'delivered', count: data.orderStats.delivered },
+            { status: 'cancelled', count: data.orderStats.cancelled },
+            { status: 'failed', count: data.orderStats.failed },
+          ],
+          byType: [],
+          byPriority: [],
+          trends: data.analytics.orderTrend.map((item) => ({
+            date: item.label,
+            orders: Math.round(item.value),
+          })),
+        });
+      } catch (fetchError) {
+        setError(
+          fetchError instanceof Error ? fetchError : new Error('Failed to load order analytics')
+        );
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    void load();
+  }, [graphQLOptions]);
+
+  return { orderData, isLoading, error };
+}
+
+export function useFleetAnalytics() {
+  const { analytics, isLoading, error } = useAnalytics();
+
+  const fleetData = useMemo(
+    () => ({
+      vehicleUtilization: analytics.fleet.utilization,
+      avgFuelLevel: 0,
+      vehiclesByType: [] as Array<{ type: string; count: number }>,
+      driverPerformance: [] as Array<{
+        id: string;
+        name: string;
+        completedOrders: number;
+        rating: number;
+        onTimeRate: number;
+      }>,
+      fleetStats: analytics.fleet,
+    }),
+    [analytics.fleet]
+  );
+
+  return { fleetData, isLoading, error };
+}
+
+export function usePerformanceAnalytics() {
+  const { analytics, isLoading, error } = useAnalytics();
+
+  const performanceData = useMemo(
+    () => ({
+      ...analytics.performance,
+      driverRatings: [] as Array<{
+        name: string;
+        overall: number;
+        punctuality: number;
+        communication: number;
+        handling: number;
+      }>,
+    }),
+    [analytics.performance]
+  );
+
+  return { performanceData, isLoading, error };
+}