@burdenoff/microfe-movethewheels 2026.822.1 → 2026.828.1

package/src/movethewheels/hooks/useReports.ts

@@ -1,6 +1,5 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useState } from 'react';
 import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
-import { executeGraphQL } from '../utils/graphqlClient';
 
 export interface MovethewheelsReport {
   id: string;
@@ -20,46 +19,6 @@ export interface GeneratedReport {
   report: MovethewheelsReport;
 }
 
-const REPORT_FIELDS = `
-  id
-  name
-  description
-  type
-  status
-  schedule
-  lastGenerated
-  createdAt
-  updatedAt
-`;
-
-const LIST_REPORTS_QUERY = `
-  query MovethewheelsReports($filter: MovethewheelsReportFilterInput, $pagination: PaginationInput) {
-    movethewheelsReports(filter: $filter, pagination: $pagination) {
-      ${REPORT_FIELDS}
-    }
-  }
-`;
-
-const CREATE_REPORT_MUTATION = `
-  mutation CreateMovethewheelsReport($input: CreateMovethewheelsReportInput!) {
-    createMovethewheelsReport(input: $input) {
-      ${REPORT_FIELDS}
-    }
-  }
-`;
-
-const GENERATE_REPORT_MUTATION = `
-  mutation GenerateMovethewheelsReport($input: GenerateMovethewheelsReportInput!) {
-    generateMovethewheelsReport(input: $input) {
-      generatedAt
-      result
-      report {
-        ${REPORT_FIELDS}
-      }
-    }
-  }
-`;
-
 export interface CreateReportInput {
   name: string;
   type: string;
@@ -87,44 +46,60 @@ interface UseReportsResult {
   ) => Promise<GeneratedReport>;
 }
 
+function newId(): string {
+  if (typeof crypto !== 'undefined' && 'randomUUID' in crypto) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+
+function storageKey(workspaceId: string | undefined): string {
+  return `movethewheels:reports:${workspaceId ?? 'default'}`;
+}
+
+function readReports(workspaceId: string | undefined): MovethewheelsReport[] {
+  if (typeof window === 'undefined') return [];
+  try {
+    const raw = window.localStorage.getItem(storageKey(workspaceId));
+    if (!raw) return [];
+    const parsed = JSON.parse(raw) as MovethewheelsReport[];
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeReports(workspaceId: string | undefined, reports: MovethewheelsReport[]): void {
+  if (typeof window === 'undefined') return;
+  try {
+    window.localStorage.setItem(storageKey(workspaceId), JSON.stringify(reports));
+  } catch {
+    // Ignore storage errors.
+  }
+}
+
 export function useReports(options: UseReportsOptions = {}): UseReportsResult {
   const { limit = 100, offset = 0 } = options;
-  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
-    useMoveTheWheels();
+  const { workspaceId } = useMoveTheWheels();
   const [reports, setReports] = useState<MovethewheelsReport[]>([]);
   const [hasMore, setHasMore] = useState(false);
   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 () => {
+  const load = useCallback(() => {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ movethewheelsReports: MovethewheelsReport[] }>(
-        graphQLOptions,
-        LIST_REPORTS_QUERY,
-        { pagination: { limit, offset } }
-      );
-      setHasMore(data.movethewheelsReports.length === limit);
-      setReports(data.movethewheelsReports);
-    } catch (fetchError) {
-      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load reports'));
+      const all = readReports(workspaceId);
+      const page = all.slice(offset, offset + limit);
+      setHasMore(page.length === limit);
+      setReports(page);
+    } catch (loadError) {
+      setError(loadError instanceof Error ? loadError : new Error('Failed to load reports'));
     } finally {
       setIsLoading(false);
     }
-  }, [graphQLOptions, limit, offset]);
+  }, [workspaceId, limit, offset]);
 
   useEffect(() => {
     void load();
@@ -136,33 +111,44 @@ export function useReports(options: UseReportsOptions = {}): UseReportsResult {
 
   const createReport = useCallback(
     async (input: CreateReportInput): Promise<MovethewheelsReport> => {
-      const data = await executeGraphQL<{ createMovethewheelsReport: MovethewheelsReport }>(
-        graphQLOptions,
-        CREATE_REPORT_MUTATION,
-        { input }
-      );
-      const created = data.createMovethewheelsReport;
-      setReports((previous) => [created, ...previous]);
+      const now = new Date().toISOString();
+      const created: MovethewheelsReport = {
+        id: newId(),
+        name: input.name,
+        description: input.description ?? null,
+        type: input.type,
+        status: input.status ?? 'ready',
+        schedule: input.schedule ?? null,
+        lastGenerated: null,
+        createdAt: now,
+        updatedAt: now,
+      };
+      setReports((previous) => {
+        const next = [created, ...previous];
+        writeReports(workspaceId, next);
+        return next;
+      });
       return created;
     },
-    [graphQLOptions]
+    [workspaceId]
   );
 
   const generateReport = useCallback(
-    async (reportId: string, parameters?: Record<string, unknown>): Promise<GeneratedReport> => {
-      const data = await executeGraphQL<{ generateMovethewheelsReport: GeneratedReport }>(
-        graphQLOptions,
-        GENERATE_REPORT_MUTATION,
-        { input: { reportId, parameters } }
-      );
-      const generated = data.generateMovethewheelsReport;
-      setReports((previous) =>
-        previous.map((item) => (item.id === reportId ? generated.report : item))
+    async (_reportId: string, _parameters?: Record<string, unknown>): Promise<GeneratedReport> => {
+      throw new Error(
+        'Report generation is not available: the movethewheelsReports surface was withdrawn from the service.'
       );
-      return generated;
     },
-    [graphQLOptions]
+    []
   );
 
-  return { reports, hasMore, isLoading, error, refetch, createReport, generateReport };
+  return {
+    reports,
+    hasMore,
+    isLoading,
+    error,
+    refetch,
+    createReport,
+    generateReport,
+  };
 }

package/src/movethewheels/hooks/useSettings.ts

@@ -1,6 +1,5 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
-import { executeGraphQL } from '../utils/graphqlClient';
 
 export type ModulePreferences = Record<string, unknown>;
 
@@ -10,26 +9,6 @@ export interface ModuleSettings {
   workspaceId: string;
 }
 
-const MODULE_SETTINGS_QUERY = `
-  query MovethewheelsModuleSettings {
-    moduleSettings {
-      preferences
-      updatedAt
-      workspaceId
-    }
-  }
-`;
-
-const UPDATE_MODULE_SETTINGS_MUTATION = `
-  mutation UpdateMovethewheelsModuleSettings($input: UpdateMovethewheelsModuleSettingsInput!) {
-    updateModuleSettings(input: $input) {
-      preferences
-      updatedAt
-      workspaceId
-    }
-  }
-`;
-
 interface UseModuleSettingsResult {
   settings: ModuleSettings | null;
   preferences: ModulePreferences;
@@ -40,41 +19,58 @@ interface UseModuleSettingsResult {
   savePreferences: (preferences: ModulePreferences) => Promise<ModuleSettings>;
 }
 
+function readSettings(workspaceId: string): ModuleSettings | null {
+  if (typeof window === 'undefined') return null;
+  try {
+    const raw = window.localStorage.getItem(`movethewheels:moduleSettings:${workspaceId}`);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as ModuleSettings;
+    if (parsed && typeof parsed === 'object' && 'preferences' in parsed) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function writeSettings(settings: ModuleSettings): void {
+  if (typeof window === 'undefined') return;
+  try {
+    window.localStorage.setItem(
+      `movethewheels:moduleSettings:${settings.workspaceId}`,
+      JSON.stringify(settings)
+    );
+  } catch {
+    // Ignore storage errors (e.g. private mode quota).
+  }
+}
+
 export function useModuleSettings(): UseModuleSettingsResult {
-  const { apiGatewayUrl, authToken, workspaceToken, workspaceId, tenantId, currentUser } =
-    useMoveTheWheels();
+  const { workspaceId } = useMoveTheWheels();
   const [settings, setSettings] = useState<ModuleSettings | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [isSaving, setIsSaving] = 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 () => {
+  const load = useCallback(() => {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ moduleSettings: ModuleSettings }>(
-        graphQLOptions,
-        MODULE_SETTINGS_QUERY
+      const stored = workspaceId ? readSettings(workspaceId) : null;
+      setSettings(
+        stored ?? {
+          preferences: {},
+          updatedAt: new Date().toISOString(),
+          workspaceId: workspaceId ?? '',
+        }
       );
-      setSettings(data.moduleSettings);
-    } catch (fetchError) {
-      setError(fetchError instanceof Error ? fetchError : new Error('Failed to load settings'));
+    } catch (loadError) {
+      setError(loadError instanceof Error ? loadError : new Error('Failed to load settings'));
     } finally {
       setIsLoading(false);
     }
-  }, [graphQLOptions]);
+  }, [workspaceId]);
 
   useEffect(() => {
     void load();
@@ -89,23 +85,24 @@ export function useModuleSettings(): UseModuleSettingsResult {
       setIsSaving(true);
       setError(null);
       try {
-        const data = await executeGraphQL<{ updateModuleSettings: ModuleSettings }>(
-          graphQLOptions,
-          UPDATE_MODULE_SETTINGS_MUTATION,
-          { input: { preferences } }
-        );
-        setSettings(data.updateModuleSettings);
-        return data.updateModuleSettings;
-      } catch (fetchError) {
+        const next: ModuleSettings = {
+          preferences,
+          updatedAt: new Date().toISOString(),
+          workspaceId: workspaceId ?? '',
+        };
+        writeSettings(next);
+        setSettings(next);
+        return next;
+      } catch (saveError) {
         const normalized =
-          fetchError instanceof Error ? fetchError : new Error('Failed to save settings');
+          saveError instanceof Error ? saveError : new Error('Failed to save settings');
         setError(normalized);
         throw normalized;
       } finally {
         setIsSaving(false);
       }
     },
-    [graphQLOptions]
+    [workspaceId]
   );
 
   // Stabilize the preferences reference. Returning `settings?.preferences ?? {}`

package/src/movethewheels/hooks/useTracking.ts

@@ -30,7 +30,7 @@ interface ApiTrackingEvent {
 interface ApiShipment {
   id: string;
   shipmentNumber: string;
-  orderId: string;
+  deliveryJobId?: string | null;
   status: string;
   estimatedDelivery?: string | null;
   trackingEvents?: ApiTrackingEvent[];
@@ -41,7 +41,7 @@ const SHIPMENTS_QUERY = `
     shipments(filter: $filter, pagination: $pagination) {
       id
       shipmentNumber
-      orderId
+      deliveryJobId
       status
       estimatedDelivery
     }
@@ -53,7 +53,7 @@ const SHIPMENT_QUERY = `
     shipment(id: $id) {
       id
       shipmentNumber
-      orderId
+      deliveryJobId
       status
       estimatedDelivery
       trackingEvents {
@@ -68,9 +68,9 @@ const SHIPMENT_QUERY = `
   }
 `;
 
-const ORDER_TRACKING_QUERY = `
-  query GetOrderTracking($orderId: ID!) {
-    orderTracking(orderId: $orderId) {
+const DELIVERY_JOB_TRACKING_QUERY = `
+  query GetDeliveryJobTracking($deliveryJobId: ID!) {
+    deliveryJobTracking(deliveryJobId: $deliveryJobId) {
       id
       shipmentId
       eventType
@@ -86,7 +86,7 @@ const ACTIVE_DELIVERIES_QUERY = `
     activeDeliveries {
       id
       shipmentNumber
-      orderId
+      deliveryJobId
       status
       estimatedDelivery
     }
@@ -163,7 +163,7 @@ export function useTracking(options: UseTrackingOptions = {}): UseTrackingResult
 
       const mapped = data.shipments.map((shipment) => ({
         id: shipment.id,
-        entityId: shipment.orderId,
+        entityId: shipment.deliveryJobId ?? shipment.id,
         entityType: 'order' as const,
         currentLocation: {
           latitude: 0,
@@ -224,14 +224,14 @@ export function useOrderTracking(orderId: string | undefined) {
     setIsLoading(true);
     setError(null);
     try {
-      const data = await executeGraphQL<{ orderTracking: ApiTrackingEvent[] }>(
+      const data = await executeGraphQL<{ deliveryJobTracking: ApiTrackingEvent[] }>(
         graphQLOptions,
-        ORDER_TRACKING_QUERY,
+        DELIVERY_JOB_TRACKING_QUERY,
         {
-          orderId,
+          deliveryJobId: orderId,
         }
       );
-      const latest = data.orderTracking[data.orderTracking.length - 1];
+      const latest = data.deliveryJobTracking[data.deliveryJobTracking.length - 1];
       setTracking(latest ? mapTrackingEventToTracking(latest, orderId) : null);
     } catch (fetchError) {
       setError(
@@ -327,7 +327,7 @@ export function useLiveTracking() {
 
           const shipmentEvents = shipmentData.shipment?.trackingEvents ?? [];
           const latestEvent = shipmentEvents[shipmentEvents.length - 1];
-          const order = orders.find((item) => item.id === shipment.orderId);
+          const order = orders.find((item) => item.id === shipment.deliveryJobId);
           if (!order) {
             return null;
           }
@@ -346,7 +346,7 @@ export function useLiveTracking() {
             driver,
             vehicle,
             tracking: latestEvent
-              ? mapTrackingEventToTracking(latestEvent, shipment.orderId)
+              ? mapTrackingEventToTracking(latestEvent, shipment.deliveryJobId ?? shipment.id)
               : null,
             estimatedArrival: shipment.estimatedDelivery
               ? new Date(shipment.estimatedDelivery)

package/src/movethewheels/pages/CreateOrderPage.tsx

@@ -6,7 +6,7 @@
 
 import { useEffect, useState } from 'react';
 import { useParams } from 'react-router';
-import { Package, ArrowLeft, Save, Plus, Trash2, Users, MapPin } from 'lucide-react';
+import { Package, ArrowLeft, Save, Plus, Trash2, Users, MapPin, CalendarClock } from 'lucide-react';
 import { PageLayout, EmptyState } from '../components/PageLayout';
 import { FormError } from '../components/FormError';
 import {
@@ -31,6 +31,22 @@ import { useCustomers } from '../hooks/useCustomers';
 import { useMoveTheWheels } from '../providers/MoveTheWheelsProvider';
 import { joinPath } from '../utils/navigation';
 
+/**
+ * `<input type="datetime-local">` needs a `YYYY-MM-DDTHH:mm` string in LOCAL
+ * time — `Date.toISOString()` would shift the value by the UTC offset and show
+ * the operator a different slot than the one stored. Returns '' for no date.
+ */
+function toDateTimeLocalValue(date: Date | undefined): string {
+  if (!date || Number.isNaN(date.getTime())) {
+    return '';
+  }
+  const pad = (value: number) => String(value).padStart(2, '0');
+  return (
+    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+    `T${pad(date.getHours())}:${pad(date.getMinutes())}`
+  );
+}
+
 export default function CreateOrderPage() {
   const { orderId } = useParams<{ orderId: string }>();
   const { basePath, navigate } = useMoveTheWheels();
@@ -58,6 +74,7 @@ export default function CreateOrderPage() {
       country: order?.deliveryAddress.country || 'USA',
     },
     items: order?.items || [],
+    scheduledDelivery: toDateTimeLocalValue(order?.scheduledDelivery),
     specialInstructions: order?.specialInstructions || '',
   });
 
@@ -89,6 +106,7 @@ export default function CreateOrderPage() {
         country: order.deliveryAddress.country || 'USA',
       },
       items: order.items || [],
+      scheduledDelivery: toDateTimeLocalValue(order.scheduledDelivery),
       specialInstructions: order.specialInstructions || '',
     });
   }, [order]);
@@ -113,6 +131,9 @@ export default function CreateOrderPage() {
     if (formData.items.length === 0) {
       return 'Add at least one item to the order.';
     }
+    if (formData.scheduledDelivery && Number.isNaN(Date.parse(formData.scheduledDelivery))) {
+      return 'Enter a valid scheduled delivery date and time.';
+    }
     return null;
   };
 
@@ -146,6 +167,8 @@ export default function CreateOrderPage() {
         pickupAddress: formData.pickupAddress,
         deliveryAddress: formData.deliveryAddress,
         items: formData.items,
+        // `null` clears an existing slot on edit; the service field is nullable.
+        scheduledDelivery: formData.scheduledDelivery ? new Date(formData.scheduledDelivery) : null,
         specialInstructions: formData.specialInstructions,
       };
 
@@ -466,7 +489,7 @@ export default function CreateOrderPage() {
                 {formData.items.map((item, index) => (
                   <div key={item.id}>
                     {index > 0 && <Separator className="my-4" />}
-                    <div className="grid grid-cols-1 md:grid-cols-6 gap-4">
+                    <div className="grid grid-cols-1 md:grid-cols-7 gap-4">
                       <div className="md:col-span-2 space-y-2">
                         <Label>Item Name</Label>
                         <Input
@@ -494,6 +517,18 @@ export default function CreateOrderPage() {
                           }
                         />
                       </div>
+                      <div className="space-y-2">
+                        <Label>Weight (kg)</Label>
+                        <Input
+                          type="number"
+                          min="0"
+                          step="0.1"
+                          value={item.weight}
+                          onChange={(e) =>
+                            updateItem(index, 'weight', parseFloat(e.target.value) || 0)
+                          }
+                        />
+                      </div>
                       <div className="space-y-2">
                         <Label>Value ($)</Label>
                         <Input
@@ -525,18 +560,40 @@ export default function CreateOrderPage() {
           </CardContent>
         </Card>
 
-        {/* Special Instructions */}
+        {/* Scheduling & handling notes */}
         <Card>
           <CardHeader>
-            <CardTitle>Special Instructions</CardTitle>
+            <CardTitle>Scheduling &amp; Handling</CardTitle>
           </CardHeader>
           <CardContent>
-            <Textarea
-              value={formData.specialInstructions}
-              onChange={(e) => updateField('specialInstructions', e.target.value)}
-              placeholder="Any special handling or delivery instructions..."
-              rows={4}
-            />
+            <div className="grid grid-cols-1 md:grid-cols-3 gap-6">
+              <div className="space-y-2">
+                <Label htmlFor="scheduledDelivery" className="flex items-center gap-1.5">
+                  <CalendarClock size={14} className="text-text-secondary" />
+                  Scheduled Delivery
+                </Label>
+                <Input
+                  id="scheduledDelivery"
+                  type="datetime-local"
+                  value={formData.scheduledDelivery}
+                  onChange={(e) => updateField('scheduledDelivery', e.target.value)}
+                />
+                <p className="text-xs text-text-secondary">
+                  The delivery window promised to the customer. Leave blank to dispatch as soon as a
+                  driver is free.
+                </p>
+              </div>
+              <div className="md:col-span-2 space-y-2">
+                <Label htmlFor="specialInstructions">Special Instructions</Label>
+                <Textarea
+                  id="specialInstructions"
+                  value={formData.specialInstructions}
+                  onChange={(e) => updateField('specialInstructions', e.target.value)}
+                  placeholder="Any special handling or delivery instructions..."
+                  rows={4}
+                />
+              </div>
+            </div>
           </CardContent>
         </Card>
       </form>

package/src/movethewheels/pages/DeliveryCapturePage.tsx

@@ -38,6 +38,8 @@ import {
   Textarea,
 } from '../components/ui';
 import { SignaturePad, type SignaturePadHandle } from '../components/SignaturePad';
+import { StatusBadge, PriorityBadge } from '../components/StatusBadge';
+import { mapOrderPriority, mapOrderStatus } from '../hooks/useOrders';
 import { FormError } from '../components/FormError';
 import { Notice, useNotice } from '../components/Notice';
 import {
@@ -284,6 +286,12 @@ export default function DeliveryCapturePage() {
                     <p className="font-medium flex items-center gap-2">
                       <Package size={16} /> {job.deliveryJobNumber}
                     </p>
+                    {/* Stop state + urgency, straight off the job record — a driver
+                        needs to know which stop is already out for delivery. */}
+                    <div className="flex flex-wrap items-center gap-1.5 py-1">
+                      <StatusBadge status={mapOrderStatus(job.status)} type="order" size="sm" />
+                      <PriorityBadge priority={mapOrderPriority(job.priority)} size="sm" />
+                    </div>
                     {job.deliveryAddress && (
                       <p className="text-sm text-text-secondary truncate">
                         {formatAddress(job.deliveryAddress)}