github-issue-tower-defence-management 1.167.0 → 1.168.1

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleTabData.ts

@@ -16,6 +16,7 @@ export type ConsoleTabSnapshot = {
   storyColors: ConsoleStoryColorSource;
   stories: ConsoleStoryEntry[];
   defaultNameWithOwner: string | null;
+  fromCache: boolean;
 };
 
 export type ConsoleTabDataState = {
@@ -61,7 +62,9 @@ const parseStoryEntries = (value: unknown): ConsoleStoryEntry[] => {
   return value.filter(isRecord) as unknown as ConsoleStoryEntry[];
 };
 
-const parseSnapshot = (payload: unknown): ConsoleTabSnapshot => ({
+const parseSnapshotData = (
+  payload: unknown,
+): Omit<ConsoleTabSnapshot, 'fromCache'> => ({
   items: parseItems(payload),
   generatedAt:
     isRecord(payload) && typeof payload.generatedAt === 'string'
@@ -96,24 +99,106 @@ const buildListUrl = (pjcode: string, tab: ConsoleTabName): string =>
 
 export const CONSOLE_TAB_REFRESH_INTERVAL_MS = 60000;
 
+const CONSOLE_LIST_CACHE_NAME = 'console-list-v1';
+
+const persistListSnapshot = (url: string, payload: unknown): void => {
+  try {
+    if (!('caches' in globalThis)) {
+      return;
+    }
+    globalThis.caches
+      .open(CONSOLE_LIST_CACHE_NAME)
+      .then((cache) =>
+        cache.put(
+          url,
+          new Response(JSON.stringify(payload), {
+            headers: { 'Content-Type': 'application/json' },
+          }),
+        ),
+      )
+      .catch((e: unknown) => {
+        console.warn('Failed to persist tab snapshot to cache:', e);
+      });
+  } catch (e: unknown) {
+    console.warn('Failed to access cache storage:', e);
+  }
+};
+
+const loadListSnapshotFromCache = async (
+  url: string,
+): Promise<ConsoleTabSnapshot | null> => {
+  if (!('caches' in globalThis)) {
+    return null;
+  }
+  try {
+    const cache = await globalThis.caches.open(CONSOLE_LIST_CACHE_NAME);
+    const cached = await cache.match(url);
+    if (cached === undefined) {
+      return null;
+    }
+    const payload: unknown = await cached.json();
+    return { ...parseSnapshotData(payload), fromCache: true };
+  } catch {
+    return null;
+  }
+};
+
+const fetchSingleSnapshot = async (
+  pjcode: string,
+  tabName: ConsoleTabName,
+): Promise<{ snapshot: ConsoleTabSnapshot | null; error: Error | null }> => {
+  const url = buildListUrl(pjcode, tabName);
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const payload: unknown = await response.json();
+    persistListSnapshot(url, payload);
+    return {
+      snapshot: { ...parseSnapshotData(payload), fromCache: false },
+      error: null,
+    };
+  } catch (e: unknown) {
+    const cached = await loadListSnapshotFromCache(url);
+    if (cached !== null) {
+      return { snapshot: cached, error: null };
+    }
+    return {
+      snapshot: null,
+      error: e instanceof Error ? e : new Error(String(e)),
+    };
+  }
+};
+
 const fetchSnapshots = async (
   pjcode: string,
-): Promise<Record<ConsoleTabName, ConsoleTabSnapshot | null>> => {
-  const entries = await Promise.all(
+): Promise<{
+  snapshots: Record<ConsoleTabName, ConsoleTabSnapshot | null>;
+  firstError: Error | null;
+}> => {
+  const results = await Promise.all(
     CONSOLE_TABS.map(async (tab) => {
-      const response = await fetch(buildListUrl(pjcode, tab.name));
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const payload: unknown = await response.json();
-      return [tab.name, parseSnapshot(payload)] as const;
+      const { snapshot, error } = await fetchSingleSnapshot(pjcode, tab.name);
+      return { tabName: tab.name, snapshot, error };
     }),
   );
-  const next = emptySnapshots();
-  for (const [name, snapshot] of entries) {
-    next[name] = snapshot;
+
+  const snapshots = emptySnapshots();
+  let firstError: Error | null = null;
+
+  for (const { tabName, snapshot, error } of results) {
+    snapshots[tabName] = snapshot;
+    if (error !== null && firstError === null) {
+      firstError = error;
+    }
   }
-  return next;
+
+  const allNull = Object.values(snapshots).every((s) => s === null);
+  return {
+    snapshots,
+    firstError: allNull ? firstError : null,
+  };
 };
 
 export const useConsoleTabData = (
@@ -140,12 +225,12 @@ export const useConsoleTabData = (
 
     const load = (): void => {
       fetchSnapshots(pjcode)
-        .then((next) => {
+        .then(({ snapshots: next, firstError }) => {
           if (cancelled) {
             return;
           }
           setSnapshots(next);
-          setError(null);
+          setError(firstError !== null ? firstError.message : null);
           setIsLoading(false);
         })
         .catch((cause: unknown) => {

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.test.ts

@@ -25,7 +25,40 @@ const mockFetchFailureOnce = (status: number, rawBody: string): jest.Mock => {
   return fetchMock;
 };
 
+type MockCacheEntry = { json: jest.Mock };
+type MockCache = {
+  match: jest.Mock<Promise<MockCacheEntry | undefined>>;
+  put: jest.Mock<Promise<void>>;
+};
+
+const installMockCaches = (
+  matchResult: MockCacheEntry | undefined,
+): MockCache => {
+  const mockCache: MockCache = {
+    match: jest.fn(async () => matchResult),
+    put: jest.fn(async () => undefined),
+  };
+  Object.defineProperty(global, 'caches', {
+    value: { open: jest.fn(async () => mockCache) },
+    writable: true,
+    configurable: true,
+  });
+  return mockCache;
+};
+
+const removeMockCaches = (): void => {
+  Reflect.deleteProperty(global as Record<string, unknown>, 'caches');
+};
+
 describe('createConsoleApiClient', () => {
+  beforeEach(() => {
+    removeMockCaches();
+  });
+
+  afterEach(() => {
+    removeMockCaches();
+  });
+
   it('reads the item body from the api root without a token query', async () => {
     const fetchMock = mockFetchOnce({ body: '# Title' });
     const client = createConsoleApiClient();
@@ -243,13 +276,49 @@ describe('createConsoleApiClient', () => {
     });
   });
 
-  it('throws on a non-ok response', async () => {
+  it('throws on a non-ok response when no cache is available', async () => {
     mockFetchOnce({}, false);
     const client = createConsoleApiClient();
     await expect(
       client.fetchComments('https://github.com/o/r/issues/1'),
     ).rejects.toThrow('HTTP 500');
   });
+
+  it('returns cached comments when the network fetch rejects', async () => {
+    const cachedBody = {
+      comments: [
+        {
+          author: 'alice',
+          body: 'hello',
+          createdAt: '2026-06-19T00:00:00.000Z',
+        },
+      ],
+    };
+    installMockCaches({ json: jest.fn(async () => cachedBody) });
+    global.fetch = jest
+      .fn()
+      .mockRejectedValue(new Error('offline')) as unknown as typeof fetch;
+
+    const client = createConsoleApiClient();
+    const comments = await client.fetchComments(
+      'https://github.com/o/r/issues/1',
+    );
+    expect(comments).toEqual([
+      { author: 'alice', body: 'hello', createdAt: '2026-06-19T00:00:00.000Z' },
+    ]);
+  });
+
+  it('throws when the network fails and no cache entry exists', async () => {
+    installMockCaches(undefined);
+    global.fetch = jest
+      .fn()
+      .mockRejectedValue(new Error('offline')) as unknown as typeof fetch;
+
+    const client = createConsoleApiClient();
+    await expect(
+      client.fetchComments('https://github.com/o/r/issues/1'),
+    ).rejects.toThrow('offline');
+  });
 });
 
 describe('postConsoleOperation', () => {

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.ts

@@ -70,17 +70,53 @@ const getNumber = (value: unknown): number =>
 
 const getBoolean = (value: unknown): boolean => value === true;
 
+const CONSOLE_API_CACHE_NAME = 'console-api-v1';
+
 const requestJson = async (
   apiPath: string,
   resourceUrl: string,
 ): Promise<unknown> => {
-  const response = await fetch(
-    `${apiPath}?url=${encodeURIComponent(resourceUrl)}`,
-  );
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}`);
+  const url = `${apiPath}?url=${encodeURIComponent(resourceUrl)}`;
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const payload: unknown = await response.json();
+    try {
+      if ('caches' in globalThis) {
+        globalThis.caches
+          .open(CONSOLE_API_CACHE_NAME)
+          .then((cache) =>
+            cache.put(
+              url,
+              new Response(JSON.stringify(payload), {
+                headers: { 'Content-Type': 'application/json' },
+              }),
+            ),
+          )
+          .catch((e: unknown) => {
+            console.warn('Failed to persist API response to cache:', e);
+          });
+      }
+    } catch (e: unknown) {
+      console.warn('Failed to access cache storage:', e);
+    }
+    return payload;
+  } catch (e: unknown) {
+    try {
+      if ('caches' in globalThis) {
+        const cache = await globalThis.caches.open(CONSOLE_API_CACHE_NAME);
+        const cached = await cache.match(url);
+        if (cached !== undefined) {
+          return cached.json();
+        }
+      }
+    } catch {
+      // cache read failure, fall through to original error
+    }
+    throw e;
   }
-  return response.json();
 };
 
 const parseComments = (payload: unknown): ConsoleComment[] => {

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsolePage.tsx

@@ -126,6 +126,7 @@ export const ConsolePage = () => {
   const statusOptions = activeSnapshot?.statusOptions ?? [];
   const storyOptions = activeSnapshot?.storyOptions ?? [];
   const generatedAt = activeSnapshot?.generatedAt ?? null;
+  const fromCache = activeSnapshot?.fromCache ?? false;
 
   const selectedItem = useMemo<ConsoleListItem | null>(() => {
     if (selectedItemKey === null || activeSnapshot === null) {
@@ -274,6 +275,7 @@ export const ConsolePage = () => {
         counts={counts}
         pjcode={pjcode}
         generatedAt={generatedAt}
+        fromCache={fromCache}
         tabHref={navigation.tabHref}
         onSelectTab={navigation.selectTab}
       />

package/src/adapter/entry-points/console/ui/src/main.tsx

@@ -3,6 +3,12 @@ import { createRoot } from 'react-dom/client';
 import { ConsolePage } from '@/features/console/pages/ConsolePage';
 import './index.css';
 
+if ('serviceWorker' in navigator) {
+  navigator.serviceWorker.register('/sw.js').catch((e: unknown) => {
+    console.warn('Service worker registration failed:', e);
+  });
+}
+
 const container = document.getElementById('root');
 if (container === null) {
   throw new Error('Root container #root not found');