fix(ui): export a typed MOCK_SUBGRAPHS map from the mock data module (#1763)

packages/node-ui/src/ui/mocks/data.ts

@@ -1,4 +1,4 @@
-import type { NotificationsFeedResponse } from '../api.js';
+import type { NotificationsFeedResponse, SubGraphInfo } from '../api.js';
 
 export const MOCK_STATUS = {
   name: 'my-dkg-node',
@@ -198,3 +198,53 @@ export const MOCK_SESSIONS = {
     },
   ],
 };
+
+// GH#1763 — mock sub-graph lists keyed by CG id, mirroring the real
+// `/api/sub-graph/list` response shape. `provider.ts` previously reached for
+// this map through `(mock as any).MOCK_SUBGRAPHS`, which the module never
+// exported: the optional lookup kept mock mode from crashing, but the
+// per-CG override the comment promised could never fire and the production
+// Vite build emitted a missing-export warning on every run.
+//
+// Only CGs whose sub-graph UI is worth exercising need an entry — the
+// provider falls back to an empty list for anything absent, which is what
+// `cg:supply-chain-eu` deliberately exercises.
+export const MOCK_SUBGRAPHS: Record<
+  string,
+  { contextGraphId: string; subGraphs: SubGraphInfo[] }
+> = {
+  'cg:pharma-drug-interactions': {
+    contextGraphId: 'cg:pharma-drug-interactions',
+    subGraphs: [
+      {
+        name: 'Interactions',
+        uri: 'cg:pharma-drug-interactions/interactions',
+        description: 'Pairwise drug interaction records',
+        createdBy: 'did:dkg:agent:0x1111111111111111111111111111111111111111',
+        createdAt: '2026-04-02T09:15:00Z',
+        entityCount: 148,
+        tripleCount: 1721,
+      },
+      {
+        name: 'Contraindications',
+        uri: 'cg:pharma-drug-interactions/contraindications',
+        createdBy: 'did:dkg:agent:0x2222222222222222222222222222222222222222',
+        createdAt: '2026-04-05T16:40:00Z',
+        entityCount: 79,
+        tripleCount: 604,
+      },
+    ],
+  },
+  'cg:climate-science': {
+    contextGraphId: 'cg:climate-science',
+    subGraphs: [
+      {
+        name: 'Arctic Ice',
+        uri: 'cg:climate-science/arctic-ice',
+        description: 'Sea-ice extent projections',
+        entityCount: 32,
+        tripleCount: 410,
+      },
+    ],
+  },
+};

packages/node-ui/src/ui/mocks/provider.ts

@@ -20,7 +20,7 @@ export const mockApi = {
   // sitting at "..." after a real /sub-graph/list 404. Default to an
   // empty list; per-CG mocks can override via MOCK_SUBGRAPHS.
   fetchSubGraphs: (id: string) =>
-    delay((mock as any).MOCK_SUBGRAPHS?.[id] ?? { contextGraphId: id, subGraphs: [] }),
+    delay(mock.MOCK_SUBGRAPHS[id] ?? { contextGraphId: id, subGraphs: [] }),
   fetchNotificationsFeed: () => delay(mock.MOCK_NOTIFICATIONS_FEED),
   fetchNodeLog: () => delay(mock.MOCK_NODE_LOG),
   fetchMemorySessions: () => delay(mock.MOCK_SESSIONS),

packages/node-ui/test/mock-provider-subgraphs.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+import { MOCK_CONTEXT_GRAPHS, MOCK_SUBGRAPHS } from '../src/ui/mocks/data.js';
+import { mockApi } from '../src/ui/mocks/provider.js';
+
+// GH#1763 — `provider.ts` used to read `(mock as any).MOCK_SUBGRAPHS`, a symbol
+// `data.ts` never exported. The optional lookup stopped mock mode from
+// crashing, so the only visible symptom was a Vite missing-export warning on
+// every production build — and the per-CG override the provider's own comment
+// advertised silently could not work. These tests pin both halves of the
+// contract so the export cannot regress back into an untyped lookup.
+describe('mockApi.fetchSubGraphs (GH#1763)', () => {
+  it('exports a typed MOCK_SUBGRAPHS map from the mock data module', () => {
+    expect(MOCK_SUBGRAPHS).toBeDefined();
+    expect(typeof MOCK_SUBGRAPHS).toBe('object');
+  });
+
+  it('returns the per-context-graph override when one is defined', async () => {
+    const result = await mockApi.fetchSubGraphs('cg:pharma-drug-interactions');
+
+    expect(result).toEqual(MOCK_SUBGRAPHS['cg:pharma-drug-interactions']);
+    expect(result.contextGraphId).toBe('cg:pharma-drug-interactions');
+    expect(result.subGraphs).toHaveLength(2);
+    expect(result.subGraphs.map((s) => s.name)).toEqual(['Interactions', 'Contraindications']);
+  });
+
+  it('falls back to an empty list for a context graph with no override', async () => {
+    // `cg:supply-chain-eu` is a real mock CG deliberately left out of
+    // MOCK_SUBGRAPHS so the fallback path stays covered.
+    expect(MOCK_SUBGRAPHS['cg:supply-chain-eu']).toBeUndefined();
+
+    const result = await mockApi.fetchSubGraphs('cg:supply-chain-eu');
+
+    expect(result).toEqual({ contextGraphId: 'cg:supply-chain-eu', subGraphs: [] });
+  });
+
+  it('falls back to an empty list for an entirely unknown context graph', async () => {
+    const result = await mockApi.fetchSubGraphs('cg:does-not-exist');
+
+    expect(result).toEqual({ contextGraphId: 'cg:does-not-exist', subGraphs: [] });
+  });
+
+  it('keys every override by its own contextGraphId, matching the real response shape', () => {
+    for (const [id, entry] of Object.entries(MOCK_SUBGRAPHS)) {
+      expect(entry.contextGraphId).toBe(id);
+      for (const subGraph of entry.subGraphs) {
+        expect(typeof subGraph.name).toBe('string');
+        expect(typeof subGraph.uri).toBe('string');
+        expect(Number.isFinite(subGraph.entityCount)).toBe(true);
+        expect(Number.isFinite(subGraph.tripleCount)).toBe(true);
+      }
+    }
+  });
+
+  it('only overrides context graphs that mock mode actually lists', () => {
+    const knownCgIds = new Set(MOCK_CONTEXT_GRAPHS.contextGraphs.map((cg) => cg.id));
+    for (const id of Object.keys(MOCK_SUBGRAPHS)) {
+      expect(knownCgIds.has(id)).toBe(true);
+    }
+  });
+});