@muhgholy/next-drive 4.23.33 → 4.23.34

package/dist/{chunk-IWV6G7HQ.js → chunk-QMPV4YSZ.js}

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { Readable } from 'stream';
+import { PassThrough, Readable } from 'stream';
 import mongoose, { Schema, isValidObjectId } from 'mongoose';
 import { Server, EVENTS } from '@tus/server';
 import { FileStore } from '@tus/file-store';
@@ -505,6 +505,15 @@ var getImageSettings = (fileSizeInBytes, qualityPreset, display, size, fit, posi
     ...resolvedPosition && { position: resolvedPosition }
   };
 };
+
+// src/server/errors.ts
+var DriveError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "DriveError";
+    this.code = code;
+  }
+};
 var generatePlaceholderThumbnail = async (outputPath, mimeType) => {
   const typeParts = mimeType.split("/");
   const subtype = typeParts[1] || "file";
@@ -961,7 +970,7 @@ var GoogleDriveProvider = {
       return { usedInBytes: 0, quotaInBytes: 0 };
     }
   },
-  openStream: async (item, accountId) => {
+  openStream: async (item, accountId, options) => {
     if (item.information.type === "FOLDER") throw new Error("Could not open Google Drive file: folders cannot be streamed");
     const cachePath = path.join(getDriveConfig().storage.path, "file", item._id.toString(), "data.bin");
     if (fs.existsSync(cachePath)) {
@@ -978,24 +987,36 @@ var GoogleDriveProvider = {
       { fileId: item.provider.google.id, alt: "media" },
       { responseType: "stream" }
     );
-    const fileDir = path.dirname(cachePath);
-    if (!fs.existsSync(fileDir)) fs.mkdirSync(fileDir, { recursive: true });
-    const tempPath = `${cachePath}.tmp`;
-    const writeStream = fs.createWriteStream(tempPath);
-    res.data.pipe(writeStream);
-    writeStream.on("finish", () => {
-      try {
-        fs.renameSync(tempPath, cachePath);
-      } catch {
-        fs.unlinkSync(tempPath);
-      }
-    });
-    writeStream.on("error", () => fs.unlink(tempPath, () => {
-    }));
+    let cacheWritePromise;
+    if (!options?.skipCache) {
+      const fileDir = path.dirname(cachePath);
+      if (!fs.existsSync(fileDir)) fs.mkdirSync(fileDir, { recursive: true });
+      const tempPath = `${cachePath}.tmp`;
+      const writeStream = fs.createWriteStream(tempPath);
+      res.data.pipe(writeStream);
+      cacheWritePromise = new Promise((resolve, reject) => {
+        writeStream.on("finish", () => {
+          try {
+            fs.renameSync(tempPath, cachePath);
+            resolve();
+          } catch {
+            fs.unlink(tempPath, () => {
+            });
+            reject(new Error("Could not cache Google Drive file: failed to finalize the cached file"));
+          }
+        });
+        writeStream.on("error", (err) => {
+          fs.unlink(tempPath, () => {
+          });
+          reject(err);
+        });
+      });
+    }
     return {
       stream: res.data,
       mime: item.information.mime,
-      size: item.information.sizeInBytes
+      size: item.information.sizeInBytes,
+      cacheWritePromise
     };
   },
   getThumbnail: async (item, accountId) => {
@@ -1259,28 +1280,44 @@ var driveAddSignedUrlToken = (item, config) => {
 var driveAddSignedUrlTokens = (items, config) => {
   return items.map((item) => driveAddSignedUrlToken(item, config));
 };
-var driveReadFile = async (file) => {
+var driveReadFile = async (file, options) => {
   let drive;
   if (typeof file === "string") {
     const doc = await drive_default.findById(file);
-    if (!doc) throw new Error("Could not read file: the file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not read file: the file no longer exists");
     drive = doc;
   } else if ("toClient" in file) {
     drive = file;
   } else {
-    throw new Error("Could not read file: invalid file reference provided");
+    throw new DriveError("INVALID_REFERENCE", "Could not read file: invalid file reference provided");
   }
   if (drive.information.type !== "FILE") {
-    throw new Error("Could not read file: this item is a folder, not a file");
+    throw new DriveError("INVALID_TYPE", "Could not read file: this item is a folder, not a file");
   }
   const provider = drive.provider?.type === "GOOGLE" ? GoogleDriveProvider : LocalStorageProvider;
   const accountId = drive.storageAccountId?.toString();
-  return await provider.openStream(drive, accountId);
+  const driveId = String(drive._id);
+  let result;
+  if (provider === GoogleDriveProvider && cacheWriteLocks.has(driveId)) {
+    result = await provider.openStream(drive, accountId, { skipCache: true });
+  } else {
+    result = await provider.openStream(drive, accountId);
+    if (result.cacheWritePromise) {
+      const cacheWritePromise = result.cacheWritePromise;
+      cacheWritePromise.catch(() => {
+      });
+      cacheWriteLocks.set(driveId, cacheWritePromise);
+      cacheWritePromise.finally(() => {
+        if (cacheWriteLocks.get(driveId) === cacheWritePromise) cacheWriteLocks.delete(driveId);
+      });
+    }
+  }
+  return { ...result, stream: instrumentReadableForProgress(result.stream, result.size, options) };
 };
 var driveInfo = async (source) => {
   const fileId = typeof source === "string" ? source : source.id;
   const drive = await drive_default.findById(fileId);
-  if (!drive) throw new Error("Could not load file details: the file no longer exists");
+  if (!drive) throw new DriveError("NOT_FOUND", "Could not load file details: the file no longer exists");
   let parentName;
   if (drive.parentId) {
     const parent = await drive_default.findById(drive.parentId);
@@ -1315,19 +1352,107 @@ var driveInfo = async (source) => {
   }
   return info;
 };
-var driveFilePath = async (file) => {
+var computeTransferPercentage = (bytesDownloaded, totalBytes) => {
+  if (!totalBytes) return 0;
+  return Math.min(100, Math.round(bytesDownloaded / totalBytes * 100));
+};
+var cacheWriteLocks = /* @__PURE__ */ new Map();
+var inFlightGoogleDownloads = /* @__PURE__ */ new Map();
+var downloadGoogleFileToCache = async (drive, accountId, cachePath, totalBytes, listeners, controller) => {
+  if (controller.signal.aborted) {
+    throw new DriveError("ABORTED", "Could not download file: the download was aborted");
+  }
+  const { stream } = await GoogleDriveProvider.openStream(drive, accountId, { skipCache: true });
+  if (controller.signal.aborted) {
+    stream.destroy();
+    throw new DriveError("ABORTED", "Could not download file: the download was aborted");
+  }
+  const fileDir = path.dirname(cachePath);
+  if (!fs.existsSync(fileDir)) fs.mkdirSync(fileDir, { recursive: true });
+  const tempPath = `${cachePath}.tmp`;
+  const writeStream = fs.createWriteStream(tempPath);
+  const cleanupTempFile = () => fs.unlink(tempPath, () => {
+  });
+  const onAbort = () => {
+    const abortError = new DriveError("ABORTED", "Could not download file: the download was aborted");
+    stream.destroy(abortError);
+    writeStream.destroy(abortError);
+  };
+  controller.signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    let bytesDownloaded = 0;
+    await new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => {
+        bytesDownloaded += chunk.length;
+        const info = {
+          bytesDownloaded,
+          totalBytes,
+          percentage: computeTransferPercentage(bytesDownloaded, totalBytes)
+        };
+        for (const listener of listeners) listener(info);
+      });
+      stream.pipe(writeStream);
+      writeStream.on("finish", resolve);
+      writeStream.on("error", reject);
+      stream.on("error", reject);
+    });
+  } catch (err) {
+    cleanupTempFile();
+    if (controller.signal.aborted) {
+      throw new DriveError("ABORTED", "Could not download file: the download was aborted");
+    }
+    throw new DriveError("DOWNLOAD_FAILED", `Could not download file: ${err instanceof Error ? err.message : "an unknown error occurred"}`);
+  } finally {
+    controller.signal.removeEventListener("abort", onAbort);
+  }
+  try {
+    fs.renameSync(tempPath, cachePath);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "EXDEV") {
+      fs.copyFileSync(tempPath, cachePath);
+      fs.unlinkSync(tempPath);
+    } else {
+      cleanupTempFile();
+      throw new DriveError("DOWNLOAD_FAILED", "Could not download file: failed to finalize the cached file");
+    }
+  }
+};
+var instrumentReadableForProgress = (source, totalBytes, options) => {
+  if (!options?.onProgress && !options?.signal) return source;
+  const passThrough = new PassThrough();
+  let bytesDownloaded = 0;
+  source.on("data", (chunk) => {
+    bytesDownloaded += chunk.length;
+    options.onProgress?.({
+      bytesDownloaded,
+      totalBytes,
+      percentage: computeTransferPercentage(bytesDownloaded, totalBytes)
+    });
+  });
+  source.on("error", (err) => passThrough.destroy(err));
+  source.pipe(passThrough);
+  if (options.signal) {
+    const onAbort = () => {
+      source.destroy(new DriveError("ABORTED", "Could not read file: the read was aborted"));
+    };
+    if (options.signal.aborted) onAbort();
+    else options.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return passThrough;
+};
+var driveFilePath = async (file, options) => {
   let drive;
   if (typeof file === "string") {
     const doc = await drive_default.findById(file);
-    if (!doc) throw new Error("Could not locate file: the file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not locate file: the file no longer exists");
     drive = doc;
   } else if ("toClient" in file) {
     drive = file;
   } else {
-    throw new Error("Could not locate file: invalid file reference provided");
+    throw new DriveError("INVALID_REFERENCE", "Could not locate file: invalid file reference provided");
   }
   if (drive.information.type !== "FILE") {
-    throw new Error("Could not locate file: this item is a folder, not a file");
+    throw new DriveError("INVALID_TYPE", "Could not locate file: this item is a folder, not a file");
   }
   const config = getDriveConfig();
   const STORAGE_PATH = config.storage.path;
@@ -1335,7 +1460,7 @@ var driveFilePath = async (file) => {
   if (providerType === "LOCAL") {
     const filePath = path.join(STORAGE_PATH, "file", String(drive._id), "data.bin");
     if (!fs.existsSync(filePath)) {
-      throw new Error("Could not locate file: the stored file is missing from disk");
+      throw new DriveError("FILE_MISSING", "Could not locate file: the stored file is missing from disk");
     }
     return Object.freeze({
       path: filePath,
@@ -1346,11 +1471,34 @@ var driveFilePath = async (file) => {
     });
   }
   if (providerType === "GOOGLE") {
-    const fileDir = path.join(STORAGE_PATH, "file", String(drive._id));
+    const driveId = String(drive._id);
+    const fileDir = path.join(STORAGE_PATH, "file", driveId);
     const cachedFilePath = path.join(fileDir, "data.bin");
+    const expectedSize = drive.information.sizeInBytes;
+    const isCached = () => {
+      if (!fs.existsSync(cachedFilePath)) return false;
+      return fs.statSync(cachedFilePath).size === expectedSize;
+    };
+    if (isCached()) {
+      return Object.freeze({
+        path: cachedFilePath,
+        name: drive.name,
+        mime: drive.information.mime,
+        size: drive.information.sizeInBytes,
+        provider: "GOOGLE"
+      });
+    }
     if (fs.existsSync(cachedFilePath)) {
-      const stats = fs.statSync(cachedFilePath);
-      if (stats.size === drive.information.sizeInBytes) {
+      fs.unlinkSync(cachedFilePath);
+    }
+    const accountId = drive.storageAccountId?.toString();
+    const existingLock = cacheWriteLocks.get(driveId);
+    if (existingLock) {
+      try {
+        await existingLock;
+      } catch {
+      }
+      if (isCached()) {
         return Object.freeze({
           path: cachedFilePath,
           name: drive.name,
@@ -1359,31 +1507,26 @@ var driveFilePath = async (file) => {
           provider: "GOOGLE"
         });
       }
-      fs.unlinkSync(cachedFilePath);
     }
-    const accountId = drive.storageAccountId?.toString();
-    const { stream } = await GoogleDriveProvider.openStream(drive, accountId);
-    if (!fs.existsSync(fileDir)) {
-      fs.mkdirSync(fileDir, { recursive: true });
+    let entry = inFlightGoogleDownloads.get(driveId);
+    if (!entry) {
+      const controller = new AbortController();
+      const listeners = /* @__PURE__ */ new Set();
+      const promise = downloadGoogleFileToCache(drive, accountId, cachedFilePath, expectedSize, listeners, controller).finally(() => {
+        inFlightGoogleDownloads.delete(driveId);
+        if (cacheWriteLocks.get(driveId) === promise) cacheWriteLocks.delete(driveId);
+      });
+      entry = { promise, controller, listeners };
+      inFlightGoogleDownloads.set(driveId, entry);
+      cacheWriteLocks.set(driveId, promise);
     }
-    const tempPath = `${cachedFilePath}.tmp`;
-    const writeStream = fs.createWriteStream(tempPath);
-    await new Promise((resolve, reject) => {
-      stream.pipe(writeStream);
-      writeStream.on("finish", resolve);
-      writeStream.on("error", reject);
-      stream.on("error", reject);
-    });
-    try {
-      fs.renameSync(tempPath, cachedFilePath);
-    } catch (err) {
-      if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-        fs.copyFileSync(tempPath, cachedFilePath);
-        fs.unlinkSync(tempPath);
-      } else {
-        throw err;
-      }
+    const activeEntry = entry;
+    if (options?.onProgress) activeEntry.listeners.add(options.onProgress);
+    if (options?.signal) {
+      if (options.signal.aborted) activeEntry.controller.abort();
+      else options.signal.addEventListener("abort", () => activeEntry.controller.abort(), { once: true });
     }
+    await activeEntry.promise;
     return Object.freeze({
       path: cachedFilePath,
       name: drive.name,
@@ -1392,7 +1535,7 @@ var driveFilePath = async (file) => {
       provider: "GOOGLE"
     });
   }
-  throw new Error(`Could not locate file: unsupported storage provider "${providerType}"`);
+  throw new DriveError("UNSUPPORTED_PROVIDER", `Could not locate file: unsupported storage provider "${providerType}"`);
 };
 var driveList = async (options) => {
   const { key, folderId, accountId, limit = 100, afterId } = options;
@@ -1400,7 +1543,7 @@ var driveList = async (options) => {
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner: key });
     if (!account) {
-      throw new Error("Could not list files: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not list files: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1428,7 +1571,7 @@ var driveListFiles = async (options) => {
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner: key });
     if (!account) {
-      throw new Error("Could not load files: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not load files: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1472,7 +1615,7 @@ var driveDelete = async (source, options) => {
   let driveId;
   if (typeof source === "string") {
     const doc = await drive_default.findById(source);
-    if (!doc) throw new Error("Could not delete: the file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not delete: the file no longer exists");
     drive = doc;
     driveId = source;
   } else if ("toClient" in source) {
@@ -1480,7 +1623,7 @@ var driveDelete = async (source, options) => {
     driveId = String(drive._id);
   } else {
     const doc = await drive_default.findById(source.id);
-    if (!doc) throw new Error("Could not delete: the selected file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not delete: the selected file no longer exists");
     drive = doc;
     driveId = source.id;
   }
@@ -1492,7 +1635,7 @@ var driveDelete = async (source, options) => {
       trashedAt: null
     });
     if (childCount > 0) {
-      throw new Error(`Could not delete folder: it still contains ${childCount} item(s). Enable recursive delete to remove the folder and everything inside it.`);
+      throw new DriveError("FOLDER_NOT_EMPTY", `Could not delete folder: it still contains ${childCount} item(s). Enable recursive delete to remove the folder and everything inside it.`);
     }
   }
   const provider = drive.provider?.type === "GOOGLE" ? GoogleDriveProvider : LocalStorageProvider;
@@ -1503,17 +1646,17 @@ var driveDelete = async (source, options) => {
 var resolveFolderByPath = async (folderPath, owner, accountId) => {
   const normalizedPath = folderPath.replace(/^\/+|\/+$/g, "");
   if (!normalizedPath) {
-    throw new Error("Could not resolve folder: the folder path is empty");
+    throw new DriveError("INVALID_PATH", "Could not resolve folder: the folder path is empty");
   }
   const segments = normalizedPath.split("/").filter((s) => s.length > 0);
   if (segments.length === 0) {
-    throw new Error("Could not resolve folder: the folder path is invalid");
+    throw new DriveError("INVALID_PATH", "Could not resolve folder: the folder path is invalid");
   }
   let providerName = "LOCAL";
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner });
     if (!account) {
-      throw new Error("Could not resolve folder: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not resolve folder: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1547,7 +1690,7 @@ var driveUpload = async (source, key, options) => {
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner: key });
     if (!account) {
-      throw new Error("Could not upload: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not upload: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       provider = GoogleDriveProvider;
@@ -1558,7 +1701,7 @@ var driveUpload = async (source, key, options) => {
   let fileSize;
   if (typeof source === "string") {
     if (!fs.existsSync(source)) {
-      throw new Error("Could not upload: source file not found");
+      throw new DriveError("FILE_MISSING", "Could not upload: source file not found");
     }
     sourceFilePath = source;
     const stats = fs.statSync(source);
@@ -1617,17 +1760,17 @@ var driveUpload = async (source, key, options) => {
       mimeType = mimeTypes[ext] || "application/octet-stream";
     }
     if (config.security && !validateMimeType(mimeType, config.security.allowedMimeTypes)) {
-      throw new Error(`Could not upload: file type "${mimeType}" is not allowed`);
+      throw new DriveError("INVALID_MIME_TYPE", `Could not upload: file type "${mimeType}" is not allowed`);
     }
     if (config.security && fileSize > config.security.maxUploadSizeInBytes) {
-      throw new Error("Could not upload: file is larger than the maximum allowed size");
+      throw new DriveError("FILE_TOO_LARGE", "Could not upload: file is larger than the maximum allowed size");
     }
     const isRootMode = config.mode === "ROOT";
     if (!options.enforce && !isRootMode) {
       const information = await getDriveInformation({ method: "KEY", key });
       const quota = await provider.getQuota(key, accountId, information.storage.quotaInBytes);
       if (quota.usedInBytes + fileSize > quota.quotaInBytes) {
-        throw new Error("Could not upload: you have run out of storage space");
+        throw new DriveError("QUOTA_EXCEEDED", "Could not upload: you have run out of storage space");
       }
     }
     let resolvedParentId = null;
@@ -1739,7 +1882,7 @@ var driveCleanup = async () => {
     }
   }
   try {
-    const { getTusServer: getTusServer2 } = await import('./tus-C4T5ZDTG.js');
+    const { getTusServer: getTusServer2 } = await import('./tus-ODCMFEBZ.js');
     await getTusServer2().cleanUpExpiredUploads();
   } catch (e) {
     console.error("[next-drive] Failed to clean up expired tus uploads:", e);
@@ -1828,8 +1971,13 @@ var getTusServer = () => {
       if (!ctx) return Number.MAX_SAFE_INTEGER;
       return ctx.authenticated ? ctx.config.security?.maxUploadSizeInBytes ?? Number.MAX_SAFE_INTEGER : ctx.config.security?.unauthenticated?.maxUploadSizeInBytes ?? 0;
     },
-    // ** Keep the upload id in the query string so every method stays on `?action=upload`.
-    generateUrl: (_req, { path: p, id }) => `${p}?action=upload&id=${id}`,
+    // ** Keep the upload id in the query string so every method stays on `?action=upload`. Derive
+    // ** the path from the ACTUAL incoming request rather than the static `apiPath` this server was
+    // ** constructed with - the two can drift apart (config.apiUrl is frozen on `globalThis` for the
+    // ** life of the process, see getTusServer() above, so it can go stale after a proxy/route change
+    // ** without a full restart). Mirroring the request's own path makes the continuation URL always
+    // ** match wherever the client actually is, regardless of what `apiUrl` was configured with.
+    generateUrl: (req, { id }) => `${new URL(req.url).pathname}?action=upload&id=${id}`,
     // ** SECURITY: the id becomes a filesystem path inside FileStore (fs.unlink/read/resolve), and it
     // ** arrives from the client-controlled query string. Only accept the exact format our
     // ** namingFunction produces (32 lowercase hex) so a crafted `?id=../../..` cannot traverse out
@@ -1984,6 +2132,6 @@ var handleUpload = async (req, res, ctx) => {
   res.end(response.body ? Buffer.from(await response.arrayBuffer()) : void 0);
 };
 
-export { GoogleDriveProvider, LocalStorageProvider, account_default, driveCleanup, driveConfiguration, driveConfirm, driveDelete, driveFilePath, driveGetUrl, driveInfo, driveList, driveListFiles, drivePurgeExpired, driveReadFile, driveUpload, drive_default, getDriveConfig, getDriveInformation, getImageSettings, getTusServer, handleUpload, resolveProvider, resolveTusCorsOptions, withSignedUrl, withSignedUrls };
-//# sourceMappingURL=chunk-IWV6G7HQ.js.map
-//# sourceMappingURL=chunk-IWV6G7HQ.js.map
+export { DriveError, GoogleDriveProvider, LocalStorageProvider, account_default, driveCleanup, driveConfiguration, driveConfirm, driveDelete, driveFilePath, driveGetUrl, driveInfo, driveList, driveListFiles, drivePurgeExpired, driveReadFile, driveUpload, drive_default, getDriveConfig, getDriveInformation, getImageSettings, getTusServer, handleUpload, resolveProvider, resolveTusCorsOptions, withSignedUrl, withSignedUrls };
+//# sourceMappingURL=chunk-QMPV4YSZ.js.map
+//# sourceMappingURL=chunk-QMPV4YSZ.js.map