@muhgholy/next-drive 4.2.0 → 4.3.0

package/dist/{chunk-RGE7EYMF.js → chunk-MTGJTRD5.js}

@@ -1,68 +1,15 @@
 import formidable from 'formidable';
-import path3 from 'path';
-import fs4 from 'fs';
+import path from 'path';
+import fs from 'fs';
 import os2 from 'os';
 import crypto2 from 'crypto';
-import mongoose2, { Schema, isValidObjectId } from 'mongoose';
+import mongoose, { Schema, isValidObjectId } from 'mongoose';
 import sharp from 'sharp';
 import { z } from 'zod';
 import ffmpeg from 'fluent-ffmpeg';
 import { google } from 'googleapis';
 
 // src/server/index.ts
-var globalConfig = null;
-var driveConfiguration = (config) => {
-  if (mongoose2.connection.readyState !== 1) {
-    throw new Error("Database not connected. Please connect to Mongoose before initializing next-drive.");
-  }
-  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");
-  return globalConfig;
-};
-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 Schema({
   type: { type: String, enum: ["FILE", "FOLDER"], required: true },
   sizeInBytes: { type: Number, default: 0 },
@@ -115,8 +62,214 @@ DriveSchema.method("toClient", async function() {
     createdAt: data.createdAt
   };
 });
-var Drive = mongoose2.models.Drive || mongoose2.model("Drive", DriveSchema);
+var Drive = mongoose.models.Drive || mongoose.model("Drive", DriveSchema);
 var drive_default = Drive;
+
+// src/server/utils/migration.ts
+var MIGRATION_FILE = ".migration-version";
+var CURRENT_VERSION = 1;
+var migrations = [
+  {
+    version: 1,
+    name: "restructure-file-paths",
+    migrate: async (storagePath) => {
+      const fileDir = path.join(storagePath, "file");
+      if (!fs.existsSync(fileDir)) {
+        fs.mkdirSync(fileDir, { recursive: true });
+      }
+      const files = await drive_default.find({
+        "provider.type": "LOCAL",
+        "information.type": "FILE",
+        "information.path": { $exists: true, $ne: "" }
+      }).lean();
+      for (const file of files) {
+        const info = file.information;
+        const oldPath = info.path;
+        if (!oldPath) continue;
+        if (oldPath.startsWith("file/")) continue;
+        const fileId = String(file._id);
+        const newRelativePath = path.join("file", fileId, "data.bin");
+        const oldFullPath = path.join(storagePath, oldPath);
+        const newFullPath = path.join(storagePath, newRelativePath);
+        if (fs.existsSync(oldFullPath)) {
+          const newDir = path.dirname(newFullPath);
+          if (!fs.existsSync(newDir)) {
+            fs.mkdirSync(newDir, { recursive: true });
+          }
+          try {
+            fs.renameSync(oldFullPath, newFullPath);
+          } catch (err) {
+            if (err instanceof Error && "code" in err && err.code === "EXDEV") {
+              fs.copyFileSync(oldFullPath, newFullPath);
+              fs.unlinkSync(oldFullPath);
+            } else {
+              console.error(`[next-drive] Migration failed for file ${fileId}:`, err);
+              continue;
+            }
+          }
+          const oldDir = path.dirname(oldFullPath);
+          try {
+            const remaining = fs.readdirSync(oldDir);
+            if (remaining.length === 0) {
+              fs.rmdirSync(oldDir);
+            }
+          } catch {
+          }
+        }
+        await drive_default.updateOne(
+          { _id: file._id },
+          { $set: { "information.path": newRelativePath } }
+        );
+      }
+      const oldCacheDir = path.join(storagePath, "cache", "thumbnails");
+      if (fs.existsSync(oldCacheDir)) {
+        const thumbnails = fs.readdirSync(oldCacheDir);
+        for (const thumb of thumbnails) {
+          const fileId = thumb.replace(".webp", "");
+          const oldThumbPath = path.join(oldCacheDir, thumb);
+          const newThumbDir = path.join(storagePath, "file", fileId, "cache");
+          const newThumbPath = path.join(newThumbDir, "thumbnail.webp");
+          if (fs.existsSync(oldThumbPath) && !fs.existsSync(newThumbPath)) {
+            if (!fs.existsSync(newThumbDir)) {
+              fs.mkdirSync(newThumbDir, { recursive: true });
+            }
+            try {
+              fs.renameSync(oldThumbPath, newThumbPath);
+            } catch {
+            }
+          }
+        }
+        try {
+          fs.rmSync(oldCacheDir, { recursive: true, force: true });
+          const cacheParent = path.join(storagePath, "cache");
+          const remaining = fs.readdirSync(cacheParent);
+          if (remaining.length === 0) {
+            fs.rmdirSync(cacheParent);
+          }
+        } catch {
+        }
+      }
+      const oldLibraryDir = path.join(storagePath, "library", "google");
+      if (fs.existsSync(oldLibraryDir)) {
+        const cachedFiles = fs.readdirSync(oldLibraryDir);
+        for (const cached of cachedFiles) {
+          const fileId = cached.split(".")[0];
+          if (!fileId) continue;
+          const oldCachedPath = path.join(oldLibraryDir, cached);
+          const newCachedDir = path.join(storagePath, "file", fileId);
+          const newCachedPath = path.join(newCachedDir, "data.bin");
+          if (fs.existsSync(oldCachedPath) && !fs.existsSync(newCachedPath)) {
+            if (!fs.existsSync(newCachedDir)) {
+              fs.mkdirSync(newCachedDir, { recursive: true });
+            }
+            try {
+              fs.renameSync(oldCachedPath, newCachedPath);
+            } catch {
+            }
+          }
+        }
+        try {
+          fs.rmSync(path.join(storagePath, "library"), { recursive: true, force: true });
+        } catch {
+        }
+      }
+      const oldDriveDir = path.join(storagePath, "drive");
+      if (fs.existsSync(oldDriveDir)) {
+        try {
+          fs.rmSync(oldDriveDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      console.log("[next-drive] Migration v1 complete: restructure-file-paths");
+    }
+  }
+];
+var runMigrations = async (storagePath) => {
+  const versionFile = path.join(storagePath, MIGRATION_FILE);
+  let currentVersion = 0;
+  if (fs.existsSync(versionFile)) {
+    try {
+      currentVersion = parseInt(fs.readFileSync(versionFile, "utf-8").trim(), 10) || 0;
+    } catch {
+      currentVersion = 0;
+    }
+  }
+  if (currentVersion >= CURRENT_VERSION) return;
+  if (!fs.existsSync(storagePath)) {
+    fs.mkdirSync(storagePath, { recursive: true });
+  }
+  const pendingMigrations = migrations.filter((m) => m.version > currentVersion);
+  for (const migration of pendingMigrations.sort((a, b) => a.version - b.version)) {
+    console.log(`[next-drive] Running migration v${migration.version}: ${migration.name}`);
+    try {
+      await migration.migrate(storagePath);
+      fs.writeFileSync(versionFile, String(migration.version));
+    } catch (error) {
+      console.error(`[next-drive] Migration v${migration.version} failed:`, error);
+      throw error;
+    }
+  }
+};
+
+// src/server/config.ts
+var globalConfig = null;
+var migrationRun = false;
+var driveConfiguration = async (config) => {
+  if (mongoose.connection.readyState !== 1) {
+    throw new Error("Database not connected. Please connect to Mongoose before initializing next-drive.");
+  }
+  if (!migrationRun) {
+    await runMigrations(config.storage.path);
+    migrationRun = true;
+  }
+  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");
+  return globalConfig;
+};
+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 StorageAccountSchema = new Schema(
   {
     owner: { type: Schema.Types.Mixed, default: null },
@@ -144,7 +297,7 @@ StorageAccountSchema.method("toClient", async function() {
     createdAt: data.createdAt
   };
 });
-var StorageAccount = mongoose2.models.StorageAccount || mongoose2.model("StorageAccount", StorageAccountSchema);
+var StorageAccount = mongoose.models.StorageAccount || mongoose.model("StorageAccount", StorageAccountSchema);
 var account_default = StorageAccount;
 var validateMimeType = (mime, allowedTypes) => {
   if (allowedTypes.includes("*/*")) return true;
@@ -159,7 +312,7 @@ var validateMimeType = (mime, allowedTypes) => {
 };
 var computeFileHash = (filePath) => new Promise((resolve, reject) => {
   const hash = crypto2.createHash("sha256");
-  const stream = fs4.createReadStream(filePath);
+  const stream = fs.createReadStream(filePath);
   stream.on("data", (data) => hash.update(data));
   stream.on("end", () => resolve(hash.digest("hex")));
   stream.on("error", reject);
@@ -203,9 +356,7 @@ var listQuerySchema = z.object({
 });
 z.object({
   id: objectIdSchema,
-  token: z.string().optional(),
-  q: z.enum(["ultralow", "low", "medium", "high", "normal"]).optional(),
-  format: z.enum(["webp", "jpeg", "png"]).optional()
+  token: z.string().optional()
 });
 z.object({
   id: objectIdSchema,
@@ -295,12 +446,13 @@ 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 (!fs4.existsSync(filePath)) {
+    const storagePath = getDriveConfig().storage.path;
+    const filePath = path.join(storagePath, "file", item._id.toString(), "data.bin");
+    if (!fs.existsSync(filePath)) {
       throw new Error("File not found on disk");
     }
-    const stat = fs4.statSync(filePath);
-    const stream = fs4.createReadStream(filePath);
+    const stat = fs.statSync(filePath);
+    const stream = fs.createReadStream(filePath);
     return {
       stream,
       mime: item.information.mime,
@@ -310,28 +462,30 @@ var LocalStorageProvider = {
   getThumbnail: async (item, accountId) => {
     if (item.information.type !== "FILE") throw new Error("No thumbnail for folder");
     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 (!fs4.existsSync(originalPath)) throw new Error("Original file not found");
-    if (fs4.existsSync(thumbPath)) {
-      return fs4.createReadStream(thumbPath);
+    const fileDir = path.join(storagePath, "file", item._id.toString());
+    const originalPath = path.join(fileDir, "data.bin");
+    const thumbDir = path.join(fileDir, "cache");
+    const thumbPath = path.join(thumbDir, "thumbnail.webp");
+    if (!fs.existsSync(originalPath)) throw new Error("Original file not found");
+    if (fs.existsSync(thumbPath)) {
+      return fs.createReadStream(thumbPath);
     }
-    if (!fs4.existsSync(path3.dirname(thumbPath))) fs4.mkdirSync(path3.dirname(thumbPath), { recursive: true });
+    if (!fs.existsSync(thumbDir)) fs.mkdirSync(thumbDir, { 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/")) {
       await new Promise((resolve, reject) => {
         ffmpeg(originalPath).screenshots({
           count: 1,
-          folder: path3.dirname(thumbPath),
-          filename: path3.basename(thumbPath),
+          folder: path.dirname(thumbPath),
+          filename: path.basename(thumbPath),
           size: "300x?"
         }).on("end", resolve).on("error", reject);
       });
     } else {
       throw new Error("Unsupported mime type for thumbnail");
     }
-    return fs4.createReadStream(thumbPath);
+    return fs.createReadStream(thumbPath);
   },
   createFolder: async (name, parentId, owner, accountId) => {
     const getNextOrderValue2 = async (owner2) => {
@@ -353,33 +507,34 @@ var LocalStorageProvider = {
   uploadFile: async (drive, filePath, accountId) => {
     if (drive.information.type !== "FILE") throw new Error("Invalid drive type");
     const storagePath = getDriveConfig().storage.path;
-    const destPath = path3.join(storagePath, drive.information.path);
-    const dirPath = path3.dirname(destPath);
-    if (!fs4.existsSync(filePath)) {
+    const destDir = path.join(storagePath, "file", String(drive._id));
+    const destPath = path.join(destDir, "data.bin");
+    if (!fs.existsSync(filePath)) {
       throw new Error("Source file not found");
     }
-    if (!fs4.existsSync(dirPath)) {
-      fs4.mkdirSync(dirPath, { recursive: true });
+    if (!fs.existsSync(destDir)) {
+      fs.mkdirSync(destDir, { recursive: true });
     }
     try {
-      fs4.renameSync(filePath, destPath);
+      fs.renameSync(filePath, destPath);
     } catch (err) {
       if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-        fs4.copyFileSync(filePath, destPath);
-        fs4.unlinkSync(filePath);
+        fs.copyFileSync(filePath, destPath);
+        fs.unlinkSync(filePath);
       } else {
         throw err;
       }
     }
-    if (!fs4.existsSync(destPath)) {
+    if (!fs.existsSync(destPath)) {
       throw new Error("Failed to write file to destination");
     }
-    const destStats = fs4.statSync(destPath);
+    const destStats = fs.statSync(destPath);
     if (destStats.size !== drive.information.sizeInBytes) {
-      fs4.unlinkSync(destPath);
+      fs.unlinkSync(destPath);
       throw new Error(`Destination file size mismatch: expected ${drive.information.sizeInBytes}, got ${destStats.size}`);
     }
     drive.status = "READY";
+    drive.information.path = path.join("file", String(drive._id), "data.bin");
     drive.information.hash = await computeFileHash(destPath);
     if (drive.information.mime.startsWith("image/")) {
       const meta = await extractImageMetadata(destPath);
@@ -405,10 +560,9 @@ var LocalStorageProvider = {
     const allItemsToDelete = [...items, ...allChildren];
     for (const item of allItemsToDelete) {
       if (item.information.type === "FILE" && item.information.path) {
-        const fullPath = path3.join(getDriveConfig().storage.path, item.information.path);
-        const dirPath = path3.dirname(fullPath);
-        if (fs4.existsSync(dirPath)) {
-          fs4.rmSync(dirPath, { recursive: true, force: true });
+        const fileDir = path.join(getDriveConfig().storage.path, "file", item._id.toString());
+        if (fs.existsSync(fileDir)) {
+          fs.rmSync(fileDir, { recursive: true, force: true });
         }
       }
     }
@@ -428,8 +582,7 @@ var LocalStorageProvider = {
   move: async (id, newParentId, owner, accountId) => {
     const item = await drive_default.findOne({ _id: id, owner });
     if (!item) throw new Error("Item not found");
-    item.parentId;
-    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose2.Types.ObjectId(newParentId);
+    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose.Types.ObjectId(newParentId);
     await item.save();
     return item.toClient();
   },
@@ -472,17 +625,19 @@ var GoogleDriveProvider = {
         return;
       }
     }
-    let nextPageToken = void 0;
+    let pageToken = void 0;
     const allSyncedGoogleIds = /* @__PURE__ */ new Set();
     do {
-      const res = await drive.files.list({
+      const listParams = {
         q: `'${googleParentId}' in parents and trashed = false`,
         fields: "nextPageToken, files(id, name, mimeType, size, webViewLink, iconLink, thumbnailLink, createdTime)",
         pageSize: 1e3,
-        pageToken: nextPageToken
-      });
-      nextPageToken = res.data.nextPageToken || void 0;
-      const files = res.data.files || [];
+        pageToken
+      };
+      const res = await drive.files.list(listParams);
+      const responseData = res.data;
+      pageToken = responseData.nextPageToken ?? void 0;
+      const files = responseData.files ?? [];
       for (const file of files) {
         if (!file.id || !file.name || !file.mimeType) continue;
         allSyncedGoogleIds.add(file.id);
@@ -521,7 +676,7 @@ var GoogleDriveProvider = {
           { upsert: true, new: true, setDefaultsOnInsert: true }
         );
       }
-    } while (nextPageToken);
+    } while (pageToken);
     const dbItems = await drive_default.find({
       owner,
       storageAccountId: foundAccountId,
@@ -537,18 +692,19 @@ var GoogleDriveProvider = {
   },
   syncTrash: async (owner, accountId) => {
     const { client, accountId: foundAccountId } = await createAuthClient(owner, accountId);
-    const drive = google.drive({ version: "v3", auth: client });
-    let nextPageToken = void 0;
-    do {
-      const res = await drive.files.list({
+    const driveApi = google.drive({ version: "v3", auth: client });
+    const fetchTrashedFiles = async (pageToken) => {
+      return driveApi.files.list({
         q: "trashed = true",
         fields: "nextPageToken, files(id, name, mimeType, size, webViewLink, iconLink, thumbnailLink, createdTime)",
         pageSize: 100,
-        // Limit sync for performance
-        pageToken: nextPageToken
+        pageToken
       });
-      nextPageToken = res.data.nextPageToken || void 0;
-      const files = res.data.files || [];
+    };
+    let nextToken = void 0;
+    do {
+      const listResult = await fetchTrashedFiles(nextToken);
+      const files = listResult.data.files || [];
       for (const file of files) {
         if (!file.id || !file.name || !file.mimeType) continue;
         const isFolder = file.mimeType === "application/vnd.google-apps.folder";
@@ -582,7 +738,8 @@ var GoogleDriveProvider = {
           { upsert: true, setDefaultsOnInsert: true }
         );
       }
-    } while (nextPageToken);
+      nextToken = listResult.data.nextPageToken ?? void 0;
+    } while (nextToken);
   },
   search: async (query, owner, accountId) => {
     const { client, accountId: foundAccountId } = await createAuthClient(owner, accountId);
@@ -666,7 +823,10 @@ var GoogleDriveProvider = {
     const drive = 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");
-    const res = await drive.files.get({ fileId: item.provider.google.id, alt: "media" }, { responseType: "stream" });
+    const res = await drive.files.get(
+      { fileId: item.provider.google.id, alt: "media" },
+      { responseType: "stream" }
+    );
     return {
       stream: res.data,
       mime: item.information.mime,
@@ -674,10 +834,36 @@ var GoogleDriveProvider = {
     };
   },
   getThumbnail: async (item, accountId) => {
+    const config = getDriveConfig();
+    const storagePath = config.storage.path;
+    const thumbDir = path.join(storagePath, "file", item._id.toString(), "cache");
+    const thumbPath = path.join(thumbDir, "thumbnail.webp");
+    if (fs.existsSync(thumbPath)) {
+      return fs.createReadStream(thumbPath);
+    }
     const { client } = await createAuthClient(item.owner, accountId || item.storageAccountId?.toString());
     if (!item.provider?.google?.thumbnailLink) throw new Error("No thumbnail available");
     const res = await client.request({ url: item.provider.google.thumbnailLink, responseType: "stream" });
-    return res.data;
+    if (!fs.existsSync(thumbDir)) {
+      fs.mkdirSync(thumbDir, { recursive: true });
+    }
+    const tempPath = `${thumbPath}.tmp`;
+    const writeStream = fs.createWriteStream(tempPath);
+    await new Promise((resolve, reject) => {
+      res.data.pipe(writeStream);
+      writeStream.on("finish", resolve);
+      writeStream.on("error", reject);
+    });
+    try {
+      fs.renameSync(tempPath, thumbPath);
+    } catch {
+      fs.unlinkSync(tempPath);
+    }
+    if (fs.existsSync(thumbPath)) {
+      return fs.createReadStream(thumbPath);
+    }
+    const refetch = await client.request({ url: item.provider.google.thumbnailLink, responseType: "stream" });
+    return refetch.data;
   },
   createFolder: async (name, parentId, owner, accountId) => {
     const { client, accountId: foundAccountId } = await createAuthClient(owner, accountId);
@@ -734,7 +920,7 @@ var GoogleDriveProvider = {
         },
         media: {
           mimeType: drive.information.mime,
-          body: fs4.createReadStream(filePath)
+          body: fs.createReadStream(filePath)
         },
         fields: "id, name, mimeType, webViewLink, iconLink, thumbnailLink, size"
       });
@@ -752,7 +938,7 @@ var GoogleDriveProvider = {
       };
     } catch (error) {
       drive.status = "FAILED";
-      console.error("Google Upload Error:", error);
+      console.error("[next-drive] Google Upload Error:", error);
       throw error;
     }
     await drive.save();
@@ -853,7 +1039,7 @@ var GoogleDriveProvider = {
       removeParents: previousGoogleParentId,
       fields: "id, parents"
     });
-    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose2.Types.ObjectId(newParentId);
+    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose.Types.ObjectId(newParentId);
     await item.save();
     return item.toClient();
   },
@@ -863,7 +1049,7 @@ var GoogleDriveProvider = {
     const account = await account_default.findById(accountId);
     if (account?.metadata?.provider === "GOOGLE" && account.metadata.google?.credentials) {
       const creds = account.metadata.google.credentials;
-      if (typeof creds === "object" && "access_token" in creds) {
+      if (typeof creds === "object" && "access_token" in creds && typeof creds.access_token === "string") {
         await client.revokeToken(creds.access_token);
       }
     }
@@ -965,8 +1151,8 @@ var driveFilePath = async (file) => {
   const STORAGE_PATH = config.storage.path;
   const providerType = drive.provider?.type || "LOCAL";
   if (providerType === "LOCAL") {
-    const filePath = path3.join(STORAGE_PATH, drive.information.path);
-    if (!fs4.existsSync(filePath)) {
+    const filePath = path.join(STORAGE_PATH, "file", String(drive._id), "data.bin");
+    if (!fs.existsSync(filePath)) {
       throw new Error(`Local file not found on disk: ${filePath}`);
     }
     return Object.freeze({
@@ -978,11 +1164,10 @@ var driveFilePath = async (file) => {
     });
   }
   if (providerType === "GOOGLE") {
-    const libraryDir = path3.join(STORAGE_PATH, "library", "google");
-    const fileName = `${drive._id}${path3.extname(drive.name)}`;
-    const cachedFilePath = path3.join(libraryDir, fileName);
-    if (fs4.existsSync(cachedFilePath)) {
-      const stats = fs4.statSync(cachedFilePath);
+    const fileDir = path.join(STORAGE_PATH, "file", String(drive._id));
+    const cachedFilePath = path.join(fileDir, "data.bin");
+    if (fs.existsSync(cachedFilePath)) {
+      const stats = fs.statSync(cachedFilePath);
       if (stats.size === drive.information.sizeInBytes) {
         return Object.freeze({
           path: cachedFilePath,
@@ -992,15 +1177,15 @@ var driveFilePath = async (file) => {
           provider: "GOOGLE"
         });
       }
-      fs4.unlinkSync(cachedFilePath);
+      fs.unlinkSync(cachedFilePath);
     }
     const accountId = drive.storageAccountId?.toString();
     const { stream } = await GoogleDriveProvider.openStream(drive, accountId);
-    if (!fs4.existsSync(libraryDir)) {
-      fs4.mkdirSync(libraryDir, { recursive: true });
+    if (!fs.existsSync(fileDir)) {
+      fs.mkdirSync(fileDir, { recursive: true });
     }
     const tempPath = `${cachedFilePath}.tmp`;
-    const writeStream = fs4.createWriteStream(tempPath);
+    const writeStream = fs.createWriteStream(tempPath);
     await new Promise((resolve, reject) => {
       stream.pipe(writeStream);
       writeStream.on("finish", resolve);
@@ -1008,11 +1193,11 @@ var driveFilePath = async (file) => {
       stream.on("error", reject);
     });
     try {
-      fs4.renameSync(tempPath, cachedFilePath);
+      fs.renameSync(tempPath, cachedFilePath);
     } catch (err) {
       if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-        fs4.copyFileSync(tempPath, cachedFilePath);
-        fs4.unlinkSync(tempPath);
+        fs.copyFileSync(tempPath, cachedFilePath);
+        fs.unlinkSync(tempPath);
       } else {
         throw err;
       }
@@ -1103,28 +1288,28 @@ var driveUpload = async (source, key, options) => {
   let sourceFilePath;
   let fileSize;
   if (typeof source === "string") {
-    if (!fs4.existsSync(source)) {
+    if (!fs.existsSync(source)) {
       throw new Error(`Source file not found: ${source}`);
     }
     sourceFilePath = source;
-    const stats = fs4.statSync(source);
+    const stats = fs.statSync(source);
     fileSize = stats.size;
   } else if (Buffer.isBuffer(source)) {
-    const tempDir = path3.join(os2.tmpdir(), "next-drive-uploads");
-    if (!fs4.existsSync(tempDir)) {
-      fs4.mkdirSync(tempDir, { recursive: true });
+    const tempDir = path.join(os2.tmpdir(), "next-drive-uploads");
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
     }
-    tempFilePath = path3.join(tempDir, `upload-${crypto2.randomUUID()}.tmp`);
-    fs4.writeFileSync(tempFilePath, source);
+    tempFilePath = path.join(tempDir, `upload-${crypto2.randomUUID()}.tmp`);
+    fs.writeFileSync(tempFilePath, source);
     sourceFilePath = tempFilePath;
     fileSize = source.length;
   } else {
-    const tempDir = path3.join(os2.tmpdir(), "next-drive-uploads");
-    if (!fs4.existsSync(tempDir)) {
-      fs4.mkdirSync(tempDir, { recursive: true });
+    const tempDir = path.join(os2.tmpdir(), "next-drive-uploads");
+    if (!fs.existsSync(tempDir)) {
+      fs.mkdirSync(tempDir, { recursive: true });
     }
-    tempFilePath = path3.join(tempDir, `upload-${crypto2.randomUUID()}.tmp`);
-    const writeStream = fs4.createWriteStream(tempFilePath);
+    tempFilePath = path.join(tempDir, `upload-${crypto2.randomUUID()}.tmp`);
+    const writeStream = fs.createWriteStream(tempFilePath);
     await new Promise((resolve, reject) => {
       source.pipe(writeStream);
       writeStream.on("finish", resolve);
@@ -1132,7 +1317,7 @@ var driveUpload = async (source, key, options) => {
       source.on("error", reject);
     });
     sourceFilePath = tempFilePath;
-    const stats = fs4.statSync(tempFilePath);
+    const stats = fs.statSync(tempFilePath);
     fileSize = stats.size;
   }
   try {
@@ -1140,7 +1325,7 @@ var driveUpload = async (source, key, options) => {
     if (options.mime) {
       mimeType = options.mime;
     } else {
-      const ext = path3.extname(options.name).toLowerCase();
+      const ext = path.extname(options.name).toLowerCase();
       const mimeTypes = {
         ".jpg": "image/jpeg",
         ".jpeg": "image/jpeg",
@@ -1186,10 +1371,7 @@ var driveUpload = async (source, key, options) => {
       status: "UPLOADING"
     });
     if (provider.name === "LOCAL" && drive.information.type === "FILE") {
-      let sanitizedExt = path3.extname(options.name) || ".bin";
-      sanitizedExt = sanitizedExt.replace(/[^a-zA-Z0-9.]/g, "").slice(0, 11);
-      if (!sanitizedExt.startsWith(".")) sanitizedExt = ".bin";
-      drive.information.path = path3.join(String(drive._id), `data${sanitizedExt}`);
+      drive.information.path = path.join("file", String(drive._id), "data.bin");
     }
     await drive.save();
     try {
@@ -1207,8 +1389,8 @@ var driveUpload = async (source, key, options) => {
       throw err;
     }
   } finally {
-    if (tempFilePath && fs4.existsSync(tempFilePath)) {
-      fs4.rmSync(tempFilePath, { force: true });
+    if (tempFilePath && fs.existsSync(tempFilePath)) {
+      fs.rmSync(tempFilePath, { force: true });
     }
   }
 };
@@ -1538,8 +1720,8 @@ 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(os2.tmpdir(), "next-drive-uploads");
-        if (!fs4.existsSync(systemTmpDir)) fs4.mkdirSync(systemTmpDir, { recursive: true });
+        const systemTmpDir = path.join(os2.tmpdir(), "next-drive-uploads");
+        if (!fs.existsSync(systemTmpDir)) fs.mkdirSync(systemTmpDir, { recursive: true });
         const form = formidable({
           multiples: false,
           maxFileSize: (config.security?.maxUploadSizeInBytes ?? 1024 * 1024 * 1024) * 2,
@@ -1554,7 +1736,7 @@ var driveAPIHandler = async (req, res) => {
         });
         const cleanupTempFiles = (files2) => {
           Object.values(files2).flat().forEach((file) => {
-            if (file && fs4.existsSync(file.filepath)) fs4.rmSync(file.filepath, { force: true });
+            if (file && fs.existsSync(file.filepath)) fs.rmSync(file.filepath, { force: true });
           });
         };
         const getString = (f) => Array.isArray(f) ? f[0] : f || "";
@@ -1574,7 +1756,7 @@ var driveAPIHandler = async (req, res) => {
         }
         const { chunkIndex, totalChunks, driveId, fileName, fileSize: fileSizeInBytes, fileType, folderId } = uploadData.data;
         let currentUploadId = driveId;
-        const tempBaseDir = path3.join(os2.tmpdir(), "next-drive-uploads");
+        const tempBaseDir = path.join(os2.tmpdir(), "next-drive-uploads");
         if (!currentUploadId) {
           if (chunkIndex !== 0) return res.status(400).json({ message: "Missing upload ID for non-zero chunk" });
           if (fileType && config.security) {
@@ -1591,8 +1773,8 @@ var driveAPIHandler = async (req, res) => {
             }
           }
           currentUploadId = crypto2.randomUUID();
-          const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          fs4.mkdirSync(uploadDir, { recursive: true });
+          const uploadDir = path.join(tempBaseDir, currentUploadId);
+          fs.mkdirSync(uploadDir, { recursive: true });
           const metadata = {
             owner,
             accountId,
@@ -1603,34 +1785,34 @@ var driveAPIHandler = async (req, res) => {
             mimeType: fileType,
             totalChunks
           };
-          fs4.writeFileSync(path3.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
+          fs.writeFileSync(path.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
         }
         if (currentUploadId) {
-          const uploadDir = path3.join(tempBaseDir, currentUploadId);
-          if (!fs4.existsSync(uploadDir)) {
+          const uploadDir = path.join(tempBaseDir, currentUploadId);
+          if (!fs.existsSync(uploadDir)) {
             cleanupTempFiles(files);
             return res.status(404).json({ status: 404, message: "Upload session not found or expired" });
           }
           try {
             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}`);
+            const partPath = path.join(uploadDir, `part_${chunkIndex}`);
             try {
-              fs4.renameSync(chunkFile.filepath, partPath);
+              fs.renameSync(chunkFile.filepath, partPath);
             } catch (err) {
               if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-                fs4.copyFileSync(chunkFile.filepath, partPath);
-                fs4.unlinkSync(chunkFile.filepath);
+                fs.copyFileSync(chunkFile.filepath, partPath);
+                fs.unlinkSync(chunkFile.filepath);
               } else {
                 throw err;
               }
             }
-            const uploadedParts = fs4.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
+            const uploadedParts = fs.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
             if (uploadedParts.length === totalChunks) {
-              const metaPath = path3.join(uploadDir, "metadata.json");
-              const meta = JSON.parse(fs4.readFileSync(metaPath, "utf-8"));
-              const finalTempPath = path3.join(uploadDir, "final.bin");
-              const writeStream = fs4.createWriteStream(finalTempPath);
+              const metaPath = path.join(uploadDir, "metadata.json");
+              const meta = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+              const finalTempPath = path.join(uploadDir, "final.bin");
+              const writeStream = fs.createWriteStream(finalTempPath);
               let streamError = null;
               writeStream.on("error", (err) => {
                 streamError = err;
@@ -1644,12 +1826,12 @@ var driveAPIHandler = async (req, res) => {
                   writeStream.destroy();
                   throw streamError;
                 }
-                const pPath = path3.join(uploadDir, `part_${i}`);
-                if (!fs4.existsSync(pPath)) {
+                const pPath = path.join(uploadDir, `part_${i}`);
+                if (!fs.existsSync(pPath)) {
                   writeStream.destroy();
                   throw new Error(`Missing chunk part: ${i}`);
                 }
-                const data = fs4.readFileSync(pPath);
+                const data = fs.readFileSync(pPath);
                 const canContinue = writeStream.write(data);
                 if (!canContinue) {
                   await new Promise((resolve, reject) => {
@@ -1667,10 +1849,10 @@ var driveAPIHandler = async (req, res) => {
                 writeStream.on("finish", resolve);
                 writeStream.once("error", reject);
               });
-              if (!fs4.existsSync(finalTempPath)) {
+              if (!fs.existsSync(finalTempPath)) {
                 throw new Error("Failed to create merged file");
               }
-              const finalStats = fs4.statSync(finalTempPath);
+              const finalStats = fs.statSync(finalTempPath);
               if (finalStats.size !== meta.fileSize) {
                 throw new Error(`File size mismatch: expected ${meta.fileSize}, got ${finalStats.size}`);
               }
@@ -1688,15 +1870,12 @@ var driveAPIHandler = async (req, res) => {
                 totalChunks
               });
               if (meta.providerName === "LOCAL" && drive.information.type === "FILE") {
-                let ext = path3.extname(meta.name) || ".bin";
-                ext = ext.replace(/[^a-zA-Z0-9.]/g, "").slice(0, 11);
-                if (!ext.startsWith(".")) ext = ".bin";
-                drive.information.path = path3.join(String(drive._id), `data${ext}`);
+                drive.information.path = path.join("file", String(drive._id), "data.bin");
               }
               await drive.save();
               try {
                 const item = await provider.uploadFile(drive, finalTempPath, meta.accountId);
-                fs4.rmSync(uploadDir, { recursive: true, force: true });
+                fs.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) {
@@ -1725,10 +1904,10 @@ var driveAPIHandler = async (req, res) => {
         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(os2.tmpdir(), "next-drive-uploads", id);
-        if (fs4.existsSync(tempUploadDir)) {
+        const tempUploadDir = path.join(os2.tmpdir(), "next-drive-uploads", id);
+        if (fs.existsSync(tempUploadDir)) {
           try {
-            fs4.rmSync(tempUploadDir, { recursive: true, force: true });
+            fs.rmSync(tempUploadDir, { recursive: true, force: true });
           } catch (e) {
             console.error("Failed to cleanup temp upload:", e);
           }
@@ -1871,5 +2050,5 @@ var driveAPIHandler = async (req, res) => {
 };
 
 export { driveAPIHandler, driveConfiguration, driveDelete, driveFilePath, driveFileSchemaZod, driveGetUrl, driveInfo, driveList, driveReadFile, driveUpload, getDriveConfig, getDriveInformation };
-//# sourceMappingURL=chunk-RGE7EYMF.js.map
-//# sourceMappingURL=chunk-RGE7EYMF.js.map
+//# sourceMappingURL=chunk-MTGJTRD5.js.map
+//# sourceMappingURL=chunk-MTGJTRD5.js.map