Lightemerald/hydra
1
0
Fork 0
mirror of https://github.com/hydralauncher/hydra.git synced 2026-01-18 08:43:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ci: adding dockerfile

Browse Source
This commit is contained in:
Chubby Granny Chaser
2025-10-13 17:01:45 +01:00
parent a439095260
commit e5659543ce
57 changed files with 1407 additions and 1617 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/main/events/catalogue/check-game-review.ts
View File

@@ -1,15 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { GameShop } from "@types";
const checkGameReview = async (
_event: Electron.IpcMainInvokeEvent,
shop: GameShop,
objectId: string
) => {
return HydraApi.get(`/games/${shop}/${objectId}/reviews/check`, null, {
needsAuth: true,
});
};
registerEvent("checkGameReview", checkGameReview);

18
src/main/events/catalogue/create-game-review.ts
View File

@@ -1,18 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { GameShop } from "@types";
const createGameReview = async (
_event: Electron.IpcMainInvokeEvent,
shop: GameShop,
objectId: string,
reviewHtml: string,
score: number
) => {
return HydraApi.post(`/games/${shop}/${objectId}/reviews`, {
reviewHtml,
score,
});
};
registerEvent("createGameReview", createGameReview);

14
src/main/events/catalogue/delete-review.ts
View File

@@ -1,14 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { GameShop } from "@types";
const deleteReview = async (
_event: Electron.IpcMainInvokeEvent,
shop: GameShop,
objectId: string,
reviewId: string
) => {
return HydraApi.delete(`/games/${shop}/${objectId}/reviews/${reviewId}`);
};
registerEvent("deleteReview", deleteReview);

22
src/main/events/catalogue/get-catalogue.ts
View File

@@ -1,22 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import { CatalogueCategory } from "@shared";
import { ShopAssets } from "@types";
const getCatalogue = async (
_event: Electron.IpcMainInvokeEvent,
category: CatalogueCategory
) => {
const params = new URLSearchParams({
take: "12",
skip: "0",
});
return HydraApi.get<ShopAssets[]>(
`/catalogue/${category}?${params.toString()}`,
{},
{ needsAuth: false }
);
};
registerEvent("getCatalogue", getCatalogue);

10
src/main/events/catalogue/get-developers.ts
View File

@@ -1,10 +0,0 @@
import { HydraApi } from "@main/services";
import { registerEvent } from "../register-event";
const getDevelopers = async (_event: Electron.IpcMainInvokeEvent) => {
return HydraApi.get<string[]>(`/catalogue/developers`, null, {
needsAuth: false,
});
};
registerEvent("getDevelopers", getDevelopers);

26
src/main/events/catalogue/get-game-reviews.ts
View File

@@ -1,26 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { GameShop } from "@types";
const getGameReviews = async (
_event: Electron.IpcMainInvokeEvent,
shop: GameShop,
objectId: string,
take: number = 20,
skip: number = 0,
sortBy: string = "newest"
) => {
const params = new URLSearchParams({
take: take.toString(),
skip: skip.toString(),
sortBy,
});
return HydraApi.get(
`/games/${shop}/${objectId}/reviews?${params.toString()}`,
null,
{ needsAuth: false }
);
};
registerEvent("getGameReviews", getGameReviews);

16
src/main/events/catalogue/get-how-long-to-beat.ts
View File

@@ -1,16 +0,0 @@
import type { GameShop, HowLongToBeatCategory } from "@types";
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const getHowLongToBeat = async (
_event: Electron.IpcMainInvokeEvent,
objectId: string,
shop: GameShop
): Promise<HowLongToBeatCategory[] | null> => {
return HydraApi.get(`/games/${shop}/${objectId}/how-long-to-beat`, null, {
needsAuth: false,
});
};
registerEvent("getHowLongToBeat", getHowLongToBeat);

10
src/main/events/catalogue/get-publishers.ts
View File

@@ -1,10 +0,0 @@
import { HydraApi } from "@main/services";
import { registerEvent } from "../register-event";
const getPublishers = async (_event: Electron.IpcMainInvokeEvent) => {
return HydraApi.get<string[]>(`/catalogue/publishers`, null, {
needsAuth: false,
});
};
registerEvent("getPublishers", getPublishers);

22
src/main/events/catalogue/get-trending-games.ts
View File

@@ -1,22 +0,0 @@
import { db, levelKeys } from "@main/level";
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { TrendingGame } from "@types";
const getTrendingGames = async (_event: Electron.IpcMainInvokeEvent) => {
const language = await db
.get<string, string>(levelKeys.language, {
valueEncoding: "utf8",
})
.then((language) => language || "en");
const trendingGames = await HydraApi.get<TrendingGame[]>(
"/catalogue/featured",
{ language },
{ needsAuth: false }
).catch(() => []);
return trendingGames.slice(0, 1);
};
registerEvent("getTrendingGames", getTrendingGames);

18
src/main/events/catalogue/search-games.ts
View File

@@ -1,18 +0,0 @@
import type { CatalogueSearchPayload } from "@types";
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const searchGames = async (
_event: Electron.IpcMainInvokeEvent,
payload: CatalogueSearchPayload,
take: number,
skip: number
) => {
return HydraApi.post(
"/catalogue/search",
{ ...payload, take, skip },
{ needsAuth: false }
);
};
registerEvent("searchGames", searchGames);

18
src/main/events/catalogue/vote-review.ts
View File

@@ -1,18 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { GameShop } from "@types";
const voteReview = async (
_event: Electron.IpcMainInvokeEvent,
shop: GameShop,
objectId: string,
reviewId: string,
voteType: "upvote" | "downvote"
) => {
return HydraApi.put(
`/games/${shop}/${objectId}/reviews/${reviewId}/${voteType}`,
{}
);
};
registerEvent("voteReview", voteReview);

12
src/main/events/cloud-save/delete-game-artifact.ts
View File

@@ -1,12 +0,0 @@
import { HydraApi } from "@main/services";
import { registerEvent } from "../register-event";
const deleteGameArtifact = async (
_event: Electron.IpcMainInvokeEvent,
gameArtifactId: string
) =>
HydraApi.delete<{ ok: boolean }>(
`/profile/games/artifacts/${gameArtifactId}`
);
registerEvent("deleteGameArtifact", deleteGameArtifact);

33
src/main/events/cloud-save/get-game-artifacts.ts
View File

@@ -1,33 +0,0 @@
import { HydraApi } from "@main/services";
import { registerEvent } from "../register-event";
import type { GameArtifact, GameShop } from "@types";
import { SubscriptionRequiredError, UserNotLoggedInError } from "@shared";
const getGameArtifacts = async (
_event: Electron.IpcMainInvokeEvent,
objectId: string,
shop: GameShop
) => {
const params = new URLSearchParams({
objectId,
shop,
});
return HydraApi.get<GameArtifact[]>(
`/profile/games/artifacts?${params.toString()}`,
{},
{ needsSubscription: true }
).catch((err) => {
if (err instanceof SubscriptionRequiredError) {
return [];
}
if (err instanceof UserNotLoggedInError) {
return [];
}
throw err;
});
};
registerEvent("getGameArtifacts", getGameArtifacts);

14
src/main/events/cloud-save/rename-game-artifact.ts
View File

@@ -1,14 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const renameGameArtifact = async (
_event: Electron.IpcMainInvokeEvent,
gameArtifactId: string,
label: string
) => {
await HydraApi.put(`/profile/games/artifacts/${gameArtifactId}`, {
label,
});
};
registerEvent("renameGameArtifact", renameGameArtifact);

16
src/main/events/cloud-save/toggle-artifact-freeze.ts
View File

@@ -1,16 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const toggleArtifactFreeze = async (
_event: Electron.IpcMainInvokeEvent,
gameArtifactId: string,
freeze: boolean
) => {
if (freeze) {
await HydraApi.put(`/profile/games/artifacts/${gameArtifactId}/freeze`);
} else {
await HydraApi.put(`/profile/games/artifacts/${gameArtifactId}/unfreeze`);
}
};
registerEvent("toggleArtifactFreeze", toggleArtifactFreeze);

30
src/main/events/index.ts
View File

@@ -1,20 +1,9 @@
import { appVersion, defaultDownloadsPath, isStaging } from "@main/constants";
import { ipcMain } from "electron";
import "./catalogue/get-catalogue";
import "./catalogue/get-game-shop-details";
import "./catalogue/get-how-long-to-beat";
import "./catalogue/get-random-game";
import "./catalogue/search-games";
import "./catalogue/get-game-stats";
import "./catalogue/get-trending-games";
import "./catalogue/get-publishers";
import "./catalogue/get-developers";
import "./catalogue/create-game-review";
import "./catalogue/get-game-reviews";
import "./catalogue/vote-review";
import "./catalogue/delete-review";
import "./catalogue/check-game-review";
import "./hardware/get-disk-free-space";
import "./hardware/check-folder-write-permission";
import "./library/add-game-to-library";
@@ -50,9 +39,7 @@ import "./library/copy-custom-game-asset";
import "./misc/open-checkout";
import "./misc/open-external";
import "./misc/show-open-dialog";
import "./misc/get-features";
import "./misc/show-item-in-folder";
import "./misc/get-badges";
import "./misc/install-common-redist";
import "./misc/can-install-common-redist";
import "./misc/save-temp-file";
@@ -60,6 +47,7 @@ import "./misc/delete-temp-file";
import "./misc/install-hydra-decky-plugin";
import "./misc/get-hydra-decky-plugin-info";
import "./misc/check-homebrew-folder-exists";
import "./misc/hydra-api-call";
import "./torrenting/cancel-game-download";
import "./torrenting/pause-game-download";
import "./torrenting/resume-game-download";
@@ -79,33 +67,17 @@ import "./download-sources/put-download-source";
import "./auth/sign-out";
import "./auth/open-auth-window";
import "./auth/get-session-hash";
import "./user/get-user";
import "./user/get-user-library";
import "./user/get-blocked-users";
import "./user/block-user";
import "./user/unblock-user";
import "./user/get-user-friends";
import "./user/get-auth";
import "./user/get-user-stats";
import "./user/report-user";
import "./user/get-unlocked-achievements";
import "./user/get-compared-unlocked-achievements";
import "./profile/get-friend-requests";
import "./profile/get-me";
import "./profile/undo-friendship";
import "./profile/update-friend-request";
import "./profile/update-profile";
import "./profile/process-profile-image";
import "./profile/send-friend-request";
import "./profile/sync-friend-requests";
import "./cloud-save/download-game-artifact";
import "./cloud-save/get-game-artifacts";
import "./cloud-save/get-game-backup-preview";
import "./cloud-save/upload-save-game";
import "./cloud-save/delete-game-artifact";
import "./cloud-save/select-game-backup-path";
import "./cloud-save/toggle-artifact-freeze";
import "./cloud-save/rename-game-artifact";
import "./notifications/publish-new-repacks-notification";
import "./notifications/update-achievement-notification-window";
import "./notifications/show-achievement-test-notification";

22
src/main/events/misc/get-badges.ts
View File

@@ -1,22 +0,0 @@
import { Badge } from "@types";
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import { db, levelKeys } from "@main/level";
const getBadges = async (_event: Electron.IpcMainInvokeEvent) => {
const language = await db
.get<string, string>(levelKeys.language, {
valueEncoding: "utf8",
})
.then((language) => language || "en");
const params = new URLSearchParams({
locale: language,
});
return HydraApi.get<Badge[]>(`/badges?${params.toString()}`, null, {
needsAuth: false,
});
};
registerEvent("getBadges", getBadges);

8
src/main/events/misc/get-features.ts
View File

@@ -1,8 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const getFeatures = async (_event: Electron.IpcMainInvokeEvent) => {
return HydraApi.get<string[]>("/features", null, { needsAuth: false });
};
registerEvent("getFeatures", getFeatures);

38
src/main/events/misc/hydra-api-call.ts Normal file
View File

@@ -0,0 +1,38 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
interface HydraApiCallPayload {
method: "get" | "post" | "put" | "patch" | "delete";
url: string;
data?: unknown;
params?: unknown;
options?: {
needsAuth?: boolean;
needsSubscription?: boolean;
ifModifiedSince?: Date;
};
}
const hydraApiCall = async (
_event: Electron.IpcMainInvokeEvent,
payload: HydraApiCallPayload
) => {
const { method, url, data, params, options } = payload;
switch (method) {
case "get":
return HydraApi.get(url, params, options);
case "post":
return HydraApi.post(url, data, options);
case "put":
return HydraApi.put(url, data, options);
case "patch":
return HydraApi.patch(url, data, options);
case "delete":
return HydraApi.delete(url, options);
default:
throw new Error(`Unsupported HTTP method: ${method}`);
}
};
registerEvent("hydraApiCall", hydraApiCall);

11
src/main/events/profile/get-friend-requests.ts
View File

@@ -1,11 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { FriendRequest } from "@types";
const getFriendRequests = async (
_event: Electron.IpcMainInvokeEvent
): Promise<FriendRequest[]> => {
return HydraApi.get(`/profile/friend-requests`).catch(() => []);
};
registerEvent("getFriendRequests", getFriendRequests);

11
src/main/events/profile/send-friend-request.ts
View File

@@ -1,11 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const sendFriendRequest = async (
_event: Electron.IpcMainInvokeEvent,
userId: string
) => {
return HydraApi.post("/profile/friend-requests", { friendCode: userId });
};
registerEvent("sendFriendRequest", sendFriendRequest);

11
src/main/events/profile/undo-friendship.ts
View File

@@ -1,11 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const undoFriendship = async (
_event: Electron.IpcMainInvokeEvent,
userId: string
) => {
await HydraApi.delete(`/profile/friends/${userId}`);
};
registerEvent("undoFriendship", undoFriendship);

19
src/main/events/profile/update-friend-request.ts
View File

@@ -1,19 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { FriendRequestAction } from "@types";
const updateFriendRequest = async (
_event: Electron.IpcMainInvokeEvent,
userId: string,
action: FriendRequestAction
) => {
if (action == "CANCEL") {
return HydraApi.delete(`/profile/friend-requests/${userId}`);
}
return HydraApi.patch(`/profile/friend-requests/${userId}`, {
requestState: action,
});
};
registerEvent("updateFriendRequest", updateFriendRequest);

11
src/main/events/user/block-user.ts
View File

@@ -1,11 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const blockUser = async (
_event: Electron.IpcMainInvokeEvent,
userId: string
) => {
await HydraApi.post(`/users/${userId}/block`);
};
registerEvent("blockUser", blockUser);

19
src/main/events/user/get-blocked-users.ts
View File

@@ -1,19 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import { UserNotLoggedInError } from "@shared";
import type { UserBlocks } from "@types";
export const getBlockedUsers = async (
_event: Electron.IpcMainInvokeEvent,
take: number,
skip: number
): Promise<UserBlocks> => {
return HydraApi.get(`/profile/blocks`, { take, skip }).catch((err) => {
if (err instanceof UserNotLoggedInError) {
return { blocks: [] };
}
throw err;
});
};
registerEvent("getBlockedUsers", getBlockedUsers);

32
src/main/events/user/get-user-friends.ts
View File

@@ -1,32 +0,0 @@
import { db } from "@main/level";
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { User, UserFriends } from "@types";
import { levelKeys } from "@main/level/sublevels";
export const getUserFriends = async (
userId: string,
take: number,
skip: number
): Promise<UserFriends> => {
const user = await db.get<string, User>(levelKeys.user, {
valueEncoding: "json",
});
if (user?.id === userId) {
return HydraApi.get(`/profile/friends`, { take, skip });
}
return HydraApi.get(`/users/${userId}/friends`, { take, skip });
};
const getUserFriendsEvent = async (
_event: Electron.IpcMainInvokeEvent,
userId: string,
take: number,
skip: number
) => {
return getUserFriends(userId, take, skip);
};
registerEvent("getUserFriends", getUserFriendsEvent);

28
src/main/events/user/get-user-library.ts
View File

@@ -1,28 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { UserLibraryResponse } from "@types";
const getUserLibrary = async (
_event: Electron.IpcMainInvokeEvent,
userId: string,
take: number = 12,
skip: number = 0,
sortBy?: string
): Promise<UserLibraryResponse | null> => {
const params = new URLSearchParams();
params.append("take", take.toString());
params.append("skip", skip.toString());
if (sortBy) {
params.append("sortBy", sortBy);
}
const queryString = params.toString();
const baseUrl = `/users/${userId}/library`;
const url = queryString ? `${baseUrl}?${queryString}` : baseUrl;
return HydraApi.get<UserLibraryResponse>(url).catch(() => null);
};
registerEvent("getUserLibrary", getUserLibrary);

12
src/main/events/user/get-user-stats.ts
View File

@@ -1,12 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { UserStats } from "@types";
export const getUserStats = async (
_event: Electron.IpcMainInvokeEvent,
userId: string
): Promise<UserStats> => {
return HydraApi.get(`/users/${userId}/stats`);
};
registerEvent("getUserStats", getUserStats);

12
src/main/events/user/get-user.ts
View File

@@ -1,12 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
import type { UserProfile } from "@types";
const getUser = async (
_event: Electron.IpcMainInvokeEvent,
userId: string
): Promise<UserProfile | null> => {
return HydraApi.get<UserProfile>(`/users/${userId}`).catch(() => null);
};
registerEvent("getUser", getUser);

16
src/main/events/user/report-user.ts
View File

@@ -1,16 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
export const reportUser = async (
_event: Electron.IpcMainInvokeEvent,
userId: string,
reason: string,
description: string
): Promise<void> => {
return HydraApi.post(`/users/${userId}/report`, {
reason,
description,
});
};
registerEvent("reportUser", reportUser);

11
src/main/events/user/unblock-user.ts
View File

@@ -1,11 +0,0 @@
import { registerEvent } from "../register-event";
import { HydraApi } from "@main/services";
const unblockUser = async (
_event: Electron.IpcMainInvokeEvent,
userId: string
) => {
await HydraApi.post(`/users/${userId}/unblock`);
};
registerEvent("unblockUser", unblockUser);

2
src/main/services/hydra-api.ts
View File

@@ -12,7 +12,7 @@ import { db } from "@main/level";
import { levelKeys } from "@main/level/sublevels";
import type { Auth, User } from "@types";
interface HydraApiOptions {
export interface HydraApiOptions {
needsAuth?: boolean;
needsSubscription?: boolean;
ifModifiedSince?: Date;

16
src/main/services/window-manager.ts
View File

@@ -62,12 +62,16 @@ export class WindowManager {
`${process.env["ELECTRON_RENDERER_URL"]}#/${hash}`
);
} else {
this.mainWindow?.loadFile(
path.join(__dirname, "../renderer/index.html"),
{
hash,
}
);
this.mainWindow
?.loadURL(`https://staging.hydralauncher.gg/#/${hash}`)
.catch(() => {
this.mainWindow?.loadFile(
path.join(__dirname, "../renderer/index.html"),
{
hash,
}
);
});
}
}