fix(manifests): fix delta manifest generation

server/api/v1/client/chunk.get.ts

@@ -60,5 +60,7 @@ export default defineEventHandler(async (h3) => {
 
   const gameReadStream = fs.createReadStream(gameFile, { start, end: end - 1 }); // end needs to be offset by 1
 
+  console.log(`sending game chunk for ${gameId}`);
+
   return sendStream(h3, gameReadStream);
 });

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

@@ -1,5 +1,6 @@
 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);
@@ -21,11 +22,34 @@ export default defineClientEventHandler(async (h3, {}) => {
       setupCommand: true,
       launchCommand: true,
       delta: true,
+      dropletManifest: true,
     },
     orderBy: {
       versionIndex: "desc", // Latest one first
     },
   });
 
-  return versions;
+  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/internal/downloads/manifest.ts

@@ -56,29 +56,40 @@ class ManifestGenerator {
   async generateManifest(gameId: string, versionName: string) {
     const versions: GameVersion[] = [];
 
-    for (let i = 0; true; i++) {
+    const baseVersion = await prisma.gameVersion.findUnique({
-      const currentVersion = (
-        await prisma.gameVersion.findMany({
       where: {
+        gameId_versionName: {
           gameId: gameId,
           versionName: versionName,
         },
-          orderBy: {
-            versionIndex: "desc", // Get highest priority first
       },
-          skip: i,
+    });
-          take: 1,
+    if (!baseVersion) return undefined;
-        })
+    versions.push(baseVersion);
-      )[0];
+
+    // Collect other versions if this is a delta
+    if (baseVersion.delta) {
+      // Start at the same index minus one, and keep grabbing them
+      // until we run out or we hit something that isn't a delta
+      for (let i = baseVersion.versionIndex - 1; true; i--) {
+        const currentVersion = await prisma.gameVersion.findFirst({
+          where: {
+            gameId: gameId,
+            versionIndex: i,
+            platform: baseVersion.platform,
+          },
+        });
         if (!currentVersion) return undefined;
         versions.push(currentVersion);
         if (!currentVersion.delta) break;
       }
-
+    }
     const leastToMost = versions.reverse();
     const metadata: DropManifestMetadata[] = leastToMost.map((e) => {
       return {
-        manifest: JSON.parse(e.dropletManifest?.toString() ?? "{}") as DropManifest,
+        manifest: JSON.parse(
+          e.dropletManifest?.toString() ?? "{}"
+        ) as DropManifest,
         versionName: e.versionName,
       };
     });