mirror of
https://github.com/hydralauncher/hydra.git
synced 2026-01-24 19:31:03 +00:00
feat: using api download sources
This commit is contained in:
Chubby Granny Chaser
@@ -1,76 +1,45 @@
|
||||
import { registerEvent } from "../register-event";
|
||||
import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
|
||||
import { HydraApi, logger } from "@main/services";
|
||||
import { importDownloadSourceToLocal } from "./helpers";
|
||||
import { HydraApi } from "@main/services/hydra-api";
|
||||
import { downloadSourcesSublevel } from "@main/level";
|
||||
import type { DownloadSource } from "@types";
|
||||
|
||||
const addDownloadSource = async (
|
||||
_event: Electron.IpcMainInvokeEvent,
|
||||
url: string
|
||||
) => {
|
||||
const result = await importDownloadSourceToLocal(url, true);
|
||||
if (!result) {
|
||||
throw new Error("Failed to import download source");
|
||||
}
|
||||
|
||||
// Verify that repacks were actually written to the database (read-after-write)
|
||||
// This ensures all async operations are complete before proceeding
|
||||
let repackCount = 0;
|
||||
for await (const [, repack] of repacksSublevel.iterator()) {
|
||||
if (repack.downloadSourceId === result.id) {
|
||||
repackCount++;
|
||||
}
|
||||
}
|
||||
|
||||
await HydraApi.post("/profile/download-sources", {
|
||||
urls: [url],
|
||||
});
|
||||
|
||||
const { fingerprint } = await HydraApi.put<{ fingerprint: string }>(
|
||||
"/download-sources",
|
||||
{
|
||||
objectIds: result.objectIds,
|
||||
},
|
||||
{ needsAuth: false }
|
||||
);
|
||||
|
||||
// Update the source with fingerprint
|
||||
const updatedSource = await downloadSourcesSublevel.get(`${result.id}`);
|
||||
if (updatedSource) {
|
||||
await downloadSourcesSublevel.put(`${result.id}`, {
|
||||
...updatedSource,
|
||||
fingerprint,
|
||||
updatedAt: new Date(),
|
||||
});
|
||||
}
|
||||
|
||||
// Final verification: ensure the source with fingerprint is persisted
|
||||
const finalSource = await downloadSourcesSublevel.get(`${result.id}`);
|
||||
if (!finalSource || !finalSource.fingerprint) {
|
||||
throw new Error("Failed to persist download source with fingerprint");
|
||||
}
|
||||
|
||||
// Verify repacks still exist after fingerprint update
|
||||
let finalRepackCount = 0;
|
||||
for await (const [, repack] of repacksSublevel.iterator()) {
|
||||
if (repack.downloadSourceId === result.id) {
|
||||
finalRepackCount++;
|
||||
}
|
||||
}
|
||||
|
||||
if (finalRepackCount !== repackCount) {
|
||||
logger.warn(
|
||||
`Repack count mismatch! Before: ${repackCount}, After: ${finalRepackCount}`
|
||||
try {
|
||||
const downloadSource = await HydraApi.post<DownloadSource>(
|
||||
"/download-sources",
|
||||
{
|
||||
url,
|
||||
},
|
||||
{ needsAuth: false }
|
||||
);
|
||||
} else {
|
||||
logger.info(
|
||||
`Final verification passed: ${finalRepackCount} repacks confirmed`
|
||||
);
|
||||
}
|
||||
|
||||
return {
|
||||
...result,
|
||||
fingerprint,
|
||||
};
|
||||
if (HydraApi.isLoggedIn()) {
|
||||
try {
|
||||
await HydraApi.post("/profile/download-sources", {
|
||||
urls: [url],
|
||||
});
|
||||
} catch (error) {
|
||||
console.error("Failed to add download source to profile:", error);
|
||||
}
|
||||
}
|
||||
|
||||
const downloadSourceForStorage = {
|
||||
...downloadSource,
|
||||
fingerprint: downloadSource.fingerprint || "",
|
||||
};
|
||||
await downloadSourcesSublevel.put(
|
||||
downloadSource.id,
|
||||
downloadSourceForStorage
|
||||
);
|
||||
|
||||
return downloadSource;
|
||||
} catch (error) {
|
||||
console.error("Failed to add download source:", error);
|
||||
throw error;
|
||||
}
|
||||
};
|
||||
|
||||
registerEvent("addDownloadSource", addDownloadSource);
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
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);
|
||||
@@ -1,13 +0,0 @@
|
||||
import { registerEvent } from "../register-event";
|
||||
import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
|
||||
import { invalidateIdCaches } from "./helpers";
|
||||
|
||||
const deleteAllDownloadSources = async (
|
||||
_event: Electron.IpcMainInvokeEvent
|
||||
) => {
|
||||
await Promise.all([repacksSublevel.clear(), downloadSourcesSublevel.clear()]);
|
||||
|
||||
invalidateIdCaches();
|
||||
};
|
||||
|
||||
registerEvent("deleteAllDownloadSources", deleteAllDownloadSources);
|
||||
@@ -1,28 +0,0 @@
|
||||
import { registerEvent } from "../register-event";
|
||||
import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
|
||||
import { invalidateIdCaches } from "./helpers";
|
||||
|
||||
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}`);
|
||||
|
||||
invalidateIdCaches();
|
||||
};
|
||||
|
||||
registerEvent("deleteDownloadSource", deleteDownloadSource);
|
||||
@@ -1,19 +0,0 @@
|
||||
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);
|
||||
@@ -1,8 +1,8 @@
|
||||
import { HydraApi } from "@main/services";
|
||||
import { downloadSourcesSublevel } from "@main/level";
|
||||
import { registerEvent } from "../register-event";
|
||||
|
||||
const getDownloadSources = async (_event: Electron.IpcMainInvokeEvent) => {
|
||||
return HydraApi.get("/profile/download-sources");
|
||||
return downloadSourcesSublevel.values().all();
|
||||
};
|
||||
|
||||
registerEvent("getDownloadSources", getDownloadSources);
|
||||
|
||||
@@ -1,314 +0,0 @@
|
||||
import axios from "axios";
|
||||
import { z } from "zod";
|
||||
import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
|
||||
import { DownloadSourceStatus } from "@shared";
|
||||
import crypto from "node:crypto";
|
||||
import { logger, ResourceCache } from "@main/services";
|
||||
|
||||
export 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),
|
||||
})
|
||||
),
|
||||
});
|
||||
|
||||
export type TitleHashMapping = Record<string, number[]>;
|
||||
|
||||
let titleHashMappingCache: TitleHashMapping | null = null;
|
||||
|
||||
export const getTitleHashMapping = async (): Promise<TitleHashMapping> => {
|
||||
if (titleHashMappingCache) {
|
||||
return titleHashMappingCache;
|
||||
}
|
||||
|
||||
try {
|
||||
const cached =
|
||||
ResourceCache.getCachedData<TitleHashMapping>("sources-manifest");
|
||||
if (cached) {
|
||||
titleHashMappingCache = cached;
|
||||
return cached;
|
||||
}
|
||||
|
||||
const fetched = await ResourceCache.fetchAndCache<TitleHashMapping>(
|
||||
"sources-manifest",
|
||||
"https://cdn.losbroxas.org/sources-manifest.json",
|
||||
10000
|
||||
);
|
||||
titleHashMappingCache = fetched;
|
||||
return fetched;
|
||||
} catch (error) {
|
||||
logger.error("Failed to fetch title hash mapping:", error);
|
||||
return {} as TitleHashMapping;
|
||||
}
|
||||
};
|
||||
|
||||
export const hashTitle = (title: string): string => {
|
||||
return crypto.createHash("sha256").update(title).digest("hex");
|
||||
};
|
||||
|
||||
export type SteamGamesByLetter = Record<string, { id: string; name: string }[]>;
|
||||
export type FormattedSteamGame = {
|
||||
id: string;
|
||||
name: string;
|
||||
formattedName: string;
|
||||
};
|
||||
export type FormattedSteamGamesByLetter = Record<string, FormattedSteamGame[]>;
|
||||
|
||||
export const formatName = (name: string) => {
|
||||
return name
|
||||
.normalize("NFD")
|
||||
.replaceAll(/[\u0300-\u036f]/g, "")
|
||||
.toLowerCase()
|
||||
.replaceAll(/[^a-z0-9]/g, "");
|
||||
};
|
||||
|
||||
export const formatRepackName = (name: string) => {
|
||||
return formatName(name.replace("[DL]", ""));
|
||||
};
|
||||
|
||||
interface DownloadSource {
|
||||
id: number;
|
||||
url: string;
|
||||
name: string;
|
||||
etag: string | null;
|
||||
status: number;
|
||||
downloadCount: number;
|
||||
objectIds: string[];
|
||||
fingerprint?: string;
|
||||
createdAt: Date;
|
||||
updatedAt: Date;
|
||||
}
|
||||
|
||||
const getDownloadSourcesMap = async (): Promise<
|
||||
Map<string, DownloadSource>
|
||||
> => {
|
||||
const map = new Map();
|
||||
for await (const [key, source] of downloadSourcesSublevel.iterator()) {
|
||||
map.set(key, source);
|
||||
}
|
||||
|
||||
return map;
|
||||
};
|
||||
|
||||
export const checkUrlExists = async (url: string): Promise<boolean> => {
|
||||
const sources = await getDownloadSourcesMap();
|
||||
for (const source of sources.values()) {
|
||||
if (source.url === url) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
let steamGamesFormattedCache: FormattedSteamGamesByLetter | null = null;
|
||||
|
||||
export const getSteamGames = async (): Promise<FormattedSteamGamesByLetter> => {
|
||||
if (steamGamesFormattedCache) {
|
||||
return steamGamesFormattedCache;
|
||||
}
|
||||
|
||||
let steamGames: SteamGamesByLetter;
|
||||
|
||||
const cached = ResourceCache.getCachedData<SteamGamesByLetter>(
|
||||
"steam-games-by-letter"
|
||||
);
|
||||
if (cached) {
|
||||
steamGames = cached;
|
||||
} else {
|
||||
steamGames = await ResourceCache.fetchAndCache<SteamGamesByLetter>(
|
||||
"steam-games-by-letter",
|
||||
`${import.meta.env.MAIN_VITE_EXTERNAL_RESOURCES_URL}/steam-games-by-letter.json`
|
||||
);
|
||||
}
|
||||
|
||||
const formattedData: FormattedSteamGamesByLetter = {};
|
||||
for (const [letter, games] of Object.entries(steamGames)) {
|
||||
formattedData[letter] = games.map((game) => ({
|
||||
...game,
|
||||
formattedName: formatName(game.name),
|
||||
}));
|
||||
}
|
||||
|
||||
steamGamesFormattedCache = formattedData;
|
||||
return formattedData;
|
||||
};
|
||||
|
||||
export type SublevelIterator = AsyncIterable<[string, { id: number }]>;
|
||||
|
||||
export interface SublevelWithId {
|
||||
iterator: () => SublevelIterator;
|
||||
}
|
||||
|
||||
let maxRepackId: number | null = null;
|
||||
let maxDownloadSourceId: number | null = null;
|
||||
|
||||
export const getNextId = async (sublevel: SublevelWithId): Promise<number> => {
|
||||
const isRepackSublevel = sublevel === repacksSublevel;
|
||||
const isDownloadSourceSublevel = sublevel === downloadSourcesSublevel;
|
||||
|
||||
if (isRepackSublevel && maxRepackId !== null) {
|
||||
return ++maxRepackId;
|
||||
}
|
||||
|
||||
if (isDownloadSourceSublevel && maxDownloadSourceId !== null) {
|
||||
return ++maxDownloadSourceId;
|
||||
}
|
||||
|
||||
let maxId = 0;
|
||||
for await (const [, value] of sublevel.iterator()) {
|
||||
if (value.id > maxId) {
|
||||
maxId = value.id;
|
||||
}
|
||||
}
|
||||
|
||||
if (isRepackSublevel) {
|
||||
maxRepackId = maxId;
|
||||
} else if (isDownloadSourceSublevel) {
|
||||
maxDownloadSourceId = maxId;
|
||||
}
|
||||
|
||||
return maxId + 1;
|
||||
};
|
||||
|
||||
export const invalidateIdCaches = () => {
|
||||
maxRepackId = null;
|
||||
maxDownloadSourceId = null;
|
||||
};
|
||||
|
||||
export const addNewDownloads = async (
|
||||
downloadSource: { id: number; name: string },
|
||||
downloads: z.infer<typeof downloadSourceSchema>["downloads"],
|
||||
steamGames: FormattedSteamGamesByLetter
|
||||
) => {
|
||||
const now = new Date();
|
||||
const objectIdsOnSource = new Set<string>();
|
||||
|
||||
let nextRepackId = await getNextId(repacksSublevel);
|
||||
|
||||
const batch = repacksSublevel.batch();
|
||||
|
||||
// Get title hash mapping and perform matching in worker thread
|
||||
const titleHashMapping = await getTitleHashMapping();
|
||||
|
||||
const { GameMatcherWorkerManager } = await import("@main/services");
|
||||
const matchResult = await GameMatcherWorkerManager.matchDownloads(
|
||||
downloads,
|
||||
steamGames,
|
||||
titleHashMapping
|
||||
);
|
||||
|
||||
// Process matched results and write to database
|
||||
for (const matchedDownload of matchResult.matchedDownloads) {
|
||||
for (const id of matchedDownload.objectIds) {
|
||||
objectIdsOnSource.add(id);
|
||||
}
|
||||
|
||||
const repack = {
|
||||
id: nextRepackId++,
|
||||
objectIds: matchedDownload.objectIds,
|
||||
title: matchedDownload.title,
|
||||
uris: matchedDownload.uris,
|
||||
fileSize: matchedDownload.fileSize,
|
||||
repacker: downloadSource.name,
|
||||
uploadDate: matchedDownload.uploadDate,
|
||||
downloadSourceId: downloadSource.id,
|
||||
createdAt: now,
|
||||
updatedAt: now,
|
||||
};
|
||||
|
||||
batch.put(`${repack.id}`, repack);
|
||||
}
|
||||
|
||||
await batch.write();
|
||||
|
||||
logger.info(
|
||||
`Matching stats for ${downloadSource.name}: Hash=${matchResult.stats.hashMatchCount}, Fuzzy=${matchResult.stats.fuzzyMatchCount}, None=${matchResult.stats.noMatchCount}`
|
||||
);
|
||||
|
||||
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 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
|
||||
);
|
||||
|
||||
// Invalidate ID caches after creating new repacks to prevent ID collisions
|
||||
invalidateIdCaches();
|
||||
|
||||
return {
|
||||
...downloadSource,
|
||||
objectIds,
|
||||
};
|
||||
};
|
||||
|
||||
export const updateDownloadSourcePreservingTimestamp = async (
|
||||
existingSource: DownloadSource,
|
||||
url: string
|
||||
) => {
|
||||
const response = await axios.get<z.infer<typeof downloadSourceSchema>>(url);
|
||||
|
||||
const updatedSource = {
|
||||
...existingSource,
|
||||
name: response.data.name,
|
||||
etag: response.headers["etag"] || null,
|
||||
status: DownloadSourceStatus.UpToDate,
|
||||
downloadCount: response.data.downloads.length,
|
||||
updatedAt: new Date(),
|
||||
// Preserve the original createdAt timestamp
|
||||
};
|
||||
|
||||
await downloadSourcesSublevel.put(`${existingSource.id}`, updatedSource);
|
||||
|
||||
return updatedSource;
|
||||
};
|
||||
@@ -1,18 +1,27 @@
|
||||
import { HydraApi } from "@main/services";
|
||||
import { downloadSourcesSublevel } from "@main/level";
|
||||
import { registerEvent } from "../register-event";
|
||||
|
||||
const removeDownloadSource = async (
|
||||
_event: Electron.IpcMainInvokeEvent,
|
||||
url?: string,
|
||||
removeAll = false
|
||||
removeAll = false,
|
||||
downloadSourceId?: string
|
||||
) => {
|
||||
const params = new URLSearchParams({
|
||||
all: removeAll.toString(),
|
||||
});
|
||||
|
||||
if (url) params.set("url", url);
|
||||
if (downloadSourceId) params.set("downloadSourceId", downloadSourceId);
|
||||
|
||||
return HydraApi.delete(`/profile/download-sources?${params.toString()}`);
|
||||
if (HydraApi.isLoggedIn()) {
|
||||
void HydraApi.delete(`/profile/download-sources?${params.toString()}`);
|
||||
}
|
||||
|
||||
if (removeAll) {
|
||||
await downloadSourcesSublevel.clear();
|
||||
} else if (downloadSourceId) {
|
||||
await downloadSourcesSublevel.del(downloadSourceId);
|
||||
}
|
||||
};
|
||||
|
||||
registerEvent("removeDownloadSource", removeDownloadSource);
|
||||
|
||||
@@ -1,19 +0,0 @@
|
||||
import { HydraApi, logger } from "@main/services";
|
||||
import { importDownloadSourceToLocal, checkUrlExists } from "./helpers";
|
||||
|
||||
export const syncDownloadSourcesFromApi = async () => {
|
||||
try {
|
||||
const apiSources = await HydraApi.get<
|
||||
{ url: string; createdAt: string; updatedAt: string }[]
|
||||
>("/profile/download-sources");
|
||||
|
||||
for (const apiSource of apiSources) {
|
||||
const exists = await checkUrlExists(apiSource.url);
|
||||
if (!exists) {
|
||||
await importDownloadSourceToLocal(apiSource.url, false);
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
logger.error("Failed to sync download sources from API:", error);
|
||||
}
|
||||
};
|
||||
@@ -1,105 +1,24 @@
|
||||
import { HydraApi } from "@main/services";
|
||||
import { registerEvent } from "../register-event";
|
||||
import axios, { AxiosError } from "axios";
|
||||
import { downloadSourcesSublevel, repacksSublevel } from "@main/level";
|
||||
import { DownloadSourceStatus } from "@shared";
|
||||
import {
|
||||
invalidateIdCaches,
|
||||
downloadSourceSchema,
|
||||
getSteamGames,
|
||||
addNewDownloads,
|
||||
} from "./helpers";
|
||||
import { downloadSourcesSublevel } from "@main/level";
|
||||
import type { DownloadSource } from "@types";
|
||||
|
||||
const syncDownloadSources = async (
|
||||
_event: Electron.IpcMainInvokeEvent
|
||||
): Promise<number> => {
|
||||
let newRepacksCount = 0;
|
||||
const syncDownloadSources = async (_event: Electron.IpcMainInvokeEvent) => {
|
||||
const downloadSources = await downloadSourcesSublevel.values().all();
|
||||
|
||||
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 response = await HydraApi.post<DownloadSource[]>(
|
||||
"/download-sources/sync",
|
||||
{
|
||||
ids: downloadSources.map((downloadSource) => downloadSource.id),
|
||||
},
|
||||
{ needsAuth: false }
|
||||
);
|
||||
|
||||
// Use a Set for O(1) lookups instead of O(n) with array.some()
|
||||
const existingRepackTitles = new Set<string>();
|
||||
for await (const [, repack] of repacksSublevel.iterator()) {
|
||||
existingRepackTitles.add(repack.title);
|
||||
}
|
||||
|
||||
// Handle sources with missing fingerprints individually, don't delete all sources
|
||||
const sourcesWithFingerprints = downloadSources.filter(
|
||||
(source) => source.fingerprint
|
||||
);
|
||||
const sourcesWithoutFingerprints = downloadSources.filter(
|
||||
(source) => !source.fingerprint
|
||||
);
|
||||
|
||||
// For sources without fingerprints, just continue with normal sync
|
||||
// They will get fingerprints updated later by updateMissingFingerprints
|
||||
const allSourcesToSync = [
|
||||
...sourcesWithFingerprints,
|
||||
...sourcesWithoutFingerprints,
|
||||
];
|
||||
|
||||
for (const downloadSource of allSourcesToSync) {
|
||||
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();
|
||||
|
||||
// O(1) lookup instead of O(n) - massive performance improvement
|
||||
const repacks = source.downloads.filter(
|
||||
(download) => !existingRepackTitles.has(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,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
invalidateIdCaches();
|
||||
|
||||
return newRepacksCount;
|
||||
} catch (err) {
|
||||
return -1;
|
||||
for (const downloadSource of response) {
|
||||
await downloadSourcesSublevel.put(downloadSource.id, downloadSource);
|
||||
}
|
||||
|
||||
return response;
|
||||
};
|
||||
|
||||
registerEvent("syncDownloadSources", syncDownloadSources);
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
import { registerEvent } from "../register-event";
|
||||
import { downloadSourcesSublevel } from "@main/level";
|
||||
import { HydraApi, logger } 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;
|
||||
}
|
||||
|
||||
logger.info(
|
||||
`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) {
|
||||
logger.error(
|
||||
`Failed to update fingerprint for source ${source.id}:`,
|
||||
error
|
||||
);
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
return sourcesNeedingFingerprints.length;
|
||||
};
|
||||
|
||||
registerEvent("updateMissingFingerprints", updateMissingFingerprints);
|
||||
@@ -1,32 +0,0 @@
|
||||
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);
|
||||
@@ -63,14 +63,7 @@ import "./autoupdater/restart-and-install-update";
|
||||
import "./user-preferences/authenticate-real-debrid";
|
||||
import "./user-preferences/authenticate-torbox";
|
||||
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";
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
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);
|
||||
@@ -1,18 +1,6 @@
|
||||
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;
|
||||
}
|
||||
import type { DownloadSource } from "@types";
|
||||
|
||||
export const downloadSourcesSublevel = db.sublevel<string, DownloadSource>(
|
||||
levelKeys.downloadSources,
|
||||
|
||||
@@ -7,4 +7,3 @@ export * from "./game-achievements";
|
||||
export * from "./keys";
|
||||
export * from "./themes";
|
||||
export * from "./download-sources";
|
||||
export * from "./repacks";
|
||||
|
||||
@@ -18,5 +18,4 @@ export const levelKeys = {
|
||||
screenState: "screenState",
|
||||
rpcPassword: "rpcPassword",
|
||||
downloadSources: "downloadSources",
|
||||
repacks: "repacks",
|
||||
};
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
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",
|
||||
}
|
||||
);
|
||||
@@ -16,19 +16,11 @@ import {
|
||||
Ludusavi,
|
||||
Lock,
|
||||
DeckyPlugin,
|
||||
ResourceCache,
|
||||
GameMatcherWorkerManager,
|
||||
} from "@main/services";
|
||||
|
||||
export const loadState = async () => {
|
||||
await Lock.acquireLock();
|
||||
|
||||
ResourceCache.initialize();
|
||||
await ResourceCache.updateResourcesOnStartup();
|
||||
|
||||
// Initialize game matcher worker thread
|
||||
GameMatcherWorkerManager.initialize();
|
||||
|
||||
const userPreferences = await db.get<string, UserPreferences | null>(
|
||||
levelKeys.userPreferences,
|
||||
{
|
||||
|
||||
@@ -1,145 +0,0 @@
|
||||
import { Worker } from "worker_threads";
|
||||
import workerPath from "../workers/game-matcher-worker?modulePath";
|
||||
|
||||
interface WorkerMessage {
|
||||
id: string;
|
||||
data: unknown;
|
||||
}
|
||||
|
||||
interface WorkerResponse {
|
||||
id: string;
|
||||
success: boolean;
|
||||
result?: unknown;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export type TitleHashMapping = Record<string, number[]>;
|
||||
|
||||
export type FormattedSteamGame = {
|
||||
id: string;
|
||||
name: string;
|
||||
formattedName: string;
|
||||
};
|
||||
export type FormattedSteamGamesByLetter = Record<string, FormattedSteamGame[]>;
|
||||
|
||||
interface DownloadToMatch {
|
||||
title: string;
|
||||
uris: string[];
|
||||
uploadDate: string;
|
||||
fileSize: string;
|
||||
}
|
||||
|
||||
interface MatchedDownload {
|
||||
title: string;
|
||||
uris: string[];
|
||||
uploadDate: string;
|
||||
fileSize: string;
|
||||
objectIds: string[];
|
||||
usedHashMatch: boolean;
|
||||
}
|
||||
|
||||
interface MatchResponse {
|
||||
matchedDownloads: MatchedDownload[];
|
||||
stats: {
|
||||
hashMatchCount: number;
|
||||
fuzzyMatchCount: number;
|
||||
noMatchCount: number;
|
||||
};
|
||||
}
|
||||
|
||||
export class GameMatcherWorkerManager {
|
||||
private static worker: Worker | null = null;
|
||||
private static messageId = 0;
|
||||
private static pendingMessages = new Map<
|
||||
string,
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
{ resolve: (value: any) => void; reject: (error: Error) => void }
|
||||
>();
|
||||
|
||||
public static initialize() {
|
||||
if (this.worker) {
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
console.log(
|
||||
"[GameMatcherWorker] Initializing worker with path:",
|
||||
workerPath
|
||||
);
|
||||
|
||||
this.worker = new Worker(workerPath);
|
||||
|
||||
this.worker.on("message", (response: WorkerResponse) => {
|
||||
const pending = this.pendingMessages.get(response.id);
|
||||
if (pending) {
|
||||
if (response.success) {
|
||||
pending.resolve(response.result);
|
||||
} else {
|
||||
pending.reject(new Error(response.error || "Unknown error"));
|
||||
}
|
||||
this.pendingMessages.delete(response.id);
|
||||
}
|
||||
});
|
||||
|
||||
this.worker.on("error", (error) => {
|
||||
console.error("[GameMatcherWorker] Worker error:", error);
|
||||
for (const [id, pending] of this.pendingMessages.entries()) {
|
||||
pending.reject(error);
|
||||
this.pendingMessages.delete(id);
|
||||
}
|
||||
});
|
||||
|
||||
this.worker.on("exit", (code) => {
|
||||
if (code !== 0) {
|
||||
console.error(
|
||||
`[GameMatcherWorker] Worker stopped with exit code ${code}`
|
||||
);
|
||||
}
|
||||
this.worker = null;
|
||||
for (const [id, pending] of this.pendingMessages.entries()) {
|
||||
pending.reject(new Error("Worker exited unexpectedly"));
|
||||
this.pendingMessages.delete(id);
|
||||
}
|
||||
});
|
||||
|
||||
console.log("[GameMatcherWorker] Worker initialized successfully");
|
||||
} catch (error) {
|
||||
console.error("[GameMatcherWorker] Failed to initialize worker:", error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
private static sendMessage<T>(data: unknown): Promise<T> {
|
||||
if (!this.worker) {
|
||||
return Promise.reject(new Error("Worker not initialized"));
|
||||
}
|
||||
|
||||
const id = `msg_${++this.messageId}`;
|
||||
const message: WorkerMessage = { id, data };
|
||||
|
||||
return new Promise<T>((resolve, reject) => {
|
||||
this.pendingMessages.set(id, { resolve, reject });
|
||||
this.worker!.postMessage(message);
|
||||
});
|
||||
}
|
||||
|
||||
public static async matchDownloads(
|
||||
downloads: DownloadToMatch[],
|
||||
steamGames: FormattedSteamGamesByLetter,
|
||||
titleHashMapping: TitleHashMapping
|
||||
): Promise<MatchResponse> {
|
||||
return this.sendMessage<MatchResponse>({
|
||||
downloads,
|
||||
steamGames,
|
||||
titleHashMapping,
|
||||
});
|
||||
}
|
||||
|
||||
public static terminate() {
|
||||
if (this.worker) {
|
||||
this.worker.terminate();
|
||||
this.worker = null;
|
||||
this.pendingMessages.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -105,11 +105,6 @@ export class HydraApi {
|
||||
|
||||
// WSClient.close();
|
||||
// WSClient.connect();
|
||||
|
||||
const { syncDownloadSourcesFromApi } = await import(
|
||||
"../events/download-sources/sync-download-sources-from-api"
|
||||
);
|
||||
syncDownloadSourcesFromApi();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -18,5 +18,3 @@ export * from "./library-sync";
|
||||
export * from "./wine";
|
||||
export * from "./lock";
|
||||
export * from "./decky-plugin";
|
||||
export * from "./resource-cache";
|
||||
export * from "./game-matcher-worker-manager";
|
||||
|
||||
@@ -1,157 +0,0 @@
|
||||
import { app } from "electron";
|
||||
import axios from "axios";
|
||||
import fs from "node:fs";
|
||||
import path from "node:path";
|
||||
import { logger } from "./logger";
|
||||
|
||||
interface CachedResource<T = unknown> {
|
||||
data: T;
|
||||
etag: string | null;
|
||||
}
|
||||
|
||||
export class ResourceCache {
|
||||
private static cacheDir: string;
|
||||
|
||||
static initialize() {
|
||||
this.cacheDir = path.join(app.getPath("userData"), "resource-cache");
|
||||
|
||||
if (!fs.existsSync(this.cacheDir)) {
|
||||
fs.mkdirSync(this.cacheDir, { recursive: true });
|
||||
}
|
||||
}
|
||||
|
||||
private static getCacheFilePath(resourceName: string): string {
|
||||
return path.join(this.cacheDir, `${resourceName}.json`);
|
||||
}
|
||||
|
||||
private static getEtagFilePath(resourceName: string): string {
|
||||
return path.join(this.cacheDir, `${resourceName}.etag`);
|
||||
}
|
||||
|
||||
private static readCachedResource<T = unknown>(
|
||||
resourceName: string
|
||||
): CachedResource<T> | null {
|
||||
const dataPath = this.getCacheFilePath(resourceName);
|
||||
const etagPath = this.getEtagFilePath(resourceName);
|
||||
|
||||
if (!fs.existsSync(dataPath)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
try {
|
||||
const data = JSON.parse(fs.readFileSync(dataPath, "utf-8")) as T;
|
||||
const etag = fs.existsSync(etagPath)
|
||||
? fs.readFileSync(etagPath, "utf-8")
|
||||
: null;
|
||||
|
||||
return { data, etag };
|
||||
} catch (error) {
|
||||
logger.error(`Failed to read cached resource ${resourceName}:`, error);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
private static writeCachedResource<T = unknown>(
|
||||
resourceName: string,
|
||||
data: T,
|
||||
etag: string | null
|
||||
): void {
|
||||
const dataPath = this.getCacheFilePath(resourceName);
|
||||
const etagPath = this.getEtagFilePath(resourceName);
|
||||
|
||||
try {
|
||||
fs.writeFileSync(dataPath, JSON.stringify(data), "utf-8");
|
||||
|
||||
if (etag) {
|
||||
fs.writeFileSync(etagPath, etag, "utf-8");
|
||||
}
|
||||
|
||||
logger.info(
|
||||
`Cached resource ${resourceName} with etag: ${etag || "none"}`
|
||||
);
|
||||
} catch (error) {
|
||||
logger.error(`Failed to write cached resource ${resourceName}:`, error);
|
||||
}
|
||||
}
|
||||
|
||||
static async fetchAndCache<T = unknown>(
|
||||
resourceName: string,
|
||||
url: string,
|
||||
timeout: number = 10000
|
||||
): Promise<T> {
|
||||
const cached = this.readCachedResource<T>(resourceName);
|
||||
const headers: Record<string, string> = {};
|
||||
|
||||
if (cached?.etag) {
|
||||
headers["If-None-Match"] = cached.etag;
|
||||
}
|
||||
|
||||
try {
|
||||
const response = await axios.get<T>(url, {
|
||||
headers,
|
||||
timeout,
|
||||
});
|
||||
|
||||
const newEtag = response.headers["etag"] || null;
|
||||
this.writeCachedResource(resourceName, response.data, newEtag);
|
||||
|
||||
return response.data;
|
||||
} catch (error: unknown) {
|
||||
const axiosError = error as {
|
||||
response?: { status?: number };
|
||||
message?: string;
|
||||
};
|
||||
|
||||
if (axiosError.response?.status === 304 && cached) {
|
||||
logger.info(`Resource ${resourceName} not modified, using cache`);
|
||||
return cached.data;
|
||||
}
|
||||
|
||||
if (cached) {
|
||||
logger.warn(
|
||||
`Failed to fetch ${resourceName}, using cached version:`,
|
||||
axiosError.message || "Unknown error"
|
||||
);
|
||||
return cached.data;
|
||||
}
|
||||
|
||||
logger.error(
|
||||
`Failed to fetch ${resourceName} and no cache available:`,
|
||||
error
|
||||
);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
static getCachedData<T = unknown>(resourceName: string): T | null {
|
||||
const cached = this.readCachedResource<T>(resourceName);
|
||||
return cached?.data || null;
|
||||
}
|
||||
|
||||
static async updateResourcesOnStartup(): Promise<void> {
|
||||
logger.info("Starting background resource cache update...");
|
||||
|
||||
const resources = [
|
||||
{
|
||||
name: "steam-games-by-letter",
|
||||
url: `${import.meta.env.MAIN_VITE_EXTERNAL_RESOURCES_URL}/steam-games-by-letter.json`,
|
||||
},
|
||||
{
|
||||
name: "sources-manifest",
|
||||
url: "https://cdn.losbroxas.org/sources-manifest.json",
|
||||
},
|
||||
];
|
||||
|
||||
await Promise.allSettled(
|
||||
resources.map(async (resource) => {
|
||||
try {
|
||||
await this.fetchAndCache(resource.name, resource.url);
|
||||
} catch (error) {
|
||||
logger.error(`Failed to update ${resource.name} on startup:`, error);
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
logger.info("Resource cache update complete");
|
||||
}
|
||||
}
|
||||
@@ -1,158 +0,0 @@
|
||||
import { parentPort } from "worker_threads";
|
||||
import crypto from "node:crypto";
|
||||
|
||||
export type TitleHashMapping = Record<string, number[]>;
|
||||
|
||||
export type FormattedSteamGame = {
|
||||
id: string;
|
||||
name: string;
|
||||
formattedName: string;
|
||||
};
|
||||
export type FormattedSteamGamesByLetter = Record<string, FormattedSteamGame[]>;
|
||||
|
||||
interface DownloadToMatch {
|
||||
title: string;
|
||||
uris: string[];
|
||||
uploadDate: string;
|
||||
fileSize: string;
|
||||
}
|
||||
|
||||
interface MatchedDownload {
|
||||
title: string;
|
||||
uris: string[];
|
||||
uploadDate: string;
|
||||
fileSize: string;
|
||||
objectIds: string[];
|
||||
usedHashMatch: boolean;
|
||||
}
|
||||
|
||||
interface MatchRequest {
|
||||
downloads: DownloadToMatch[];
|
||||
steamGames: FormattedSteamGamesByLetter;
|
||||
titleHashMapping: TitleHashMapping;
|
||||
}
|
||||
|
||||
interface MatchResponse {
|
||||
matchedDownloads: MatchedDownload[];
|
||||
stats: {
|
||||
hashMatchCount: number;
|
||||
fuzzyMatchCount: number;
|
||||
noMatchCount: number;
|
||||
};
|
||||
}
|
||||
|
||||
const hashTitle = (title: string): string => {
|
||||
return crypto.createHash("sha256").update(title).digest("hex");
|
||||
};
|
||||
|
||||
const formatName = (name: string) => {
|
||||
return name
|
||||
.normalize("NFD")
|
||||
.replaceAll(/[\u0300-\u036f]/g, "")
|
||||
.toLowerCase()
|
||||
.replaceAll(/[^a-z0-9]/g, "");
|
||||
};
|
||||
|
||||
const formatRepackName = (name: string) => {
|
||||
return formatName(name.replace("[DL]", ""));
|
||||
};
|
||||
|
||||
const matchDownloads = (request: MatchRequest): MatchResponse => {
|
||||
const { downloads, steamGames, titleHashMapping } = request;
|
||||
const matchedDownloads: MatchedDownload[] = [];
|
||||
|
||||
let hashMatchCount = 0;
|
||||
let fuzzyMatchCount = 0;
|
||||
let noMatchCount = 0;
|
||||
|
||||
for (const download of downloads) {
|
||||
let objectIds: string[] = [];
|
||||
let usedHashMatch = false;
|
||||
|
||||
const titleHash = hashTitle(download.title);
|
||||
const steamIdsFromHash = titleHashMapping[titleHash];
|
||||
|
||||
if (steamIdsFromHash && steamIdsFromHash.length > 0) {
|
||||
hashMatchCount++;
|
||||
usedHashMatch = true;
|
||||
objectIds = steamIdsFromHash.map(String);
|
||||
}
|
||||
|
||||
if (!usedHashMatch) {
|
||||
let gamesInSteam: FormattedSteamGame[] = [];
|
||||
const formattedTitle = formatRepackName(download.title);
|
||||
|
||||
if (formattedTitle && formattedTitle.length > 0) {
|
||||
const [firstLetter] = formattedTitle;
|
||||
const games = steamGames[firstLetter] || [];
|
||||
|
||||
gamesInSteam = games.filter((game) =>
|
||||
formattedTitle.startsWith(game.formattedName)
|
||||
);
|
||||
|
||||
if (gamesInSteam.length === 0) {
|
||||
gamesInSteam = games.filter(
|
||||
(game) =>
|
||||
formattedTitle.includes(game.formattedName) ||
|
||||
game.formattedName.includes(formattedTitle)
|
||||
);
|
||||
}
|
||||
|
||||
if (gamesInSteam.length === 0) {
|
||||
for (const letter of Object.keys(steamGames)) {
|
||||
const letterGames = steamGames[letter] || [];
|
||||
const matches = letterGames.filter(
|
||||
(game) =>
|
||||
formattedTitle.includes(game.formattedName) ||
|
||||
game.formattedName.includes(formattedTitle)
|
||||
);
|
||||
if (matches.length > 0) {
|
||||
gamesInSteam = matches;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (gamesInSteam.length > 0) {
|
||||
fuzzyMatchCount++;
|
||||
objectIds = gamesInSteam.map((game) => String(game.id));
|
||||
} else {
|
||||
noMatchCount++;
|
||||
}
|
||||
} else {
|
||||
noMatchCount++;
|
||||
}
|
||||
}
|
||||
|
||||
matchedDownloads.push({
|
||||
...download,
|
||||
objectIds,
|
||||
usedHashMatch,
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
matchedDownloads,
|
||||
stats: {
|
||||
hashMatchCount,
|
||||
fuzzyMatchCount,
|
||||
noMatchCount,
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
// Message handler
|
||||
if (parentPort) {
|
||||
parentPort.on("message", (message: { id: string; data: MatchRequest }) => {
|
||||
try {
|
||||
const result = matchDownloads(message.data);
|
||||
parentPort!.postMessage({ id: message.id, success: true, result });
|
||||
} catch (error) {
|
||||
parentPort!.postMessage({
|
||||
id: message.id,
|
||||
success: false,
|
||||
error: error instanceof Error ? error.message : String(error),
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user