@burdenoff/microfe-movethewheels 2026.510.105

package/src/movethewheels/hooks/useOrders.ts

@@ -0,0 +1,703 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
+import type { Order, OrderFilter, OrderStatus } from '../types';
+import { executeGraphQL } from '../utils/graphqlClient';
+
+interface UseOrdersOptions {
+  filters?: OrderFilter;
+  limit?: number;
+  offset?: number;
+}
+
+interface UseOrdersResult {
+  orders: Order[];
+  totalOrders: number;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => void;
+  createOrder: (order: Partial<Order>) => Promise<Order>;
+  updateOrder: (id: string, updates: Partial<Order>) => Promise<Order>;
+  deleteOrder: (id: string) => Promise<void>;
+  updateOrderStatus: (id: string, status: OrderStatus) => Promise<Order>;
+}
+
+interface ApiOrder {
+  id: string;
+  orderNumber: string;
+  customerId: string;
+  orderType: string;
+  status: string;
+  priority: string;
+  pickupAddress: Record<string, unknown> | null;
+  deliveryAddress: Record<string, unknown> | null;
+  items: unknown;
+  pricing: unknown;
+  trackingNumber?: string | null;
+  specialInstructions?: string | null;
+  scheduledDelivery?: string | null;
+  vehicleId?: string | null;
+  driverId?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  customer?: {
+    name?: string | null;
+    email?: string | null;
+    phone?: string | null;
+    company?: string | null;
+  } | null;
+  statusHistory?: Array<{
+    status: string;
+    notes?: string | null;
+    location?: Record<string, unknown> | null;
+    createdAt: string;
+    createdBy?: string | null;
+  }>;
+}
+
+const LIST_ORDERS_QUERY = `
+  query ListMovethewheelsOrders($filter: OrderFilterInput, $pagination: PaginationInput) {
+    movethewheelsOrders(filter: $filter, pagination: $pagination) {
+      id
+      orderNumber
+      customerId
+      orderType
+      status
+      priority
+      pickupAddress
+      deliveryAddress
+      items
+      pricing
+      trackingNumber
+      specialInstructions
+      scheduledDelivery
+      vehicleId
+      driverId
+      createdAt
+      updatedAt
+      customer {
+        name
+        email
+        phone
+        company
+      }
+      statusHistory {
+        status
+        notes
+        location
+        createdAt
+        createdBy
+      }
+    }
+  }
+`;
+
+const GET_ORDER_QUERY = `
+  query GetMovethewheelsOrder($id: ID!) {
+    movethewheelsOrder(id: $id) {
+      id
+      orderNumber
+      customerId
+      orderType
+      status
+      priority
+      pickupAddress
+      deliveryAddress
+      items
+      pricing
+      trackingNumber
+      specialInstructions
+      scheduledDelivery
+      vehicleId
+      driverId
+      createdAt
+      updatedAt
+      customer {
+        name
+        email
+        phone
+        company
+      }
+      statusHistory {
+        status
+        notes
+        location
+        createdAt
+        createdBy
+      }
+    }
+  }
+`;
+
+const ORDER_STATS_QUERY = `
+  query GetOrderStatsBundle {
+    orderStats {
+      total
+      pending
+      inTransit
+      delivered
+      cancelled
+      failed
+    }
+    financeMetrics {
+      revenue {
+        totalRevenue
+        averageOrderValue
+      }
+    }
+  }
+`;
+
+const CREATE_ORDER_MUTATION = `
+  mutation CreateMovethewheelsOrder($input: CreateOrderInput!) {
+    createMovethewheelsOrder(input: $input) {
+      id
+      orderNumber
+      customerId
+      orderType
+      status
+      priority
+      pickupAddress
+      deliveryAddress
+      items
+      pricing
+      trackingNumber
+      specialInstructions
+      scheduledDelivery
+      vehicleId
+      driverId
+      createdAt
+      updatedAt
+      customer {
+        name
+        email
+        phone
+        company
+      }
+      statusHistory {
+        status
+        notes
+        location
+        createdAt
+        createdBy
+      }
+    }
+  }
+`;
+
+const UPDATE_ORDER_MUTATION = `
+  mutation UpdateMovethewheelsOrder($id: ID!, $input: UpdateOrderInput!) {
+    updateMovethewheelsOrder(id: $id, input: $input) {
+      id
+      orderNumber
+      customerId
+      orderType
+      status
+      priority
+      pickupAddress
+      deliveryAddress
+      items
+      pricing
+      trackingNumber
+      specialInstructions
+      scheduledDelivery
+      vehicleId
+      driverId
+      createdAt
+      updatedAt
+      customer {
+        name
+        email
+        phone
+        company
+      }
+      statusHistory {
+        status
+        notes
+        location
+        createdAt
+        createdBy
+      }
+    }
+  }
+`;
+
+const UPDATE_ORDER_STATUS_MUTATION = `
+  mutation UpdateMovethewheelsOrderStatus($id: ID!, $input: UpdateOrderStatusInput!) {
+    updateMovethewheelsOrderStatus(id: $id, input: $input) {
+      id
+      orderNumber
+      customerId
+      orderType
+      status
+      priority
+      pickupAddress
+      deliveryAddress
+      items
+      pricing
+      trackingNumber
+      specialInstructions
+      scheduledDelivery
+      vehicleId
+      driverId
+      createdAt
+      updatedAt
+      customer {
+        name
+        email
+        phone
+        company
+      }
+      statusHistory {
+        status
+        notes
+        location
+        createdAt
+        createdBy
+      }
+    }
+  }
+`;
+
+const DELETE_ORDER_MUTATION = `
+  mutation DeleteMovethewheelsOrder($id: ID!) {
+    deleteMovethewheelsOrder(id: $id)
+  }
+`;
+
+function mapOrderStatus(status: string): OrderStatus {
+  switch (status) {
+    case 'PENDING':
+      return 'pending';
+    case 'CONFIRMED':
+      return 'confirmed';
+    case 'ASSIGNED':
+      return 'assigned';
+    case 'PICKED_UP':
+      return 'picked_up';
+    case 'IN_TRANSIT':
+      return 'in_transit';
+    case 'OUT_FOR_DELIVERY':
+      return 'out_for_delivery';
+    case 'DELIVERED':
+      return 'delivered';
+    case 'CANCELLED':
+      return 'cancelled';
+    default:
+      return 'failed';
+  }
+}
+
+function mapOrderType(type: string): 'b2b' | 'b2c' {
+  return type === 'B2B' ? 'b2b' : 'b2c';
+}
+
+function mapOrderPriority(priority: string): 'low' | 'normal' | 'high' | 'urgent' {
+  switch (priority) {
+    case 'LOW':
+      return 'low';
+    case 'HIGH':
+      return 'high';
+    case 'URGENT':
+    case 'CRITICAL':
+      return 'urgent';
+    default:
+      return 'normal';
+  }
+}
+
+function toApiStatus(status: OrderStatus): string {
+  switch (status) {
+    case 'pending':
+      return 'PENDING';
+    case 'confirmed':
+      return 'CONFIRMED';
+    case 'assigned':
+      return 'ASSIGNED';
+    case 'picked_up':
+      return 'PICKED_UP';
+    case 'in_transit':
+      return 'IN_TRANSIT';
+    case 'out_for_delivery':
+      return 'OUT_FOR_DELIVERY';
+    case 'delivered':
+      return 'DELIVERED';
+    case 'cancelled':
+      return 'CANCELLED';
+    default:
+      return 'FAILED';
+  }
+}
+
+function toApiOrderType(orderType: 'b2b' | 'b2c' | undefined): string {
+  return orderType === 'b2b' ? 'B2B' : 'B2C';
+}
+
+function toApiPriority(priority: 'low' | 'normal' | 'high' | 'urgent' | undefined): string {
+  switch (priority) {
+    case 'low':
+      return 'LOW';
+    case 'high':
+      return 'HIGH';
+    case 'urgent':
+      return 'URGENT';
+    default:
+      return 'MEDIUM';
+  }
+}
+
+function mapAddress(address: Record<string, unknown> | null | undefined): Order['pickupAddress'] {
+  return {
+    street: '',
+    city: '',
+    state: '',
+    postalCode: '',
+    country: '',
+    ...(address ?? {}),
+  } as Order['pickupAddress'];
+}
+
+function mapOrder(order: ApiOrder): Order {
+  return {
+    id: order.id,
+    orderNumber: order.orderNumber,
+    customerId: order.customerId,
+    customerInfo: {
+      name: order.customer?.name ?? 'Unknown Customer',
+      email: order.customer?.email ?? '',
+      phone: order.customer?.phone ?? '',
+      company: order.customer?.company ?? undefined,
+    },
+    items: Array.isArray(order.items) ? (order.items as Order['items']) : [],
+    status: mapOrderStatus(order.status),
+    orderType: mapOrderType(order.orderType),
+    priority: mapOrderPriority(order.priority),
+    pickupAddress: mapAddress(order.pickupAddress),
+    deliveryAddress: mapAddress(order.deliveryAddress),
+    trackingNumber: order.trackingNumber ?? '',
+    specialInstructions: order.specialInstructions ?? undefined,
+    pricing: {
+      subtotal: 0,
+      taxes: 0,
+      fees: { delivery: 0, handling: 0 },
+      total: 0,
+      currency: 'USD',
+      paymentMethod: 'unknown',
+      paymentStatus: 'pending',
+      ...(typeof order.pricing === 'object' && order.pricing !== null ? order.pricing : {}),
+    } as Order['pricing'],
+    timeline:
+      order.statusHistory?.map((entry) => ({
+        timestamp: new Date(entry.createdAt),
+        status: mapOrderStatus(entry.status),
+        location: entry.location as Order['timeline'][number]['location'],
+        notes: entry.notes ?? undefined,
+        performedBy: entry.createdBy ?? 'system',
+      })) ?? [],
+    scheduledDelivery: order.scheduledDelivery ? new Date(order.scheduledDelivery) : undefined,
+    vehicleId: order.vehicleId ?? undefined,
+    driverId: order.driverId ?? undefined,
+    createdAt: new Date(order.createdAt),
+    updatedAt: new Date(order.updatedAt),
+  };
+}
+
+export function useOrders(options: UseOrdersOptions = {}): UseOrdersResult {
+  const { filters, limit = 20, offset = 0 } = options;
+  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
+    useMoveTheWheels();
+
+  const [orders, setOrders] = useState<Order[]>([]);
+  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 loadOrders = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{
+        movethewheelsOrders: ApiOrder[];
+      }>(graphQLOptions, LIST_ORDERS_QUERY, {
+        filter: {
+          status: filters?.status ? toApiStatus(filters.status) : undefined,
+          priority: filters?.priority
+            ? toApiPriority(filters.priority as 'low' | 'normal' | 'high' | 'urgent')
+            : undefined,
+          orderType: filters?.orderType ? toApiOrderType(filters.orderType) : undefined,
+          customerId: filters?.customerId,
+          driverId: filters?.driverId,
+        },
+        pagination: { limit, offset },
+      });
+
+      setOrders(data.movethewheelsOrders.map(mapOrder));
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load orders'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [filters, graphQLOptions, limit, offset]);
+
+  useEffect(() => {
+    void loadOrders();
+  }, [loadOrders]);
+
+  const refetch = useCallback(() => {
+    void loadOrders();
+  }, [loadOrders]);
+
+  const createOrder = useCallback(
+    async (orderData: Partial<Order>): Promise<Order> => {
+      const orderNumber =
+        orderData.orderNumber ??
+        `ORD-${new Date().getFullYear()}-${Date.now().toString().slice(-6)}`;
+
+      const data = await executeGraphQL<{
+        createMovethewheelsOrder: ApiOrder;
+      }>(graphQLOptions, CREATE_ORDER_MUTATION, {
+        input: {
+          orderNumber,
+          orderType: toApiOrderType(orderData.orderType),
+          status: toApiStatus(orderData.status ?? 'pending'),
+          priority: toApiPriority(orderData.priority),
+          customerId: orderData.customerId,
+          pickupAddress: orderData.pickupAddress ?? {},
+          deliveryAddress: orderData.deliveryAddress ?? {},
+          items: orderData.items ?? [],
+          pricing: orderData.pricing ?? null,
+          specialInstructions: orderData.specialInstructions,
+          trackingNumber: orderData.trackingNumber,
+          scheduledDelivery: orderData.scheduledDelivery?.toISOString(),
+          vehicleId: orderData.vehicleId,
+          driverId: orderData.driverId,
+        },
+      });
+
+      const created = mapOrder(data.createMovethewheelsOrder);
+      setOrders((previous) => [created, ...previous]);
+      return created;
+    },
+    [graphQLOptions]
+  );
+
+  const updateOrder = useCallback(
+    async (id: string, updates: Partial<Order>): Promise<Order> => {
+      const data = await executeGraphQL<{
+        updateMovethewheelsOrder: ApiOrder;
+      }>(graphQLOptions, UPDATE_ORDER_MUTATION, {
+        id,
+        input: {
+          orderType: updates.orderType ? toApiOrderType(updates.orderType) : undefined,
+          status: updates.status ? toApiStatus(updates.status) : undefined,
+          priority: updates.priority ? toApiPriority(updates.priority) : undefined,
+          customerId: updates.customerId,
+          pickupAddress: updates.pickupAddress,
+          deliveryAddress: updates.deliveryAddress,
+          items: updates.items,
+          pricing: updates.pricing,
+          specialInstructions: updates.specialInstructions,
+          trackingNumber: updates.trackingNumber,
+          scheduledDelivery: updates.scheduledDelivery?.toISOString(),
+          vehicleId: updates.vehicleId,
+          driverId: updates.driverId,
+        },
+      });
+
+      const updated = mapOrder(data.updateMovethewheelsOrder);
+      setOrders((previous) => previous.map((item) => (item.id === id ? updated : item)));
+      return updated;
+    },
+    [graphQLOptions]
+  );
+
+  const deleteOrder = useCallback(
+    async (id: string): Promise<void> => {
+      await executeGraphQL<{ deleteMovethewheelsOrder: boolean }>(
+        graphQLOptions,
+        DELETE_ORDER_MUTATION,
+        { id }
+      );
+      setOrders((previous) => previous.filter((item) => item.id !== id));
+    },
+    [graphQLOptions]
+  );
+
+  const updateOrderStatus = useCallback(
+    async (id: string, status: OrderStatus): Promise<Order> => {
+      const data = await executeGraphQL<{
+        updateMovethewheelsOrderStatus: ApiOrder;
+      }>(graphQLOptions, UPDATE_ORDER_STATUS_MUTATION, {
+        id,
+        input: {
+          status: toApiStatus(status),
+        },
+      });
+
+      const updated = mapOrder(data.updateMovethewheelsOrderStatus);
+      setOrders((previous) => previous.map((item) => (item.id === id ? updated : item)));
+      return updated;
+    },
+    [graphQLOptions]
+  );
+
+  return {
+    orders,
+    totalOrders: orders.length,
+    isLoading,
+    error,
+    refetch,
+    createOrder,
+    updateOrder,
+    deleteOrder,
+    updateOrderStatus,
+  };
+}
+
+export function useOrder(orderId: string | undefined) {
+  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
+    useMoveTheWheels();
+  const [order, setOrder] = useState<Order | null>(null);
+  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 loadOrder = useCallback(async () => {
+    if (!orderId) {
+      setOrder(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{
+        movethewheelsOrder: ApiOrder | null;
+      }>(graphQLOptions, GET_ORDER_QUERY, { id: orderId });
+
+      setOrder(data.movethewheelsOrder ? mapOrder(data.movethewheelsOrder) : null);
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load order'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions, orderId]);
+
+  useEffect(() => {
+    void loadOrder();
+  }, [loadOrder]);
+
+  const refetch = useCallback(() => {
+    void loadOrder();
+  }, [loadOrder]);
+
+  return { order, isLoading, error, refetch };
+}
+
+export function useOrderStats() {
+  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
+    useMoveTheWheels();
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [stats, setStats] = useState({
+    total: 0,
+    byStatus: {
+      pending: 0,
+      confirmed: 0,
+      assigned: 0,
+      picked_up: 0,
+      in_transit: 0,
+      out_for_delivery: 0,
+      delivered: 0,
+      cancelled: 0,
+      failed: 0,
+    },
+    totalRevenue: 0,
+    todayOrders: 0,
+    avgOrderValue: 0,
+  });
+
+  const graphQLOptions = useMemo(
+    () => ({
+      apiGatewayUrl,
+      authToken,
+      workspaceToken,
+      workspaceId,
+      tenantId,
+      actorId: currentUser?.id,
+    }),
+    [apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser?.id]
+  );
+
+  const loadStats = useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await executeGraphQL<{
+        orderStats: {
+          total: number;
+          pending: number;
+          inTransit: number;
+          delivered: number;
+          cancelled: number;
+          failed: number;
+        };
+        financeMetrics: {
+          revenue: {
+            totalRevenue: number;
+            averageOrderValue: number;
+          };
+        };
+      }>(graphQLOptions, ORDER_STATS_QUERY);
+
+      setStats({
+        total: data.orderStats.total,
+        byStatus: {
+          pending: data.orderStats.pending,
+          confirmed: 0,
+          assigned: 0,
+          picked_up: 0,
+          in_transit: data.orderStats.inTransit,
+          out_for_delivery: 0,
+          delivered: data.orderStats.delivered,
+          cancelled: data.orderStats.cancelled,
+          failed: data.orderStats.failed,
+        },
+        totalRevenue: data.financeMetrics.revenue.totalRevenue,
+        todayOrders: 0,
+        avgOrderValue: data.financeMetrics.revenue.averageOrderValue,
+      });
+    } catch (fetchError) {
+      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load order stats'));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [graphQLOptions]);
+
+  useEffect(() => {
+    void loadStats();
+  }, [loadStats]);
+
+  return { stats, isLoading, error };
+}