@valentinkolb/filegate 2.3.3 → 2.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@valentinkolb/filegate",
-  "version": "2.3.3",
+  "version": "2.3.5",
   "type": "module",
   "license": "MIT",
   "repository": {

package/src/handlers/upload.ts

@@ -113,20 +113,20 @@ const assembleFile = async (meta: UploadMeta): Promise<string | null> => {
 
     try {
       for (let i = 0; i < meta.totalChunks; i++) {
-        // Stream each chunk instead of loading entirely into memory
-        const chunkFile = Bun.file(chunkPath(meta.uploadId, i));
+        const chunkFilePath = chunkPath(meta.uploadId, i);
+        const chunkFile = Bun.file(chunkFilePath);
 
-        // Verify chunk exists before streaming
+        // Verify chunk exists before reading
         if (!(await chunkFile.exists())) {
           writer.end();
           await rm(pathResult.realPath).catch(() => {});
           return `chunk ${i} not found during assembly`;
         }
 
-        for await (const data of chunkFile.stream()) {
-          hasher.update(data);
-          writer.write(data);
-        }
+        // Read chunk as buffer (more reliable than streaming)
+        const data = new Uint8Array(await chunkFile.arrayBuffer());
+        hasher.update(data);
+        writer.write(data);
       }
       await writer.end();
     } catch (e) {
@@ -272,32 +272,33 @@ app.post(
       return c.json({ error: `chunk index ${chunkIndex} exceeds total ${meta.totalChunks}` }, 400);
     }
 
-    const body = c.req.raw.body;
-    if (!body) return c.json({ error: "missing body" }, 400);
+    // Read body as ArrayBuffer (more reliable than streaming)
+    let bodyBuffer: ArrayBuffer;
+    try {
+      bodyBuffer = await c.req.arrayBuffer();
+    } catch {
+      return c.json({ error: "failed to read request body" }, 400);
+    }
 
-    // Stream chunks to a temporary file to avoid memory accumulation
-    const tempChunkPath = chunkPath(uploadId, chunkIndex) + ".tmp";
-    let chunkSize = 0;
+    if (bodyBuffer.byteLength === 0) {
+      return c.json({ error: "missing body" }, 400);
+    }
+
+    if (bodyBuffer.byteLength > config.maxChunkBytes) {
+      return c.json({ error: `chunk size exceeds maximum (${config.maxChunkBytes / 1024 / 1024}MB)` }, 413);
+    }
+
+    const bodyData = new Uint8Array(bodyBuffer);
     const hasher = new Bun.CryptoHasher("sha256");
+    hasher.update(bodyData);
 
+    // Write chunk to temporary file
+    const tempChunkPath = chunkPath(uploadId, chunkIndex) + ".tmp";
     await mkdir(chunksDir(uploadId), { recursive: true });
-    const tempFile = Bun.file(tempChunkPath);
-    const writer = tempFile.writer();
 
     try {
-      for await (const chunk of body) {
-        chunkSize += chunk.length;
-        if (chunkSize > config.maxChunkBytes) {
-          writer.end();
-          await rm(tempChunkPath).catch(() => {});
-          return c.json({ error: `chunk size exceeds maximum (${config.maxChunkBytes / 1024 / 1024}MB)` }, 413);
-        }
-        hasher.update(chunk);
-        writer.write(chunk);
-      }
-      await writer.end();
+      await Bun.write(tempChunkPath, bodyData);
     } catch (e) {
-      writer.end();
       await rm(tempChunkPath).catch(() => {});
       throw e;
     }