@muhgholy/next-drive 1.3.0 → 1.4.0

package/dist/server/index.js

@@ -1,20 +1,26 @@
+import formidable from 'formidable';
+import path from 'path';
+import fs2 from 'fs';
+import mongoose2, { Schema, isValidObjectId } from 'mongoose';
+import crypto2 from 'crypto';
+import sharp from 'sharp';
+import { z } from 'zod';
+import ffmpeg from 'fluent-ffmpeg';
+import { google } from 'googleapis';
+import 'clsx';
+import 'tailwind-merge';
+import 'lucide-react';
+import 'react/jsx-runtime';
+
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-
-// src/server/index.ts
-import formidable from "formidable";
-import path4 from "path";
-import fs5 from "fs";
-
-// src/server/config.ts
-import mongoose from "mongoose";
 var globalConfig = null;
 var driveConfiguration = (config) => {
-  if (mongoose.connection.readyState !== 1) {
+  if (mongoose2.connection.readyState !== 1) {
     throw new Error("Database not connected. Please connect to Mongoose before initializing next-drive.");
   }
   const mergedConfig = {
@@ -45,9 +51,6 @@ var getDriveInformation = async (req) => {
   const config = getDriveConfig();
   return config.information(req);
 };
-
-// src/server/database/mongoose/schema/drive.ts
-import mongoose2, { Schema } from "mongoose";
 var informationSchema = new Schema({
   type: { type: String, enum: ["FILE", "FOLDER"], required: true },
   sizeInBytes: { type: Number, default: 0 },
@@ -102,18 +105,15 @@ DriveSchema.method("toClient", async function() {
 });
 var Drive = mongoose2.models.Drive || mongoose2.model("Drive", DriveSchema);
 var drive_default = Drive;
-
-// src/server/database/mongoose/schema/storage/account.ts
-import mongoose3, { Schema as Schema2 } from "mongoose";
-var StorageAccountSchema = new Schema2(
+var StorageAccountSchema = new Schema(
   {
-    owner: { type: Schema2.Types.Mixed, default: null },
+    owner: { type: Schema.Types.Mixed, default: null },
     name: { type: String, required: true },
     metadata: {
       provider: { type: String, enum: ["GOOGLE"], required: true },
       google: {
         email: { type: String, required: true },
-        credentials: { type: Schema2.Types.Mixed, required: true }
+        credentials: { type: Schema.Types.Mixed, required: true }
       }
     },
     createdAt: { type: Date, default: Date.now }
@@ -132,13 +132,8 @@ StorageAccountSchema.method("toClient", async function() {
     createdAt: data.createdAt
   };
 });
-var StorageAccount = mongoose3.models.StorageAccount || mongoose3.model("StorageAccount", StorageAccountSchema);
+var StorageAccount = mongoose2.models.StorageAccount || mongoose2.model("StorageAccount", StorageAccountSchema);
 var account_default = StorageAccount;
-
-// src/server/utils.ts
-import fs from "fs";
-import crypto2 from "crypto";
-import sharp from "sharp";
 var validateMimeType = (mime, allowedTypes) => {
   if (allowedTypes.includes("*/*")) return true;
   return allowedTypes.some((pattern) => {
@@ -152,7 +147,7 @@ var validateMimeType = (mime, allowedTypes) => {
 };
 var computeFileHash = (filePath) => new Promise((resolve, reject) => {
   const hash = crypto2.createHash("sha256");
-  const stream = fs.createReadStream(filePath);
+  const stream = fs2.createReadStream(filePath);
   stream.on("data", (data) => hash.update(data));
   stream.on("end", () => resolve(hash.digest("hex")));
   stream.on("error", reject);
@@ -165,10 +160,6 @@ var extractImageMetadata = async (filePath) => {
     return null;
   }
 };
-
-// src/server/zod/schemas.ts
-import { z } from "zod";
-import { isValidObjectId } from "mongoose";
 var objectIdSchema = z.string().refine((val) => isValidObjectId(val), {
   message: "Invalid ObjectId format"
 });
@@ -216,7 +207,7 @@ var renameBodySchema = z.object({
 var deleteQuerySchema = z.object({
   id: objectIdSchema
 });
-var deleteManyBodySchema = z.object({
+z.object({
   ids: z.array(objectIdSchema).min(1).max(1e3)
 });
 var createFolderBodySchema = z.object({
@@ -227,7 +218,7 @@ var moveBodySchema = z.object({
   ids: z.array(objectIdSchema).min(1).max(1e3),
   targetFolderId: z.union([z.literal("root"), objectIdSchema, z.undefined()]).optional()
 });
-var reorderBodySchema = z.object({
+z.object({
   ids: z.array(objectIdSchema).min(1).max(1e3)
 });
 var searchQuerySchema = z.object({
@@ -239,13 +230,13 @@ var searchQuerySchema = z.object({
   }),
   trashed: z.string().optional().transform((val) => val === "true")
 });
-var restoreQuerySchema = z.object({
+z.object({
   id: objectIdSchema
 });
-var cancelQuerySchema = z.object({
+z.object({
   id: objectIdSchema
 });
-var purgeTrashQuerySchema = z.object({
+z.object({
   days: z.number().int().min(1).max(365).optional()
 });
 var driveFileSchemaZod = z.object({
@@ -262,13 +253,6 @@ function sanitizeContentDispositionFilename(filename) {
   const basename = filename.replace(/^.*[\\\/]/, "");
   return basename.replace(/["\r\n]/g, "").replace(/[^\x20-\x7E]/g, "").slice(0, 255);
 }
-
-// src/server/providers/local.ts
-import fs2 from "fs";
-import path from "path";
-import mongoose4 from "mongoose";
-import ffmpeg from "fluent-ffmpeg";
-import sharp2 from "sharp";
 var STORAGE_PATH = path.join(process.cwd(), "storage");
 var LocalStorageProvider = {
   name: "LOCAL",
@@ -282,7 +266,7 @@ var LocalStorageProvider = {
       { $group: { _id: null, total: { $sum: "$information.sizeInBytes" } } }
     ]);
     const usedInBytes = result[0]?.total || 0;
-    const config = getDriveConfig();
+    getDriveConfig();
     return { usedInBytes, quotaInBytes: 10 * 1024 * 1024 * 1024 };
   },
   openStream: async (item, accountId) => {
@@ -309,7 +293,7 @@ var LocalStorageProvider = {
     }
     if (!fs2.existsSync(path.dirname(thumbPath))) fs2.mkdirSync(path.dirname(thumbPath), { recursive: true });
     if (item.information.mime.startsWith("image/")) {
-      await sharp2(originalPath).resize(300, 300, { fit: "inside" }).toFormat("webp", { quality: 80 }).toFile(thumbPath);
+      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({
@@ -400,21 +384,15 @@ 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");
-    const oldParentId = item.parentId;
-    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose4.Types.ObjectId(newParentId);
+    item.parentId;
+    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose2.Types.ObjectId(newParentId);
     await item.save();
     return item.toClient();
   },
   revokeToken: async (owner, accountId) => {
   }
 };
-
-// src/server/providers/google.ts
-import fs3 from "fs";
-import path2 from "path";
-import { google } from "googleapis";
-import mongoose5 from "mongoose";
-var STORAGE_PATH2 = path2.join(process.cwd(), "storage");
+path.join(process.cwd(), "storage");
 var createAuthClient = async (owner, accountId) => {
   const query = { owner, "metadata.provider": "GOOGLE" };
   if (accountId) query._id = accountId;
@@ -694,7 +672,7 @@ var GoogleDriveProvider = {
         },
         media: {
           mimeType: drive.information.mime,
-          body: fs3.createReadStream(filePath)
+          body: fs2.createReadStream(filePath)
         },
         fields: "id, name, mimeType, webViewLink, iconLink, thumbnailLink, size"
       });
@@ -813,7 +791,7 @@ var GoogleDriveProvider = {
       removeParents: previousGoogleParentId,
       fields: "id, parents"
     });
-    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose5.Types.ObjectId(newParentId);
+    item.parentId = newParentId === "root" || !newParentId ? null : new mongoose2.Types.ObjectId(newParentId);
     await item.save();
     return item.toClient();
   },
@@ -829,11 +807,6 @@ var GoogleDriveProvider = {
     }
   }
 };
-
-// src/server/controllers/drive.ts
-import fs4 from "fs";
-import path3 from "path";
-import crypto3 from "crypto";
 var driveGetUrl = (fileId, options) => {
   const config = getDriveConfig();
   if (!config.security.signedUrls?.enabled) {
@@ -848,7 +821,7 @@ var driveGetUrl = (fileId, options) => {
   } else {
     expiryTimestamp = Math.floor(Date.now() / 1e3) + expiresIn;
   }
-  const signature = crypto3.createHmac("sha256", secret).update(`${fileId}:${expiryTimestamp}`).digest("hex");
+  const signature = crypto2.createHmac("sha256", secret).update(`${fileId}:${expiryTimestamp}`).digest("hex");
   const token = Buffer.from(`${expiryTimestamp}:${signature}`).toString("base64url");
   return `/api/drive?action=serve&id=${fileId}&token=${token}`;
 };
@@ -888,8 +861,8 @@ var driveFilePath = async (file) => {
   const STORAGE_PATH3 = config.storage.path;
   const providerType = drive.provider?.type || "LOCAL";
   if (providerType === "LOCAL") {
-    const filePath = path3.join(STORAGE_PATH3, drive.information.path);
-    if (!fs4.existsSync(filePath)) {
+    const filePath = path.join(STORAGE_PATH3, drive.information.path);
+    if (!fs2.existsSync(filePath)) {
       throw new Error(`Local file not found on disk: ${filePath}`);
     }
     return Object.freeze({
@@ -901,11 +874,11 @@ var driveFilePath = async (file) => {
     });
   }
   if (providerType === "GOOGLE") {
-    const libraryDir = path3.join(STORAGE_PATH3, "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 libraryDir = path.join(STORAGE_PATH3, "library", "google");
+    const fileName = `${drive._id}${path.extname(drive.name)}`;
+    const cachedFilePath = path.join(libraryDir, fileName);
+    if (fs2.existsSync(cachedFilePath)) {
+      const stats = fs2.statSync(cachedFilePath);
       if (stats.size === drive.information.sizeInBytes) {
         return Object.freeze({
           path: cachedFilePath,
@@ -915,22 +888,22 @@ var driveFilePath = async (file) => {
           provider: "GOOGLE"
         });
       }
-      fs4.unlinkSync(cachedFilePath);
+      fs2.unlinkSync(cachedFilePath);
     }
     const accountId = drive.storageAccountId?.toString();
     const { stream } = await GoogleDriveProvider.openStream(drive, accountId);
-    if (!fs4.existsSync(libraryDir)) {
-      fs4.mkdirSync(libraryDir, { recursive: true });
+    if (!fs2.existsSync(libraryDir)) {
+      fs2.mkdirSync(libraryDir, { recursive: true });
     }
     const tempPath = `${cachedFilePath}.tmp`;
-    const writeStream = fs4.createWriteStream(tempPath);
+    const writeStream = fs2.createWriteStream(tempPath);
     await new Promise((resolve, reject) => {
       stream.pipe(writeStream);
       writeStream.on("finish", resolve);
       writeStream.on("error", reject);
       stream.on("error", reject);
     });
-    fs4.renameSync(tempPath, cachedFilePath);
+    fs2.renameSync(tempPath, cachedFilePath);
     return Object.freeze({
       path: cachedFilePath,
       name: drive.name,
@@ -941,12 +914,6 @@ var driveFilePath = async (file) => {
   }
   throw new Error(`Unsupported provider: ${providerType}`);
 };
-
-// src/client/utils.tsx
-import { clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
-import { File, Folder, Image, Video, Music, FileText, FileCode, FileArchive } from "lucide-react";
-import { jsx } from "react/jsx-runtime";
 var driveCreateUrl = (driveFile, apiEndpoint, options) => {
   const params = new URLSearchParams({
     action: "serve",
@@ -1143,10 +1110,10 @@ var driveAPIHandler = async (req, res) => {
         const form = formidable({
           multiples: false,
           maxFileSize: config.security.maxUploadSizeInBytes * 2,
-          uploadDir: path4.join(STORAGE_PATH3, "temp"),
+          uploadDir: path.join(STORAGE_PATH3, "temp"),
           keepExtensions: true
         });
-        if (!fs5.existsSync(path4.join(STORAGE_PATH3, "temp"))) fs5.mkdirSync(path4.join(STORAGE_PATH3, "temp"), { recursive: true });
+        if (!fs2.existsSync(path.join(STORAGE_PATH3, "temp"))) fs2.mkdirSync(path.join(STORAGE_PATH3, "temp"), { recursive: true });
         const [fields, files] = await new Promise((resolve, reject) => {
           form.parse(req, (err, fields2, files2) => {
             if (err) reject(err);
@@ -1155,7 +1122,7 @@ var driveAPIHandler = async (req, res) => {
         });
         const cleanupTempFiles = (files2) => {
           Object.values(files2).flat().forEach((file) => {
-            if (file && fs5.existsSync(file.filepath)) fs5.rmSync(file.filepath, { force: true });
+            if (file && fs2.existsSync(file.filepath)) fs2.rmSync(file.filepath, { force: true });
           });
         };
         const getString = (f) => Array.isArray(f) ? f[0] : f || "";
@@ -1175,7 +1142,7 @@ var driveAPIHandler = async (req, res) => {
         }
         const { chunkIndex, totalChunks, driveId, fileName, fileSize: fileSizeInBytes, fileType, folderId } = uploadData.data;
         let currentUploadId = driveId;
-        const tempBaseDir = path4.join(STORAGE_PATH3, "temp", "uploads");
+        const tempBaseDir = path.join(STORAGE_PATH3, "temp", "uploads");
         if (!currentUploadId) {
           if (chunkIndex !== 0) return res.status(400).json({ message: "Missing upload ID for non-zero chunk" });
           if (fileType && !validateMimeType(fileType, config.security.allowedMimeTypes)) {
@@ -1188,8 +1155,8 @@ var driveAPIHandler = async (req, res) => {
             return res.status(413).json({ status: 413, message: "Storage quota exceeded" });
           }
           currentUploadId = crypto.randomUUID();
-          const uploadDir = path4.join(tempBaseDir, currentUploadId);
-          fs5.mkdirSync(uploadDir, { recursive: true });
+          const uploadDir = path.join(tempBaseDir, currentUploadId);
+          fs2.mkdirSync(uploadDir, { recursive: true });
           const metadata = {
             owner,
             accountId,
@@ -1200,28 +1167,28 @@ var driveAPIHandler = async (req, res) => {
             mimeType: fileType,
             totalChunks
           };
-          fs5.writeFileSync(path4.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
+          fs2.writeFileSync(path.join(uploadDir, "metadata.json"), JSON.stringify(metadata));
         }
         if (currentUploadId) {
-          const uploadDir = path4.join(tempBaseDir, currentUploadId);
-          if (!fs5.existsSync(uploadDir)) {
+          const uploadDir = path.join(tempBaseDir, currentUploadId);
+          if (!fs2.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 = path4.join(uploadDir, `part_${chunkIndex}`);
-            fs5.renameSync(chunkFile.filepath, partPath);
-            const uploadedParts = fs5.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
+            const partPath = path.join(uploadDir, `part_${chunkIndex}`);
+            fs2.renameSync(chunkFile.filepath, partPath);
+            const uploadedParts = fs2.readdirSync(uploadDir).filter((f) => f.startsWith("part_"));
             if (uploadedParts.length === totalChunks) {
-              const metaPath = path4.join(uploadDir, "metadata.json");
-              const meta = JSON.parse(fs5.readFileSync(metaPath, "utf-8"));
-              const finalTempPath = path4.join(uploadDir, "final.bin");
-              const writeStream = fs5.createWriteStream(finalTempPath);
+              const metaPath = path.join(uploadDir, "metadata.json");
+              const meta = JSON.parse(fs2.readFileSync(metaPath, "utf-8"));
+              const finalTempPath = path.join(uploadDir, "final.bin");
+              const writeStream = fs2.createWriteStream(finalTempPath);
               for (let i = 0; i < totalChunks; i++) {
-                const pPath = path4.join(uploadDir, `part_${i}`);
-                const data = fs5.readFileSync(pPath);
+                const pPath = path.join(uploadDir, `part_${i}`);
+                const data = fs2.readFileSync(pPath);
                 writeStream.write(data);
               }
               writeStream.end();
@@ -1239,12 +1206,12 @@ var driveAPIHandler = async (req, res) => {
                 totalChunks
               });
               if (meta.providerName === "LOCAL" && drive.information.type === "FILE") {
-                drive.information.path = path4.join("drive", String(drive._id), "data.bin");
+                drive.information.path = path.join("drive", String(drive._id), "data.bin");
               }
               await drive.save();
               try {
                 const item = await provider.uploadFile(drive, finalTempPath, meta.accountId);
-                fs5.rmSync(uploadDir, { recursive: true, force: true });
+                fs2.rmSync(uploadDir, { recursive: true, force: true });
                 const newQuota = await provider.getQuota(meta.owner, meta.accountId);
                 res.status(200).json({ status: 200, message: "Upload complete", data: { type: "UPLOAD_COMPLETE", driveId: String(drive._id), item }, statistic: { storage: newQuota } });
               } catch (err) {
@@ -1432,16 +1399,7 @@ var driveAPIHandler = async (req, res) => {
     res.status(500).json({ status: 500, message: error instanceof Error ? error.message : "Unknown error" });
   }
 };
-export {
-  driveAPIHandler,
-  driveConfiguration,
-  driveCreateSrcSet,
-  driveCreateUrl,
-  driveFilePath,
-  driveFileSchemaZod,
-  driveGetUrl,
-  driveReadFile,
-  getDriveConfig,
-  getDriveInformation
-};
+
+export { driveAPIHandler, driveConfiguration, driveCreateSrcSet, driveCreateUrl, driveFilePath, driveFileSchemaZod, driveGetUrl, driveReadFile, getDriveConfig, getDriveInformation };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map