@muhgholy/next-drive 3.2.3 → 3.4.0

package/README.md

@@ -103,16 +103,6 @@ import { driveAPIHandler } from "@muhgholy/next-drive/server";
 import type { NextApiRequest, NextApiResponse } from "next";
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
-	// Parse JSON body manually (body parser is disabled)
-	if (req.headers["content-type"]?.includes("application/json")) {
-		const chunks: Buffer[] = [];
-		for await (const chunk of req) chunks.push(chunk);
-		const buffer = Buffer.concat(chunks);
-		req.body = buffer.length > 0 ? JSON.parse(buffer.toString()) : {};
-	} else {
-		req.body = req.body || {};
-	}
-
 	return driveAPIHandler(req, res);
 }
 
@@ -281,6 +271,16 @@ const file = await driveUpload(
 		enforce: true, // Skip quota check
 	}
 );
+
+// Upload from Buffer
+const buffer = Buffer.from("file content");
+const file = await driveUpload(
+	buffer,
+	{ userId: "123" },
+	{
+		name: "document.txt",
+	}
+);
 ```
 
 **Options:**

package/dist/{chunk-WSOFHT7J.js → chunk-MJ4Y7XLI.js}

@@ -1,7 +1,7 @@
 import { __require } from './chunk-DGUM43GV.js';
 import formidable from 'formidable';
 import path3 from 'path';
-import fs2 from 'fs';
+import fs4 from 'fs';
 import os2 from 'os';
 import mongoose2, { Schema, isValidObjectId } from 'mongoose';
 import crypto3 from 'crypto';
@@ -139,7 +139,7 @@ var validateMimeType = (mime, allowedTypes) => {
 };
 var computeFileHash = (filePath) => new Promise((resolve, reject) => {
   const hash = crypto3.createHash("sha256");
-  const stream = fs2.createReadStream(filePath);
+  const stream = fs4.createReadStream(filePath);
   stream.on("data", (data) => hash.update(data));
   stream.on("end", () => resolve(hash.digest("hex")));
   stream.on("error", reject);
@@ -270,11 +270,11 @@ var LocalStorageProvider = {
   openStream: async (item, accountId) => {
     if (item.information.type !== "FILE") throw new Error("Cannot stream folder");
     const filePath = path3.join(getDriveConfig().storage.path, item.information.path);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       throw new Error("File not found on disk");
     }
-    const stat = fs2.statSync(filePath);
-    const stream = fs2.createReadStream(filePath);
+    const stat = fs4.statSync(filePath);
+    const stream = fs4.createReadStream(filePath);
     return {
       stream,
       mime: item.information.mime,
@@ -286,11 +286,11 @@ var LocalStorageProvider = {
     const storagePath = getDriveConfig().storage.path;
     const originalPath = path3.join(storagePath, item.information.path);
     const thumbPath = path3.join(storagePath, "cache", "thumbnails", `${item._id.toString()}.webp`);
-    if (!fs2.existsSync(originalPath)) throw new Error("Original file not found");
-    if (fs2.existsSync(thumbPath)) {
-      return fs2.createReadStream(thumbPath);
+    if (!fs4.existsSync(originalPath)) throw new Error("Original file not found");
+    if (fs4.existsSync(thumbPath)) {
+      return fs4.createReadStream(thumbPath);
     }
-    if (!fs2.existsSync(path3.dirname(thumbPath))) fs2.mkdirSync(path3.dirname(thumbPath), { recursive: true });
+    if (!fs4.existsSync(path3.dirname(thumbPath))) fs4.mkdirSync(path3.dirname(thumbPath), { recursive: true });
     if (item.information.mime.startsWith("image/")) {
       await sharp(originalPath).resize(300, 300, { fit: "inside" }).toFormat("webp", { quality: 80 }).toFile(thumbPath);
     } else if (item.information.mime.startsWith("video/")) {
@@ -305,7 +305,7 @@ var LocalStorageProvider = {
     } else {
       throw new Error("Unsupported mime type for thumbnail");
     }
-    return fs2.createReadStream(thumbPath);
+    return fs4.createReadStream(thumbPath);
   },
   createFolder: async (name, parentId, owner, accountId) => {
     const getNextOrderValue2 = async (owner2) => {
@@ -329,28 +329,28 @@ var LocalStorageProvider = {
     const storagePath = getDriveConfig().storage.path;
     const destPath = path3.join(storagePath, drive.information.path);
     const dirPath = path3.dirname(destPath);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       throw new Error("Source file not found");
     }
-    if (!fs2.existsSync(dirPath)) {
-      fs2.mkdirSync(dirPath, { recursive: true });
+    if (!fs4.existsSync(dirPath)) {
+      fs4.mkdirSync(dirPath, { recursive: true });
     }
     try {
-      fs2.renameSync(filePath, destPath);
+      fs4.renameSync(filePath, destPath);
     } catch (err) {
       if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-        fs2.copyFileSync(filePath, destPath);
-        fs2.unlinkSync(filePath);
+        fs4.copyFileSync(filePath, destPath);
+        fs4.unlinkSync(filePath);
       } else {
         throw err;
       }
     }
-    if (!fs2.existsSync(destPath)) {
+    if (!fs4.existsSync(destPath)) {
       throw new Error("Failed to write file to destination");
     }
-    const destStats = fs2.statSync(destPath);
+    const destStats = fs4.statSync(destPath);
     if (destStats.size !== drive.information.sizeInBytes) {
-      fs2.unlinkSync(destPath);
+      fs4.unlinkSync(destPath);
       throw new Error(`Destination file size mismatch: expected ${drive.information.sizeInBytes}, got ${destStats.size}`);
     }
     drive.status = "READY";
@@ -381,8 +381,8 @@ var LocalStorageProvider = {
       if (item.information.type === "FILE" && item.information.path) {
         const fullPath = path3.join(getDriveConfig().storage.path, item.information.path);
         const dirPath = path3.dirname(fullPath);
-        if (fs2.existsSync(dirPath)) {
-          fs2.rmSync(dirPath, { recursive: true, force: true });
+        if (fs4.existsSync(dirPath)) {
+          fs4.rmSync(dirPath, { recursive: true, force: true });
         }
       }
     }
@@ -691,7 +691,7 @@ var GoogleDriveProvider = {
         },
         media: {
           mimeType: drive.information.mime,
-          body: fs2.createReadStream(filePath)
+          body: fs4.createReadStream(filePath)
         },
         fields: "id, name, mimeType, webViewLink, iconLink, thumbnailLink, size"
       });
@@ -885,7 +885,7 @@ var driveFilePath = async (file) => {
   const providerType = drive.provider?.type || "LOCAL";
   if (providerType === "LOCAL") {
     const filePath = path3.join(STORAGE_PATH, drive.information.path);
-    if (!fs2.existsSync(filePath)) {
+    if (!fs4.existsSync(filePath)) {
       throw new Error(`Local file not found on disk: ${filePath}`);
     }
     return Object.freeze({
@@ -900,8 +900,8 @@ var driveFilePath = async (file) => {
     const libraryDir = path3.join(STORAGE_PATH, "library", "google");
     const fileName = `${drive._id}${path3.extname(drive.name)}`;
     const cachedFilePath = path3.join(libraryDir, fileName);
-    if (fs2.existsSync(cachedFilePath)) {
-      const stats = fs2.statSync(cachedFilePath);
+    if (fs4.existsSync(cachedFilePath)) {
+      const stats = fs4.statSync(cachedFilePath);
       if (stats.size === drive.information.sizeInBytes) {
         return Object.freeze({
           path: cachedFilePath,
@@ -911,15 +911,15 @@ var driveFilePath = async (file) => {
           provider: "GOOGLE"
         });
       }
-      fs2.unlinkSync(cachedFilePath);
+      fs4.unlinkSync(cachedFilePath);
     }
     const accountId = drive.storageAccountId?.toString();
     const { stream } = await GoogleDriveProvider.openStream(drive, accountId);
-    if (!fs2.existsSync(libraryDir)) {
-      fs2.mkdirSync(libraryDir, { recursive: true });
+    if (!fs4.existsSync(libraryDir)) {
+      fs4.mkdirSync(libraryDir, { recursive: true });
     }
     const tempPath = `${cachedFilePath}.tmp`;
-    const writeStream = fs2.createWriteStream(tempPath);
+    const writeStream = fs4.createWriteStream(tempPath);
     await new Promise((resolve, reject) => {
       stream.pipe(writeStream);
       writeStream.on("finish", resolve);
@@ -927,11 +927,11 @@ var driveFilePath = async (file) => {
       stream.on("error", reject);
     });
     try {
-      fs2.renameSync(tempPath, cachedFilePath);
+      fs4.renameSync(tempPath, cachedFilePath);
     } catch (err) {
       if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-        fs2.copyFileSync(tempPath, cachedFilePath);
-        fs2.unlinkSync(tempPath);
+        fs4.copyFileSync(tempPath, cachedFilePath);
+        fs4.unlinkSync(tempPath);
       } else {
         throw err;
       }
@@ -1022,19 +1022,28 @@ var driveUpload = async (source, key, options) => {
   let sourceFilePath;
   let fileSize;
   if (typeof source === "string") {
-    if (!fs2.existsSync(source)) {
+    if (!fs4.existsSync(source)) {
       throw new Error(`Source file not found: ${source}`);
     }
     sourceFilePath = source;
-    const stats = fs2.statSync(source);
+    const stats = fs4.statSync(source);
     fileSize = stats.size;
+  } else if (Buffer.isBuffer(source)) {
+    const tempDir = path3.join(os2.tmpdir(), "next-drive-uploads");
+    if (!fs4.existsSync(tempDir)) {
+      fs4.mkdirSync(tempDir, { recursive: true });
+    }
+    tempFilePath = path3.join(tempDir, `upload-${crypto3.randomUUID()}.tmp`);
+    fs4.writeFileSync(tempFilePath, source);
+    sourceFilePath = tempFilePath;
+    fileSize = source.length;
   } else {
     const tempDir = path3.join(os2.tmpdir(), "next-drive-uploads");
-    if (!fs2.existsSync(tempDir)) {
-      fs2.mkdirSync(tempDir, { recursive: true });
+    if (!fs4.existsSync(tempDir)) {
+      fs4.mkdirSync(tempDir, { recursive: true });
     }
     tempFilePath = path3.join(tempDir, `upload-${crypto3.randomUUID()}.tmp`);
-    const writeStream = fs2.createWriteStream(tempFilePath);
+    const writeStream = fs4.createWriteStream(tempFilePath);
     await new Promise((resolve, reject) => {
       source.pipe(writeStream);
       writeStream.on("finish", resolve);
@@ -1042,7 +1051,7 @@ var driveUpload = async (source, key, options) => {
       source.on("error", reject);
     });
     sourceFilePath = tempFilePath;
-    const stats = fs2.statSync(tempFilePath);
+    const stats = fs4.statSync(tempFilePath);
     fileSize = stats.size;
   }
   try {
@@ -1098,14 +1107,21 @@ var driveUpload = async (source, key, options) => {
     await drive.save();
     try {
       const item = await provider.uploadFile(drive, sourceFilePath, accountId);
-      return item;
+      return {
+        id: item.id,
+        file: {
+          name: item.name,
+          mime: item.information.type === "FILE" ? item.information.mime : "application/x-folder",
+          size: item.information.type === "FILE" ? item.information.sizeInBytes : 0
+        }
+      };
     } catch (err) {
       await drive_default.deleteOne({ _id: drive._id });
       throw err;
     }
   } finally {
-    if (tempFilePath && fs2.existsSync(tempFilePath)) {
-      fs2.rmSync(tempFilePath, { force: true });
+    if (tempFilePath && fs4.existsSync(tempFilePath)) {
+      fs4.rmSync(tempFilePath, { force: true });
     }
   }
 };
@@ -1371,7 +1387,7 @@ var driveAPIHandler = async (req, res) => {
       case "upload": {
         if (req.method !== "POST") return res.status(405).json({ status: 405, message: "Only POST allowed" });
         const systemTmpDir = path3.join(os2.tmpdir(), "next-drive-uploads");
-        if (!fs2.existsSync(systemTmpDir)) fs2.mkdirSync(systemTmpDir, { recursive: true });
+        if (!fs4.existsSync(systemTmpDir)) fs4.mkdirSync(systemTmpDir, { recursive: true });
         const form = formidable({
           multiples: false,
           maxFileSize: config.security.maxUploadSizeInBytes * 2,
@@ -1386,7 +1402,7 @@ var driveAPIHandler = async (req, res) => {
         });
         const cleanupTempFiles = (files2) => {
           Object.values(files2).flat().forEach((file) => {
-            if (file && fs2.existsSync(file.filepath)) fs2.rmSync(file.filepath, { force: true });
+            if (file && fs4.existsSync(file.filepath)) fs4.rmSync(file.filepath, { force: true });
           });
         };
         const getString = (f) => Array.isArray(f) ? f[0] : f || "";
@@ -1420,7 +1436,7 @@ var driveAPIHandler = async (req, res) => {
           }
           currentUploadId = crypto.randomUUID();
           const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          fs2.mkdirSync(uploadDir, { recursive: true });
+          fs4.mkdirSync(uploadDir, { recursive: true });
           const metadata = {
             owner,
             accountId,
@@ -1431,11 +1447,11 @@ var driveAPIHandler = async (req, res) => {
             mimeType: fileType,
             totalChunks
           };
-          fs2.writeFileSync(path3.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
+          fs4.writeFileSync(path3.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
         }
         if (currentUploadId) {
           const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          if (!fs2.existsSync(uploadDir)) {
+          if (!fs4.existsSync(uploadDir)) {
             cleanupTempFiles(files);
             return res.status(404).json({ status: 404, message: "Upload session not found or expired" });
           }
@@ -1444,32 +1460,32 @@ var driveAPIHandler = async (req, res) => {
             if (!chunkFile) throw new Error("No chunk file received");
             const partPath = path3.join(uploadDir, `part_${chunkIndex}`);
             try {
-              fs2.renameSync(chunkFile.filepath, partPath);
+              fs4.renameSync(chunkFile.filepath, partPath);
             } catch (err) {
               if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-                fs2.copyFileSync(chunkFile.filepath, partPath);
-                fs2.unlinkSync(chunkFile.filepath);
+                fs4.copyFileSync(chunkFile.filepath, partPath);
+                fs4.unlinkSync(chunkFile.filepath);
               } else {
                 throw err;
               }
             }
-            const uploadedParts = fs2.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
+            const uploadedParts = fs4.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
             if (uploadedParts.length === totalChunks) {
               const metaPath = path3.join(uploadDir, "metadata.json");
-              const meta = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
+              const meta = JSON.parse(fs4.readFileSync(metaPath, "utf-8"));
               const finalTempPath = path3.join(uploadDir, "final.bin");
-              const writeStream = fs2.createWriteStream(finalTempPath);
+              const writeStream = fs4.createWriteStream(finalTempPath);
               await new Promise((resolve, reject) => {
                 writeStream.on("open", () => resolve());
                 writeStream.on("error", reject);
               });
               for (let i = 0; i < totalChunks; i++) {
                 const pPath = path3.join(uploadDir, `part_${i}`);
-                if (!fs2.existsSync(pPath)) {
+                if (!fs4.existsSync(pPath)) {
                   writeStream.destroy();
                   throw new Error(`Missing chunk part: ${i}`);
                 }
-                const data = fs2.readFileSync(pPath);
+                const data = fs4.readFileSync(pPath);
                 writeStream.write(data);
               }
               await new Promise((resolve, reject) => {
@@ -1477,10 +1493,10 @@ var driveAPIHandler = async (req, res) => {
                 writeStream.on("finish", resolve);
                 writeStream.on("error", reject);
               });
-              if (!fs2.existsSync(finalTempPath)) {
+              if (!fs4.existsSync(finalTempPath)) {
                 throw new Error("Failed to create merged file");
               }
-              const finalStats = fs2.statSync(finalTempPath);
+              const finalStats = fs4.statSync(finalTempPath);
               if (finalStats.size !== meta.fileSize) {
                 throw new Error(`File size mismatch: expected ${meta.fileSize}, got ${finalStats.size}`);
               }
@@ -1506,7 +1522,7 @@ var driveAPIHandler = async (req, res) => {
               await drive.save();
               try {
                 const item = await provider.uploadFile(drive, finalTempPath, meta.accountId);
-                fs2.rmSync(uploadDir, { recursive: true, force: true });
+                fs4.rmSync(uploadDir, { recursive: true, force: true });
                 const newQuota = await provider.getQuota(meta.owner, meta.accountId, information.storage.quotaInBytes);
                 res.status(200).json({ status: 200, message: "Upload complete", data: { type: "UPLOAD_COMPLETE", driveId: String(drive._id), item }, statistic: { storage: newQuota } });
               } catch (err) {
@@ -1536,9 +1552,9 @@ var driveAPIHandler = async (req, res) => {
         if (!cancelData.success) return res.status(400).json({ status: 400, message: "Invalid ID" });
         const { id } = cancelData.data;
         const tempUploadDir = path3.join(os2.tmpdir(), "next-drive-uploads", id);
-        if (fs2.existsSync(tempUploadDir)) {
+        if (fs4.existsSync(tempUploadDir)) {
           try {
-            fs2.rmSync(tempUploadDir, { recursive: true, force: true });
+            fs4.rmSync(tempUploadDir, { recursive: true, force: true });
           } catch (e) {
             console.error("Failed to cleanup temp upload:", e);
           }
@@ -1717,5 +1733,5 @@ var driveAPIHandler = async (req, res) => {
 };
 
 export { driveAPIHandler, driveConfiguration, driveDelete, driveFilePath, driveFileSchemaZod, driveGetUrl, driveList, driveReadFile, driveUpload, getDriveConfig, getDriveInformation };
-//# sourceMappingURL=chunk-WSOFHT7J.js.map
-//# sourceMappingURL=chunk-WSOFHT7J.js.map
+//# sourceMappingURL=chunk-MJ4Y7XLI.js.map
+//# sourceMappingURL=chunk-MJ4Y7XLI.js.map