feat: updating play label on hero panel

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

@@ -1,25 +1,22 @@
-import { formatName, repackerFormatter } from "@main/helpers";
-import { getTrendingGames } from "@main/services";
-import type { CatalogueCategory, CatalogueEntry } from "@types";
+import { formatName, getSteamAppAsset, repackerFormatter } from "@main/helpers";
+import type { CatalogueCategory, CatalogueEntry, GameShop } from "@types";
 
 import { stateManager } from "@main/state-manager";
-import { searchGames } from "../helpers/search-games";
+import { searchGames, searchRepacks } from "../helpers/search-games";
 import { registerEvent } from "../register-event";
+import { requestSteam250 } from "@main/services";
 
 const repacks = stateManager.getValue("repacks");
 
+interface GetStringForLookup {
+  (index: number): string;
+}
+
 const getCatalogue = async (
   _event: Electron.IpcMainInvokeEvent,
   category: CatalogueCategory
 ) => {
-  const trendingGames = await getTrendingGames();
-
-  let i = 0;
-  const results: CatalogueEntry[] = [];
-
-  const getStringForLookup = (index: number) => {
-    if (category === "trending") return trendingGames[index];
-
+  const getStringForLookup = (index: number): string => {
     const repack = repacks[index];
     const formatter =
       repackerFormatter[repack.repacker as keyof typeof repackerFormatter];
@@ -30,10 +27,56 @@ const getCatalogue = async (
   if (!repacks.length) return [];
 
   const resultSize = 12;
-  const requestSize = resultSize * 2;
-  let lookupRequest = [];
 
-  while (results.length < resultSize) {
+  if (category === "trending") {
+    return getTrendingCatalogue(resultSize);
+  } else {
+    return getRecentlyAddedCatalogue(
+      resultSize,
+      resultSize,
+      getStringForLookup
+    );
+  }
+};
+
+const getTrendingCatalogue = async (
+  resultSize: number
+): Promise<CatalogueEntry[]> => {
+  const results: CatalogueEntry[] = [];
+  const trendingGames = await requestSteam250("/30day");
+  for (
+    let i = 0;
+    i < trendingGames.length && results.length < resultSize;
+    i++
+  ) {
+    if (!trendingGames[i]) continue;
+
+    const { title, objectID } = trendingGames[i];
+    const repacks = searchRepacks(title);
+
+    if (title && repacks.length) {
+      const catalogueEntry = {
+        objectID,
+        title,
+        shop: "steam" as GameShop,
+        cover: getSteamAppAsset("library", objectID),
+      };
+
+      results.push({ ...catalogueEntry, repacks });
+    }
+  }
+  return results;
+};
+
+const getRecentlyAddedCatalogue = async (
+  resultSize: number,
+  requestSize: number,
+  getStringForLookup: GetStringForLookup
+): Promise<CatalogueEntry[]> => {
+  let lookupRequest = [];
+  const results: CatalogueEntry[] = [];
+
+  for (let i = 0; results.length < resultSize; i++) {
     const stringForLookup = getStringForLookup(i);
 
     if (!stringForLookup) {
@@ -41,9 +84,7 @@ const getCatalogue = async (
       continue;
     }
 
-    lookupRequest.push(searchGames(stringForLookup));
-
-    i++;
+    lookupRequest.push(searchGames({ query: stringForLookup }));
 
     if (lookupRequest.length < requestSize) {
       continue;

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

@@ -0,0 +1,32 @@
+import type { CatalogueEntry } from "@types";
+
+import { registerEvent } from "../register-event";
+import { searchGames } from "../helpers/search-games";
+import slice from "lodash/slice";
+
+const getGames = async (
+  _event: Electron.IpcMainInvokeEvent,
+  take?: number,
+  prevCursor = 0
+): Promise<{ results: CatalogueEntry[]; cursor: number }> => {
+  let results: CatalogueEntry[] = [];
+  let i = 0;
+
+  const batchSize = 100;
+
+  while (results.length < take) {
+    const games = await searchGames({
+      take: batchSize,
+      skip: (i + prevCursor) * batchSize,
+    });
+    results = [...results, ...games.filter((game) => game.repacks.length)];
+    i++;
+  }
+
+  return { results: slice(results, 0, take), cursor: prevCursor + i };
+};
+
+registerEvent(getGames, {
+  name: "getGames",
+  memoize: true,
+});

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

@@ -11,10 +11,10 @@ const getRandomGame = async (_event: Electron.IpcMainInvokeEvent) => {
     const shuffledList = shuffle(games);
 
     for (const game of shuffledList) {
-      const repacks = searchRepacks(formatName(game));
+      const repacks = searchRepacks(formatName(game.title));
 
       if (repacks.length) {
-        const results = await searchGames(game);
+        const results = await searchGames({ query: game.title });
 
         if (results.length) {
           return results[0].objectID;

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

@@ -2,7 +2,8 @@ import { registerEvent } from "../register-event";
 import { searchGames } from "../helpers/search-games";
 
 registerEvent(
-  (_event: Electron.IpcMainInvokeEvent, query: string) => searchGames(query),
+  (_event: Electron.IpcMainInvokeEvent, query: string) =>
+    searchGames({ query, take: 12 }),
   {
     name: "searchGames",
     memoize: true,

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

@@ -4,8 +4,10 @@ import orderBy from "lodash/orderBy";
 import type { GameRepack, GameShop, CatalogueEntry } from "@types";
 
 import { formatName, getSteamAppAsset, repackerFormatter } from "@main/helpers";
-import { searchSteamGame } from "@main/services";
 import { stateManager } from "@main/state-manager";
+import { steamGameRepository } from "@main/repository";
+import { FindManyOptions, Like } from "typeorm";
+import { SteamGame } from "@main/entity";
 
 const { Index } = flexSearch;
 const repacksIndex = new Index();
@@ -32,33 +34,41 @@ export const searchRepacks = (title: string): GameRepack[] => {
   );
 };
 
-export const searchGames = async (query: string): Promise<CatalogueEntry[]> => {
-  const formattedName = formatName(query);
+export interface SearchGamesArgs {
+  query?: string;
+  take?: number;
+  skip?: number;
+}
 
-  const steamResults = await searchSteamGame(formattedName);
+export const searchGames = async ({
+  query,
+  take,
+  skip,
+}: SearchGamesArgs): Promise<CatalogueEntry[]> => {
+  const options: FindManyOptions<SteamGame> = {};
 
-  const results = steamResults.map((result) => ({
-    objectID: result.objectID,
-    title: result.name,
-    shop: "steam" as GameShop,
-    cover: getSteamAppAsset("library", result.objectID),
-  }));
-
-  const gamesIndex = new Index({
-    tokenize: "full",
-  });
-
-  for (let i = 0; i < results.length; i++) {
-    const game = results[i];
-    gamesIndex.add(i, game.title);
+  if (query) {
+    options.where = {
+      name: query ? Like(`%${formatName(query)}%`) : undefined,
+    };
   }
 
-  const filteredResults = gamesIndex
-    .search(query)
-    .map((index) => results[index as number]);
+  const steamResults = await steamGameRepository.find({
+    ...options,
+    take,
+    skip,
+    order: { name: "ASC" },
+  });
+
+  const results = steamResults.map((result) => ({
+    objectID: String(result.id),
+    title: result.name,
+    shop: "steam" as GameShop,
+    cover: getSteamAppAsset("library", String(result.id)),
+  }));
 
   return Promise.all(
-    filteredResults.map(async (result) => ({
+    results.map(async (result) => ({
       ...result,
       repacks: searchRepacks(result.title),
     }))

src/main/events/index.ts

@@ -24,6 +24,7 @@ import "./library/remove-game";
 import "./library/delete-game-folder";
 import "./catalogue/get-random-game";
 import "./catalogue/get-how-long-to-beat";
+import "./catalogue/get-games";
 
 ipcMain.handle("ping", () => "pong");
 ipcMain.handle("getVersion", () => app.getVersion());