fix: fetch missing stories for registered games on startup

Author: nnnSMM

src/App.svelte

@@ -8,6 +8,7 @@
   import { setupGlobalTooltips } from "@/lib/tooltip";
   import { setupHistoryTracker } from "@/lib/historyTrack";
   import { initializeAllGameCache } from "@/lib/scrapeAllGame";
+  import { works } from "@/store/works";
   import ImportDropFiles from "@/components/Home/ImportDropFiles.svelte";
   import { backgroundState } from "@/store/background";
   import { location, replace } from "svelte-spa-router";
@@ -58,6 +59,7 @@
     didInitializeMainApp = true;
     initialize();
     initializeAllGameCache();
+    void works.ensureRegisteredStories();
   };
 
   onMount(async () => {

src/lib/utils.ts

@@ -39,11 +39,18 @@ type LocalStorageCacheOptions = {
 
 const DAY_MILLISECONDS = 1000 * 60 * 60 * 24;
 
+export type LocalStorageCacheGetter<K extends string | number, T> = ((
+  key: K
+) => Promise<T>) & {
+  peek: (key: K) => T | undefined;
+  setValue: (key: K, value: T) => void;
+};
+
 export const createLocalStorageCache = <K extends string | number, T>(
   key: string,
   fetcher: (key: K) => Promise<T>,
   options: number | LocalStorageCacheOptions = DAY_MILLISECONDS
-) => {
+): LocalStorageCacheGetter<K, T> => {
   const invalidateMilliseconds =
     typeof options === "number"
       ? options
@@ -79,7 +86,7 @@ export const createLocalStorageCache = <K extends string | number, T>(
     });
   };
 
-  const getter = async (key: K): Promise<T> => {
+  const getter = (async (key: K): Promise<T> => {
     const now = new Date().getTime();
     prune(now);
     const cached = getCache()[key];
@@ -95,7 +102,17 @@ export const createLocalStorageCache = <K extends string | number, T>(
       };
     });
     return value;
+  }) as LocalStorageCacheGetter<K, T>;
+
+  getter.peek = (key: K) => getCache()[key]?.value;
+  getter.setValue = (key: K, value: T) => {
+    const createdAt = new Date().getTime();
+    cache.update((v) => ({
+      ...v,
+      [key]: { value, createdAt, version },
+    }));
   };
+
   return getter;
 };
 

src/store/works.test.ts

@@ -0,0 +1,92 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { commandGetAllElements } from "@/lib/command";
+import { getWorkByScrape } from "@/lib/scrapeWork";
+import type { CollectionElement, Work } from "@/lib/types";
+
+vi.mock("@/lib/command", () => ({
+  commandGetAllElements: vi.fn(),
+}));
+
+vi.mock("@/lib/scrapeWork", () => ({
+  getWorkByScrape: vi.fn(),
+}));
+
+const work = (id: number, description?: string): Work => ({
+  id,
+  name: `work-${id}`,
+  brandId: 1,
+  brandName: "brand",
+  description,
+  officialHomePage: "",
+  sellday: "2026-01-01",
+  imgUrl: "",
+  statistics: {
+    median: 0,
+    average: 0,
+    count: 0,
+    playTime: "0",
+  },
+  creators: {
+    illustrators: [],
+    writers: [],
+    voiceActors: [],
+  },
+  musics: [],
+});
+
+const collectionElement = (id: number): CollectionElement => ({
+  id,
+  gamename: `game-${id}`,
+  gamenameRuby: "",
+  brandname: "brand",
+  brandnameRuby: "",
+  sellday: "2026-01-01",
+  isNukige: false,
+  installAt: null,
+  firstPlayAt: null,
+  lastPlayAt: null,
+  likeAt: null,
+  playStatus: 0,
+  totalPlayTimeSeconds: 0,
+  registeredAt: "2026-01-01",
+  exePath: "",
+  lnkPath: "",
+  icon: "",
+  thumbnail: "",
+  thumbnailWidth: null,
+  thumbnailHeight: null,
+  updatedAt: "2026-01-01",
+});
+
+const loadWorks = async () => (await import("./works")).works;
+
+describe("works.ensureRegisteredStories", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.clearAllMocks();
+    localStorage.clear();
+  });
+
+  it("fetches stories only for registered works missing a cached description", async () => {
+    localStorage.setItem(
+      "works-cache",
+      JSON.stringify({
+        1: { value: work(1, "cached story"), createdAt: Date.now(), version: 8 },
+        2: { value: work(2), createdAt: Date.now(), version: 8 },
+        3: { value: work(3), createdAt: Date.now(), version: 8 },
+      })
+    );
+    vi.mocked(commandGetAllElements).mockResolvedValue([
+      collectionElement(1),
+      collectionElement(2),
+    ]);
+    vi.mocked(getWorkByScrape).mockResolvedValue(work(2, "fetched story"));
+
+    const works = await loadWorks();
+    await works.ensureRegisteredStories();
+
+    expect(getWorkByScrape).toHaveBeenCalledTimes(1);
+    expect(getWorkByScrape).toHaveBeenCalledWith(2);
+    expect(await works.get(2)).toMatchObject({ description: "fetched story" });
+  });
+});

src/store/works.ts

@@ -1,9 +1,17 @@
 import { getWorkByScrape } from "@/lib/scrapeWork";
+import { commandGetAllElements } from "@/lib/command";
 import type { Work } from "@/lib/types";
 import { createLocalStorageCache } from "@/lib/utils";
 
 const WORKS_CACHE_VERSION = 8;
 const WORKS_CACHE_TTL_MS = 1000 * 60 * 60 * 24 * 7;
+const DESCRIPTION_PREFETCH_DELAY_MS = 500;
+
+const hasStoryDescription = (work: Work | undefined) =>
+  !!work?.description?.trim();
+
+const wait = (milliseconds: number) =>
+  new Promise((resolve) => setTimeout(resolve, milliseconds));
 
 const createWorks = () => {
   const getter = createLocalStorageCache<number, Work>(
@@ -17,6 +25,31 @@ const createWorks = () => {
 
   return {
     get: getter,
+    ensureRegisteredStories: async () => {
+      let elements;
+      try {
+        elements = await commandGetAllElements();
+      } catch (error) {
+        console.warn("[works] failed to load registered games", error);
+        return;
+      }
+
+      for (const element of elements) {
+        if (hasStoryDescription(getter.peek(element.id))) {
+          continue;
+        }
+
+        try {
+          getter.setValue(element.id, await getWorkByScrape(element.id));
+        } catch (error) {
+          console.warn(
+            `[works] failed to fetch missing story for ${element.id}`,
+            error
+          );
+        }
+        await wait(DESCRIPTION_PREFETCH_DELAY_MS);
+      }
+    },
   };
 };