@muhgholy/next-drive 1.7.0 → 2.0.0

package/dist/{chunk-D6GHXEOY.js → chunk-LJCUIGLV.js}

@@ -1,7 +1,8 @@
 import { __require } from './chunk-DGUM43GV.js';
 import formidable from 'formidable';
 import path3 from 'path';
-import fs2 from 'fs';
+import fs5 from 'fs';
+import os from 'os';
 import mongoose2, { Schema, isValidObjectId } from 'mongoose';
 import crypto2 from 'crypto';
 import sharp from 'sharp';
@@ -138,7 +139,7 @@ var validateMimeType = (mime, allowedTypes) => {
 };
 var computeFileHash = (filePath) => new Promise((resolve, reject) => {
   const hash = crypto2.createHash("sha256");
-  const stream = fs2.createReadStream(filePath);
+  const stream = fs5.createReadStream(filePath);
   stream.on("data", (data) => hash.update(data));
   stream.on("end", () => resolve(hash.digest("hex")));
   stream.on("error", reject);
@@ -224,8 +225,8 @@ var searchQuerySchema = z.object({
 z.object({
   id: objectIdSchema
 });
-z.object({
-  id: objectIdSchema
+var cancelQuerySchema = z.object({
+  id: z.string().uuid()
 });
 z.object({
   days: z.number().int().min(1).max(365).optional()
@@ -258,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 (!fs2.existsSync(filePath)) {
+    if (!fs5.existsSync(filePath)) {
       throw new Error("File not found on disk");
     }
-    const stat = fs2.statSync(filePath);
-    const stream = fs2.createReadStream(filePath);
+    const stat = fs5.statSync(filePath);
+    const stream = fs5.createReadStream(filePath);
     return {
       stream,
       mime: item.information.mime,
@@ -274,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 (!fs2.existsSync(originalPath)) throw new Error("Original file not found");
-    if (fs2.existsSync(thumbPath)) {
-      return fs2.createReadStream(thumbPath);
+    if (!fs5.existsSync(originalPath)) throw new Error("Original file not found");
+    if (fs5.existsSync(thumbPath)) {
+      return fs5.createReadStream(thumbPath);
     }
-    if (!fs2.existsSync(path3.dirname(thumbPath))) fs2.mkdirSync(path3.dirname(thumbPath), { recursive: true });
+    if (!fs5.existsSync(path3.dirname(thumbPath))) fs5.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/")) {
@@ -293,7 +294,7 @@ var LocalStorageProvider = {
     } else {
       throw new Error("Unsupported mime type for thumbnail");
     }
-    return fs2.createReadStream(thumbPath);
+    return fs5.createReadStream(thumbPath);
   },
   createFolder: async (name, parentId, owner, accountId) => {
     const getNextOrderValue = async (owner2) => {
@@ -316,8 +317,8 @@ var LocalStorageProvider = {
     if (drive.information.type !== "FILE") throw new Error("Invalid drive type");
     const destPath = path3.join(getDriveConfig().storage.path, drive.information.path);
     const dirPath = path3.dirname(destPath);
-    if (!fs2.existsSync(dirPath)) fs2.mkdirSync(dirPath, { recursive: true });
-    fs2.renameSync(filePath, destPath);
+    if (!fs5.existsSync(dirPath)) fs5.mkdirSync(dirPath, { recursive: true });
+    fs5.renameSync(filePath, destPath);
     drive.status = "READY";
     drive.information.hash = await computeFileHash(destPath);
     if (drive.information.mime.startsWith("image/")) {
@@ -346,8 +347,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 (fs5.existsSync(dirPath)) {
+          fs5.rmSync(dirPath, { recursive: true, force: true });
         }
       }
     }
@@ -651,7 +652,7 @@ var GoogleDriveProvider = {
         },
         media: {
           mimeType: drive.information.mime,
-          body: fs2.createReadStream(filePath)
+          body: fs5.createReadStream(filePath)
         },
         fields: "id, name, mimeType, webViewLink, iconLink, thumbnailLink, size"
       });
@@ -841,7 +842,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 (!fs5.existsSync(filePath)) {
       throw new Error(`Local file not found on disk: ${filePath}`);
     }
     return Object.freeze({
@@ -856,8 +857,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 (fs5.existsSync(cachedFilePath)) {
+      const stats = fs5.statSync(cachedFilePath);
       if (stats.size === drive.information.sizeInBytes) {
         return Object.freeze({
           path: cachedFilePath,
@@ -867,22 +868,22 @@ var driveFilePath = async (file) => {
           provider: "GOOGLE"
         });
       }
-      fs2.unlinkSync(cachedFilePath);
+      fs5.unlinkSync(cachedFilePath);
     }
     const accountId = drive.storageAccountId?.toString();
     const { stream } = await GoogleDriveProvider.openStream(drive, accountId);
-    if (!fs2.existsSync(libraryDir)) {
-      fs2.mkdirSync(libraryDir, { recursive: true });
+    if (!fs5.existsSync(libraryDir)) {
+      fs5.mkdirSync(libraryDir, { recursive: true });
     }
     const tempPath = `${cachedFilePath}.tmp`;
-    const writeStream = fs2.createWriteStream(tempPath);
+    const writeStream = fs5.createWriteStream(tempPath);
     await new Promise((resolve, reject) => {
       stream.pipe(writeStream);
       writeStream.on("finish", resolve);
       writeStream.on("error", reject);
       stream.on("error", reject);
     });
-    fs2.renameSync(tempPath, cachedFilePath);
+    fs5.renameSync(tempPath, cachedFilePath);
     return Object.freeze({
       path: cachedFilePath,
       name: drive.name,
@@ -978,9 +979,11 @@ var driveAPIHandler = async (req, res) => {
           const { provider: provider2 } = req.query;
           if (provider2 === "GOOGLE") {
             const { clientId, clientSecret, redirectUri } = config.storage?.google || {};
-            if (!clientId || !clientSecret) return res.status(500).json({ status: 500, message: "Google not configured" });
+            if (!clientId || !clientSecret || !redirectUri) return res.status(500).json({ status: 500, message: "Google not configured" });
             const { google: google2 } = __require("googleapis");
-            const oAuth2Client = new google2.auth.OAuth2(clientId, clientSecret, redirectUri);
+            const callbackUri = new URL(redirectUri);
+            callbackUri.searchParams.set("action", "callback");
+            const oAuth2Client = new google2.auth.OAuth2(clientId, clientSecret, callbackUri.toString());
             const state = Buffer.from(JSON.stringify({ owner })).toString("base64");
             const url = oAuth2Client.generateAuthUrl({
               access_type: "offline",
@@ -997,8 +1000,11 @@ var driveAPIHandler = async (req, res) => {
           const { code, state } = req.query;
           if (!code) return res.status(400).json({ status: 400, message: "Missing code" });
           const { clientId, clientSecret, redirectUri } = config.storage?.google || {};
+          if (!clientId || !clientSecret || !redirectUri) return res.status(500).json({ status: 500, message: "Google not configured" });
           const { google: google2 } = __require("googleapis");
-          const oAuth2Client = new google2.auth.OAuth2(clientId, clientSecret, redirectUri);
+          const callbackUri = new URL(redirectUri);
+          callbackUri.searchParams.set("action", "callback");
+          const oAuth2Client = new google2.auth.OAuth2(clientId, clientSecret, callbackUri.toString());
           const { tokens } = await oAuth2Client.getToken(code);
           oAuth2Client.setCredentials(tokens);
           const oauth2 = google2.oauth2({ version: "v2", auth: oAuth2Client });
@@ -1022,7 +1028,35 @@ var driveAPIHandler = async (req, res) => {
             });
           }
           res.setHeader("Content-Type", "text/html");
-          return res.send('<script>window.opener.postMessage("oauth-success", "*"); window.close();</script>');
+          return res.send(`<!DOCTYPE html>
+<html>
+<head><title>Authentication Complete</title></head>
+<body>
+<p>Authentication successful! This window will close automatically.</p>
+<script>
+(function() {
+	// Method 1: postMessage for popup windows
+	if (window.opener) {
+		try {
+			window.opener.postMessage('oauth-success', '*');
+		} catch (e) {}
+	}
+	// Method 2: localStorage event for new tabs (macOS fullscreen mode)
+	try {
+		localStorage.setItem('next-drive-oauth-success', Date.now().toString());
+		localStorage.removeItem('next-drive-oauth-success');
+	} catch (e) {}
+	// Close the window/tab
+	window.close();
+	// Fallback: If window.close() doesn't work (some browsers block it),
+	// show a message to manually close
+	setTimeout(function() {
+		document.body.innerHTML = '<p style="font-family: system-ui; text-align: center; margin-top: 50px;">Authentication successful!<br>You can close this tab now.</p>';
+	}, 500);
+})();
+</script>
+</body>
+</html>`);
         }
         case "listAccounts": {
           const accounts = await account_default.find({ owner });
@@ -1108,13 +1142,14 @@ var driveAPIHandler = async (req, res) => {
       // ** 3. UPLOAD **
       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 });
         const form = formidable({
           multiples: false,
           maxFileSize: config.security.maxUploadSizeInBytes * 2,
-          uploadDir: path3.join(STORAGE_PATH, "temp"),
+          uploadDir: systemTmpDir,
           keepExtensions: true
         });
-        if (!fs2.existsSync(path3.join(STORAGE_PATH, "temp"))) fs2.mkdirSync(path3.join(STORAGE_PATH, "temp"), { recursive: true });
         const [fields, files] = await new Promise((resolve, reject) => {
           form.parse(req, (err, fields2, files2) => {
             if (err) reject(err);
@@ -1123,7 +1158,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 && fs5.existsSync(file.filepath)) fs5.rmSync(file.filepath, { force: true });
           });
         };
         const getString = (f) => Array.isArray(f) ? f[0] : f || "";
@@ -1143,7 +1178,7 @@ var driveAPIHandler = async (req, res) => {
         }
         const { chunkIndex, totalChunks, driveId, fileName, fileSize: fileSizeInBytes, fileType, folderId } = uploadData.data;
         let currentUploadId = driveId;
-        const tempBaseDir = path3.join(STORAGE_PATH, "temp", "uploads");
+        const tempBaseDir = path3.join(os.tmpdir(), "next-drive-uploads");
         if (!currentUploadId) {
           if (chunkIndex !== 0) return res.status(400).json({ message: "Missing upload ID for non-zero chunk" });
           if (fileType && !validateMimeType(fileType, config.security.allowedMimeTypes)) {
@@ -1157,7 +1192,7 @@ var driveAPIHandler = async (req, res) => {
           }
           currentUploadId = crypto.randomUUID();
           const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          fs2.mkdirSync(uploadDir, { recursive: true });
+          fs5.mkdirSync(uploadDir, { recursive: true });
           const metadata = {
             owner,
             accountId,
@@ -1168,11 +1203,11 @@ var driveAPIHandler = async (req, res) => {
             mimeType: fileType,
             totalChunks
           };
-          fs2.writeFileSync(path3.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
+          fs5.writeFileSync(path3.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
         }
         if (currentUploadId) {
           const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          if (!fs2.existsSync(uploadDir)) {
+          if (!fs5.existsSync(uploadDir)) {
             cleanupTempFiles(files);
             return res.status(404).json({ status: 404, message: "Upload session not found or expired" });
           }
@@ -1180,16 +1215,16 @@ 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}`);
-            fs2.renameSync(chunkFile.filepath, partPath);
-            const uploadedParts = fs2.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
+            fs5.renameSync(chunkFile.filepath, partPath);
+            const uploadedParts = fs5.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(fs5.readFileSync(metaPath, "utf-8"));
               const finalTempPath = path3.join(uploadDir, "final.bin");
-              const writeStream = fs2.createWriteStream(finalTempPath);
+              const writeStream = fs5.createWriteStream(finalTempPath);
               for (let i = 0; i < totalChunks; i++) {
                 const pPath = path3.join(uploadDir, `part_${i}`);
-                const data = fs2.readFileSync(pPath);
+                const data = fs5.readFileSync(pPath);
                 writeStream.write(data);
               }
               writeStream.end();
@@ -1215,7 +1250,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 });
+                fs5.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) {
@@ -1239,7 +1274,22 @@ var driveAPIHandler = async (req, res) => {
         cleanupTempFiles(files);
         return res.status(400).json({ status: 400, message: "Invalid upload request" });
       }
-      // ** 4. CREATE FOLDER **
+      // ** 4. CANCEL UPLOAD **
+      case "cancel": {
+        const cancelData = cancelQuerySchema.safeParse(req.query);
+        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)) {
+          try {
+            fs5.rmSync(tempUploadDir, { recursive: true, force: true });
+          } catch (e) {
+            console.error("Failed to cleanup temp upload:", e);
+          }
+        }
+        return res.status(200).json({ status: 200, message: "Upload cancelled", data: null });
+      }
+      // ** 5. CREATE FOLDER **
       case "createFolder": {
         const folderData = createFolderBodySchema.safeParse(req.body);
         if (!folderData.success) return res.status(400).json({ status: 400, message: folderData.error.errors[0].message });
@@ -1411,5 +1461,5 @@ var driveAPIHandler = async (req, res) => {
 };
 
 export { driveAPIHandler, driveConfiguration, driveFilePath, driveFileSchemaZod, driveGetUrl, driveReadFile, getDriveConfig, getDriveInformation };
-//# sourceMappingURL=chunk-D6GHXEOY.js.map
-//# sourceMappingURL=chunk-D6GHXEOY.js.map
+//# sourceMappingURL=chunk-LJCUIGLV.js.map
+//# sourceMappingURL=chunk-LJCUIGLV.js.map