feat: removing dexie

src/main/events/download-sources/add-download-source.ts

@@ -0,0 +1,42 @@
+import { registerEvent } from "../register-event";
+import { downloadSourcesSublevel } from "@main/level";
+import { HydraApi } from "@main/services";
+import { importDownloadSourceToLocal } from "./helpers";
+
+const addDownloadSource = async (
+  _event: Electron.IpcMainInvokeEvent,
+  url: string
+) => {
+  const result = await importDownloadSourceToLocal(url, true);
+  if (!result) {
+    throw new Error("Failed to import download source");
+  }
+
+  await HydraApi.post("/profile/download-sources", {
+    urls: [url],
+  });
+
+  const { fingerprint } = await HydraApi.put<{ fingerprint: string }>(
+    "/download-sources",
+    {
+      objectIds: result.objectIds,
+    },
+    { needsAuth: false }
+  );
+
+  const updatedSource = await downloadSourcesSublevel.get(`${result.id}`);
+  if (updatedSource) {
+    await downloadSourcesSublevel.put(`${result.id}`, {
+      ...updatedSource,
+      fingerprint,
+      updatedAt: new Date(),
+    });
+  }
+
+  return {
+    ...result,
+    fingerprint,
+  };
+};
+
+registerEvent("addDownloadSource", addDownloadSource);

src/main/events/download-sources/check-download-source-exists.ts

@@ -0,0 +1,17 @@
+import { registerEvent } from "../register-event";
+import { downloadSourcesSublevel } from "@main/level";
+
+const checkDownloadSourceExists = async (
+  _event: Electron.IpcMainInvokeEvent,
+  url: string
+): Promise<boolean> => {
+  for await (const [, source] of downloadSourcesSublevel.iterator()) {
+    if (source.url === url) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+registerEvent("checkDownloadSourceExists", checkDownloadSourceExists);

src/main/events/download-sources/create-download-sources.ts

@@ -1,13 +0,0 @@
-import { HydraApi } from "@main/services";
-import { registerEvent } from "../register-event";
-
-const createDownloadSources = async (
-  _event: Electron.IpcMainInvokeEvent,
-  urls: string[]
-) => {
-  await HydraApi.post("/profile/download-sources", {
-    urls,
-  });
-};
-
-registerEvent("createDownloadSources", createDownloadSources);

src/main/events/download-sources/delete-all-download-sources.ts

@@ -0,0 +1,10 @@
+import { registerEvent } from "../register-event";
+import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
+
+const deleteAllDownloadSources = async (
+  _event: Electron.IpcMainInvokeEvent
+) => {
+  await Promise.all([repacksSublevel.clear(), downloadSourcesSublevel.clear()]);
+};
+
+registerEvent("deleteAllDownloadSources", deleteAllDownloadSources);

src/main/events/download-sources/delete-download-source.ts

@@ -0,0 +1,25 @@
+import { registerEvent } from "../register-event";
+import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
+
+const deleteDownloadSource = async (
+  _event: Electron.IpcMainInvokeEvent,
+  id: number
+) => {
+  const repacksToDelete: string[] = [];
+
+  for await (const [key, repack] of repacksSublevel.iterator()) {
+    if (repack.downloadSourceId === id) {
+      repacksToDelete.push(key);
+    }
+  }
+
+  const batch = repacksSublevel.batch();
+  for (const key of repacksToDelete) {
+    batch.del(key);
+  }
+  await batch.write();
+
+  await downloadSourcesSublevel.del(`${id}`);
+};
+
+registerEvent("deleteDownloadSource", deleteDownloadSource);

src/main/events/download-sources/get-download-sources-list.ts

@@ -0,0 +1,19 @@
+import { registerEvent } from "../register-event";
+import { downloadSourcesSublevel, DownloadSource } from "@main/level";
+
+const getDownloadSourcesList = async (_event: Electron.IpcMainInvokeEvent) => {
+  const sources: DownloadSource[] = [];
+
+  for await (const [, source] of downloadSourcesSublevel.iterator()) {
+    sources.push(source);
+  }
+
+  // Sort by createdAt descending
+  sources.sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+
+  return sources;
+};
+
+registerEvent("getDownloadSourcesList", getDownloadSourcesList);

src/main/events/download-sources/helpers.ts

@@ -0,0 +1,171 @@
+import axios from "axios";
+import { z } from "zod";
+import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
+import { DownloadSourceStatus } from "@shared";
+
+const downloadSourceSchema = z.object({
+  name: z.string().max(255),
+  downloads: z.array(
+    z.object({
+      title: z.string().max(255),
+      uris: z.array(z.string()),
+      uploadDate: z.string().max(255),
+      fileSize: z.string().max(255),
+    })
+  ),
+});
+
+type SteamGamesByLetter = Record<string, { id: string; name: string }[]>;
+
+const formatName = (name: string) => {
+  return name
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "");
+};
+
+const formatRepackName = (name: string) => {
+  return formatName(name.replace("[DL]", ""));
+};
+
+export const checkUrlExists = async (url: string): Promise<boolean> => {
+  for await (const [, source] of downloadSourcesSublevel.iterator()) {
+    if (source.url === url) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const getSteamGames = async () => {
+  const response = await axios.get<SteamGamesByLetter>(
+    `${import.meta.env.MAIN_VITE_EXTERNAL_RESOURCES_URL}/steam-games-by-letter.json`
+  );
+
+  return response.data;
+};
+
+type SublevelIterator = AsyncIterable<[string, { id: number }]>;
+
+interface SublevelWithId {
+  iterator: () => SublevelIterator;
+}
+
+const getNextId = async (sublevel: SublevelWithId): Promise<number> => {
+  let maxId = 0;
+  for await (const [, value] of sublevel.iterator()) {
+    if (value.id > maxId) {
+      maxId = value.id;
+    }
+  }
+  return maxId + 1;
+};
+
+const addNewDownloads = async (
+  downloadSource: { id: number; name: string },
+  downloads: z.infer<typeof downloadSourceSchema>["downloads"],
+  steamGames: SteamGamesByLetter
+) => {
+  const now = new Date();
+  const objectIdsOnSource = new Set<string>();
+
+  let nextRepackId = await getNextId(repacksSublevel);
+
+  for (const download of downloads) {
+    const formattedTitle = formatRepackName(download.title);
+    const [firstLetter] = formattedTitle;
+    const games = steamGames[firstLetter] || [];
+
+    const gamesInSteam = games.filter((game) =>
+      formattedTitle.startsWith(formatName(game.name))
+    );
+
+    if (gamesInSteam.length === 0) continue;
+
+    for (const game of gamesInSteam) {
+      objectIdsOnSource.add(String(game.id));
+    }
+
+    const repack = {
+      id: nextRepackId++,
+      objectIds: gamesInSteam.map((game) => String(game.id)),
+      title: download.title,
+      uris: download.uris,
+      fileSize: download.fileSize,
+      repacker: downloadSource.name,
+      uploadDate: download.uploadDate,
+      downloadSourceId: downloadSource.id,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    await repacksSublevel.put(`${repack.id}`, repack);
+  }
+
+  const existingSource = await downloadSourcesSublevel.get(
+    `${downloadSource.id}`
+  );
+  if (existingSource) {
+    await downloadSourcesSublevel.put(`${downloadSource.id}`, {
+      ...existingSource,
+      objectIds: Array.from(objectIdsOnSource),
+    });
+  }
+
+  return Array.from(objectIdsOnSource);
+};
+
+export const importDownloadSourceToLocal = async (
+  url: string,
+  throwOnDuplicate = false
+) => {
+  const urlExists = await checkUrlExists(url);
+  if (urlExists) {
+    if (throwOnDuplicate) {
+      throw new Error("Download source with this URL already exists");
+    }
+    return null;
+  }
+
+  const response = await axios.get<z.infer<typeof downloadSourceSchema>>(url);
+
+  const steamGames = await getSteamGames();
+
+  const now = new Date();
+
+  const urlExistsBeforeInsert = await checkUrlExists(url);
+  if (urlExistsBeforeInsert) {
+    if (throwOnDuplicate) {
+      throw new Error("Download source with this URL already exists");
+    }
+    return null;
+  }
+
+  const nextId = await getNextId(downloadSourcesSublevel);
+
+  const downloadSource = {
+    id: nextId,
+    url,
+    name: response.data.name,
+    etag: response.headers["etag"] || null,
+    status: DownloadSourceStatus.UpToDate,
+    downloadCount: response.data.downloads.length,
+    objectIds: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  await downloadSourcesSublevel.put(`${downloadSource.id}`, downloadSource);
+
+  const objectIds = await addNewDownloads(
+    downloadSource,
+    response.data.downloads,
+    steamGames
+  );
+
+  return {
+    ...downloadSource,
+    objectIds,
+  };
+};

src/main/events/download-sources/put-download-source.ts

@@ -1,17 +0,0 @@
-import { HydraApi } from "@main/services";
-import { registerEvent } from "../register-event";
-
-const putDownloadSource = async (
-  _event: Electron.IpcMainInvokeEvent,
-  objectIds: string[]
-) => {
-  return HydraApi.put<{ fingerprint: string }>(
-    "/download-sources",
-    {
-      objectIds,
-    },
-    { needsAuth: false }
-  );
-};
-
-registerEvent("putDownloadSource", putDownloadSource);

src/main/events/download-sources/sync-download-sources-from-api.ts

@@ -0,0 +1,26 @@
+import { HydraApi } from "@main/services";
+import { downloadSourcesSublevel } from "@main/level";
+import { importDownloadSourceToLocal } from "./helpers";
+
+export const syncDownloadSourcesFromApi = async () => {
+  try {
+    const apiSources = await HydraApi.get<
+      { url: string; createdAt: string; updatedAt: string }[]
+    >("/profile/download-sources");
+
+    const localSources: { url: string }[] = [];
+    for await (const [, source] of downloadSourcesSublevel.iterator()) {
+      localSources.push(source);
+    }
+
+    const localUrls = new Set(localSources.map((s) => s.url));
+
+    for (const apiSource of apiSources) {
+      if (!localUrls.has(apiSource.url)) {
+        await importDownloadSourceToLocal(apiSource.url, false);
+      }
+    }
+  } catch (error) {
+    console.error("Failed to sync download sources from API:", error);
+  }
+};

src/main/events/download-sources/sync-download-sources.ts

@@ -0,0 +1,267 @@
+import { registerEvent } from "../register-event";
+import axios, { AxiosError } from "axios";
+import { z } from "zod";
+import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
+import { DownloadSourceStatus } from "@shared";
+
+const downloadSourceSchema = z.object({
+  name: z.string().max(255),
+  downloads: z.array(
+    z.object({
+      title: z.string().max(255),
+      uris: z.array(z.string()),
+      uploadDate: z.string().max(255),
+      fileSize: z.string().max(255),
+    })
+  ),
+});
+
+type SteamGamesByLetter = Record<string, { id: string; name: string }[]>;
+
+const formatName = (name: string) => {
+  return name
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "");
+};
+
+const formatRepackName = (name: string) => {
+  return formatName(name.replace("[DL]", ""));
+};
+
+const checkUrlExists = async (url: string): Promise<boolean> => {
+  for await (const [, source] of downloadSourcesSublevel.iterator()) {
+    if (source.url === url) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const getSteamGames = async () => {
+  const response = await axios.get<SteamGamesByLetter>(
+    `${import.meta.env.MAIN_VITE_EXTERNAL_RESOURCES_URL}/steam-games-by-letter.json`
+  );
+
+  return response.data;
+};
+
+type SublevelIterator = AsyncIterable<[string, { id: number }]>;
+
+interface SublevelWithId {
+  iterator: () => SublevelIterator;
+}
+
+const getNextId = async (sublevel: SublevelWithId): Promise<number> => {
+  let maxId = 0;
+  for await (const [, value] of sublevel.iterator()) {
+    if (value.id > maxId) {
+      maxId = value.id;
+    }
+  }
+  return maxId + 1;
+};
+
+const addNewDownloads = async (
+  downloadSource: { id: number; name: string },
+  downloads: z.infer<typeof downloadSourceSchema>["downloads"],
+  steamGames: SteamGamesByLetter
+) => {
+  const now = new Date();
+  const objectIdsOnSource = new Set<string>();
+
+  let nextRepackId = await getNextId(repacksSublevel);
+
+  for (const download of downloads) {
+    const formattedTitle = formatRepackName(download.title);
+    const [firstLetter] = formattedTitle;
+    const games = steamGames[firstLetter] || [];
+
+    const gamesInSteam = games.filter((game) =>
+      formattedTitle.startsWith(formatName(game.name))
+    );
+
+    if (gamesInSteam.length === 0) continue;
+
+    for (const game of gamesInSteam) {
+      objectIdsOnSource.add(String(game.id));
+    }
+
+    const repack = {
+      id: nextRepackId++,
+      objectIds: gamesInSteam.map((game) => String(game.id)),
+      title: download.title,
+      uris: download.uris,
+      fileSize: download.fileSize,
+      repacker: downloadSource.name,
+      uploadDate: download.uploadDate,
+      downloadSourceId: downloadSource.id,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    await repacksSublevel.put(`${repack.id}`, repack);
+  }
+
+  const existingSource = await downloadSourcesSublevel.get(
+    `${downloadSource.id}`
+  );
+  if (existingSource) {
+    await downloadSourcesSublevel.put(`${downloadSource.id}`, {
+      ...existingSource,
+      objectIds: Array.from(objectIdsOnSource),
+    });
+  }
+};
+
+const deleteDownloadSource = async (id: number) => {
+  const repacksToDelete: string[] = [];
+
+  for await (const [key, repack] of repacksSublevel.iterator()) {
+    if (repack.downloadSourceId === id) {
+      repacksToDelete.push(key);
+    }
+  }
+
+  const batch = repacksSublevel.batch();
+  for (const key of repacksToDelete) {
+    batch.del(key);
+  }
+  await batch.write();
+
+  await downloadSourcesSublevel.del(`${id}`);
+};
+
+const importDownloadSource = async (url: string) => {
+  const urlExists = await checkUrlExists(url);
+  if (urlExists) {
+    return;
+  }
+
+  const response = await axios.get<z.infer<typeof downloadSourceSchema>>(url);
+
+  const steamGames = await getSteamGames();
+
+  const now = new Date();
+
+  const urlExistsBeforeInsert = await checkUrlExists(url);
+  if (urlExistsBeforeInsert) {
+    return;
+  }
+
+  const nextId = await getNextId(downloadSourcesSublevel);
+
+  const downloadSource = {
+    id: nextId,
+    url,
+    name: response.data.name,
+    etag: response.headers["etag"] || null,
+    status: DownloadSourceStatus.UpToDate,
+    downloadCount: response.data.downloads.length,
+    objectIds: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  await downloadSourcesSublevel.put(`${downloadSource.id}`, downloadSource);
+
+  await addNewDownloads(downloadSource, response.data.downloads, steamGames);
+};
+
+const syncDownloadSources = async (
+  _event: Electron.IpcMainInvokeEvent
+): Promise<number> => {
+  let newRepacksCount = 0;
+
+  try {
+    const downloadSources: Array<{
+      id: number;
+      url: string;
+      name: string;
+      etag: string | null;
+      status: number;
+      downloadCount: number;
+      objectIds: string[];
+      fingerprint?: string;
+      createdAt: Date;
+      updatedAt: Date;
+    }> = [];
+    for await (const [, source] of downloadSourcesSublevel.iterator()) {
+      downloadSources.push(source);
+    }
+
+    const existingRepacks: Array<{
+      id: number;
+      title: string;
+      uris: string[];
+      repacker: string;
+      fileSize: string | null;
+      objectIds: string[];
+      uploadDate: Date | string | null;
+      downloadSourceId: number;
+      createdAt: Date;
+      updatedAt: Date;
+    }> = [];
+    for await (const [, repack] of repacksSublevel.iterator()) {
+      existingRepacks.push(repack);
+    }
+
+    if (downloadSources.some((source) => !source.fingerprint)) {
+      await Promise.all(
+        downloadSources.map(async (source) => {
+          await deleteDownloadSource(source.id);
+          await importDownloadSource(source.url);
+        })
+      );
+    } else {
+      for (const downloadSource of downloadSources) {
+        const headers: Record<string, string> = {};
+
+        if (downloadSource.etag) {
+          headers["If-None-Match"] = downloadSource.etag;
+        }
+
+        try {
+          const response = await axios.get(downloadSource.url, {
+            headers,
+          });
+
+          const source = downloadSourceSchema.parse(response.data);
+          const steamGames = await getSteamGames();
+
+          const repacks = source.downloads.filter(
+            (download) =>
+              !existingRepacks.some((repack) => repack.title === download.title)
+          );
+
+          await downloadSourcesSublevel.put(`${downloadSource.id}`, {
+            ...downloadSource,
+            etag: response.headers["etag"] || null,
+            downloadCount: source.downloads.length,
+            status: DownloadSourceStatus.UpToDate,
+          });
+
+          await addNewDownloads(downloadSource, repacks, steamGames);
+
+          newRepacksCount += repacks.length;
+        } catch (err: unknown) {
+          const isNotModified = (err as AxiosError).response?.status === 304;
+
+          await downloadSourcesSublevel.put(`${downloadSource.id}`, {
+            ...downloadSource,
+            status: isNotModified
+              ? DownloadSourceStatus.UpToDate
+              : DownloadSourceStatus.Errored,
+          });
+        }
+      }
+    }
+
+    return newRepacksCount;
+  } catch (err) {
+    return -1;
+  }
+};
+
+registerEvent("syncDownloadSources", syncDownloadSources);

src/main/events/download-sources/update-missing-fingerprints.ts

@@ -0,0 +1,67 @@
+import { registerEvent } from "../register-event";
+import { downloadSourcesSublevel } from "@main/level";
+import { HydraApi } from "@main/services";
+
+const updateMissingFingerprints = async (
+  _event: Electron.IpcMainInvokeEvent
+): Promise<number> => {
+  const sourcesNeedingFingerprints: Array<{
+    id: number;
+    objectIds: string[];
+  }> = [];
+
+  for await (const [, source] of downloadSourcesSublevel.iterator()) {
+    if (
+      !source.fingerprint &&
+      source.objectIds &&
+      source.objectIds.length > 0
+    ) {
+      sourcesNeedingFingerprints.push({
+        id: source.id,
+        objectIds: source.objectIds,
+      });
+    }
+  }
+
+  if (sourcesNeedingFingerprints.length === 0) {
+    return 0;
+  }
+
+  console.log(
+    `Updating fingerprints for ${sourcesNeedingFingerprints.length} sources`
+  );
+
+  await Promise.all(
+    sourcesNeedingFingerprints.map(async (source) => {
+      try {
+        const { fingerprint } = await HydraApi.put<{ fingerprint: string }>(
+          "/download-sources",
+          {
+            objectIds: source.objectIds,
+          },
+          { needsAuth: false }
+        );
+
+        const existingSource = await downloadSourcesSublevel.get(
+          `${source.id}`
+        );
+        if (existingSource) {
+          await downloadSourcesSublevel.put(`${source.id}`, {
+            ...existingSource,
+            fingerprint,
+            updatedAt: new Date(),
+          });
+        }
+      } catch (error) {
+        console.error(
+          `Failed to update fingerprint for source ${source.id}:`,
+          error
+        );
+      }
+    })
+  );
+
+  return sourcesNeedingFingerprints.length;
+};
+
+registerEvent("updateMissingFingerprints", updateMissingFingerprints);

src/main/events/download-sources/validate-download-source.ts

@@ -0,0 +1,32 @@
+import { registerEvent } from "../register-event";
+import axios from "axios";
+import { z } from "zod";
+
+const downloadSourceSchema = z.object({
+  name: z.string().max(255),
+  downloads: z.array(
+    z.object({
+      title: z.string().max(255),
+      uris: z.array(z.string()),
+      uploadDate: z.string().max(255),
+      fileSize: z.string().max(255),
+    })
+  ),
+});
+
+const validateDownloadSource = async (
+  _event: Electron.IpcMainInvokeEvent,
+  url: string
+) => {
+  const response = await axios.get<z.infer<typeof downloadSourceSchema>>(url);
+
+  const { name } = downloadSourceSchema.parse(response.data);
+
+  return {
+    name,
+    etag: response.headers["etag"] || null,
+    downloadCount: response.data.downloads.length,
+  };
+};
+
+registerEvent("validateDownloadSource", validateDownloadSource);

src/main/events/index.ts

@@ -63,7 +63,15 @@ import "./autoupdater/restart-and-install-update";
 import "./user-preferences/authenticate-real-debrid";
 import "./user-preferences/authenticate-all-debrid";
 import "./user-preferences/authenticate-torbox";
-import "./download-sources/put-download-source";
+import "./download-sources/add-download-source";
+import "./download-sources/update-missing-fingerprints";
+import "./download-sources/delete-download-source";
+import "./download-sources/delete-all-download-sources";
+import "./download-sources/validate-download-source";
+import "./download-sources/sync-download-sources";
+import "./download-sources/get-download-sources-list";
+import "./download-sources/check-download-source-exists";
+import "./repacks/get-all-repacks";
 import "./auth/sign-out";
 import "./auth/open-auth-window";
 import "./auth/get-session-hash";
@@ -91,7 +99,6 @@ import "./themes/get-custom-theme-by-id";
 import "./themes/get-active-custom-theme";
 import "./themes/close-editor-window";
 import "./themes/toggle-custom-theme";
-import "./download-sources/create-download-sources";
 import "./download-sources/remove-download-source";
 import "./download-sources/get-download-sources";
 import { isPortableVersion } from "@main/helpers";

src/main/events/library/cleanup-unused-assets.ts

@@ -19,7 +19,6 @@ const getAllCustomGameAssets = async (): Promise<string[]> => {
 };
 
 const getUsedAssetPaths = async (): Promise<Set<string>> => {
-  // Get all custom games from the level database
   const { gamesSublevel } = await import("@main/level");
   const allGames = await gamesSublevel.iterator().all();
 
@@ -30,7 +29,6 @@ const getUsedAssetPaths = async (): Promise<Set<string>> => {
   const usedPaths = new Set<string>();
 
   customGames.forEach((game) => {
-    // Extract file paths from local URLs
     if (game.iconUrl?.startsWith("local:")) {
       usedPaths.add(game.iconUrl.replace("local:", ""));
     }

src/main/events/library/copy-custom-game-asset.ts

@@ -13,29 +13,23 @@ const copyCustomGameAsset = async (
     throw new Error("Source file does not exist");
   }
 
-  // Ensure assets directory exists
   if (!fs.existsSync(ASSETS_PATH)) {
     fs.mkdirSync(ASSETS_PATH, { recursive: true });
   }
 
-  // Create custom games assets subdirectory
   const customGamesAssetsPath = path.join(ASSETS_PATH, "custom-games");
   if (!fs.existsSync(customGamesAssetsPath)) {
     fs.mkdirSync(customGamesAssetsPath, { recursive: true });
   }
 
-  // Get file extension
   const fileExtension = path.extname(sourcePath);
 
-  // Generate unique filename
   const uniqueId = randomUUID();
   const fileName = `${assetType}-${uniqueId}${fileExtension}`;
   const destinationPath = path.join(customGamesAssetsPath, fileName);
 
-  // Copy the file
   await fs.promises.copyFile(sourcePath, destinationPath);
 
-  // Return the local URL format
   return `local:${destinationPath}`;
 };
 

src/main/events/repacks/get-all-repacks.ts

@@ -0,0 +1,16 @@
+import { registerEvent } from "../register-event";
+import { repacksSublevel, GameRepack } from "@main/level";
+
+const getAllRepacks = async (_event: Electron.IpcMainInvokeEvent) => {
+  const repacks: GameRepack[] = [];
+
+  for await (const [, repack] of repacksSublevel.iterator()) {
+    if (Array.isArray(repack.objectIds)) {
+      repacks.push(repack);
+    }
+  }
+
+  return repacks;
+};
+
+registerEvent("getAllRepacks", getAllRepacks);

src/main/level/sublevels/download-sources.ts

@@ -0,0 +1,22 @@
+import { db } from "../level";
+import { levelKeys } from "./keys";
+
+export interface DownloadSource {
+  id: number;
+  name: string;
+  url: string;
+  status: number;
+  objectIds: string[];
+  downloadCount: number;
+  fingerprint?: string;
+  etag: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export const downloadSourcesSublevel = db.sublevel<string, DownloadSource>(
+  levelKeys.downloadSources,
+  {
+    valueEncoding: "json",
+  }
+);

src/main/level/sublevels/index.ts

@@ -6,3 +6,5 @@ export * from "./game-stats-cache";
 export * from "./game-achievements";
 export * from "./keys";
 export * from "./themes";
+export * from "./download-sources";
+export * from "./repacks";

src/main/level/sublevels/keys.ts

@@ -17,4 +17,6 @@ export const levelKeys = {
   language: "language",
   screenState: "screenState",
   rpcPassword: "rpcPassword",
+  downloadSources: "downloadSources",
+  repacks: "repacks",
 };

src/main/level/sublevels/repacks.ts

@@ -0,0 +1,22 @@
+import { db } from "../level";
+import { levelKeys } from "./keys";
+
+export interface GameRepack {
+  id: number;
+  title: string;
+  uris: string[];
+  repacker: string;
+  fileSize: string | null;
+  objectIds: string[];
+  uploadDate: Date | string | null;
+  downloadSourceId: number;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export const repacksSublevel = db.sublevel<string, GameRepack>(
+  levelKeys.repacks,
+  {
+    valueEncoding: "json",
+  }
+);

src/main/services/hydra-api.ts

@@ -102,8 +102,14 @@ export class HydraApi {
       WindowManager.mainWindow.webContents.send("on-signin");
       await clearGamesRemoteIds();
       uploadGamesBatch();
+
       // WSClient.close();
       // WSClient.connect();
+
+      const { syncDownloadSourcesFromApi } = await import(
+        "../events/download-sources/sync-download-sources-from-api"
+      );
+      syncDownloadSourcesFromApi();
     }
   }