@burdenoff/microfe-movethewheels 2026.827.1 → 2026.830.1

package/src/movethewheels/MoveTheWheelsRoot.tsx

@@ -30,6 +30,7 @@ import { MoveTheWheelsProvider } from './providers/MoveTheWheelsProvider';
 import { FeatureFlagProvider, useFeatureFlag } from '@burdenoff/fe-libs/shared/feature-flags';
 import type { NavItem, MoveTheWheelsRootProps } from './types';
 import { MoveTheWheelsRoutes } from './MoveTheWheelsRoutes';
+import { useTr } from './hooks';
 
 /**
  * Registers the MoveTheWheels sidebar nav tree with the host shell.
@@ -43,6 +44,8 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
   registerNavItems,
   basePath = '/',
 }) => {
+  const tr = useTr();
+
   // The backend has no ServiceProvider/ServiceOffering model (dropped by
   // migration 20260707000001_movethewheels_reuse_cleanup) — hide the
   // Marketplace nav entry until a serviceProviders/serviceOfferings resolver
@@ -62,7 +65,7 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
 
     const movethewheelsNavItem: NavItem = {
       id: 'movethewheels',
-      label: 'MoveTheWheels',
+      label: tr('movethewheels.page.title', 'MoveTheWheels'),
       path: basePath,
       icon: <Truck size={20} />,
       order: 25,
@@ -70,49 +73,49 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
       children: [
         {
           id: 'mtw-dashboard',
-          label: 'Dashboard',
+          label: tr('movethewheels.root.nav.dashboard', 'Dashboard'),
           path: basePath,
           icon: <LayoutDashboard size={16} />,
           order: 1,
         },
         {
           id: 'mtw-orders',
-          label: 'Orders',
+          label: tr('movethewheels.root.nav.orders', 'Orders'),
           path: joinPath(basePath, 'orders'),
           icon: <Package size={16} />,
           order: 2,
         },
         {
           id: 'mtw-tracking',
-          label: 'Tracking',
+          label: tr('movethewheels.root.nav.tracking', 'Tracking'),
           path: joinPath(basePath, 'tracking'),
           icon: <Map size={16} />,
           order: 3,
         },
         {
           id: 'mtw-fleet',
-          label: 'Fleet',
+          label: tr('movethewheels.root.nav.fleet', 'Fleet'),
           path: joinPath(basePath, 'fleet'),
           icon: <Truck size={16} />,
           order: 4,
           children: [
             {
               id: 'mtw-fleet-overview',
-              label: 'Overview',
+              label: tr('movethewheels.root.nav.overview', 'Overview'),
               path: joinPath(basePath, 'fleet'),
               icon: <LayoutDashboard size={14} />,
               order: 1,
             },
             {
               id: 'mtw-vehicles',
-              label: 'Vehicles',
+              label: tr('movethewheels.root.nav.vehicles', 'Vehicles'),
               path: joinPath(basePath, 'fleet/vehicles'),
               icon: <Car size={14} />,
               order: 2,
             },
             {
               id: 'mtw-drivers',
-              label: 'Drivers',
+              label: tr('movethewheels.root.nav.drivers', 'Drivers'),
               path: joinPath(basePath, 'fleet/drivers'),
               icon: <UserCheck size={14} />,
               order: 3,
@@ -121,28 +124,28 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
         },
         {
           id: 'mtw-inventory',
-          label: 'Inventory',
+          label: tr('movethewheels.root.nav.inventory', 'Inventory'),
           path: joinPath(basePath, 'inventory'),
           icon: <Warehouse size={16} />,
           order: 5,
           children: [
             {
               id: 'mtw-inventory-overview',
-              label: 'Overview',
+              label: tr('movethewheels.root.nav.overview', 'Overview'),
               path: joinPath(basePath, 'inventory'),
               icon: <LayoutDashboard size={14} />,
               order: 1,
             },
             {
               id: 'mtw-products',
-              label: 'Products',
+              label: tr('movethewheels.root.nav.products', 'Products'),
               path: joinPath(basePath, 'inventory/products'),
               icon: <Boxes size={14} />,
               order: 2,
             },
             {
               id: 'mtw-warehouses',
-              label: 'Warehouses',
+              label: tr('movethewheels.root.nav.warehouses', 'Warehouses'),
               path: joinPath(basePath, 'inventory/warehouses'),
               icon: <Warehouse size={14} />,
               order: 3,
@@ -151,28 +154,28 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
         },
         {
           id: 'mtw-customers',
-          label: 'Customers',
+          label: tr('movethewheels.root.nav.customers', 'Customers'),
           path: joinPath(basePath, 'customers'),
           icon: <Users size={16} />,
           order: 6,
         },
         {
           id: 'mtw-routes',
-          label: 'Routes',
+          label: tr('movethewheels.root.nav.routes', 'Routes'),
           path: joinPath(basePath, 'routes'),
           icon: <Route size={16} />,
           order: 7,
         },
         {
           id: 'mtw-analytics',
-          label: 'Analytics',
+          label: tr('movethewheels.root.nav.analytics', 'Analytics'),
           path: joinPath(basePath, 'analytics'),
           icon: <BarChart3 size={16} />,
           order: 8,
         },
         {
           id: 'mtw-finance',
-          label: 'Finance',
+          label: tr('movethewheels.root.nav.finance', 'Finance'),
           path: joinPath(basePath, 'finance'),
           icon: <DollarSign size={16} />,
           order: 9,
@@ -183,7 +186,7 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
           ? [
               {
                 id: 'mtw-marketplace',
-                label: 'Marketplace',
+                label: tr('movethewheels.root.nav.marketplace', 'Marketplace'),
                 path: joinPath(basePath, 'marketplace'),
                 icon: <Store size={16} />,
                 order: 10,
@@ -192,28 +195,28 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
           : []),
         {
           id: 'mtw-import-export',
-          label: 'Import/Export',
+          label: tr('movethewheels.root.nav.importExport', 'Import/Export'),
           path: joinPath(basePath, 'import-export'),
           icon: <Globe size={16} />,
           order: 11,
         },
         {
           id: 'mtw-reports',
-          label: 'Reports',
+          label: tr('movethewheels.root.nav.reports', 'Reports'),
           path: joinPath(basePath, 'reports'),
           icon: <FileText size={16} />,
           order: 12,
         },
         {
           id: 'mtw-ai-assistant',
-          label: 'AI Assistant',
+          label: tr('movethewheels.root.nav.aiAssistant', 'AI Assistant'),
           path: joinPath(basePath, 'ai-assistant'),
           icon: <Bot size={16} />,
           order: 13,
         },
         {
           id: 'mtw-settings',
-          label: 'Settings',
+          label: tr('movethewheels.root.nav.settings', 'Settings'),
           path: joinPath(basePath, 'settings'),
           icon: <Settings size={16} />,
           order: 99,
@@ -226,7 +229,7 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
 
     // Return cleanup function to unregister on unmount
     return cleanup;
-  }, [registerNavItems, basePath, marketplaceEnabled]);
+  }, [registerNavItems, basePath, marketplaceEnabled, tr]);
 
   return null;
 };
@@ -254,6 +257,7 @@ const NavRegistrar: FC<Pick<MoveTheWheelsRootProps, 'registerNavItems' | 'basePa
  */
 export const MoveTheWheelsRoot: FC<MoveTheWheelsRootProps> = (props) => {
   const { registerNavItems, registerFooterItems, basePath = '/' } = props;
+  const tr = useTr();
 
   // Register footer items
   useEffect(() => {
@@ -262,7 +266,7 @@ export const MoveTheWheelsRoot: FC<MoveTheWheelsRootProps> = (props) => {
     const footerItems = [
       {
         id: 'mtw-status',
-        label: 'Logistics Ready',
+        label: tr('movethewheels.root.footer.status', 'Logistics Ready'),
         type: 'status' as const,
         order: 20,
         section: 'left' as const,
@@ -271,7 +275,7 @@ export const MoveTheWheelsRoot: FC<MoveTheWheelsRootProps> = (props) => {
 
     const cleanup = registerFooterItems(footerItems);
     return cleanup;
-  }, [registerFooterItems]);
+  }, [registerFooterItems, tr]);
 
   return (
     <FeatureFlagProvider workspaceId={null} gateway="global" defaultEnabled={true}>

package/src/movethewheels/MoveTheWheelsRoutes.tsx

@@ -9,6 +9,7 @@ import { Routes, Route, useNavigate } from 'react-router';
 import { lazy, Suspense } from 'react';
 import { NotFoundPage } from '@burdenoff/fe-libs/shared/pages';
 import { useMoveTheWheels } from './providers/MoveTheWheelsProvider';
+import { useTr } from './hooks';
 
 /**
  * Catch-all 404 rendered inside the content area (previously a redirect to ""
@@ -18,9 +19,10 @@ import { useMoveTheWheels } from './providers/MoveTheWheelsProvider';
 function MoveTheWheelsNotFound() {
   const { navigate, basePath } = useMoveTheWheels();
   const routerNavigate = useNavigate();
+  const tr = useTr();
   return (
     <NotFoundPage
-      homeLabel="Back to MoveTheWheels"
+      homeLabel={tr('movethewheels.root.notFound.homeLabel', 'Back to MoveTheWheels')}
       onGoHome={() => {
         if (navigate) {
           navigate(basePath || '/');
@@ -34,11 +36,12 @@ function MoveTheWheelsNotFound() {
 
 // Loading fallback
 function PageLoader() {
+  const tr = useTr();
   return (
     <div className="flex items-center justify-center min-h-[400px]">
       <div className="flex flex-col items-center gap-3">
         <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-primary"></div>
-        <p className="text-sm text-text-secondary">Loading...</p>
+        <p className="text-sm text-text-secondary">{tr('movethewheels.root.loading', 'Loading...')}</p>
       </div>
     </div>
   );

package/src/movethewheels/hooks/index.ts

@@ -4,6 +4,9 @@
  * All custom hooks for data access and operations.
  */
 
+// Shared i18n helper
+export { useTr } from '../shared/hooks/useTr';
+
 // Orders
 export { useOrders, useOrder, useOrderStats } from './useOrders';
 

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 };

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,
+  };
 }