feat: Expand caching to Libraries, PlayMode, Status and Application Path

Author: colin969

src/back/DatabaseCache.ts

@@ -14,7 +14,7 @@ type TagCache = {
 };
 
 const cacheKeyList: string[] = [];
-let gameSaved = false;
+let gameSaveCount = 0;
 let tagCache: TagCache | null = null;
 
 async function loadTagCache(cachePath: string): Promise<void> {
@@ -124,7 +124,7 @@ async function loadStringCache(key: string, cachePath: string): Promise<GameStri
 }
 
 export function markGameSave(fpPath: string) {
-  gameSaved = true;
+  gameSaveCount += 1;
   for (const key of cacheKeyList) {
     const cachePath = path.join(fpPath, 'Cache', `${key}.json`);
     try {
@@ -149,6 +149,7 @@ function getStringCachedDataFactory(
   doSearch: (search: GameSearch) => Promise<string[]>
 ): (state: BackState, tagFilters: TagFilterGroup[]) => Promise<string[]> {
   let cache: GameStringCache | null = null;
+  let gameSaveCountLocal = gameSaveCount;
   cacheKeyList.push(key);
 
   return async (state, tagFilters) => {
@@ -164,10 +165,11 @@ function getStringCachedDataFactory(
     return databaseReady()
     .then(async (db) => {
       const gameCount = await db.countGames();
-      if (!gameSaved && cache!.gameCount === gameCount && cache!.filterKey === flatKey) {
-        // Same game count and filter key, pretty accurate cache
+      if (gameSaveCountLocal === gameSaveCount && cache!.gameCount === gameCount && cache!.filterKey === flatKey) {
+        // No new games saved, same game count and filter key, pretty accurate cache
         return cache!.data;
       }
+      gameSaveCountLocal = gameSaveCount;
       const search = getTaggedSearch(tagFilters);
       const data = await doSearch(search);
       await saveStringCache(cachePath, gameCount, flatKey, data);
@@ -176,6 +178,43 @@ function getStringCachedDataFactory(
   };
 }
 
+function getStringCachedDataTaglessFactory(
+  key: string,
+  doSearch: () => Promise<string[]>
+): (state: BackState) => Promise<string[]> {
+  let cache: GameStringCache | null = null;
+  let gameSaveCountLocal = gameSaveCount;
+  cacheKeyList.push(key);
+
+  return async (state) => {
+    console.log('Loading cache for ' + key);
+    const cachePath = path.join(state.config.flashpointPath, 'Cache', `${key}.json`);
+
+    if (cache === null) {
+      cache = await loadStringCache(key, cachePath);
+    }
+
+
+    return databaseReady()
+    .then(async (db) => {
+      const gameCount = await db.countGames();
+      if (gameSaveCountLocal === gameSaveCount && cache!.gameCount === gameCount) {
+        // No new games saved and same game count, pretty accurate cache
+        return cache!.data;
+      }
+      gameSaveCountLocal = gameSaveCount;
+      const data = await doSearch();
+      await saveStringCache(cachePath, gameCount, '', data);
+      return data;
+    });
+  };
+}
+
 export const getAllDevelopers = getStringCachedDataFactory('developers', (search) => fpDatabase.findAllGameDevelopers(search));
 export const getAllPublishers = getStringCachedDataFactory('publishers', (search) => fpDatabase.findAllGamePublishers(search));
 export const getAllSeries = getStringCachedDataFactory('series', (search) => fpDatabase.findAllGameSeries(search));
+
+export const getAllLibraries = getStringCachedDataTaglessFactory('libraries', () => fpDatabase.findAllGameLibraries());
+export const getAllStatuses = getStringCachedDataTaglessFactory('statuses', () => fpDatabase.findAllGameStatuses());
+export const getAllApplicationPaths = getStringCachedDataTaglessFactory('applicationPaths', () => fpDatabase.findAllGameApplicationPaths());
+export const getAllPlayModes = getStringCachedDataTaglessFactory('playModes', () => fpDatabase.findAllGamePlayModes());

src/back/index.ts

@@ -42,6 +42,7 @@ import { saveCurationFpfssInfo } from './curate/fpfss';
 import { loadCurationIndexImage } from './curate/parse';
 import { readCurationMeta } from './curate/read';
 import { onFileServerRequestCurationFileFactory, onFileServerRequestPostCuration } from './curate/util';
+import { getAllApplicationPaths, getAllLibraries, getAllPlayModes, getAllStatuses } from './DatabaseCache';
 import { axios } from './dns';
 import { downloadGameData } from './download';
 import { Downloader } from './Downloader';
@@ -864,17 +865,18 @@ async function initialize() {
     state.socketServer.broadcast(BackOut.OPEN_ALERT, 'Failed to open database: ' + e);
   }
 
+  state.init[BackInit.DATABASE_READY] = true;
+
   // Populate unique values
   state.suggestions = {
     tags: [],
-    playMode: await fpDatabase.findAllGamePlayModes(),
+    playMode: await getAllPlayModes(state),
     platforms: (await fpDatabase.findAllPlatforms()).map(p => p.name),
-    status: await fpDatabase.findAllGameStatuses(),
-    applicationPath: await fpDatabase.findAllGameApplicationPaths(),
-    library: await fpDatabase.findAllGameLibraries(),
+    status: await getAllStatuses(state),
+    applicationPath: await getAllApplicationPaths(state),
+    library: await getAllLibraries(state),
   };
 
-  state.init[BackInit.DATABASE_READY] = true;
   state.initEmitter.emit(BackInit.DATABASE_READY);
 
   // Check for Flashpoint Manager Updates

src/back/responses.ts

@@ -61,7 +61,7 @@ import * as url from 'url';
 import * as util from 'util';
 import * as YAML from 'yaml';
 import { ConfigFile } from './ConfigFile';
-import { getAllDevelopers, getAllPublishers, getAllSeries, getTags, markGameSave } from './DatabaseCache';
+import { getAllApplicationPaths, getAllDevelopers, getAllLibraries, getAllPlayModes, getAllPublishers, getAllSeries, getAllStatuses, getTags, markGameSave } from './DatabaseCache';
 import { ExtConfigFile } from './ExtConfigFile';
 import { escapeArgsForShell, GameLauncher } from './GameLauncher';
 import { ManagedChildProcess } from './ManagedChildProcess';
@@ -242,7 +242,7 @@ export function registerRequestCallbacks(state: BackState, init: () => Promise<v
   });
 
   state.socketServer.register(BackIn.GET_RENDERER_LOADED_DATA, async (event) => {
-    const libraries = await fpDatabase.findAllGameLibraries();
+    const libraries = await getAllLibraries(state);
 
     // Fetch update feed in background
     if (state.preferences.updateFeedUrl) {
@@ -537,11 +537,11 @@ export function registerRequestCallbacks(state: BackState, init: () => Promise<v
       // Send out new suggestions and library lists
       state.suggestions = {
         tags: [],
-        playMode: await fpDatabase.findAllGamePlayModes(),
+        playMode: await getAllPlayModes(state),
         platforms: (await fpDatabase.findAllPlatforms()).map(p => p.name),
-        status: await fpDatabase.findAllGameStatuses(),
-        applicationPath: await fpDatabase.findAllGameApplicationPaths(),
-        library: await fpDatabase.findAllGameLibraries(),
+        status: await getAllStatuses(state),
+        applicationPath: await getAllApplicationPaths(state),
+        library: await getAllLibraries(state),
       };
       state.platformAppPaths = processPlatformAppPaths(await fpDatabase.findPlatformAppPaths()); // Update cache
       const total = await fpDatabase.countGames();
@@ -590,11 +590,11 @@ export function registerRequestCallbacks(state: BackState, init: () => Promise<v
   state.socketServer.register(BackIn.GET_SUGGESTIONS, async () => {
     const suggestions: GamePropSuggestions = {
       tags: [],
-      playMode: await fpDatabase.findAllGamePlayModes(),
+      playMode: await getAllPlayModes(state),
       platforms: (await fpDatabase.findAllPlatforms()).map(p => p.name),
-      status: await fpDatabase.findAllGameStatuses(),
-      applicationPath: await fpDatabase.findAllGameApplicationPaths(),
-      library: await fpDatabase.findAllGameLibraries(),
+      status: await getAllStatuses(state),
+      applicationPath: await getAllApplicationPaths(state),
+      library: await getAllLibraries(state),
     };
     state.platformAppPaths = processPlatformAppPaths(await fpDatabase.findPlatformAppPaths()); // Update cache
     return {