@muhgholy/next-drive 3.0.0 → 3.2.0

package/README.md

@@ -4,13 +4,13 @@ File storage and management for Next.js and Express apps. Includes a responsive
 
 ## Features
 
-- 📁 **File Management** – Upload, rename, move, organize files and folders
-- 🔍 **Search** – Search active files or trash with real-time filtering
-- 🗑️ **Trash System** – Soft delete, restore, and empty trash
-- 📱 **Responsive UI** – Optimized for desktop and mobile
-- 🎬 **Video Thumbnails** – Auto-generated thumbnails (requires FFmpeg)
-- 🔐 **Security** – Signed URLs and configurable upload limits
-- 📊 **View Modes** – Grid/List views with sorting and grouping
+-    📁 **File Management** – Upload, rename, move, organize files and folders
+-    🔍 **Search** – Search active files or trash with real-time filtering
+-    🗑️ **Trash System** – Soft delete, restore, and empty trash
+-    📱 **Responsive UI** – Optimized for desktop and mobile
+-    🎬 **Video Thumbnails** – Auto-generated thumbnails (requires FFmpeg)
+-    🔐 **Security** – Signed URLs and configurable upload limits
+-    📊 **View Modes** – Grid/List views with sorting and grouping
 
 ---
 
@@ -49,7 +49,7 @@ Add the package to your Tailwind content config:
 ```js
 // tailwind.config.js
 export default {
-	content: ['./app/**/*.{js,ts,jsx,tsx,mdx}', './pages/**/*.{js,ts,jsx,tsx,mdx}', './components/**/*.{js,ts,jsx,tsx,mdx}', './node_modules/@muhgholy/next-drive/dist/**/*.{js,mjs}'],
+	content: ["./app/**/*.{js,ts,jsx,tsx,mdx}", "./pages/**/*.{js,ts,jsx,tsx,mdx}", "./components/**/*.{js,ts,jsx,tsx,mdx}", "./node_modules/@muhgholy/next-drive/dist/**/*.{js,mjs}"],
 };
 ```
 
@@ -65,16 +65,16 @@ Create `lib/drive.ts` to configure storage, security, and authentication:
 
 ```typescript
 // lib/drive.ts
-import { driveConfiguration } from '@muhgholy/next-drive/server';
-import type { TDriveConfigInformation } from '@muhgholy/next-drive/server';
+import { driveConfiguration } from "@muhgholy/next-drive/server";
+import type { TDriveConfigInformation } from "@muhgholy/next-drive/server";
 
 driveConfiguration({
-	database: 'MONGOOSE',
-	apiUrl: '/api/drive',
-	storage: { path: '/var/data/drive' },
+	database: "MONGOOSE",
+	apiUrl: "/api/drive",
+	storage: { path: "/var/data/drive" },
 	security: {
 		maxUploadSizeInBytes: 50 * 1024 * 1024, // 50MB
-		allowedMimeTypes: ['image/*', 'video/*', 'application/pdf'],
+		allowedMimeTypes: ["image/*", "video/*", "application/pdf"],
 		signedUrls: {
 			enabled: true,
 			secret: process.env.DRIVE_SECRET!,
@@ -83,7 +83,7 @@ driveConfiguration({
 	},
 	information: async (req): Promise<TDriveConfigInformation> => {
 		const auth = await verifyAuth(req);
-		if (!auth) throw new Error('Unauthenticated');
+		if (!auth) throw new Error("Unauthenticated");
 		return {
 			key: { userId: auth.userId },
 			storage: { quotaInBytes: 1024 * 1024 * 1024 }, // 1GB
@@ -98,13 +98,13 @@ driveConfiguration({
 
 ```typescript
 // pages/api/drive.ts
-import '@/lib/drive';
-import { driveAPIHandler } from '@muhgholy/next-drive/server';
-import type { NextApiRequest, NextApiResponse } from 'next';
+import "@/lib/drive";
+import { driveAPIHandler } from "@muhgholy/next-drive/server";
+import type { NextApiRequest, NextApiResponse } from "next";
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse) {
 	// Parse JSON body manually (body parser is disabled)
-	if (req.headers['content-type']?.includes('application/json')) {
+	if (req.headers["content-type"]?.includes("application/json")) {
 		const chunks: Buffer[] = [];
 		for await (const chunk of req) chunks.push(chunk);
 		const buffer = Buffer.concat(chunks);
@@ -127,10 +127,10 @@ Wrap your app with `DriveProvider`:
 
 ```tsx
 // app/layout.tsx
-import { DriveProvider } from '@muhgholy/next-drive/client';
+import { DriveProvider } from "@muhgholy/next-drive/client";
 
 export default function RootLayout({ children }) {
-	return <DriveProvider apiEndpoint='/api/drive'>{children}</DriveProvider>;
+	return <DriveProvider apiEndpoint="/api/drive">{children}</DriveProvider>;
 }
 ```
 
@@ -139,7 +139,7 @@ export default function RootLayout({ children }) {
 **File Explorer:**
 
 ```tsx
-import { DriveExplorer } from '@muhgholy/next-drive/client';
+import { DriveExplorer } from "@muhgholy/next-drive/client";
 
 export default function DrivePage() {
 	return <DriveExplorer />;
@@ -149,13 +149,13 @@ export default function DrivePage() {
 **File Picker (for forms):**
 
 ```tsx
-import { useState } from 'react';
-import { DriveFileChooser } from '@muhgholy/next-drive/client';
-import type { TDriveFile } from '@muhgholy/next-drive/client';
+import { useState } from "react";
+import { DriveFileChooser } from "@muhgholy/next-drive/client";
+import type { TDriveFile } from "@muhgholy/next-drive/client";
 
 function MyForm() {
 	const [file, setFile] = useState<TDriveFile | null>(null);
-	return <DriveFileChooser value={file} onChange={setFile} accept='image/*' />;
+	return <DriveFileChooser value={file} onChange={setFile} accept="image/*" />;
 }
 ```
 
@@ -167,20 +167,20 @@ Use the Express adapter instead of Next.js API routes:
 
 ```typescript
 // lib/drive.ts
-import { driveConfigurationExpress } from '@muhgholy/next-drive/server/express';
-import type { TDriveConfigInformation } from '@muhgholy/next-drive/server/express';
+import { driveConfigurationExpress } from "@muhgholy/next-drive/server/express";
+import type { TDriveConfigInformation } from "@muhgholy/next-drive/server/express";
 
 driveConfigurationExpress({
-	database: 'MONGOOSE',
-	apiUrl: '/api/drive',
-	storage: { path: '/var/data/drive' },
+	database: "MONGOOSE",
+	apiUrl: "/api/drive",
+	storage: { path: "/var/data/drive" },
 	security: {
 		maxUploadSizeInBytes: 50 * 1024 * 1024,
-		allowedMimeTypes: ['image/*', 'video/*', 'application/pdf'],
+		allowedMimeTypes: ["image/*", "video/*", "application/pdf"],
 	},
 	information: async (req): Promise<TDriveConfigInformation> => {
 		const auth = await verifyAuth(req);
-		if (!auth) throw new Error('Unauthenticated');
+		if (!auth) throw new Error("Unauthenticated");
 		return {
 			key: { userId: auth.userId },
 			storage: { quotaInBytes: 1024 * 1024 * 1024 },
@@ -191,12 +191,12 @@ driveConfigurationExpress({
 
 ```typescript
 // routes/drive.ts
-import './lib/drive';
-import express from 'express';
-import { driveAPIHandlerExpress } from '@muhgholy/next-drive/server/express';
+import "./lib/drive";
+import express from "express";
+import { driveAPIHandlerExpress } from "@muhgholy/next-drive/server/express";
 
 const router = express.Router();
-router.all('/drive', driveAPIHandlerExpress);
+router.all("/drive", driveAPIHandlerExpress);
 
 export default router;
 ```
@@ -210,8 +210,8 @@ export default router;
 Validate file data in forms or API routes:
 
 ```typescript
-import { z } from 'zod';
-import { driveFileSchemaZod } from '@muhgholy/next-drive/schemas';
+import { z } from "zod";
+import { driveFileSchemaZod } from "@muhgholy/next-drive/schemas";
 
 const formSchema = z.object({
 	asset: driveFileSchemaZod,
@@ -228,8 +228,8 @@ const formSchema = z.object({
 Generate URLs for displaying files:
 
 ```tsx
-import { useDrive } from '@muhgholy/next-drive/client';
-import type { TDriveFile } from '@muhgholy/next-drive/client';
+import { useDrive } from "@muhgholy/next-drive/client";
+import type { TDriveFile } from "@muhgholy/next-drive/client";
 
 function MyComponent({ driveFile }: { driveFile: TDriveFile }) {
 	const { createUrl, createSrcSet } = useDrive();
@@ -238,10 +238,10 @@ function MyComponent({ driveFile }: { driveFile: TDriveFile }) {
 	const url = createUrl(driveFile);
 
 	// With quality and format
-	const optimizedUrl = createUrl(driveFile, { quality: 'medium', format: 'webp' });
+	const optimizedUrl = createUrl(driveFile, { quality: "medium", format: "webp" });
 
 	// Responsive srcSet for images
-	const { srcSet, sizes } = createSrcSet(driveFile, 'webp');
+	const { srcSet, sizes } = createSrcSet(driveFile, "webp");
 
 	return <img src={optimizedUrl} srcSet={srcSet} sizes={sizes} alt={driveFile.file.name} />;
 }
@@ -251,10 +251,51 @@ function MyComponent({ driveFile }: { driveFile: TDriveFile }) {
 
 ## Server-Side File Access
 
+### Upload File
+
+Upload files programmatically from server-side code:
+
+```typescript
+import { driveUpload } from "@muhgholy/next-drive/server";
+
+// Upload from file path
+const file = await driveUpload(
+	"/tmp/photo.jpg",
+	{ userId: "123" },
+	{
+		name: "photo.jpg",
+		parentId: "folderId", // Optional: folder ID or null for root
+		accountId: "LOCAL", // Optional: storage account ID
+		enforce: false, // Optional: bypass quota check
+	}
+);
+
+// Upload from stream
+import fs from "fs";
+const stream = fs.createReadStream("/tmp/video.mp4");
+const file = await driveUpload(
+	stream,
+	{ userId: "123" },
+	{
+		name: "video.mp4",
+		enforce: true, // Skip quota check
+	}
+);
+```
+
+**Options:**
+
+| Option      | Type             | Required | Description                                    |
+| ----------- | ---------------- | -------- | ---------------------------------------------- |
+| `name`      | `string`         | Yes      | File name with extension                       |
+| `parentId`  | `string \| null` | No       | Parent folder ID (null or 'root' for root)     |
+| `accountId` | `string`         | No       | Storage account ID ('LOCAL' for local storage) |
+| `enforce`   | `boolean`        | No       | Bypass quota check (default: false)            |
+
 ### Get Signed URL
 
 ```typescript
-import { driveGetUrl } from '@muhgholy/next-drive/server';
+import { driveGetUrl } from "@muhgholy/next-drive/server";
 
 // Default expiry (from config)
 const url = driveGetUrl(fileId);
@@ -263,13 +304,13 @@ const url = driveGetUrl(fileId);
 const url = driveGetUrl(fileId, { expiry: 7200 }); // 2 hours
 
 // Specific date
-const url = driveGetUrl(fileId, { expiry: new Date('2026-12-31') });
+const url = driveGetUrl(fileId, { expiry: new Date("2026-12-31") });
 ```
 
 ### Read File Stream
 
 ```typescript
-import { driveReadFile } from '@muhgholy/next-drive/server';
+import { driveReadFile } from "@muhgholy/next-drive/server";
 
 // Using file ID
 const { stream, mime, size } = await driveReadFile(fileId);
@@ -285,15 +326,15 @@ const { stream, mime, size } = await driveReadFile(drive);
 For libraries requiring file paths (Sharp, FFmpeg, etc.):
 
 ```typescript
-import { driveFilePath } from '@muhgholy/next-drive/server';
+import { driveFilePath } from "@muhgholy/next-drive/server";
 
 const { path, mime, size, provider } = await driveFilePath(fileId);
 
 // Use with Sharp
-await sharp(path).resize(800, 600).toFile('output.jpg');
+await sharp(path).resize(800, 600).toFile("output.jpg");
 
 // Use with FFmpeg
-await ffmpeg(path).format('mp4').save('output.mp4');
+await ffmpeg(path).format("mp4").save("output.mp4");
 ```
 
 > Google Drive files are automatically downloaded to local cache.
@@ -342,7 +383,7 @@ cors: {
 **Client setup for CORS:**
 
 ```tsx
-<DriveProvider apiEndpoint='https://api.example.com/drive' withCredentials={true}>
+<DriveProvider apiEndpoint="https://api.example.com/drive" withCredentials={true}>
 	{children}
 </DriveProvider>
 ```

package/dist/{chunk-KCDI2FBD.js → chunk-F5ZVJGYN.js}

@@ -2,9 +2,9 @@ import { __require } from './chunk-DGUM43GV.js';
 import formidable from 'formidable';
 import path3 from 'path';
 import fs2 from 'fs';
-import os from 'os';
+import os2 from 'os';
 import mongoose2, { Schema, isValidObjectId } from 'mongoose';
-import crypto2 from 'crypto';
+import crypto3 from 'crypto';
 import sharp from 'sharp';
 import { z } from 'zod';
 import ffmpeg from 'fluent-ffmpeg';
@@ -138,7 +138,7 @@ var validateMimeType = (mime, allowedTypes) => {
   });
 };
 var computeFileHash = (filePath) => new Promise((resolve, reject) => {
-  const hash = crypto2.createHash("sha256");
+  const hash = crypto3.createHash("sha256");
   const stream = fs2.createReadStream(filePath);
   stream.on("data", (data) => hash.update(data));
   stream.on("end", () => resolve(hash.digest("hex")));
@@ -252,7 +252,18 @@ var LocalStorageProvider = {
   search: async (query, owner, accountId) => {
   },
   getQuota: async (owner, accountId, configuredQuotaInBytes) => {
-    const result = await drive_default.aggregate([{ $match: { owner, "information.type": "FILE", trashedAt: null } }, { $group: { _id: null, total: { $sum: "$information.sizeInBytes" } } }]);
+    const result = await drive_default.aggregate([
+      {
+        $match: {
+          owner,
+          "information.type": "FILE",
+          trashedAt: null,
+          "provider.type": "LOCAL",
+          storageAccountId: accountId || null
+        }
+      },
+      { $group: { _id: null, total: { $sum: "$information.sizeInBytes" } } }
+    ]);
     const usedInBytes = result[0]?.total || 0;
     return { usedInBytes, quotaInBytes: configuredQuotaInBytes ?? 0 };
   },
@@ -297,7 +308,7 @@ var LocalStorageProvider = {
     return fs2.createReadStream(thumbPath);
   },
   createFolder: async (name, parentId, owner, accountId) => {
-    const getNextOrderValue = async (owner2) => {
+    const getNextOrderValue2 = async (owner2) => {
       const lastItem = await drive_default.findOne({ owner: owner2 }, {}, { sort: { order: -1 } });
       return lastItem ? lastItem.order + 1 : 0;
     };
@@ -305,7 +316,7 @@ var LocalStorageProvider = {
       owner,
       name,
       parentId: parentId === "root" || !parentId ? null : parentId,
-      order: await getNextOrderValue(owner),
+      order: await getNextOrderValue2(owner),
       provider: { type: "LOCAL" },
       information: { type: "FOLDER" },
       status: "READY"
@@ -815,6 +826,10 @@ var GoogleDriveProvider = {
     }
   }
 };
+var getNextOrderValue = async (owner) => {
+  const lastItem = await drive_default.findOne({ owner }, {}, { sort: { order: -1 } });
+  return lastItem ? lastItem.order + 1 : 0;
+};
 var driveGetUrl = (fileId, options) => {
   const config = getDriveConfig();
   if (!config.security.signedUrls?.enabled) {
@@ -829,7 +844,7 @@ var driveGetUrl = (fileId, options) => {
   } else {
     expiryTimestamp = Math.floor(Date.now() / 1e3) + expiresIn;
   }
-  const signature = crypto2.createHmac("sha256", secret).update(`${fileId}:${expiryTimestamp}`).digest("hex");
+  const signature = crypto3.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}`;
 };
@@ -931,6 +946,110 @@ var driveFilePath = async (file) => {
   }
   throw new Error(`Unsupported provider: ${providerType}`);
 };
+var driveUpload = async (source, key, options) => {
+  const config = getDriveConfig();
+  let provider = LocalStorageProvider;
+  const accountId = options.accountId;
+  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");
+    }
+    if (account.metadata.provider === "GOOGLE") {
+      provider = GoogleDriveProvider;
+    }
+  }
+  let tempFilePath = null;
+  let sourceFilePath;
+  let fileSize;
+  if (typeof source === "string") {
+    if (!fs2.existsSync(source)) {
+      throw new Error(`Source file not found: ${source}`);
+    }
+    sourceFilePath = source;
+    const stats = fs2.statSync(source);
+    fileSize = stats.size;
+  } else {
+    const tempDir = path3.join(os2.tmpdir(), "next-drive-uploads");
+    if (!fs2.existsSync(tempDir)) {
+      fs2.mkdirSync(tempDir, { recursive: true });
+    }
+    tempFilePath = path3.join(tempDir, `upload-${crypto3.randomUUID()}.tmp`);
+    const writeStream = fs2.createWriteStream(tempFilePath);
+    await new Promise((resolve, reject) => {
+      source.pipe(writeStream);
+      writeStream.on("finish", resolve);
+      writeStream.on("error", reject);
+      source.on("error", reject);
+    });
+    sourceFilePath = tempFilePath;
+    const stats = fs2.statSync(tempFilePath);
+    fileSize = stats.size;
+  }
+  try {
+    const ext = path3.extname(options.name).toLowerCase();
+    const mimeTypes = {
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".png": "image/png",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".svg": "image/svg+xml",
+      ".mp4": "video/mp4",
+      ".mov": "video/quicktime",
+      ".avi": "video/x-msvideo",
+      ".pdf": "application/pdf",
+      ".doc": "application/msword",
+      ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".xls": "application/vnd.ms-excel",
+      ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".txt": "text/plain",
+      ".json": "application/json",
+      ".zip": "application/zip"
+    };
+    const mimeType = mimeTypes[ext] || "application/octet-stream";
+    if (!validateMimeType(mimeType, config.security.allowedMimeTypes)) {
+      throw new Error(`File type ${mimeType} not allowed`);
+    }
+    if (fileSize > config.security.maxUploadSizeInBytes) {
+      throw new Error(`File size ${fileSize} exceeds maximum allowed size ${config.security.maxUploadSizeInBytes}`);
+    }
+    if (!options.enforce) {
+      const quota = await provider.getQuota(key, accountId, void 0);
+      if (quota.usedInBytes + fileSize > quota.quotaInBytes) {
+        throw new Error("Storage quota exceeded");
+      }
+    }
+    const drive = new drive_default({
+      owner: key,
+      storageAccountId: accountId || null,
+      provider: { type: provider.name },
+      name: options.name,
+      parentId: options.parentId === "root" || !options.parentId ? null : options.parentId,
+      order: await getNextOrderValue(key),
+      information: { type: "FILE", sizeInBytes: fileSize, mime: mimeType, path: "" },
+      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}`);
+    }
+    await drive.save();
+    try {
+      const item = await provider.uploadFile(drive, sourceFilePath, accountId);
+      return item;
+    } catch (err) {
+      await drive_default.deleteOne({ _id: drive._id });
+      throw err;
+    }
+  } finally {
+    if (tempFilePath && fs2.existsSync(tempFilePath)) {
+      fs2.rmSync(tempFilePath, { force: true });
+    }
+  }
+};
 
 // src/server/index.ts
 var getProvider = async (req, owner) => {
@@ -1192,7 +1311,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" });
-        const systemTmpDir = path3.join(os.tmpdir(), "next-drive-uploads");
+        const systemTmpDir = path3.join(os2.tmpdir(), "next-drive-uploads");
         if (!fs2.existsSync(systemTmpDir)) fs2.mkdirSync(systemTmpDir, { recursive: true });
         const form = formidable({
           multiples: false,
@@ -1228,7 +1347,7 @@ var driveAPIHandler = async (req, res) => {
         }
         const { chunkIndex, totalChunks, driveId, fileName, fileSize: fileSizeInBytes, fileType, folderId } = uploadData.data;
         let currentUploadId = driveId;
-        const tempBaseDir = path3.join(os.tmpdir(), "next-drive-uploads");
+        const tempBaseDir = path3.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 && !validateMimeType(fileType, config.security.allowedMimeTypes)) {
@@ -1357,7 +1476,7 @@ 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(os.tmpdir(), "next-drive-uploads", id);
+        const tempUploadDir = path3.join(os2.tmpdir(), "next-drive-uploads", id);
         if (fs2.existsSync(tempUploadDir)) {
           try {
             fs2.rmSync(tempUploadDir, { recursive: true, force: true });
@@ -1538,6 +1657,6 @@ var driveAPIHandler = async (req, res) => {
   }
 };
 
-export { driveAPIHandler, driveConfiguration, driveFilePath, driveFileSchemaZod, driveGetUrl, driveReadFile, getDriveConfig, getDriveInformation };
-//# sourceMappingURL=chunk-KCDI2FBD.js.map
-//# sourceMappingURL=chunk-KCDI2FBD.js.map
+export { driveAPIHandler, driveConfiguration, driveFilePath, driveFileSchemaZod, driveGetUrl, driveReadFile, driveUpload, getDriveConfig, getDriveInformation };
+//# sourceMappingURL=chunk-F5ZVJGYN.js.map
+//# sourceMappingURL=chunk-F5ZVJGYN.js.map