@muhgholy/next-drive 4.23.6 → 4.23.7

package/dist/{chunk-VIB7R4JN.cjs → chunk-LAKT7IJJ.cjs}

@@ -542,11 +542,11 @@ var LocalStorageProvider = {
     return { usedInBytes, quotaInBytes: configuredQuotaInBytes ?? 0 };
   },
   openStream: async (item, accountId) => {
-    if (item.information.type !== "FILE") throw new Error("Cannot stream folder");
+    if (item.information.type !== "FILE") throw new Error("Could not open local file: folders cannot be streamed");
     const storagePath = getDriveConfig().storage.path;
     const filePath = path__default.default.join(storagePath, "file", item._id.toString(), "data.bin");
     if (!fs__default.default.existsSync(filePath)) {
-      throw new Error("File not found on disk");
+      throw new Error("Could not open local file: it is missing from disk");
     }
     const stat = fs__default.default.statSync(filePath);
     const stream = fs__default.default.createReadStream(filePath);
@@ -557,13 +557,13 @@ var LocalStorageProvider = {
     };
   },
   getThumbnail: async (item, accountId) => {
-    if (item.information.type !== "FILE") throw new Error("No thumbnail for folder");
+    if (item.information.type !== "FILE") throw new Error("No preview available: folders do not have thumbnails");
     const storagePath = getDriveConfig().storage.path;
     const fileDir = path__default.default.join(storagePath, "file", item._id.toString());
     const originalPath = path__default.default.join(fileDir, "data.bin");
     const thumbDir = path__default.default.join(fileDir, "cache");
     const thumbPath = path__default.default.join(thumbDir, "thumbnail.webp");
-    if (!fs__default.default.existsSync(originalPath)) throw new Error("Original file not found");
+    if (!fs__default.default.existsSync(originalPath)) throw new Error("Could not generate preview: the original file is missing");
     if (fs__default.default.existsSync(thumbPath)) {
       return fs__default.default.createReadStream(thumbPath);
     }
@@ -612,12 +612,12 @@ var LocalStorageProvider = {
     return folder.toClient();
   },
   uploadFile: async (drive, filePath, accountId) => {
-    if (drive.information.type !== "FILE") throw new Error("Invalid drive type");
+    if (drive.information.type !== "FILE") throw new Error("Could not save local file: invalid file record");
     const storagePath = getDriveConfig().storage.path;
     const destDir = path__default.default.join(storagePath, "file", String(drive._id));
     const destPath = path__default.default.join(destDir, "data.bin");
     if (!fs__default.default.existsSync(filePath)) {
-      throw new Error("Source file not found");
+      throw new Error("Could not save local file: the uploaded data is missing");
     }
     if (!fs__default.default.existsSync(destDir)) {
       fs__default.default.mkdirSync(destDir, { recursive: true });
@@ -633,12 +633,12 @@ var LocalStorageProvider = {
       }
     }
     if (!fs__default.default.existsSync(destPath)) {
-      throw new Error("Failed to write file to destination");
+      throw new Error("Could not save local file: writing to storage failed");
     }
     const destStats = fs__default.default.statSync(destPath);
     if (destStats.size !== drive.information.sizeInBytes) {
       fs__default.default.unlinkSync(destPath);
-      throw new Error(`Destination file size mismatch: expected ${drive.information.sizeInBytes}, got ${destStats.size}`);
+      throw new Error("Could not save local file: the stored data was incomplete (size mismatch)");
     }
     drive.status = "READY";
     drive.information.path = path__default.default.join("file", String(drive._id), "data.bin");
@@ -683,12 +683,12 @@ var LocalStorageProvider = {
   },
   rename: async (id, newName, owner, accountId) => {
     const item = await drive_default.findOneAndUpdate({ _id: id, owner }, { name: newName }, { new: true });
-    if (!item) throw new Error("Item not found");
+    if (!item) throw new Error("Could not rename: the item no longer exists");
     return item.toClient();
   },
   move: async (id, newParentId, owner, accountId) => {
     const item = await drive_default.findOne({ _id: id, owner });
-    if (!item) throw new Error("Item not found");
+    if (!item) throw new Error("Could not move: the item no longer exists");
     item.parentId = newParentId === "root" || !newParentId ? null : new mongoose__default.default.Types.ObjectId(newParentId);
     await item.save();
     return item.toClient();
@@ -731,13 +731,13 @@ var createAuthClient = async (owner, accountId) => {
   const query = { owner, "metadata.provider": "GOOGLE" };
   if (accountId) query._id = accountId;
   const account = await account_default.findOne(query);
-  if (!account) throw new Error("Google Drive account not connected");
+  if (!account) throw new Error("Could not reach Google Drive: account not connected");
   const config = getDriveConfig();
   const { clientId, clientSecret, redirectUri } = config.storage?.google || {};
-  if (!clientId || !clientSecret) throw new Error("Google credentials not configured on server");
+  if (!clientId || !clientSecret) throw new Error("Could not reach Google Drive: Google credentials are not configured on the server");
   const oAuth2Client = new googleapis.google.auth.OAuth2(clientId, clientSecret, redirectUri);
   if (account.metadata.provider !== "GOOGLE" || !account.metadata.google) {
-    throw new Error("Invalid Google Account Metadata");
+    throw new Error("Could not reach Google Drive: account data is invalid, please reconnect");
   }
   oAuth2Client.setCredentials(account.metadata.google.credentials);
   oAuth2Client.on("tokens", async (tokens) => {
@@ -959,8 +959,8 @@ var GoogleDriveProvider = {
   openStream: async (item, accountId) => {
     const { client } = await createAuthClient(item.owner, accountId || item.storageAccountId?.toString());
     const drive = googleapis.google.drive({ version: "v3", auth: client });
-    if (!item.provider?.google?.id) throw new Error("Missing Google File ID");
-    if (item.information.type === "FOLDER") throw new Error("Cannot stream folder");
+    if (!item.provider?.google?.id) throw new Error("Could not open Google Drive file: its Google file ID is missing");
+    if (item.information.type === "FOLDER") throw new Error("Could not open Google Drive file: folders cannot be streamed");
     const res = await drive.files.get(
       { fileId: item.provider.google.id, alt: "media" },
       { responseType: "stream" }
@@ -980,7 +980,7 @@ var GoogleDriveProvider = {
       return fs__default.default.createReadStream(thumbPath);
     }
     const { client } = await createAuthClient(item.owner, accountId || item.storageAccountId?.toString());
-    if (!item.provider?.google?.thumbnailLink) throw new Error("No thumbnail available");
+    if (!item.provider?.google?.thumbnailLink) throw new Error("No preview available for this Google Drive file");
     const res = await client.request({ url: item.provider.google.thumbnailLink, responseType: "stream" });
     if (!fs__default.default.existsSync(thumbDir)) {
       fs__default.default.mkdirSync(thumbDir, { recursive: true });
@@ -1020,7 +1020,7 @@ var GoogleDriveProvider = {
       fields: "id, name, mimeType, webViewLink, iconLink"
     });
     const file = res.data;
-    if (!file.id) throw new Error("Failed to create folder on Google Drive");
+    if (!file.id) throw new Error("Could not create folder on Google Drive");
     const folder = new drive_default({
       owner,
       name: file.name,
@@ -1041,7 +1041,7 @@ var GoogleDriveProvider = {
     return folder.toClient();
   },
   uploadFile: async (drive, filePath, accountId) => {
-    if (drive.information.type !== "FILE") throw new Error("Invalid drive type");
+    if (drive.information.type !== "FILE") throw new Error("Could not upload to Google Drive: invalid file record");
     const { client } = await createAuthClient(drive.owner, accountId || drive.storageAccountId?.toString());
     const googleDrive = googleapis.google.drive({ version: "v3", auth: client });
     let googleParentId = "root";
@@ -1063,7 +1063,7 @@ var GoogleDriveProvider = {
         fields: "id, name, mimeType, webViewLink, iconLink, thumbnailLink, size"
       });
       const gFile = res.data;
-      if (!gFile.id) throw new Error("Upload to Google Drive failed");
+      if (!gFile.id) throw new Error("Could not upload to Google Drive: no file was created");
       drive.status = "READY";
       drive.provider = {
         type: "GOOGLE",
@@ -1135,7 +1135,7 @@ var GoogleDriveProvider = {
     const { client } = await createAuthClient(owner, accountId);
     const drive = googleapis.google.drive({ version: "v3", auth: client });
     const item = await drive_default.findOne({ _id: id, owner });
-    if (!item || !item.provider?.google?.id) throw new Error("Item not found");
+    if (!item || !item.provider?.google?.id) throw new Error("Could not rename on Google Drive: item not found or not synced");
     await drive.files.update({
       fileId: item.provider.google.id,
       requestBody: { name: newName }
@@ -1148,7 +1148,7 @@ var GoogleDriveProvider = {
     const { client, accountId: foundAccountId } = await createAuthClient(owner, accountId);
     const drive = googleapis.google.drive({ version: "v3", auth: client });
     const item = await drive_default.findOne({ _id: id, owner });
-    if (!item || !item.provider?.google?.id) throw new Error("Item not found or not synced");
+    if (!item || !item.provider?.google?.id) throw new Error("Could not move on Google Drive: item not found or not synced");
     let previousGoogleParentId = void 0;
     if (item.parentId) {
       const oldParent = await drive_default.findOne({ _id: item.parentId, owner });
@@ -1168,7 +1168,7 @@ var GoogleDriveProvider = {
     let newGoogleParentId = "root";
     if (newParentId && newParentId !== "root") {
       const newParent = await drive_default.findOne({ _id: newParentId, owner });
-      if (!newParent || !newParent.provider?.google?.id) throw new Error("Target folder not found in Google Drive");
+      if (!newParent || !newParent.provider?.google?.id) throw new Error("Could not move on Google Drive: target folder not found");
       newGoogleParentId = newParent.provider.google.id;
     }
     await drive.files.update({
@@ -1236,15 +1236,15 @@ var driveReadFile = async (file) => {
   let drive;
   if (typeof file === "string") {
     const doc = await drive_default.findById(file);
-    if (!doc) throw new Error(`File not found: ${file}`);
+    if (!doc) throw new Error("Could not read file: the file no longer exists");
     drive = doc;
   } else if ("toClient" in file) {
     drive = file;
   } else {
-    throw new Error("Invalid file parameter provided");
+    throw new Error("Could not read file: invalid file reference provided");
   }
   if (drive.information.type !== "FILE") {
-    throw new Error("Cannot read a folder");
+    throw new Error("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();
@@ -1253,7 +1253,7 @@ var driveReadFile = async (file) => {
 var driveInfo = async (source) => {
   const fileId = typeof source === "string" ? source : source.id;
   const drive = await drive_default.findById(fileId);
-  if (!drive) throw new Error(`File not found: ${fileId}`);
+  if (!drive) throw new Error("Could not load file details: the file no longer exists");
   let parentName;
   if (drive.parentId) {
     const parent = await drive_default.findById(drive.parentId);
@@ -1292,15 +1292,15 @@ var driveFilePath = async (file) => {
   let drive;
   if (typeof file === "string") {
     const doc = await drive_default.findById(file);
-    if (!doc) throw new Error(`File not found: ${file}`);
+    if (!doc) throw new Error("Could not locate file: the file no longer exists");
     drive = doc;
   } else if ("toClient" in file) {
     drive = file;
   } else {
-    throw new Error("Invalid file parameter provided");
+    throw new Error("Could not locate file: invalid file reference provided");
   }
   if (drive.information.type !== "FILE") {
-    throw new Error("Cannot get path for a folder");
+    throw new Error("Could not locate file: this item is a folder, not a file");
   }
   const config = getDriveConfig();
   const STORAGE_PATH = config.storage.path;
@@ -1308,7 +1308,7 @@ var driveFilePath = async (file) => {
   if (providerType === "LOCAL") {
     const filePath = path__default.default.join(STORAGE_PATH, "file", String(drive._id), "data.bin");
     if (!fs__default.default.existsSync(filePath)) {
-      throw new Error(`Local file not found on disk: ${filePath}`);
+      throw new Error("Could not locate file: the stored file is missing from disk");
     }
     return Object.freeze({
       path: filePath,
@@ -1365,7 +1365,7 @@ var driveFilePath = async (file) => {
       provider: "GOOGLE"
     });
   }
-  throw new Error(`Unsupported provider: ${providerType}`);
+  throw new Error(`Could not locate file: unsupported storage provider "${providerType}"`);
 };
 var driveList = async (options) => {
   const { key, folderId, accountId, limit = 100, afterId } = options;
@@ -1373,7 +1373,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("Invalid Storage Account");
+      throw new Error("Could not list files: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1401,7 +1401,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("Invalid Storage Account");
+      throw new Error("Could not load files: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1445,7 +1445,7 @@ var driveDelete = async (source, options) => {
   let driveId;
   if (typeof source === "string") {
     const doc = await drive_default.findById(source);
-    if (!doc) throw new Error(`File not found: ${source}`);
+    if (!doc) throw new Error("Could not delete: the file no longer exists");
     drive = doc;
     driveId = source;
   } else if ("toClient" in source) {
@@ -1453,7 +1453,7 @@ var driveDelete = async (source, options) => {
     driveId = String(drive._id);
   } else {
     const doc = await drive_default.findById(source.id);
-    if (!doc) throw new Error(`File not found: ${source.id}`);
+    if (!doc) throw new Error("Could not delete: the selected file no longer exists");
     drive = doc;
     driveId = source.id;
   }
@@ -1465,7 +1465,7 @@ var driveDelete = async (source, options) => {
       trashedAt: null
     });
     if (childCount > 0) {
-      throw new Error(`Cannot delete folder: it contains ${childCount} item(s). Use recurse: true to delete folder and all its contents.`);
+      throw new Error(`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;
@@ -1476,17 +1476,17 @@ var driveDelete = async (source, options) => {
 var resolveFolderByPath = async (folderPath, owner, accountId) => {
   const normalizedPath = folderPath.replace(/^\/+|\/+$/g, "");
   if (!normalizedPath) {
-    throw new Error("Folder path cannot be empty");
+    throw new Error("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("Invalid folder path");
+    throw new Error("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("Invalid Storage Account");
+      throw new Error("Could not resolve folder: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1520,7 +1520,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("Invalid Storage Account");
+      throw new Error("Could not upload: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       provider = GoogleDriveProvider;
@@ -1531,7 +1531,7 @@ var driveUpload = async (source, key, options) => {
   let fileSize;
   if (typeof source === "string") {
     if (!fs__default.default.existsSync(source)) {
-      throw new Error(`Source file not found: ${source}`);
+      throw new Error("Could not upload: source file not found");
     }
     sourceFilePath = source;
     const stats = fs__default.default.statSync(source);
@@ -1590,17 +1590,17 @@ var driveUpload = async (source, key, options) => {
       mimeType = mimeTypes[ext] || "application/octet-stream";
     }
     if (config.security && !validateMimeType(mimeType, config.security.allowedMimeTypes)) {
-      throw new Error(`File type ${mimeType} not allowed`);
+      throw new Error(`Could not upload: file type "${mimeType}" is not allowed`);
     }
     if (config.security && fileSize > config.security.maxUploadSizeInBytes) {
-      throw new Error(`File size ${fileSize} exceeds maximum allowed size ${config.security.maxUploadSizeInBytes}`);
+      throw new Error("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("Storage quota exceeded");
+        throw new Error("Could not upload: you have run out of storage space");
       }
     }
     let resolvedParentId = null;
@@ -1819,7 +1819,7 @@ var getProvider = async (req, owner) => {
   }
   const account = await account_default.findOne({ _id: accountId, owner });
   if (!account) {
-    throw new Error("Invalid Storage Account");
+    throw new Error("Storage account not found or access denied");
   }
   if (account.metadata.provider === "GOOGLE") return { provider: GoogleDriveProvider, accountId: account._id.toString() };
   return { provider: LocalStorageProvider };
@@ -1882,41 +1882,41 @@ var driveAPIHandler = async (req, res) => {
     config = getDriveConfig();
   } catch (error) {
     console.error("[next-drive] Configuration error:", error);
-    res.status(500).json({ status: 500, message: "Failed to initialize drive configuration" });
+    res.status(500).json({ status: 500, message: "Drive is not ready: failed to initialize configuration" });
     return;
   }
   const isPreflightHandled = applyCorsHeaders(req, res, config);
   if (isPreflightHandled) return;
   if (!action) {
-    res.status(400).json({ status: 400, message: "Missing action query parameter" });
+    res.status(400).json({ status: 400, message: 'Missing "action" parameter in request' });
     return;
   }
   if (action === "serve" || action === "thumbnail") {
     try {
       const { id, token } = req.query;
       if (!id || typeof id !== "string") {
-        return res.status(400).json({ status: 400, message: "Missing or invalid file ID" });
+        return res.status(400).json({ status: 400, message: "Could not open file: missing or invalid file ID" });
       }
       const drive = await drive_default.findById(id);
-      if (!drive) return res.status(404).json({ status: 404, message: "File not found" });
+      if (!drive) return res.status(404).json({ status: 404, message: "File not found or no longer available" });
       if (config.security?.signedUrls?.enabled) {
         if (!token || typeof token !== "string") {
-          return res.status(401).json({ status: 401, message: "Missing or invalid token" });
+          return res.status(401).json({ status: 401, message: "Access denied: this link is missing its access token" });
         }
         try {
           const decoded = Buffer.from(token, "base64url").toString();
           const [expiryStr, signature] = decoded.split(":");
           const expiry = parseInt(expiryStr, 10);
           if (Date.now() / 1e3 > expiry) {
-            return res.status(401).json({ status: 401, message: "Token expired" });
+            return res.status(401).json({ status: 401, message: "Access denied: this link has expired" });
           }
           const { secret } = config.security.signedUrls;
           const expectedSignature = crypto2__default.default.createHmac("sha256", secret).update(`${id}:${expiry}`).digest("hex");
           if (signature !== expectedSignature) {
-            return res.status(401).json({ status: 401, message: "Invalid token" });
+            return res.status(401).json({ status: 401, message: "Access denied: this link's access token is invalid" });
           }
         } catch (err) {
-          return res.status(401).json({ status: 401, message: "Invalid token format" });
+          return res.status(401).json({ status: 401, message: "Access denied: this link's access token is malformed" });
         }
       }
       const itemProvider = drive.provider?.type === "GOOGLE" ? GoogleDriveProvider : LocalStorageProvider;
@@ -2022,7 +2022,7 @@ var driveAPIHandler = async (req, res) => {
       console.error(`[next-drive] Error in ${action}:`, error);
       return res.status(500).json({
         status: 500,
-        message: error instanceof Error ? error.message : "Unknown error"
+        message: error instanceof Error ? error.message : "Something went wrong while serving the file"
       });
     }
   }
@@ -2052,7 +2052,7 @@ var driveAPIHandler = async (req, res) => {
           const { provider: provider2 } = req.query;
           if (provider2 === "GOOGLE") {
             const { clientId, clientSecret, redirectUri } = config.storage?.google || {};
-            if (!clientId || !clientSecret || !redirectUri) return res.status(500).json({ status: 500, message: "Google not configured" });
+            if (!clientId || !clientSecret || !redirectUri) return res.status(500).json({ status: 500, message: "Google Drive is not configured on the server" });
             const callbackUri = new URL(redirectUri);
             callbackUri.searchParams.set("action", "callback");
             const oAuth2Client = new googleapis.google.auth.OAuth2(clientId, clientSecret, callbackUri.toString());
@@ -2066,13 +2066,13 @@ var driveAPIHandler = async (req, res) => {
             });
             return res.status(200).json({ status: 200, message: "Auth URL generated", data: { url } });
           }
-          return res.status(400).json({ status: 400, message: "Unknown provider" });
+          return res.status(400).json({ status: 400, message: "Unknown storage provider requested" });
         }
         case "callback": {
           const { code, state } = req.query;
-          if (!code) return res.status(400).json({ status: 400, message: "Missing code" });
+          if (!code) return res.status(400).json({ status: 400, message: "Google sign-in failed: authorization code missing" });
           const { clientId, clientSecret, redirectUri } = config.storage?.google || {};
-          if (!clientId || !clientSecret || !redirectUri) return res.status(500).json({ status: 500, message: "Google not configured" });
+          if (!clientId || !clientSecret || !redirectUri) return res.status(500).json({ status: 500, message: "Google Drive sign-in is not configured on the server" });
           const callbackUri = new URL(redirectUri);
           callbackUri.searchParams.set("action", "callback");
           const oAuth2Client = new googleapis.google.auth.OAuth2(clientId, clientSecret, callbackUri.toString());
@@ -2147,7 +2147,7 @@ var driveAPIHandler = async (req, res) => {
         case "removeAccount": {
           const { id } = req.query;
           const account = await account_default.findOne({ _id: id, owner });
-          if (!account) return res.status(404).json({ status: 404, message: "Account not found" });
+          if (!account) return res.status(404).json({ status: 404, message: "Could not disconnect: account not found" });
           if (account.metadata.provider === "GOOGLE") {
             try {
               await GoogleDriveProvider.revokeToken(owner, account._id.toString());
@@ -2165,9 +2165,9 @@ var driveAPIHandler = async (req, res) => {
     switch (action) {
       // ** 1. LIST **
       case "list": {
-        if (req.method !== "GET") return res.status(405).json({ status: 405, message: "Only GET allowed" });
+        if (req.method !== "GET") return res.status(405).json({ status: 405, message: "Listing files requires a GET request" });
         const listQuery = listQuerySchema.safeParse(req.query);
-        if (!listQuery.success) return res.status(400).json({ status: 400, message: "Invalid parameters" });
+        if (!listQuery.success) return res.status(400).json({ status: 400, message: "Could not list files: invalid request parameters" });
         const { folderId, limit, afterId } = listQuery.data;
         try {
           await provider.sync(folderId || "root", owner, accountId);
@@ -2192,7 +2192,7 @@ var driveAPIHandler = async (req, res) => {
       // ** 2. SEARCH **
       case "search": {
         const searchData = searchQuerySchema.safeParse(req.query);
-        if (!searchData.success) return res.status(400).json({ status: 400, message: "Invalid params" });
+        if (!searchData.success) return res.status(400).json({ status: 400, message: "Could not search: invalid request parameters" });
         const { q, folderId, limit, trashed } = searchData.data;
         if (!trashed) {
           try {
@@ -2217,7 +2217,7 @@ var driveAPIHandler = async (req, res) => {
       }
       // ** 3. UPLOAD **
       case "upload": {
-        if (req.method !== "POST") return res.status(405).json({ status: 405, message: "Only POST allowed" });
+        if (req.method !== "POST") return res.status(405).json({ status: 405, message: "Uploading requires a POST request" });
         const systemTmpDir = path__default.default.join(os2__default.default.tmpdir(), "next-drive-uploads");
         if (!fs__default.default.existsSync(systemTmpDir)) fs__default.default.mkdirSync(systemTmpDir, { recursive: true });
         const form = formidable__default.default({
@@ -2256,18 +2256,18 @@ var driveAPIHandler = async (req, res) => {
         let currentUploadId = driveId;
         const tempBaseDir = path__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 (chunkIndex !== 0) return res.status(400).json({ message: "Could not upload: missing upload session for this chunk" });
           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` });
+              return res.status(400).json({ status: 400, message: `Could not upload: file type "${fileType}" is not allowed` });
             }
           }
           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" });
+              return res.status(413).json({ status: 413, message: "Could not upload: you have run out of storage space" });
             }
           }
           currentUploadId = crypto2__default.default.randomUUID();
@@ -2289,11 +2289,11 @@ var driveAPIHandler = async (req, res) => {
           const uploadDir = path__default.default.join(tempBaseDir, currentUploadId);
           if (!fs__default.default.existsSync(uploadDir)) {
             cleanupTempFiles(files);
-            return res.status(404).json({ status: 404, message: "Upload session not found or expired" });
+            return res.status(404).json({ status: 404, message: "Could not upload: this upload session was not found or has expired" });
           }
           try {
             const chunkFile = Array.isArray(files.chunk) ? files.chunk[0] : files.chunk;
-            if (!chunkFile) throw new Error("No chunk file received");
+            if (!chunkFile) throw new Error("Could not upload: no file chunk was received");
             const partPath = path__default.default.join(uploadDir, `part_${chunkIndex}`);
             try {
               fs__default.default.renameSync(chunkFile.filepath, partPath);
@@ -2327,7 +2327,7 @@ var driveAPIHandler = async (req, res) => {
                 const pPath = path__default.default.join(uploadDir, `part_${i}`);
                 if (!fs__default.default.existsSync(pPath)) {
                   writeStream.destroy();
-                  throw new Error(`Missing chunk part: ${i}`);
+                  throw new Error(`Could not finish upload: chunk ${i} is missing`);
                 }
                 const data = fs__default.default.readFileSync(pPath);
                 const canContinue = writeStream.write(data);
@@ -2348,11 +2348,11 @@ var driveAPIHandler = async (req, res) => {
                 writeStream.once("error", reject);
               });
               if (!fs__default.default.existsSync(finalTempPath)) {
-                throw new Error("Failed to create merged file");
+                throw new Error("Could not finish upload: failed to assemble the file");
               }
               const finalStats = fs__default.default.statSync(finalTempPath);
               if (finalStats.size !== meta.fileSize) {
-                throw new Error(`File size mismatch: expected ${meta.fileSize}, got ${finalStats.size}`);
+                throw new Error("Could not finish upload: the assembled file is incomplete (size mismatch)");
               }
               const drive = new drive_default({
                 owner: meta.owner,
@@ -2395,12 +2395,12 @@ var driveAPIHandler = async (req, res) => {
           return;
         }
         cleanupTempFiles(files);
-        return res.status(400).json({ status: 400, message: "Invalid upload request" });
+        return res.status(400).json({ status: 400, message: "Could not upload: invalid upload request" });
       }
       // ** 4. CANCEL UPLOAD **
       case "cancel": {
         const cancelData = cancelQuerySchema.safeParse(req.query);
-        if (!cancelData.success) return res.status(400).json({ status: 400, message: "Invalid ID" });
+        if (!cancelData.success) return res.status(400).json({ status: 400, message: "Could not cancel upload: invalid ID" });
         const { id } = cancelData.data;
         const tempUploadDir = path__default.default.join(os2__default.default.tmpdir(), "next-drive-uploads", id);
         if (fs__default.default.existsSync(tempUploadDir)) {
@@ -2423,10 +2423,10 @@ var driveAPIHandler = async (req, res) => {
       // ** 5. DELETE **
       case "delete": {
         const deleteData = deleteQuerySchema.safeParse(req.query);
-        if (!deleteData.success) return res.status(400).json({ status: 400, message: "Invalid ID" });
+        if (!deleteData.success) return res.status(400).json({ status: 400, message: "Could not move to trash: invalid ID" });
         const { id } = deleteData.data;
         const drive = await drive_default.findById(id);
-        if (!drive) return res.status(404).json({ status: 404, message: "Not found" });
+        if (!drive) return res.status(404).json({ status: 404, message: "Could not move to trash: item not found" });
         const itemProvider = drive.provider?.type === "GOOGLE" ? GoogleDriveProvider : LocalStorageProvider;
         const itemAccountId = drive.storageAccountId ? drive.storageAccountId.toString() : void 0;
         try {
@@ -2441,7 +2441,7 @@ var driveAPIHandler = async (req, res) => {
       // ** 6. HARD DELETE **
       case "deletePermanent": {
         const deleteData = deleteQuerySchema.safeParse(req.query);
-        if (!deleteData.success) return res.status(400).json({ status: 400, message: "Invalid ID" });
+        if (!deleteData.success) return res.status(400).json({ status: 400, message: "Could not delete: invalid ID" });
         const { id } = deleteData.data;
         await provider.delete([id], owner, accountId);
         const quota = await provider.getQuota(owner, accountId, information.storage.quotaInBytes);
@@ -2482,10 +2482,10 @@ var driveAPIHandler = async (req, res) => {
       // ** 7C. RESTORE **
       case "restore": {
         const restoreData = deleteQuerySchema.safeParse(req.query);
-        if (!restoreData.success) return res.status(400).json({ status: 400, message: "Invalid ID" });
+        if (!restoreData.success) return res.status(400).json({ status: 400, message: "Could not restore: invalid ID" });
         const { id } = restoreData.data;
         const drive = await drive_default.findById(id);
-        if (!drive) return res.status(404).json({ status: 404, message: "Not found" });
+        if (!drive) return res.status(404).json({ status: 404, message: "Could not restore: item not found" });
         let targetParentId = drive.parentId;
         if (targetParentId) {
           const parent = await drive_default.findById(targetParentId);
@@ -2515,7 +2515,7 @@ var driveAPIHandler = async (req, res) => {
       // ** 7D. MOVE **
       case "move": {
         const moveData = moveBodySchema.safeParse(req.body);
-        if (!moveData.success) return res.status(400).json({ status: 400, message: "Invalid data" });
+        if (!moveData.success) return res.status(400).json({ status: 400, message: "Could not move: invalid request data" });
         const { ids, targetFolderId } = moveData.data;
         const items = [];
         const effectiveTargetId = targetFolderId === "root" || !targetFolderId ? null : targetFolderId;
@@ -2532,18 +2532,18 @@ var driveAPIHandler = async (req, res) => {
       // ** 8. RENAME **
       case "rename": {
         const renameData = renameBodySchema.safeParse({ id: req.query.id, ...req.body });
-        if (!renameData.success) return res.status(400).json({ status: 400, message: "Invalid data" });
+        if (!renameData.success) return res.status(400).json({ status: 400, message: "Could not rename: invalid request data" });
         const { id, newName } = renameData.data;
         const item = addSignedUrlToken(await provider.rename(id, newName, owner, accountId), config);
         return res.status(200).json({ status: 200, message: "Renamed", data: { item } });
       }
       // ** 9. THUMBNAIL **
       default:
-        res.status(400).json({ status: 400, message: `Unknown action: ${action}` });
+        res.status(400).json({ status: 400, message: `Unknown action requested: "${action}"` });
     }
   } catch (error) {
     console.error(`[next-drive] Error handling action ${action}:`, error);
-    res.status(500).json({ status: 500, message: error instanceof Error ? error.message : "Unknown error" });
+    res.status(500).json({ status: 500, message: error instanceof Error ? error.message : "Something went wrong while processing your request" });
   }
 };
 
@@ -2562,5 +2562,5 @@ exports.driveUpload = driveUpload;
 exports.drive_default = drive_default;
 exports.getDriveConfig = getDriveConfig;
 exports.getDriveInformation = getDriveInformation;
-//# sourceMappingURL=chunk-VIB7R4JN.cjs.map
-//# sourceMappingURL=chunk-VIB7R4JN.cjs.map
+//# sourceMappingURL=chunk-LAKT7IJJ.cjs.map
+//# sourceMappingURL=chunk-LAKT7IJJ.cjs.map