feat: returning with edit profile modal

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

@@ -1,35 +1,42 @@
-import type { CatalogueEntry, GameShop } from "@types";
+import type { GameShop } from "@types";
 
 import { registerEvent } from "../register-event";
-import { RepacksManager, requestSteam250 } from "@main/services";
-import { formatName, steamUrlBuilder } from "@shared";
+import { HydraApi, RepacksManager } from "@main/services";
+import { CatalogueCategory, formatName, steamUrlBuilder } from "@shared";
+import { steamGamesWorker } from "@main/workers";
 
-const resultSize = 12;
+const getCatalogue = async (
+  _event: Electron.IpcMainInvokeEvent,
+  category: CatalogueCategory
+) => {
+  const params = new URLSearchParams({
+    take: "12",
+    skip: "0",
+  });
 
-const getCatalogue = async (_event: Electron.IpcMainInvokeEvent) => {
-  const trendingGames = await requestSteam250("/90day");
-  const results: CatalogueEntry[] = [];
+  const response = await HydraApi.get<{ objectId: string; shop: GameShop }[]>(
+    `/games/${category}?${params.toString()}`
+  );
 
-  for (let i = 0; i < resultSize; i++) {
-    if (!trendingGames[i]) {
-      i++;
-      continue;
-    }
+  return Promise.all(
+    response.map(async (game) => {
+      const steamGame = await steamGamesWorker.run(Number(game.objectId), {
+        name: "getById",
+      });
 
-    const { title, objectID } = trendingGames[i]!;
-    const repacks = RepacksManager.search({ query: formatName(title) });
+      const repacks = RepacksManager.search({
+        query: formatName(steamGame.name),
+      });
 
-    const catalogueEntry = {
-      objectID,
-      title,
-      shop: "steam" as GameShop,
-      cover: steamUrlBuilder.library(objectID),
-    };
-
-    results.push({ ...catalogueEntry, repacks });
-  }
-
-  return results;
+      return {
+        title: steamGame.name,
+        shop: game.shop,
+        repacks,
+        cover: steamUrlBuilder.library(game.objectId),
+        objectID: game.objectId,
+      };
+    })
+  );
 };
 
 registerEvent("getCatalogue", getCatalogue);

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

@@ -0,0 +1,23 @@
+import type { GameShop } from "@types";
+
+import { registerEvent } from "../register-event";
+import { HydraApi } from "@main/services";
+import type { GameStats } from "@types";
+
+const getGameStats = async (
+  _event: Electron.IpcMainInvokeEvent,
+  objectId: string,
+  shop: GameShop
+) => {
+  const params = new URLSearchParams({
+    objectId,
+    shop,
+  });
+
+  const response = await HydraApi.get<GameStats>(
+    `/games/stats?${params.toString()}`
+  );
+  return response;
+};
+
+registerEvent("getGameStats", getGameStats);

src/main/events/index.ts

@@ -8,6 +8,7 @@ import "./catalogue/get-how-long-to-beat";
 import "./catalogue/get-random-game";
 import "./catalogue/search-games";
 import "./catalogue/search-game-repacks";
+import "./catalogue/get-game-stats";
 import "./hardware/get-disk-free-space";
 import "./library/add-game-to-library";
 import "./library/create-game-shortcut";

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

@@ -1,10 +1,27 @@
 import { registerEvent } from "../register-event";
-import { HydraApi } from "@main/services";
+import { HydraApi, logger } from "@main/services";
 import { steamGamesWorker } from "@main/workers";
 import type { UserProfile } from "@types";
 import { getUserFriends } from "./get-user-friends";
 import { steamUrlBuilder } from "@shared";
 
+const getSteamGame = async (objectId: string) => {
+  try {
+    const steamGame = await steamGamesWorker.run(Number(objectId), {
+      name: "getById",
+    });
+
+    return {
+      title: steamGame.name,
+      iconUrl: steamUrlBuilder.icon(objectId, steamGame.clientIcon),
+    };
+  } catch (err) {
+    logger.error("Failed to get Steam game", err);
+
+    return null;
+  }
+};
+
 const getUser = async (
   _event: Electron.IpcMainInvokeEvent,
   userId: string
@@ -20,36 +37,51 @@ const getUser = async (
     if (!profile) return null;
 
     const recentGames = await Promise.all(
-      profile.recentGames.map(async (game) => {
-        const steamGame = await steamGamesWorker.run(Number(game.objectId), {
-          name: "getById",
-        });
+      profile.recentGames
+        .map(async (game) => {
+          const steamGame = await getSteamGame(game.objectId);
 
-        return {
-          ...game,
-          title: steamGame.name,
-          iconUrl: steamUrlBuilder.icon(game.objectId, steamGame.clientIcon),
-        };
-      })
+          return {
+            ...game,
+            ...steamGame,
+          };
+        })
+        .filter((game) => game)
     );
 
-    // const libraryGames = await Promise.all(
-    //   profile.libraryGames.map(async (game) => {
-    //     return getSteamUserGame(game);
-    //   })
-    // );
+    const libraryGames = await Promise.all(
+      profile.libraryGames
+        .map(async (game) => {
+          const steamGame = await getSteamGame(game.objectId);
 
-    // const currentGame = await getGameRunning(profile.currentGame);
+          return {
+            ...game,
+            ...steamGame,
+          };
+        })
+        .filter((game) => game)
+    );
+
+    if (profile.currentGame) {
+      const steamGame = await getSteamGame(profile.currentGame.objectId);
+
+      if (steamGame) {
+        profile.currentGame = {
+          ...profile.currentGame,
+          ...steamGame,
+        };
+      }
+    }
 
     return {
       ...profile,
-      // libraryGames,
+      libraryGames,
       recentGames,
       friends: friends.friends,
       totalFriends: friends.totalFriends,
-      // currentGame,
     };
   } catch (err) {
+    console.log("err", err);
     return null;
   }
 };

src/main/index.ts

@@ -7,7 +7,7 @@ import url from "node:url";
 import { electronApp, optimizer } from "@electron-toolkit/utils";
 import { logger, PythonInstance, WindowManager } from "@main/services";
 import { dataSource } from "@main/data-source";
-import * as resources from "@locales";
+import resources from "@locales";
 import { userPreferencesRepository } from "@main/repository";
 import { knexClient, migrationConfig } from "./knex-client";
 

src/main/services/library-sync/create-game.ts

@@ -3,6 +3,15 @@ import { HydraApi } from "../hydra-api";
 import { gameRepository } from "@main/repository";
 
 export const createGame = async (game: Game) => {
+  console.log({ objectId: game.objectID, shop: game.shop });
+
+  HydraApi.post("/games/download", {
+    objectId: game.objectID,
+    shop: game.shop,
+  }).catch((err) => {
+    console.log(err);
+  });
+
   HydraApi.post(`/profile/games`, {
     objectId: game.objectID,
     playTimeInMilliseconds: Math.trunc(game.playTimeInMilliseconds),