Merge branch 'main' into linux-install

src/main/events/autoupdater/check-for-updates.ts

@@ -0,0 +1,48 @@
+import { AppUpdaterEvents } from "@types";
+import { registerEvent } from "../register-event";
+import updater, { ProgressInfo, UpdateInfo } from "electron-updater";
+import { WindowManager } from "@main/services";
+import { app } from "electron";
+
+const { autoUpdater } = updater;
+
+const sendEvent = (event: AppUpdaterEvents) => {
+  WindowManager.splashWindow?.webContents.send("autoUpdaterEvent", event);
+};
+
+const mockValuesForDebug = async () => {
+  sendEvent({ type: "update-downloaded" });
+};
+
+const checkForUpdates = async (_event: Electron.IpcMainInvokeEvent) => {
+  autoUpdater
+    .addListener("error", () => {
+      sendEvent({ type: "error" });
+    })
+    .addListener("checking-for-update", () => {
+      sendEvent({ type: "checking-for-updates" });
+    })
+    .addListener("update-not-available", () => {
+      sendEvent({ type: "update-not-available" });
+    })
+    .addListener("update-available", (info: UpdateInfo) => {
+      sendEvent({ type: "update-available", info });
+    })
+    .addListener("update-downloaded", () => {
+      sendEvent({ type: "update-downloaded" });
+    })
+    .addListener("download-progress", (info: ProgressInfo) => {
+      sendEvent({ type: "download-progress", info });
+    })
+    .addListener("update-cancelled", () => {
+      sendEvent({ type: "update-cancelled" });
+    });
+
+  if (app.isPackaged) {
+    autoUpdater.checkForUpdates();
+  } else {
+    await mockValuesForDebug();
+  }
+};
+
+registerEvent("checkForUpdates", checkForUpdates);

src/main/events/autoupdater/continue-to-main-window.ts

@@ -0,0 +1,12 @@
+import { WindowManager } from "@main/services";
+import { registerEvent } from "../register-event";
+import updater from "electron-updater";
+
+const { autoUpdater } = updater;
+
+const continueToMainWindow = async (_event: Electron.IpcMainInvokeEvent) => {
+  autoUpdater.removeAllListeners();
+  WindowManager.prepareMainWindowAndCloseSplash();
+};
+
+registerEvent("continueToMainWindow", continueToMainWindow);

src/main/events/autoupdater/restart-and-install-update.ts

@@ -0,0 +1,17 @@
+import { app } from "electron";
+import { registerEvent } from "../register-event";
+import updater from "electron-updater";
+import { WindowManager } from "@main/services";
+
+const { autoUpdater } = updater;
+
+const restartAndInstallUpdate = async (_event: Electron.IpcMainInvokeEvent) => {
+  if (app.isPackaged) {
+    autoUpdater.quitAndInstall(true, true);
+  } else {
+    autoUpdater.removeAllListeners();
+    WindowManager.prepareMainWindowAndCloseSplash();
+  }
+};
+
+registerEvent("restartAndInstallUpdate", restartAndInstallUpdate);

src/main/events/catalogue/get-catalogue.ts

@@ -92,7 +92,4 @@ const getRecentlyAddedCatalogue = async (
   return results.slice(0, resultSize);
 };
 
-registerEvent(getCatalogue, {
-  name: "getCatalogue",
-  memoize: true,
-});
+registerEvent("getCatalogue", getCatalogue);

src/main/events/catalogue/get-game-shop-details.ts

@@ -1,9 +1,10 @@
-import { gameShopCacheRepository, steamGameRepository } from "@main/repository";
+import { gameShopCacheRepository } from "@main/repository";
 import { getSteamAppDetails } from "@main/services";
 
 import type { ShopDetails, GameShop, SteamAppDetails } from "@types";
 
 import { registerEvent } from "../register-event";
+import { stateManager } from "@main/state-manager";
 
 const getLocalizedSteamAppDetails = (
   objectID: string,
@@ -13,10 +14,11 @@ const getLocalizedSteamAppDetails = (
     return getSteamAppDetails(objectID, language);
   }
 
-  return Promise.all([
-    steamGameRepository.findOne({ where: { id: Number(objectID) } }),
-    getSteamAppDetails(objectID, language),
-  ]).then(([steamGame, localizedAppDetails]) => {
+  return getSteamAppDetails(objectID, language).then((localizedAppDetails) => {
+    const steamGame = stateManager
+      .getValue("steamGames")
+      .find((game) => game.id === Number(objectID));
+
     if (steamGame && localizedAppDetails) {
       return {
         ...localizedAppDetails,
@@ -72,7 +74,4 @@ const getGameShopDetails = async (
   throw new Error("Not implemented");
 };
 
-registerEvent(getGameShopDetails, {
-  name: "getGameShopDetails",
-  memoize: true,
-});
+registerEvent("getGameShopDetails", getGameShopDetails);

src/main/events/catalogue/get-games.ts

@@ -36,7 +36,4 @@ const getGames = async (
   return { results, cursor: i };
 };
 
-registerEvent(getGames, {
-  name: "getGames",
-  memoize: true,
-});
+registerEvent("getGames", getGames);

src/main/events/catalogue/get-how-long-to-beat.ts

@@ -42,7 +42,4 @@ const getHowLongToBeat = async (
   });
 };
 
-registerEvent(getHowLongToBeat, {
-  name: "getHowLongToBeat",
-  memoize: true,
-});
+registerEvent("getHowLongToBeat", getHowLongToBeat);

src/main/events/catalogue/get-random-game.ts

@@ -36,6 +36,4 @@ const getRandomGame = async (_event: Electron.IpcMainInvokeEvent) => {
   return state.games[state.index];
 };
 
-registerEvent(getRandomGame, {
-  name: "getRandomGame",
-});
+registerEvent("getRandomGame", getRandomGame);

src/main/events/catalogue/search-game-repacks.ts

@@ -8,7 +8,4 @@ const searchGameRepacks = (
   return searchRepacks(query);
 };
 
-registerEvent(searchGameRepacks, {
-  name: "searchGameRepacks",
-  memoize: true,
-});
+registerEvent("searchGameRepacks", searchGameRepacks);

src/main/events/catalogue/search-games.ts

@@ -9,7 +9,4 @@ const searchGamesEvent = async (
   return searchGames({ query, take: 12 });
 };
 
-registerEvent(searchGamesEvent, {
-  name: "searchGames",
-  memoize: true,
-});
+registerEvent("searchGames", searchGamesEvent);

src/main/events/hardware/get-disk-free-space.ts

@@ -7,6 +7,4 @@ const getDiskFreeSpace = async (
   path: string
 ) => checkDiskSpace(path);
 
-registerEvent(getDiskFreeSpace, {
-  name: "getDiskFreeSpace",
-});
+registerEvent("getDiskFreeSpace", getDiskFreeSpace);

src/main/events/index.ts

@@ -14,7 +14,6 @@ import "./library/close-game";
 import "./library/delete-game-folder";
 import "./library/get-game-by-object-id";
 import "./library/get-library";
-import "./library/get-repackers-friendly-names";
 import "./library/open-game";
 import "./library/open-game-installer";
 import "./library/remove-game";
@@ -28,6 +27,9 @@ import "./torrenting/start-game-download";
 import "./user-preferences/get-user-preferences";
 import "./user-preferences/update-user-preferences";
 import "./user-preferences/auto-launch";
+import "./autoupdater/check-for-updates";
+import "./autoupdater/restart-and-install-update";
+import "./autoupdater/continue-to-main-window";
 
 ipcMain.handle("ping", () => "pong");
 ipcMain.handle("getVersion", () => app.getVersion());

src/main/events/library/add-game-to-library.ts

@@ -3,8 +3,8 @@ import { gameRepository } from "@main/repository";
 import { registerEvent } from "../register-event";
 
 import type { GameShop } from "@types";
-import { getFileBase64 } from "@main/helpers";
-import { getSteamGameIconUrl } from "@main/services";
+import { getFileBase64, getSteamAppAsset } from "@main/helpers";
+import { stateManager } from "@main/state-manager";
 
 const addGameToLibrary = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -27,21 +27,31 @@ const addGameToLibrary = async (
     )
     .then(async ({ affected }) => {
       if (!affected) {
-        const iconUrl = await getFileBase64(
-          await getSteamGameIconUrl(objectID)
-        );
+        const steamGame = stateManager
+          .getValue("steamGames")
+          .find((game) => game.id === Number(objectID));
 
-        await gameRepository.insert({
-          title,
-          iconUrl,
-          objectID,
-          shop: gameShop,
-          executablePath,
-        });
+        const iconUrl = steamGame?.clientIcon
+          ? getSteamAppAsset("icon", objectID, steamGame.clientIcon)
+          : null;
+
+        await gameRepository
+          .insert({
+            title,
+            iconUrl,
+            objectID,
+            shop: gameShop,
+            executablePath,
+          })
+          .then(() => {
+            if (iconUrl) {
+              getFileBase64(iconUrl).then((base64) =>
+                gameRepository.update({ objectID }, { iconUrl: base64 })
+              );
+            }
+          });
       }
     });
 };
 
-registerEvent(addGameToLibrary, {
-  name: "addGameToLibrary",
-});
+registerEvent("addGameToLibrary", addGameToLibrary);

src/main/events/library/close-game.ts

@@ -36,6 +36,4 @@ const closeGame = async (
   return false;
 };
 
-registerEvent(closeGame, {
-  name: "closeGame",
-});
+registerEvent("closeGame", closeGame);

src/main/events/library/delete-game-folder.ts

@@ -47,6 +47,4 @@ const deleteGameFolder = async (
   }
 };
 
-registerEvent(deleteGameFolder, {
-  name: "deleteGameFolder",
-});
+registerEvent("deleteGameFolder", deleteGameFolder);

src/main/events/library/get-game-by-object-id.ts

@@ -16,6 +16,4 @@ const getGameByObjectID = async (
     },
   });
 
-registerEvent(getGameByObjectID, {
-  name: "getGameByObjectID",
-});
+registerEvent("getGameByObjectID", getGameByObjectID);

src/main/events/library/get-library.ts

@@ -28,6 +28,4 @@ const getLibrary = async () =>
       )
     );
 
-registerEvent(getLibrary, {
-  name: "getLibrary",
-});
+registerEvent("getLibrary", getLibrary);

src/main/events/library/get-repackers-friendly-names.ts

@@ -1,12 +0,0 @@
-import { registerEvent } from "../register-event";
-import { stateManager } from "@main/state-manager";
-
-const getRepackersFriendlyNames = async () =>
-  stateManager.getValue("repackersFriendlyNames").reduce((prev, next) => {
-    return { ...prev, [next.name]: next.friendlyName };
-  }, {});
-
-registerEvent(getRepackersFriendlyNames, {
-  name: "getRepackersFriendlyNames",
-  memoize: true,
-});

src/main/events/library/open-game-installer.ts

@@ -54,6 +54,4 @@ const openGameInstaller = async (
   return false;
 };
 
-registerEvent(openGameInstaller, {
-  name: "openGameInstaller",
-});
+registerEvent("openGameInstaller", openGameInstaller);

src/main/events/library/open-game.ts

@@ -13,6 +13,4 @@ const openGame = async (
   shell.openPath(executablePath);
 };
 
-registerEvent(openGame, {
-  name: "openGame",
-});
+registerEvent("openGame", openGame);

src/main/events/library/remove-game-from-library.ts

@@ -8,6 +8,4 @@ const removeGameFromLibrary = async (
   gameRepository.update({ id: gameId }, { isDeleted: true });
 };
 
-registerEvent(removeGameFromLibrary, {
-  name: "removeGameFromLibrary",
-});
+registerEvent("removeGameFromLibrary", removeGameFromLibrary);

src/main/events/library/remove-game.ts

@@ -20,6 +20,4 @@ const removeGame = async (
   );
 };
 
-registerEvent(removeGame, {
-  name: "removeGame",
-});
+registerEvent("removeGame", removeGame);

src/main/events/misc/open-external.ts

@@ -4,6 +4,4 @@ import { registerEvent } from "../register-event";
 const openExternal = async (_event: Electron.IpcMainInvokeEvent, src: string) =>
   shell.openExternal(src);
 
-registerEvent(openExternal, {
-  name: "openExternal",
-});
+registerEvent("openExternal", openExternal);

src/main/events/misc/show-open-dialog.ts

@@ -13,6 +13,4 @@ const showOpenDialog = async (
   throw new Error("Main window is not available");
 };
 
-registerEvent(showOpenDialog, {
-  name: "showOpenDialog",
-});
+registerEvent("showOpenDialog", showOpenDialog);

src/main/events/register-event.ts

@@ -1,37 +1,11 @@
 import { ipcMain } from "electron";
 
-import { stateManager } from "@main/state-manager";
-
-interface EventArgs {
-  name: string;
-  memoize?: boolean;
-}
-
 export const registerEvent = (
-  listener: (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any,
-  { name, memoize = false }: EventArgs
+  name: string,
+  listener: (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any
 ) => {
-  ipcMain.handle(name, (event: Electron.IpcMainInvokeEvent, ...args) => {
-    const eventResults = stateManager.getValue("eventResults");
-    const keys = Array.from(eventResults.keys());
-
-    const key = [name, args] as [string, any[]];
-
-    const memoizationKey = keys.find(([memoizedEvent, memoizedArgs]) => {
-      const sameEvent = name === memoizedEvent;
-      const sameArgs = memoizedArgs.every((arg, index) => arg === args[index]);
-
-      return sameEvent && sameArgs;
-    });
-
-    if (memoizationKey) return eventResults.get(memoizationKey);
-
+  ipcMain.handle(name, async (event: Electron.IpcMainInvokeEvent, ...args) => {
     return Promise.resolve(listener(event, ...args)).then((result) => {
-      if (memoize) {
-        eventResults.set(key, JSON.parse(JSON.stringify(result)));
-        stateManager.setValue("eventResults", eventResults);
-      }
-
       if (!result) return result;
       return JSON.parse(JSON.stringify(result));
     });

src/main/events/torrenting/cancel-game-download.ts

@@ -50,6 +50,4 @@ const cancelGameDownload = async (
     });
 };
 
-registerEvent(cancelGameDownload, {
-  name: "cancelGameDownload",
-});
+registerEvent("cancelGameDownload", cancelGameDownload);

src/main/events/torrenting/pause-game-download.ts

@@ -27,6 +27,4 @@ const pauseGameDownload = async (
     });
 };
 
-registerEvent(pauseGameDownload, {
-  name: "pauseGameDownload",
-});
+registerEvent("pauseGameDownload", pauseGameDownload);

src/main/events/torrenting/resume-game-download.ts

@@ -46,6 +46,4 @@ const resumeGameDownload = async (
   }
 };
 
-registerEvent(resumeGameDownload, {
-  name: "resumeGameDownload",
-});
+registerEvent("resumeGameDownload", resumeGameDownload);

src/main/events/torrenting/start-game-download.ts

@@ -1,4 +1,3 @@
-import { getSteamGameIconUrl } from "@main/services";
 import {
   gameRepository,
   repackRepository,
@@ -8,10 +7,11 @@ import {
 import { registerEvent } from "../register-event";
 
 import type { GameShop } from "@types";
-import { getFileBase64 } from "@main/helpers";
+import { getFileBase64, getSteamAppAsset } from "@main/helpers";
 import { In } from "typeorm";
 import { DownloadManager } from "@main/services";
 import { Downloader, GameStatus } from "@shared";
+import { stateManager } from "@main/state-manager";
 
 const startGameDownload = async (
   _event: Electron.IpcMainInvokeEvent,
@@ -76,18 +76,34 @@ const startGameDownload = async (
 
     return game;
   } else {
-    const iconUrl = await getFileBase64(await getSteamGameIconUrl(objectID));
+    const steamGame = stateManager
+      .getValue("steamGames")
+      .find((game) => game.id === Number(objectID));
 
-    const createdGame = await gameRepository.save({
-      title,
-      iconUrl,
-      objectID,
-      downloader,
-      shop: gameShop,
-      status: GameStatus.Downloading,
-      downloadPath,
-      repack: { id: repackId },
-    });
+    const iconUrl = steamGame?.clientIcon
+      ? getSteamAppAsset("icon", objectID, steamGame.clientIcon)
+      : null;
+
+    const createdGame = await gameRepository
+      .save({
+        title,
+        iconUrl,
+        objectID,
+        downloader,
+        shop: gameShop,
+        status: GameStatus.Downloading,
+        downloadPath,
+        repack: { id: repackId },
+      })
+      .then((result) => {
+        if (iconUrl) {
+          getFileBase64(iconUrl).then((base64) =>
+            gameRepository.update({ objectID }, { iconUrl: base64 })
+          );
+        }
+
+        return result;
+      });
 
     DownloadManager.downloadGame(createdGame.id);
 
@@ -97,6 +113,4 @@ const startGameDownload = async (
   }
 };
 
-registerEvent(startGameDownload, {
-  name: "startGameDownload",
-});
+registerEvent("startGameDownload", startGameDownload);

src/main/events/user-preferences/auto-launch.ts

@@ -16,6 +16,4 @@ const autoLaunch = async (
   }
 };
 
-registerEvent(autoLaunch, {
-  name: "autoLaunch",
-});
+registerEvent("autoLaunch", autoLaunch);

src/main/events/user-preferences/get-user-preferences.ts

@@ -6,6 +6,4 @@ const getUserPreferences = async () =>
     where: { id: 1 },
   });
 
-registerEvent(getUserPreferences, {
-  name: "getUserPreferences",
-});
+registerEvent("getUserPreferences", getUserPreferences);

src/main/events/user-preferences/update-user-preferences.ts

@@ -21,6 +21,4 @@ const updateUserPreferences = async (
   );
 };
 
-registerEvent(updateUserPreferences, {
-  name: "updateUserPreferences",
-});
+registerEvent("updateUserPreferences", updateUserPreferences);