@muhgholy/next-drive 3.9.0 → 3.11.0

package/dist/{chunk-RL3P26H3.cjs → chunk-OGVU5UBC.cjs}

@@ -28,25 +28,35 @@ var driveConfiguration = (config) => {
   if (mongoose2__default.default.connection.readyState !== 1) {
     throw new Error("Database not connected. Please connect to Mongoose before initializing next-drive.");
   }
-  const mergedConfig = {
-    ...config,
-    security: {
-      maxUploadSizeInBytes: config.security?.maxUploadSizeInBytes ?? 10 * 1024 * 1024,
-      // Default to 10MB
-      allowedMimeTypes: config.security?.allowedMimeTypes ?? ["*/*"],
-      signedUrls: config.security?.signedUrls,
-      trash: config.security?.trash
-    },
-    information: config.information ?? (async (req) => {
-      return {
-        key: { id: "default-user" },
-        storage: { quotaInBytes: 10 * 1024 * 1024 * 1024 }
-        // Default to 10GB
-      };
-    })
-  };
-  globalConfig = mergedConfig;
-  return mergedConfig;
+  const mode = config.mode || "NORMAL";
+  if (mode === "ROOT") {
+    globalConfig = {
+      ...config,
+      mode: "ROOT",
+      security: config.security || {
+        maxUploadSizeInBytes: 1024 * 1024 * 1024 * 10,
+        // 10GB default for ROOT
+        allowedMimeTypes: ["*/*"]
+      }
+    };
+    return globalConfig;
+  } else {
+    if (!config.information) {
+      throw new Error("information callback is required in NORMAL mode");
+    }
+    globalConfig = {
+      ...config,
+      mode: "NORMAL",
+      security: {
+        maxUploadSizeInBytes: config.security?.maxUploadSizeInBytes ?? 10 * 1024 * 1024,
+        allowedMimeTypes: config.security?.allowedMimeTypes ?? ["*/*"],
+        signedUrls: config.security?.signedUrls,
+        trash: config.security?.trash
+      },
+      information: config.information
+    };
+    return globalConfig;
+  }
 };
 var getDriveConfig = () => {
   if (!globalConfig) throw new Error("Drive configuration not initialized");
@@ -54,6 +64,16 @@ var getDriveConfig = () => {
 };
 var getDriveInformation = async (req) => {
   const config = getDriveConfig();
+  if (config.mode === "ROOT") {
+    if (!config.information) {
+      return {
+        key: null,
+        storage: { quotaInBytes: Number.MAX_SAFE_INTEGER }
+        // Unlimited quota in ROOT mode
+      };
+    }
+    return config.information(req);
+  }
   return config.information(req);
 };
 var informationSchema = new mongoose2.Schema({
@@ -265,19 +285,25 @@ var LocalStorageProvider = {
   search: async (query, owner, accountId) => {
   },
   getQuota: async (owner, accountId, configuredQuotaInBytes) => {
+    const config = getDriveConfig();
+    const isRootMode = config.mode === "ROOT";
+    const match = {
+      "information.type": "FILE",
+      trashedAt: null,
+      "provider.type": "LOCAL",
+      storageAccountId: accountId || null
+    };
+    if (!isRootMode) {
+      match.owner = owner;
+    }
     const result = await drive_default.aggregate([
-      {
-        $match: {
-          owner,
-          "information.type": "FILE",
-          trashedAt: null,
-          "provider.type": "LOCAL",
-          storageAccountId: accountId || null
-        }
-      },
+      { $match: match },
       { $group: { _id: null, total: { $sum: "$information.sizeInBytes" } } }
     ]);
     const usedInBytes = result[0]?.total || 0;
+    if (isRootMode) {
+      return { usedInBytes, quotaInBytes: Number.MAX_SAFE_INTEGER };
+    }
     return { usedInBytes, quotaInBytes: configuredQuotaInBytes ?? 0 };
   },
   openStream: async (item, accountId) => {
@@ -619,6 +645,23 @@ var GoogleDriveProvider = {
     }
   },
   getQuota: async (owner, accountId, _configuredQuotaInBytes) => {
+    const config = getDriveConfig();
+    const isRootMode = config.mode === "ROOT";
+    if (isRootMode) {
+      const result = await drive_default.aggregate([
+        {
+          $match: {
+            "information.type": "FILE",
+            trashedAt: null,
+            "provider.type": "GOOGLE",
+            storageAccountId: accountId || null
+          }
+        },
+        { $group: { _id: null, total: { $sum: "$information.sizeInBytes" } } }
+      ]);
+      const usedInBytes = result[0]?.total || 0;
+      return { usedInBytes, quotaInBytes: Number.MAX_SAFE_INTEGER };
+    }
     try {
       const { client } = await createAuthClient(owner, accountId);
       const drive = googleapis.google.drive({ version: "v3", auth: client });
@@ -845,7 +888,7 @@ var getNextOrderValue = async (owner) => {
 };
 var driveGetUrl = (fileId, options) => {
   const config = getDriveConfig();
-  if (!config.security.signedUrls?.enabled) {
+  if (!config.security?.signedUrls?.enabled) {
     return `/api/drive?action=serve&id=${fileId}`;
   }
   const { secret, expiresIn } = config.security.signedUrls;
@@ -1132,13 +1175,14 @@ var driveUpload = async (source, key, options) => {
       };
       mimeType = mimeTypes[ext] || "application/octet-stream";
     }
-    if (!validateMimeType(mimeType, config.security.allowedMimeTypes)) {
+    if (config.security && !validateMimeType(mimeType, config.security.allowedMimeTypes)) {
       throw new Error(`File type ${mimeType} not allowed`);
     }
-    if (fileSize > config.security.maxUploadSizeInBytes) {
+    if (config.security && fileSize > config.security.maxUploadSizeInBytes) {
       throw new Error(`File size ${fileSize} exceeds maximum allowed size ${config.security.maxUploadSizeInBytes}`);
     }
-    if (!options.enforce) {
+    const isRootMode = config.mode === "ROOT";
+    if (!options.enforce && !isRootMode) {
       const quota = await provider.getQuota(key, accountId, void 0);
       if (quota.usedInBytes + fileSize > quota.quotaInBytes) {
         throw new Error("Storage quota exceeded");
@@ -1264,7 +1308,7 @@ var driveAPIHandler = async (req, res) => {
       }
       const drive = await drive_default.findById(id);
       if (!drive) return res.status(404).json({ status: 404, message: "File not found" });
-      if (config.security.signedUrls?.enabled) {
+      if (config.security?.signedUrls?.enabled) {
         if (!token || typeof token !== "string") {
           return res.status(401).json({ status: 401, message: "Missing or invalid token" });
         }
@@ -1316,9 +1360,11 @@ var driveAPIHandler = async (req, res) => {
     }
   }
   try {
+    const mode = config.mode || "NORMAL";
     const information = await getDriveInformation(req);
     const { key: owner } = information;
     const STORAGE_PATH = config.storage.path;
+    const isRootMode = mode === "ROOT";
     if (action === "information") {
       const { clientId, clientSecret, redirectUri } = config.storage?.google || {};
       const googleConfigured = !!(clientId && clientSecret && redirectUri);
@@ -1328,7 +1374,8 @@ var driveAPIHandler = async (req, res) => {
         data: {
           providers: {
             google: googleConfigured
-          }
+          },
+          mode
         }
       });
     }
@@ -1461,12 +1508,14 @@ var driveAPIHandler = async (req, res) => {
           console.error("Sync failed", e);
         }
         const query = {
-          owner,
           "provider.type": provider.name,
           storageAccountId: accountId || null,
           parentId: folderId === "root" || !folderId ? null : folderId,
           trashedAt: null
         };
+        if (!isRootMode) {
+          query.owner = owner;
+        }
         if (afterId) query._id = { $lt: afterId };
         const items = await drive_default.find(query, {}, { sort: { order: 1, _id: -1 }, limit });
         const plainItems = await Promise.all(items.map((item) => item.toClient()));
@@ -1486,12 +1535,14 @@ var driveAPIHandler = async (req, res) => {
           }
         }
         const query = {
-          owner,
           "provider.type": provider.name,
           storageAccountId: accountId || null,
           trashedAt: trashed ? { $ne: null } : null,
           name: { $regex: q, $options: "i" }
         };
+        if (!isRootMode) {
+          query.owner = owner;
+        }
         if (folderId && folderId !== "root") query.parentId = folderId;
         const items = await drive_default.find(query, {}, { limit, sort: { createdAt: -1 } });
         const plainItems = await Promise.all(items.map((i) => i.toClient()));
@@ -1504,7 +1555,7 @@ var driveAPIHandler = async (req, res) => {
         if (!fs4__default.default.existsSync(systemTmpDir)) fs4__default.default.mkdirSync(systemTmpDir, { recursive: true });
         const form = formidable__default.default({
           multiples: false,
-          maxFileSize: config.security.maxUploadSizeInBytes * 2,
+          maxFileSize: (config.security?.maxUploadSizeInBytes ?? 1024 * 1024 * 1024) * 2,
           uploadDir: systemTmpDir,
           keepExtensions: true
         });
@@ -1539,14 +1590,18 @@ var driveAPIHandler = async (req, res) => {
         const tempBaseDir = path3__default.default.join(os2__default.default.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)) {
-            cleanupTempFiles(files);
-            return res.status(400).json({ status: 400, message: `File type ${fileType} not allowed` });
+          if (fileType && config.security) {
+            if (!validateMimeType(fileType, config.security.allowedMimeTypes)) {
+              cleanupTempFiles(files);
+              return res.status(400).json({ status: 400, message: `File type ${fileType} not allowed` });
+            }
           }
-          const quota = await provider.getQuota(owner, accountId, information.storage.quotaInBytes);
-          if (quota.usedInBytes + fileSizeInBytes > quota.quotaInBytes) {
-            cleanupTempFiles(files);
-            return res.status(413).json({ status: 413, message: "Storage quota exceeded" });
+          if (!isRootMode) {
+            const quota = await provider.getQuota(owner, accountId, information.storage.quotaInBytes);
+            if (quota.usedInBytes + fileSizeInBytes > quota.quotaInBytes) {
+              cleanupTempFiles(files);
+              return res.status(413).json({ status: 413, message: "Storage quota exceeded" });
+            }
           }
           currentUploadId = crypto2__default.default.randomUUID();
           const uploadDir = path3__default.default.join(tempBaseDir, currentUploadId);
@@ -1589,23 +1644,41 @@ var driveAPIHandler = async (req, res) => {
               const meta = JSON.parse(fs4__default.default.readFileSync(metaPath, "utf-8"));
               const finalTempPath = path3__default.default.join(uploadDir, "final.bin");
               const writeStream = fs4__default.default.createWriteStream(finalTempPath);
+              let streamError = null;
+              writeStream.on("error", (err) => {
+                streamError = err;
+              });
               await new Promise((resolve, reject) => {
                 writeStream.on("open", () => resolve());
-                writeStream.on("error", reject);
+                writeStream.once("error", reject);
               });
               for (let i = 0; i < totalChunks; i++) {
+                if (streamError) {
+                  writeStream.destroy();
+                  throw streamError;
+                }
                 const pPath = path3__default.default.join(uploadDir, `part_${i}`);
                 if (!fs4__default.default.existsSync(pPath)) {
                   writeStream.destroy();
                   throw new Error(`Missing chunk part: ${i}`);
                 }
                 const data = fs4__default.default.readFileSync(pPath);
-                writeStream.write(data);
+                const canContinue = writeStream.write(data);
+                if (!canContinue) {
+                  await new Promise((resolve, reject) => {
+                    writeStream.once("drain", resolve);
+                    writeStream.once("error", reject);
+                  });
+                }
               }
               await new Promise((resolve, reject) => {
+                if (streamError) {
+                  reject(streamError);
+                  return;
+                }
                 writeStream.end();
                 writeStream.on("finish", resolve);
-                writeStream.on("error", reject);
+                writeStream.once("error", reject);
               });
               if (!fs4__default.default.existsSync(finalTempPath)) {
                 throw new Error("Failed to create merged file");
@@ -1822,5 +1895,5 @@ exports.driveReadFile = driveReadFile;
 exports.driveUpload = driveUpload;
 exports.getDriveConfig = getDriveConfig;
 exports.getDriveInformation = getDriveInformation;
-//# sourceMappingURL=chunk-RL3P26H3.cjs.map
-//# sourceMappingURL=chunk-RL3P26H3.cjs.map
+//# sourceMappingURL=chunk-OGVU5UBC.cjs.map
+//# sourceMappingURL=chunk-OGVU5UBC.cjs.map