@burdenoff/microfe-movethewheels 2026.827.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 ?? {}`