@muhgholy/next-drive 2.2.5 → 3.0.0

package/dist/{chunk-EV3BVXQN.js → chunk-KCDI2FBD.js}

@@ -1,7 +1,7 @@
 import { __require } from './chunk-DGUM43GV.js';
 import formidable from 'formidable';
 import path3 from 'path';
-import fs5 from 'fs';
+import fs2 from 'fs';
 import os from 'os';
 import mongoose2, { Schema, isValidObjectId } from 'mongoose';
 import crypto2 from 'crypto';
@@ -126,18 +126,6 @@ StorageAccountSchema.method("toClient", async function() {
 });
 var StorageAccount = mongoose2.models.StorageAccount || mongoose2.model("StorageAccount", StorageAccountSchema);
 var account_default = StorageAccount;
-var moveFile = (src, dest) => {
-  try {
-    fs5.renameSync(src, dest);
-  } catch (err) {
-    if (err.code === "EXDEV") {
-      fs5.copyFileSync(src, dest);
-      fs5.unlinkSync(src);
-    } else {
-      throw err;
-    }
-  }
-};
 var validateMimeType = (mime, allowedTypes) => {
   if (allowedTypes.includes("*/*")) return true;
   return allowedTypes.some((pattern) => {
@@ -151,7 +139,7 @@ var validateMimeType = (mime, allowedTypes) => {
 };
 var computeFileHash = (filePath) => new Promise((resolve, reject) => {
   const hash = crypto2.createHash("sha256");
-  const stream = fs5.createReadStream(filePath);
+  const stream = fs2.createReadStream(filePath);
   stream.on("data", (data) => hash.update(data));
   stream.on("end", () => resolve(hash.digest("hex")));
   stream.on("error", reject);
@@ -271,11 +259,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 (!fs5.existsSync(filePath)) {
+    if (!fs2.existsSync(filePath)) {
       throw new Error("File not found on disk");
     }
-    const stat = fs5.statSync(filePath);
-    const stream = fs5.createReadStream(filePath);
+    const stat = fs2.statSync(filePath);
+    const stream = fs2.createReadStream(filePath);
     return {
       stream,
       mime: item.information.mime,
@@ -287,11 +275,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 (!fs5.existsSync(originalPath)) throw new Error("Original file not found");
-    if (fs5.existsSync(thumbPath)) {
-      return fs5.createReadStream(thumbPath);
+    if (!fs2.existsSync(originalPath)) throw new Error("Original file not found");
+    if (fs2.existsSync(thumbPath)) {
+      return fs2.createReadStream(thumbPath);
     }
-    if (!fs5.existsSync(path3.dirname(thumbPath))) fs5.mkdirSync(path3.dirname(thumbPath), { recursive: true });
+    if (!fs2.existsSync(path3.dirname(thumbPath))) fs2.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/")) {
@@ -306,7 +294,7 @@ var LocalStorageProvider = {
     } else {
       throw new Error("Unsupported mime type for thumbnail");
     }
-    return fs5.createReadStream(thumbPath);
+    return fs2.createReadStream(thumbPath);
   },
   createFolder: async (name, parentId, owner, accountId) => {
     const getNextOrderValue = async (owner2) => {
@@ -327,10 +315,33 @@ var LocalStorageProvider = {
   },
   uploadFile: async (drive, filePath, accountId) => {
     if (drive.information.type !== "FILE") throw new Error("Invalid drive type");
-    const destPath = path3.join(getDriveConfig().storage.path, drive.information.path);
+    const storagePath = getDriveConfig().storage.path;
+    const destPath = path3.join(storagePath, drive.information.path);
     const dirPath = path3.dirname(destPath);
-    if (!fs5.existsSync(dirPath)) fs5.mkdirSync(dirPath, { recursive: true });
-    moveFile(filePath, destPath);
+    if (!fs2.existsSync(filePath)) {
+      throw new Error("Source file not found");
+    }
+    if (!fs2.existsSync(dirPath)) {
+      fs2.mkdirSync(dirPath, { recursive: true });
+    }
+    try {
+      fs2.renameSync(filePath, destPath);
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "EXDEV") {
+        fs2.copyFileSync(filePath, destPath);
+        fs2.unlinkSync(filePath);
+      } else {
+        throw err;
+      }
+    }
+    if (!fs2.existsSync(destPath)) {
+      throw new Error("Failed to write file to destination");
+    }
+    const destStats = fs2.statSync(destPath);
+    if (destStats.size !== drive.information.sizeInBytes) {
+      fs2.unlinkSync(destPath);
+      throw new Error(`Destination file size mismatch: expected ${drive.information.sizeInBytes}, got ${destStats.size}`);
+    }
     drive.status = "READY";
     drive.information.hash = await computeFileHash(destPath);
     if (drive.information.mime.startsWith("image/")) {
@@ -359,8 +370,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 (fs5.existsSync(dirPath)) {
-          fs5.rmSync(dirPath, { recursive: true, force: true });
+        if (fs2.existsSync(dirPath)) {
+          fs2.rmSync(dirPath, { recursive: true, force: true });
         }
       }
     }
@@ -669,7 +680,7 @@ var GoogleDriveProvider = {
         },
         media: {
           mimeType: drive.information.mime,
-          body: fs5.createReadStream(filePath)
+          body: fs2.createReadStream(filePath)
         },
         fields: "id, name, mimeType, webViewLink, iconLink, thumbnailLink, size"
       });
@@ -859,7 +870,7 @@ var driveFilePath = async (file) => {
   const providerType = drive.provider?.type || "LOCAL";
   if (providerType === "LOCAL") {
     const filePath = path3.join(STORAGE_PATH, drive.information.path);
-    if (!fs5.existsSync(filePath)) {
+    if (!fs2.existsSync(filePath)) {
       throw new Error(`Local file not found on disk: ${filePath}`);
     }
     return Object.freeze({
@@ -874,8 +885,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 (fs5.existsSync(cachedFilePath)) {
-      const stats = fs5.statSync(cachedFilePath);
+    if (fs2.existsSync(cachedFilePath)) {
+      const stats = fs2.statSync(cachedFilePath);
       if (stats.size === drive.information.sizeInBytes) {
         return Object.freeze({
           path: cachedFilePath,
@@ -885,22 +896,31 @@ var driveFilePath = async (file) => {
           provider: "GOOGLE"
         });
       }
-      fs5.unlinkSync(cachedFilePath);
+      fs2.unlinkSync(cachedFilePath);
     }
     const accountId = drive.storageAccountId?.toString();
     const { stream } = await GoogleDriveProvider.openStream(drive, accountId);
-    if (!fs5.existsSync(libraryDir)) {
-      fs5.mkdirSync(libraryDir, { recursive: true });
+    if (!fs2.existsSync(libraryDir)) {
+      fs2.mkdirSync(libraryDir, { recursive: true });
     }
     const tempPath = `${cachedFilePath}.tmp`;
-    const writeStream = fs5.createWriteStream(tempPath);
+    const writeStream = fs2.createWriteStream(tempPath);
     await new Promise((resolve, reject) => {
       stream.pipe(writeStream);
       writeStream.on("finish", resolve);
       writeStream.on("error", reject);
       stream.on("error", reject);
     });
-    moveFile(tempPath, cachedFilePath);
+    try {
+      fs2.renameSync(tempPath, cachedFilePath);
+    } catch (err) {
+      if (err instanceof Error && "code" in err && err.code === "EXDEV") {
+        fs2.copyFileSync(tempPath, cachedFilePath);
+        fs2.unlinkSync(tempPath);
+      } else {
+        throw err;
+      }
+    }
     return Object.freeze({
       path: cachedFilePath,
       name: drive.name,
@@ -1173,7 +1193,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(os.tmpdir(), "next-drive-uploads");
-        if (!fs5.existsSync(systemTmpDir)) fs5.mkdirSync(systemTmpDir, { recursive: true });
+        if (!fs2.existsSync(systemTmpDir)) fs2.mkdirSync(systemTmpDir, { recursive: true });
         const form = formidable({
           multiples: false,
           maxFileSize: config.security.maxUploadSizeInBytes * 2,
@@ -1188,7 +1208,7 @@ var driveAPIHandler = async (req, res) => {
         });
         const cleanupTempFiles = (files2) => {
           Object.values(files2).flat().forEach((file) => {
-            if (file && fs5.existsSync(file.filepath)) fs5.rmSync(file.filepath, { force: true });
+            if (file && fs2.existsSync(file.filepath)) fs2.rmSync(file.filepath, { force: true });
           });
         };
         const getString = (f) => Array.isArray(f) ? f[0] : f || "";
@@ -1222,7 +1242,7 @@ var driveAPIHandler = async (req, res) => {
           }
           currentUploadId = crypto.randomUUID();
           const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          fs5.mkdirSync(uploadDir, { recursive: true });
+          fs2.mkdirSync(uploadDir, { recursive: true });
           const metadata = {
             owner,
             accountId,
@@ -1233,11 +1253,11 @@ var driveAPIHandler = async (req, res) => {
             mimeType: fileType,
             totalChunks
           };
-          fs5.writeFileSync(path3.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
+          fs2.writeFileSync(path3.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
         }
         if (currentUploadId) {
           const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          if (!fs5.existsSync(uploadDir)) {
+          if (!fs2.existsSync(uploadDir)) {
             cleanupTempFiles(files);
             return res.status(404).json({ status: 404, message: "Upload session not found or expired" });
           }
@@ -1245,23 +1265,47 @@ var driveAPIHandler = async (req, res) => {
             const chunkFile = Array.isArray(files.chunk) ? files.chunk[0] : files.chunk;
             if (!chunkFile) throw new Error("No chunk file received");
             const partPath = path3.join(uploadDir, `part_${chunkIndex}`);
-            moveFile(chunkFile.filepath, partPath);
-            const uploadedParts = fs5.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
+            try {
+              fs2.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);
+              } else {
+                throw err;
+              }
+            }
+            const uploadedParts = fs2.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
             if (uploadedParts.length === totalChunks) {
               const metaPath = path3.join(uploadDir, "metadata.json");
-              const meta = JSON.parse(fs5.readFileSync(metaPath, "utf-8"));
+              const meta = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
               const finalTempPath = path3.join(uploadDir, "final.bin");
-              const writeStream = fs5.createWriteStream(finalTempPath);
+              const writeStream = fs2.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}`);
-                const data = fs5.readFileSync(pPath);
+                if (!fs2.existsSync(pPath)) {
+                  writeStream.destroy();
+                  throw new Error(`Missing chunk part: ${i}`);
+                }
+                const data = fs2.readFileSync(pPath);
                 writeStream.write(data);
               }
               await new Promise((resolve, reject) => {
+                writeStream.end();
                 writeStream.on("finish", resolve);
                 writeStream.on("error", reject);
-                writeStream.end();
               });
+              if (!fs2.existsSync(finalTempPath)) {
+                throw new Error("Failed to create merged file");
+              }
+              const finalStats = fs2.statSync(finalTempPath);
+              if (finalStats.size !== meta.fileSize) {
+                throw new Error(`File size mismatch: expected ${meta.fileSize}, got ${finalStats.size}`);
+              }
               const drive = new drive_default({
                 owner: meta.owner,
                 storageAccountId: meta.accountId || null,
@@ -1284,7 +1328,7 @@ var driveAPIHandler = async (req, res) => {
               await drive.save();
               try {
                 const item = await provider.uploadFile(drive, finalTempPath, meta.accountId);
-                fs5.rmSync(uploadDir, { recursive: true, force: true });
+                fs2.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) {
@@ -1314,9 +1358,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(os.tmpdir(), "next-drive-uploads", id);
-        if (fs5.existsSync(tempUploadDir)) {
+        if (fs2.existsSync(tempUploadDir)) {
           try {
-            fs5.rmSync(tempUploadDir, { recursive: true, force: true });
+            fs2.rmSync(tempUploadDir, { recursive: true, force: true });
           } catch (e) {
             console.error("Failed to cleanup temp upload:", e);
           }
@@ -1495,5 +1539,5 @@ var driveAPIHandler = async (req, res) => {
 };
 
 export { driveAPIHandler, driveConfiguration, driveFilePath, driveFileSchemaZod, driveGetUrl, driveReadFile, getDriveConfig, getDriveInformation };
-//# sourceMappingURL=chunk-EV3BVXQN.js.map
-//# sourceMappingURL=chunk-EV3BVXQN.js.map
+//# sourceMappingURL=chunk-KCDI2FBD.js.map
+//# sourceMappingURL=chunk-KCDI2FBD.js.map