feat(collections): backend

2025-01-19 16:29:29 +11:00
parent 716eac79bf
commit a309651fe4
19 changed files with 870 additions and 0 deletions
@@ -0,0 +1,11 @@
+# Library Format
+
+Drop uses a filesystem-based library format, as it targets homelabs and not enterprise-grade solutions. The format works as follows:
+
+## /{game name}
+
+The game name is only used for initial matching, and doesn't affect actual metadata. Metadata is linked to the game's database entry, which is linked to it's filesystem name (they, however, can be completely different).
+
+## /{game name}/{version name}
+
+The version name can be anything. Versions have to manually imported within the web UI. There, you can change the order of the updates and mark them as deltas. Delta updates apply files over the previous versions. 
@@ -0,0 +1,309 @@
+/**
+ * The Library Manager keeps track of games in Drop's library and their various states.
+ * It uses path relative to the library, so it can moved without issue
+ *
+ * It also provides the endpoints with information about unmatched games
+ */
+
+import fs from "fs";
+import path from "path";
+import prisma from "../db/database";
+import { GameVersion, Platform } from "@prisma/client";
+import { fuzzy } from "fast-fuzzy";
+import { recursivelyReaddir } from "../utils/recursivedirs";
+import taskHandler from "../tasks";
+import { parsePlatform } from "../utils/parseplatform";
+import droplet from "@drop/droplet";
+
+class AppLibraryManager {
+  private basePath: string;
+
+  constructor() {
+    this.basePath = process.env.LIBRARY ?? "./.data/library";
+    fs.mkdirSync(this.basePath, { recursive: true });
+  }
+
+  fetchLibraryPath() {
+    return this.basePath;
+  }
+
+  async fetchAllUnimportedGames() {
+    const dirs = fs.readdirSync(this.basePath).filter((e) => {
+      const fullDir = path.join(this.basePath, e);
+      return fs.lstatSync(fullDir).isDirectory();
+    });
+
+    const validGames = await prisma.game.findMany({
+      where: {
+        libraryBasePath: { in: dirs },
+      },
+      select: {
+        libraryBasePath: true,
+      },
+    });
+    const validGameDirs = validGames.map((e) => e.libraryBasePath);
+
+    const unregisteredGames = dirs.filter((e) => !validGameDirs.includes(e));
+
+    return unregisteredGames;
+  }
+
+  async fetchUnimportedGameVersions(
+    libraryBasePath: string,
+    versions: Array<GameVersion>
+  ) {
+    const gameDir = path.join(this.basePath, libraryBasePath);
+    const versionsDirs = fs.readdirSync(gameDir);
+    const importedVersionDirs = versions.map((e) => e.versionName);
+    const unimportedVersions = versionsDirs.filter(
+      (e) => !importedVersionDirs.includes(e)
+    );
+
+    return unimportedVersions;
+  }
+
+  async fetchGamesWithStatus() {
+    const games = await prisma.game.findMany({
+      select: {
+        id: true,
+        versions: true,
+        mName: true,
+        mShortDescription: true,
+        metadataSource: true,
+        mDevelopers: true,
+        mPublishers: true,
+        mIconId: true,
+        libraryBasePath: true,
+      },
+      orderBy: {
+        mName: "asc",
+      },
+    });
+
+    return await Promise.all(
+      games.map(async (e) => ({
+        game: e,
+        status: {
+          noVersions: e.versions.length == 0,
+          unimportedVersions: await this.fetchUnimportedGameVersions(
+            e.libraryBasePath,
+            e.versions
+          ),
+        },
+      }))
+    );
+  }
+
+  async fetchUnimportedVersions(gameId: string) {
+    const game = await prisma.game.findUnique({
+      where: { id: gameId },
+      select: {
+        versions: {
+          select: {
+            versionName: true,
+          },
+        },
+        libraryBasePath: true,
+      },
+    });
+
+    if (!game) return undefined;
+    const targetDir = path.join(this.basePath, game.libraryBasePath);
+    if (!fs.existsSync(targetDir))
+      throw new Error(
+        "Game in database, but no physical directory? Something is very very wrong..."
+      );
+    const versions = fs.readdirSync(targetDir);
+    const validVersions = versions.filter((versionDir) => {
+      const versionPath = path.join(targetDir, versionDir);
+      const stat = fs.statSync(versionPath);
+      return stat.isDirectory();
+    });
+    const currentVersions = game.versions.map((e) => e.versionName);
+
+    const unimportedVersions = validVersions.filter(
+      (e) => !currentVersions.includes(e)
+    );
+    return unimportedVersions;
+  }
+
+  async fetchUnimportedVersionInformation(gameId: string, versionName: string) {
+    const game = await prisma.game.findUnique({
+      where: { id: gameId },
+      select: { libraryBasePath: true, mName: true },
+    });
+    if (!game) return undefined;
+    const targetDir = path.join(
+      this.basePath,
+      game.libraryBasePath,
+      versionName
+    );
+    if (!fs.existsSync(targetDir)) return undefined;
+
+    const fileExts: { [key: string]: string[] } = {
+      Linux: [
+        // Ext for Unity games
+        ".x86_64",
+        // Shell scripts
+        ".sh",
+        // No extension is common for Linux binaries
+        "",
+      ],
+      Windows: [
+        // Pretty much the only one
+        ".exe",
+      ],
+    };
+
+    const options: Array<{
+      filename: string;
+      platform: string;
+      match: number;
+    }> = [];
+
+    const files = recursivelyReaddir(targetDir, 2);
+    for (const file of files) {
+      const filename = path.basename(file);
+      const dotLocation = file.lastIndexOf(".");
+      const ext = dotLocation == -1 ? "" : file.slice(dotLocation);
+      for (const [platform, checkExts] of Object.entries(fileExts)) {
+        for (const checkExt of checkExts) {
+          if (checkExt != ext) continue;
+          const fuzzyValue = fuzzy(filename, game.mName);
+          const relative = path.relative(targetDir, file);
+          options.push({
+            filename: relative,
+            platform: platform,
+            match: fuzzyValue,
+          });
+        }
+      }
+    }
+
+    const sortedOptions = options.sort((a, b) => b.match - a.match);
+
+    return sortedOptions;
+  }
+
+  // Checks are done in least to most expensive order
+  async checkUnimportedGamePath(targetPath: string) {
+    const targetDir = path.join(this.basePath, targetPath);
+    if (!fs.existsSync(targetDir)) return false;
+
+    const hasGame =
+      (await prisma.game.count({ where: { libraryBasePath: targetPath } })) > 0;
+    if (hasGame) return false;
+
+    return true;
+  }
+
+  async importVersion(
+    gameId: string,
+    versionName: string,
+    metadata: {
+      platform: string;
+      onlySetup: boolean;
+
+      setup: string;
+      setupArgs: string;
+      launch: string;
+      launchArgs: string;
+      delta: boolean;
+
+      umuId: string;
+    }
+  ) {
+    const taskId = `import:${gameId}:${versionName}`;
+
+    const platform = parsePlatform(metadata.platform);
+    if (!platform) return undefined;
+
+    const game = await prisma.game.findUnique({
+      where: { id: gameId },
+      select: { mName: true, libraryBasePath: true },
+    });
+    if (!game) return undefined;
+
+    const baseDir = path.join(this.basePath, game.libraryBasePath, versionName);
+    if (!fs.existsSync(baseDir)) return undefined;
+
+    taskHandler.create({
+      id: taskId,
+      name: `Importing version ${versionName} for ${game.mName}`,
+      requireAdmin: true,
+      async run({ progress, log }) {
+        // First, create the manifest via droplet.
+        // This takes up 90% of our progress, so we wrap it in a *0.9
+        const manifest = await new Promise<string>((resolve, reject) => {
+          droplet.generateManifest(
+            baseDir,
+            (err, value) => {
+              if (err) return reject(err);
+              progress(value * 0.9);
+            },
+            (err, line) => {
+              if (err) return reject(err);
+              log(line);
+            },
+            (err, manifest) => {
+              if (err) return reject(err);
+              resolve(manifest);
+            }
+          );
+        });
+
+        log("Created manifest successfully!");
+
+        const currentIndex = await prisma.gameVersion.count({
+          where: { gameId: gameId },
+        });
+
+        // Then, create the database object
+        if (metadata.onlySetup) {
+          await prisma.gameVersion.create({
+            data: {
+              gameId: gameId,
+              versionName: versionName,
+              dropletManifest: manifest,
+              versionIndex: currentIndex,
+              delta: metadata.delta,
+              umuIdOverride: metadata.umuId,
+              platform: platform,
+
+              onlySetup: true,
+              setupCommand: metadata.setup,
+              setupArgs: metadata.setupArgs.split(" "),
+            },
+          });
+        } else {
+          await prisma.gameVersion.create({
+            data: {
+              gameId: gameId,
+              versionName: versionName,
+              dropletManifest: manifest,
+              versionIndex: currentIndex,
+              delta: metadata.delta,
+              umuIdOverride: metadata.umuId,
+              platform: platform,
+
+              onlySetup: false,
+              setupCommand: metadata.setup,
+              setupArgs: metadata.setupArgs.split(" "),
+              launchCommand: metadata.launch,
+              launchArgs: metadata.launchArgs.split(" "),
+            },
+          });
+        }
+
+        log("Successfully created version!");
+
+        progress(100);
+      },
+    });
+
+    return taskId;
+  }
+}
+
+export const appLibraryManager = new AppLibraryManager();
+export default appLibraryManager;
@@ -0,0 +1,119 @@
+/*
+Handles managing collections
+*/
+
+import prisma from "../db/database";
+
+class UserLibraryManager {
+  // Caches the user's core library
+  private userCoreLibraryCache: { [key: string]: string } = {};
+
+  constructor() {}
+
+  private async fetchUserLibrary(userId: string) {
+    if (this.userCoreLibraryCache[userId])
+      return this.userCoreLibraryCache[userId];
+
+    let collection = await prisma.collection.findFirst({
+      where: {
+        userId,
+        isDefault: true,
+      },
+    });
+
+    if (!collection)
+      collection = await prisma.collection.create({
+        data: {
+          name: "Library",
+          userId,
+          isDefault: true,
+        },
+      });
+
+    this.userCoreLibraryCache[userId] = collection.id;
+
+    return collection.id;
+  }
+
+  async libraryAdd(gameId: string, userId: string) {
+    const userLibraryId = await this.fetchUserLibrary(userId);
+    await this.collectionAdd(gameId, userLibraryId);
+  }
+
+  async libraryRemove(gameId: string, userId: string) {
+    const userLibraryId = await this.fetchUserLibrary(userId);
+    await this.collectionRemove(gameId, userLibraryId);
+  }
+
+  async fetchLibrary(userId: string) {
+    const userLibraryId = await this.fetchUserLibrary(userId);
+    const userLibrary = await prisma.collection.findUnique({
+      where: { id: userLibraryId },
+      include: { entries: { include: { game: true } } },
+    });
+    if (!userLibrary) throw new Error("Failed to load user library");
+    return userLibrary;
+  }
+
+  async fetchCollection(collectionId: string) {
+    return await prisma.collection.findUnique({
+      where: { id: collectionId },
+      include: { entries: { include: { game: true } } },
+    });
+  }
+
+  async fetchCollections(userId: string) {
+    await this.fetchUserLibrary(userId); // Ensures user library exists, doesn't have much performance impact due to caching
+    return await prisma.collection.findMany({ where: { userId } });
+  }
+
+  async collectionAdd(gameId: string, collectionId: string) {
+    await prisma.collectionEntry.upsert({
+      where: {
+        collectionId_gameId: {
+          collectionId,
+          gameId,
+        },
+      },
+      create: {
+        collectionId,
+        gameId,
+      },
+      update: {},
+    });
+  }
+
+  async collectionRemove(gameId: string, collectionId: string) {
+    // Delete if exists
+    return (
+      (
+        await prisma.collectionEntry.deleteMany({
+          where: {
+            collectionId,
+            gameId,
+          },
+        })
+      ).count > 0
+    );
+  }
+
+  async collectionCreate(name: string, userId: string) {
+    return await prisma.collection.create({
+      data: {
+        name,
+        userId: userId,
+      },
+    });
+  }
+
+  async deleteCollection(collectionId: string) {
+    await prisma.collection.delete({
+      where: {
+        id: collectionId,
+      },
+    });
+  }
+}
+
+export const userLibraryManager = new UserLibraryManager();
+export default userLibraryManager;