feat: migrating achievements to level

src/main/services/achievements/get-game-achievement-data.ts

@@ -1,40 +1,36 @@
-import {
-  gameAchievementRepository,
-  userPreferencesRepository,
-} from "@main/repository";
+import { userPreferencesRepository } from "@main/repository";
 import { HydraApi } from "../hydra-api";
-import type { AchievementData, GameShop } from "@types";
+import type { GameShop, SteamAchievement } from "@types";
 import { UserNotLoggedInError } from "@shared";
 import { logger } from "../logger";
-import { GameAchievement } from "@main/entity";
+import { gameAchievementsSublevel, levelKeys } from "@main/level";
 
 export const getGameAchievementData = async (
   objectId: string,
   shop: GameShop,
-  cachedAchievements: GameAchievement | null
+  useCachedData: boolean
 ) => {
-  if (cachedAchievements && cachedAchievements.achievements) {
-    return JSON.parse(cachedAchievements.achievements) as AchievementData[];
-  }
+  const cachedAchievements = await gameAchievementsSublevel.get(
+    levelKeys.game(shop, objectId)
+  );
+
+  if (cachedAchievements && useCachedData)
+    return cachedAchievements.achievements;
 
   const userPreferences = await userPreferencesRepository.findOne({
     where: { id: 1 },
   });
 
-  return HydraApi.get<AchievementData[]>("/games/achievements", {
+  return HydraApi.get<SteamAchievement[]>("/games/achievements", {
     shop,
     objectId,
     language: userPreferences?.language || "en",
   })
-    .then((achievements) => {
-      gameAchievementRepository.upsert(
-        {
-          objectId,
-          shop,
-          achievements: JSON.stringify(achievements),
-        },
-        ["objectId", "shop"]
-      );
+    .then(async (achievements) => {
+      await gameAchievementsSublevel.put(levelKeys.game(shop, objectId), {
+        unlockedAchievements: cachedAchievements?.unlockedAchievements ?? [],
+        achievements,
+      });
 
       return achievements;
     })
@@ -42,15 +38,9 @@ export const getGameAchievementData = async (
       if (err instanceof UserNotLoggedInError) {
         throw err;
       }
+
       logger.error("Failed to get game achievements", err);
-      return gameAchievementRepository
-        .findOne({
-          where: { objectId, shop },
-        })
-        .then((gameAchievements) => {
-          return JSON.parse(
-            gameAchievements?.achievements || "[]"
-          ) as AchievementData[];
-        });
+
+      return [];
     });
 };

src/main/services/achievements/merge-achievements.ts

@@ -1,8 +1,5 @@
-import {
-  gameAchievementRepository,
-  userPreferencesRepository,
-} from "@main/repository";
-import type { AchievementData, GameShop, UnlockedAchievement } from "@types";
+import { userPreferencesRepository } from "@main/repository";
+import type { GameShop, UnlockedAchievement } from "@types";
 import { WindowManager } from "../window-manager";
 import { HydraApi } from "../hydra-api";
 import { getUnlockedAchievements } from "@main/events/user/get-unlocked-achievements";
@@ -10,33 +7,36 @@ import { Game } from "@main/entity";
 import { publishNewAchievementNotification } from "../notifications";
 import { SubscriptionRequiredError } from "@shared";
 import { achievementsLogger } from "../logger";
+import { gameAchievementsSublevel, levelKeys } from "@main/level";
 
 const saveAchievementsOnLocal = async (
   objectId: string,
   shop: GameShop,
-  achievements: UnlockedAchievement[],
+  unlockedAchievements: UnlockedAchievement[],
   sendUpdateEvent: boolean
 ) => {
-  return gameAchievementRepository
-    .upsert(
-      {
-        objectId,
-        shop,
-        unlockedAchievements: JSON.stringify(achievements),
-      },
-      ["objectId", "shop"]
-    )
-    .then(() => {
-      if (!sendUpdateEvent) return;
+  const levelKey = levelKeys.game(shop, objectId);
 
-      return getUnlockedAchievements(objectId, shop, true)
-        .then((achievements) => {
-          WindowManager.mainWindow?.webContents.send(
-            `on-update-achievements-${objectId}-${shop}`,
-            achievements
-          );
-        })
-        .catch(() => {});
+  return gameAchievementsSublevel
+    .get(levelKey)
+    .then(async (gameAchievement) => {
+      if (gameAchievement) {
+        await gameAchievementsSublevel.put(levelKey, {
+          ...gameAchievement,
+          unlockedAchievements: unlockedAchievements,
+        });
+
+        if (!sendUpdateEvent) return;
+
+        return getUnlockedAchievements(objectId, shop, true)
+          .then((achievements) => {
+            WindowManager.mainWindow?.webContents.send(
+              `on-update-achievements-${objectId}-${shop}`,
+              achievements
+            );
+          })
+          .catch(() => {});
+      }
     });
 };
 
@@ -46,22 +46,12 @@ export const mergeAchievements = async (
   publishNotification: boolean
 ) => {
   const [localGameAchievement, userPreferences] = await Promise.all([
-    gameAchievementRepository.findOne({
-      where: {
-        objectId: game.objectID,
-        shop: game.shop,
-      },
-    }),
+    gameAchievementsSublevel.get(levelKeys.game(game.shop, game.objectID)),
     userPreferencesRepository.findOne({ where: { id: 1 } }),
   ]);
 
-  const achievementsData = JSON.parse(
-    localGameAchievement?.achievements || "[]"
-  ) as AchievementData[];
-
-  const unlockedAchievements = JSON.parse(
-    localGameAchievement?.unlockedAchievements || "[]"
-  ).filter((achievement) => achievement.name) as UnlockedAchievement[];
+  const achievementsData = localGameAchievement?.achievements ?? [];
+  const unlockedAchievements = localGameAchievement?.unlockedAchievements ?? [];
 
   const newAchievementsMap = new Map(
     achievements.reverse().map((achievement) => {

src/main/services/hydra-api.ts

@@ -10,7 +10,7 @@ import { appVersion } from "@main/constants";
 import { getUserData } from "./user/get-user-data";
 import { isFuture, isToday } from "date-fns";
 import { db } from "@main/level";
-import { levelKeys } from "@main/level/sublevels/keys";
+import { levelKeys } from "@main/level/sublevels";
 import type { Auth, User } from "@types";
 import { Crypto } from "./crypto";
 

src/main/services/user/get-user-data.ts

@@ -3,7 +3,7 @@ import { HydraApi } from "../hydra-api";
 import { UserNotLoggedInError } from "@shared";
 import { logger } from "../logger";
 import { db } from "@main/level";
-import { levelKeys } from "@main/level/sublevels/keys";
+import { levelKeys } from "@main/level/sublevels";
 
 export const getUserData = async () => {
   return HydraApi.get<UserDetails>(`/profile/me`)