[GOG]: Switch to Galaxy way of loading library

public/locales/en/gamepage.json

@@ -133,6 +133,7 @@
     },
     "label": {
         "game": {
+            "not-installable-game": "",
             "third-party-game": "Third-Party Game NOT Supported"
         },
         "launching": "Launching",
@@ -187,6 +188,8 @@
         "downloading": "Downloading",
         "extracting": "Extracting",
         "gameNotAvailable": "Game not available",
+        "gog-goodie": "This game doesn't appear to be installable. Check downloadable content on https://gog.com/account",
+        "goodie": "Not installable",
         "hasUpdates": "New Version Available!",
         "installed": "Installed",
         "installing": "Installing",

src/backend/api/library.ts

@@ -81,6 +81,10 @@ export const handleRefreshLibrary = (
   callback: (event: Electron.IpcRendererEvent, runner: Runner) => void
 ) => ipcRenderer.on('refreshLibrary', callback)
 
+export const handleGamePush = (
+  callback: (event: Electron.IpcRendererEvent, game: GameInfo) => void
+) => ipcRenderer.on('pushGameToLibrary', callback)
+
 export const removeRecentGame = async (appName: string) =>
   ipcRenderer.invoke('removeRecent', appName)
 // eslint-disable-next-line @typescript-eslint/no-explicit-any

src/backend/cache.ts

@@ -2,6 +2,9 @@ import Store from 'electron-store'
 
 export default class CacheStore<ValueType, KeyType extends string = string> {
   private readonly store: Store
+  private in_memory_store: Map<string, ValueType>
+  private using_in_memory: boolean
+  private current_store: Store | Map<string, ValueType>
   private readonly lifespan: number | null
 
   /**
@@ -16,20 +19,34 @@ export default class CacheStore<ValueType, KeyType extends string = string> {
       name: filename,
       clearInvalidConfig: true
     })
+    this.in_memory_store = new Map<string, ValueType>()
+    this.using_in_memory = false
+    this.current_store = this.store
     this.lifespan = max_value_lifespan
   }
 
+  /**
+   * Allows to switch over to use in memory store (useful for many read and writes)
+   * IMPORTANT! after operations run commit() to update file on drive
+   */
+  public use_in_memory() {
+    // Mirror store to memory map
+    this.using_in_memory = true
+    this.in_memory_store = new Map(this.store) as Map<string, ValueType>
+    this.current_store = this.in_memory_store
+  }
+
   public get(key: KeyType): ValueType | undefined
   public get(key: KeyType, fallback: ValueType): ValueType
   public get(key: KeyType, fallback?: ValueType) {
-    if (!this.store.has(key)) {
+    if (!this.current_store.has(key)) {
       return fallback
     }
 
     if (this.lifespan) {
-      const lastUpdateTimestamp = this.store.get(`__timestamp.${key}`) as
-        | string
-        | undefined
+      const lastUpdateTimestamp = this.current_store.get(
+        `__timestamp.${key}`
+      ) as string | undefined
       if (!lastUpdateTimestamp) {
         return fallback
       }
@@ -38,28 +55,36 @@ export default class CacheStore<ValueType, KeyType extends string = string> {
       const msSinceUpdate = Date.now() - updateDate.getTime()
       const minutesSinceUpdate = msSinceUpdate / 1000 / 60
       if (minutesSinceUpdate > this.lifespan) {
-        this.store.delete(key)
-        this.store.delete(`__timestamp.${key}`)
+        this.current_store.delete(key)
+        this.current_store.delete(`__timestamp.${key}`)
         return fallback
       }
     }
 
-    return this.store.get(key) as ValueType
+    return this.current_store.get(key) as ValueType
   }
 
   public set(key: KeyType, value: ValueType) {
-    this.store.set(key, value)
-    this.store.set(`__timestamp.${key}`, Date())
+    this.current_store.set(key, value)
+    this.current_store.set(`__timestamp.${key}`, Date() as ValueType)
   }
 
   public delete(key: KeyType) {
-    this.store.delete(key)
-    this.store.delete(`__timestamp.${key}`)
+    this.current_store.delete(key)
+    this.current_store.delete(`__timestamp.${key}`)
   }
 
-  public clear = () => this.store.clear()
+  public clear = () => this.current_store.clear()
 
   public has(key: string) {
-    return this.store.has(key)
+    return this.current_store.has(key)
+  }
+
+  public commit() {
+    if (this.using_in_memory) {
+      this.store.store = Object.fromEntries(this.in_memory_store)
+      this.using_in_memory = false
+      this.current_store = this.store
+    }
   }
 }

src/backend/storeManagers/gog/electronStores.ts

@@ -15,10 +15,7 @@ const configStore = new TypeCheckedStoreBackend('gogConfigStore', {
   cwd: 'gog_store'
 })
 
-const apiInfoCache = new CacheStore<{
-  isUpdated: boolean
-  data: GamesDBData
-}>('gog_api_info')
+const apiInfoCache = new CacheStore<GamesDBData>('gog_api_info')
 const libraryStore = new CacheStore<GameInfo[], 'games'>('gog_library', null)
 const syncStore = new TypeCheckedStoreBackend('gogSyncStore', {
   cwd: 'gog_store',

src/backend/storeManagers/gog/games.ts

@@ -11,7 +11,8 @@ import {
   createReqsArray,
   getGameInfo as getGogLibraryGameInfo,
   changeGameInstallPath,
-  getMetaResponse
+  getMetaResponse,
+  getGamesData
 } from './library'
 import { join } from 'path'
 import { GameConfig } from '../../game_config'
@@ -80,7 +81,7 @@ export async function getExtraInfo(appName: string): Promise<ExtraInfo> {
   const extra: ExtraInfo = {
     about: gameInfo.extra?.about,
     reqs: await createReqsArray(appName, targetPlatform),
-    storeUrl: gameInfo.store_url
+    storeUrl: (await getGamesData(appName))?._links.store.href
   }
   return extra
 }