feat(collections): backend

components/AddLibraryButton.vue

@@ -0,0 +1,95 @@
+<template>
+  <div class="inline-flex divide-x divide-zinc-900">
+    <button
+      type="button"
+      class="inline-flex justify-center items-center gap-x-2 rounded-l-md aspect-[7/2] px-3 py-2 bg-blue-600 grow text-white shadow-sm hover:bg-blue-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600"
+    >
+      Add to Library
+      <PlusIcon class="-mr-0.5 size-6" aria-hidden="true" />
+    </button>
+    <Menu as="div" class="relative inline-block text-left grow">
+      <div class="h-full">
+        <MenuButton
+          class="inline-flex h-full w-full justify-center items-center rounded-r-md bg-blue-600 p-2 text-sm font-semibold text-white shadow-sm hover:bg-blue-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-blue-600"
+        >
+          <ChevronDownIcon
+            class="size-5"
+            aria-hidden="true"
+          />
+        </MenuButton>
+      </div>
+
+      <transition
+        enter-active-class="transition ease-out duration-100"
+        enter-from-class="transform opacity-0 scale-95"
+        enter-to-class="transform opacity-100 scale-100"
+        leave-active-class="transition ease-in duration-75"
+        leave-from-class="transform opacity-100 scale-100"
+        leave-to-class="transform opacity-0 scale-95"
+      >
+        <MenuItems
+          class="absolute right-0 z-10 mt-2 w-56 origin-top-right rounded-md bg-white shadow-lg ring-1 ring-black/5 focus:outline-none"
+        >
+          <div class="py-1">
+            <MenuItem v-slot="{ active }">
+              <a
+                href="#"
+                :class="[
+                  active
+                    ? 'bg-gray-100 text-gray-900 outline-none'
+                    : 'text-gray-700',
+                  'block px-4 py-2 text-sm',
+                ]"
+                >Account settings</a
+              >
+            </MenuItem>
+            <MenuItem v-slot="{ active }">
+              <a
+                href="#"
+                :class="[
+                  active
+                    ? 'bg-gray-100 text-gray-900 outline-none'
+                    : 'text-gray-700',
+                  'block px-4 py-2 text-sm',
+                ]"
+                >Support</a
+              >
+            </MenuItem>
+            <MenuItem v-slot="{ active }">
+              <a
+                href="#"
+                :class="[
+                  active
+                    ? 'bg-gray-100 text-gray-900 outline-none'
+                    : 'text-gray-700',
+                  'block px-4 py-2 text-sm',
+                ]"
+                >License</a
+              >
+            </MenuItem>
+            <form method="POST" action="#">
+              <MenuItem v-slot="{ active }">
+                <button
+                  type="submit"
+                  :class="[
+                    active
+                      ? 'bg-gray-100 text-gray-900 outline-none'
+                      : 'text-gray-700',
+                    'block w-full px-4 py-2 text-left text-sm',
+                  ]"
+                >
+                  Sign out
+                </button>
+              </MenuItem>
+            </form>
+          </div>
+        </MenuItems>
+      </transition>
+    </Menu>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { Menu, MenuButton, MenuItem, MenuItems } from "@headlessui/vue";
+import { ChevronDownIcon, PlusIcon } from "@heroicons/vue/20/solid";
+</script>

prisma/migrations/20250103202348_add_collections/migration.sql

@@ -0,0 +1,29 @@
+-- CreateTable
+CREATE TABLE "Collection" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "isDefault" BOOLEAN NOT NULL DEFAULT false,
+    "userId" TEXT NOT NULL,
+
+    CONSTRAINT "Collection_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "_CollectionToGame" (
+    "A" TEXT NOT NULL,
+    "B" TEXT NOT NULL,
+
+    CONSTRAINT "_CollectionToGame_AB_pkey" PRIMARY KEY ("A","B")
+);
+
+-- CreateIndex
+CREATE INDEX "_CollectionToGame_B_index" ON "_CollectionToGame"("B");
+
+-- AddForeignKey
+ALTER TABLE "Collection" ADD CONSTRAINT "Collection_userId_fkey" FOREIGN KEY ("userId") REFERENCES "User"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_CollectionToGame" ADD CONSTRAINT "_CollectionToGame_A_fkey" FOREIGN KEY ("A") REFERENCES "Collection"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "_CollectionToGame" ADD CONSTRAINT "_CollectionToGame_B_fkey" FOREIGN KEY ("B") REFERENCES "Game"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/migrations/20250109005948_use_collection_entry_to_ensure_unique_games/migration.sql

@@ -0,0 +1,28 @@
+/*
+  Warnings:
+
+  - You are about to drop the `_CollectionToGame` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- DropForeignKey
+ALTER TABLE "_CollectionToGame" DROP CONSTRAINT "_CollectionToGame_A_fkey";
+
+-- DropForeignKey
+ALTER TABLE "_CollectionToGame" DROP CONSTRAINT "_CollectionToGame_B_fkey";
+
+-- DropTable
+DROP TABLE "_CollectionToGame";
+
+-- CreateTable
+CREATE TABLE "CollectionEntry" (
+    "collectionId" TEXT NOT NULL,
+    "gameId" TEXT NOT NULL,
+
+    CONSTRAINT "CollectionEntry_pkey" PRIMARY KEY ("collectionId","gameId")
+);
+
+-- AddForeignKey
+ALTER TABLE "CollectionEntry" ADD CONSTRAINT "CollectionEntry_collectionId_fkey" FOREIGN KEY ("collectionId") REFERENCES "Collection"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "CollectionEntry" ADD CONSTRAINT "CollectionEntry_gameId_fkey" FOREIGN KEY ("gameId") REFERENCES "Game"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

prisma/schema/collection.prisma

@@ -0,0 +1,20 @@
+model Collection {
+    id   String @id @default(uuid())
+    name String
+
+    isDefault Boolean @default(false)
+    userId    String
+    user      User    @relation(fields: [userId], references: [id])
+
+    entries CollectionEntry[]
+}
+
+model CollectionEntry {
+    collectionId String
+    collection   Collection @relation(fields: [collectionId], references: [id])
+
+    gameId String
+    game   Game   @relation(fields: [gameId], references: [id])
+
+    @@id([collectionId, gameId])
+}

server/api/v1/client/game/manifest.get.ts

@@ -0,0 +1,21 @@
+import { defineClientEventHandler } from "~/server/internal/clients/event-handler";
+import manifestGenerator from "~/server/internal/downloads/manifest";
+
+export default defineClientEventHandler(async (h3) => {
+  const query = getQuery(h3);
+  const id = query.id?.toString();
+  const version = query.version?.toString();
+  if (!id || !version)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Missing id or version in query",
+    });
+
+  const manifest = await manifestGenerator.generateManifest(id, version);
+  if (!manifest)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid game or version, or no versions added.",
+    });
+  return manifest;
+});

server/api/v1/client/game/version.get.ts

@@ -0,0 +1,30 @@
+import { defineClientEventHandler } from "~/server/internal/clients/event-handler";
+import prisma from "~/server/internal/db/database";
+
+export default defineClientEventHandler(async (h3) => {
+  const query = getQuery(h3);
+  const id = query.id?.toString();
+  const version = query.version?.toString();
+  if (!id || !version)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Missing id or version in query",
+    });
+
+  const gameVersion = await prisma.gameVersion.findUnique({
+    where: {
+      gameId_versionName: {
+        gameId: id,
+        versionName: version,
+      },
+    },
+  });
+
+  if (!gameVersion)
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Game version not found",
+    });
+
+  return gameVersion;
+});

server/api/v1/client/game/versions.get.ts

@@ -0,0 +1,46 @@
+import { defineClientEventHandler } from "~/server/internal/clients/event-handler";
+import prisma from "~/server/internal/db/database";
+import { DropManifest } from "~/server/internal/downloads/manifest";
+
+export default defineClientEventHandler(async (h3, {}) => {
+  const query = getQuery(h3);
+  const id = query.id?.toString();
+  if (!id)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "No ID in request query",
+    });
+
+  const versions = await prisma.gameVersion.findMany({
+    where: {
+      gameId: id,
+    },
+    orderBy: {
+      versionIndex: "desc", // Latest one first
+    },
+  });
+
+  const mappedVersions = versions
+    .map((version) => {
+      if (!version.dropletManifest) return undefined;
+      const manifest = JSON.parse(
+        version.dropletManifest.toString()
+      ) as DropManifest;
+
+      /*
+      TODO: size estimates
+      They are a little complicated because of delta versions
+      Manifests need to be generated with the manifest generator and then
+      added up. I'm a little busy right now to implement this, though.
+      */
+
+      const newVersion = { ...version, dropletManifest: undefined };
+      delete newVersion.dropletManifest;
+      return {
+        ...newVersion,
+      };
+    })
+    .filter((e) => e);
+
+  return mappedVersions;
+});

server/api/v1/collection/[id]/entry.delete.ts

@@ -0,0 +1,26 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+
+  const id = getRouterParam(h3, "id");
+  if (!id)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "ID required in route params",
+    });
+
+  const body = await readBody(h3);
+
+  const gameId = body.id;
+  if (!gameId)
+    throw createError({ statusCode: 400, statusMessage: "Game ID required" });
+
+  await userLibraryManager.collectionRemove(id, gameId);
+  return {};
+});

server/api/v1/collection/[id]/entry.post.ts

@@ -0,0 +1,26 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+
+  const id = getRouterParam(h3, "id");
+  if (!id)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "ID required in route params",
+    });
+
+  const body = await readBody(h3);
+
+  const gameId = body.id;
+  if (!gameId)
+    throw createError({ statusCode: 400, statusMessage: "Game ID required" });
+
+  await userLibraryManager.collectionAdd(id, gameId);
+  return {};
+});

server/api/v1/collection/[id]/index.delete.ts

@@ -0,0 +1,20 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+
+  const id = getRouterParam(h3, "id");
+  if (!id)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "ID required in route params",
+    });
+
+  const collection = await userLibraryManager.deleteCollection(id);
+  return collection;
+});

server/api/v1/collection/[id]/index.get.ts

@@ -0,0 +1,20 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+
+  const id = getRouterParam(h3, "id");
+  if (!id)
+    throw createError({
+      statusCode: 400,
+      statusMessage: "ID required in route params",
+    });
+
+  const collection = await userLibraryManager.fetchCollection(id);
+  return collection;
+});

server/api/v1/collection/default/entry.delete.ts

@@ -0,0 +1,19 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+
+  const body = await readBody(h3);
+
+  const gameId = body.id;
+  if (!gameId)
+    throw createError({ statusCode: 400, statusMessage: "Game ID required" });
+
+  await userLibraryManager.libraryRemove(gameId, userId);
+  return {};
+});

server/api/v1/collection/default/entry.post.ts

@@ -0,0 +1,19 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+
+  const body = await readBody(h3);
+
+  const gameId = body.id;
+  if (!gameId)
+    throw createError({ statusCode: 400, statusMessage: "Game ID required" });
+
+  await userLibraryManager.libraryRemove(gameId, userId);
+  return {};
+});

server/api/v1/collection/index.get.ts

@@ -0,0 +1,13 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+    
+  const collections = await userLibraryManager.fetchCollections(userId);
+  return collections;
+});

server/api/v1/collection/index.post.ts

@@ -0,0 +1,19 @@
+import userLibraryManager from "~/server/internal/userlibrary";
+
+export default defineEventHandler(async (h3) => {
+  const userId = await h3.context.session.getUserId(h3);
+  if (!userId)
+    throw createError({
+      statusCode: 403,
+      statusMessage: "Requires authentication",
+    });
+
+  const body = await readBody(h3);
+
+  const name = body.name;
+  if (!name)
+    throw createError({ statusCode: 400, statusMessage: "Requires name" });
+
+  const collections = await userLibraryManager.fetchCollections(userId);
+  return collections;
+});

server/internal/applibrary/README.md

@@ -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. 

server/internal/applibrary/index.ts

@@ -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;

server/internal/userlibrary/index.ts

@@ -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;