@muhgholy/next-drive 4.23.0 → 4.23.2

package/README.md

@@ -461,6 +461,80 @@ const items = await driveList({
 | `limit`     | `number`                  | No       | Maximum items to return (default: 100)         |
 | `afterId`   | `string`                  | No       | Last item ID for pagination                    |
 
+### List Files (Paginated)
+
+List **files only** (not folders) with offset-based pagination:
+
+```typescript
+import { driveListFiles } from "@muhgholy/next-drive/server";
+
+// List all files (page 1, default limit 50)
+const result = await driveListFiles({});
+
+// List files for a specific owner
+const result = await driveListFiles({ key: { userId: "123" } });
+
+// List files in a folder with pagination
+const result = await driveListFiles({
+	key: { userId: "123" },
+	folderId: "folderIdHere",
+	page: 2,
+	limit: 20,
+});
+
+// Access pagination info
+console.log(result.pagination);
+// { page: 2, limit: 20, totalCount: 87, totalPages: 5, hasMore: true }
+```
+
+**Options:**
+
+| Option      | Type                       | Required | Description                                    |
+| ----------- | -------------------------- | -------- | ---------------------------------------------- |
+| `key`       | `Record<string, unknown>`  | No       | Owner key (omit to list all files)             |
+| `folderId`  | `string \| null`           | No       | Folder ID (null/'root' for root, omit for all) |
+| `accountId` | `string`                   | No       | Storage account ID                             |
+| `page`      | `number`                   | No       | Page number (default: 1)                       |
+| `limit`     | `number`                   | No       | Items per page (default: 50, max: 100)         |
+
+**Returns:** `{ items: TDatabaseDrive[], pagination: { page, limit, totalCount, totalPages, hasMore } }`
+
+### Direct Database Access
+
+For custom queries, use the exposed Mongoose model:
+
+```typescript
+import { DatabaseMongoDrive } from "@muhgholy/next-drive/server";
+import type { IDatabaseDriveDocument } from "@muhgholy/next-drive/server";
+
+// Custom query
+const files = await DatabaseMongoDrive.find({
+	owner: { userId: "123" },
+	"information.type": "FILE",
+	"information.mime": { $regex: "^image/" },
+});
+
+// Aggregation
+const stats = await DatabaseMongoDrive.aggregate([
+	{ $match: { owner: { userId: "123" }, trashedAt: null } },
+	{ $group: { _id: "$information.type", count: { $sum: 1 } } },
+]);
+```
+
+### Cleanup Orphaned Files
+
+Remove orphaned file folders from storage that no longer exist in the database, and clean up leftover temp directories:
+
+```typescript
+import { driveCleanup } from "@muhgholy/next-drive/server";
+
+const result = await driveCleanup();
+console.log(`Removed ${result.removed.length} orphaned folders`);
+console.log(`Freed ${result.totalFreedInBytes} bytes`);
+```
+
+**Returns:** `{ removed: string[], totalFreedInBytes: number }`
+
 ### Delete File or Folder
 
 Permanently delete a file or folder from the drive system:

package/dist/{chunk-CR3QW3QN.js → chunk-R43JCXQB.js}

@@ -1,7 +1,7 @@
 import formidable from 'formidable';
 import path from 'path';
 import fs from 'fs';
-import os3 from 'os';
+import os2 from 'os';
 import crypto2 from 'crypto';
 import mongoose, { Schema, isValidObjectId } from 'mongoose';
 import sharp2 from 'sharp';
@@ -260,7 +260,7 @@ var driveConfiguration = async (config) => {
     if (g.migrationPromise) await g.migrationPromise;
     return g.config;
   }
-  const resolvedPath = config.storage?.path || path.join(os3.tmpdir(), "next-drive-data");
+  const resolvedPath = config.storage?.path || path.join(os2.tmpdir(), "next-drive-data");
   const mode = config.mode || "NORMAL";
   if (mode === "ROOT") {
     g.config = {
@@ -1451,6 +1451,51 @@ var driveList = async (options) => {
   const items = await drive_default.find(query, {}, { sort: { order: 1, _id: -1 }, limit });
   return await Promise.all(items.map((item) => item.toClient()));
 };
+var driveListFiles = async (options) => {
+  const { key, folderId, accountId } = options;
+  const page = Math.max(1, options.page ?? 1);
+  const limit = Math.min(Math.max(1, options.limit ?? 50), 100);
+  let providerName = "LOCAL";
+  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") {
+      providerName = "GOOGLE";
+    }
+  }
+  const query = {
+    "provider.type": providerName,
+    "information.type": "FILE",
+    storageAccountId: accountId || null,
+    trashedAt: null
+  };
+  if (key !== void 0) {
+    query.owner = key;
+  }
+  if (folderId && folderId !== "root") {
+    query.parentId = folderId;
+  } else if (folderId === "root" || folderId === null) {
+    query.parentId = null;
+  }
+  const skip = (page - 1) * limit;
+  const [totalCount, items] = await Promise.all([
+    drive_default.countDocuments(query),
+    drive_default.find(query, {}, { sort: { createdAt: -1 }, skip, limit })
+  ]);
+  const totalPages = Math.ceil(totalCount / limit);
+  return {
+    items: await Promise.all(items.map((item) => item.toClient())),
+    pagination: {
+      page,
+      limit,
+      totalCount,
+      totalPages,
+      hasMore: page < totalPages
+    }
+  };
+};
 var driveDelete = async (source, options) => {
   const { recurse = true } = options || {};
   let drive;
@@ -1549,7 +1594,7 @@ var driveUpload = async (source, key, options) => {
     const stats = fs.statSync(source);
     fileSize = stats.size;
   } else if (Buffer.isBuffer(source)) {
-    const tempDir = path.join(os3.tmpdir(), "next-drive-uploads");
+    const tempDir = path.join(os2.tmpdir(), "next-drive-uploads");
     if (!fs.existsSync(tempDir)) {
       fs.mkdirSync(tempDir, { recursive: true });
     }
@@ -1558,7 +1603,7 @@ var driveUpload = async (source, key, options) => {
     sourceFilePath = tempFilePath;
     fileSize = source.length;
   } else {
-    const tempDir = path.join(os3.tmpdir(), "next-drive-uploads");
+    const tempDir = path.join(os2.tmpdir(), "next-drive-uploads");
     if (!fs.existsSync(tempDir)) {
       fs.mkdirSync(tempDir, { recursive: true });
     }
@@ -1658,6 +1703,81 @@ var driveUpload = async (source, key, options) => {
     }
   }
 };
+var driveCleanup = async () => {
+  const config = getDriveConfig();
+  const fileDir = path.join(config.storage.path, "file");
+  if (!fs.existsSync(fileDir)) {
+    return { removed: [], totalFreedInBytes: 0 };
+  }
+  const folderNames = fs.readdirSync(fileDir).filter((name) => {
+    const fullPath = path.join(fileDir, name);
+    return fs.statSync(fullPath).isDirectory();
+  });
+  if (folderNames.length === 0) {
+    return { removed: [], totalFreedInBytes: 0 };
+  }
+  const getDirSize = (dirPath) => {
+    let size = 0;
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry.name);
+        if (entry.isFile()) {
+          size += fs.statSync(entryPath).size;
+        } else if (entry.isDirectory()) {
+          size += getDirSize(entryPath);
+        }
+      }
+    } catch {
+    }
+    return size;
+  };
+  const BATCH_SIZE = 500;
+  const existingIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < folderNames.length; i += BATCH_SIZE) {
+    const batch = folderNames.slice(i, i + BATCH_SIZE);
+    const docs = await drive_default.find(
+      { _id: { $in: batch } },
+      { _id: 1 }
+    ).lean();
+    for (const doc of docs) {
+      existingIds.add(doc._id.toString());
+    }
+  }
+  const removed = [];
+  let totalFreedInBytes = 0;
+  for (const name of folderNames) {
+    if (!existingIds.has(name)) {
+      const dirPath = path.join(fileDir, name);
+      try {
+        totalFreedInBytes += getDirSize(dirPath);
+        fs.rmSync(dirPath, { recursive: true, force: true });
+        removed.push(name);
+      } catch (e) {
+        console.error(`[next-drive] Failed to remove orphaned folder ${name}:`, e);
+      }
+    }
+  }
+  const tempDir = path.join(config.storage.path, "temp");
+  if (fs.existsSync(tempDir)) {
+    try {
+      totalFreedInBytes += getDirSize(tempDir);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch (e) {
+      console.error("[next-drive] Failed to remove temp directory:", e);
+    }
+  }
+  const systemTmpDir = path.join(os2.tmpdir(), "next-drive-uploads");
+  if (fs.existsSync(systemTmpDir)) {
+    try {
+      totalFreedInBytes += getDirSize(systemTmpDir);
+      fs.rmSync(systemTmpDir, { recursive: true, force: true });
+    } catch (e) {
+      console.error("[next-drive] Failed to remove system temp directory:", e);
+    }
+  }
+  return { removed, totalFreedInBytes };
+};
 
 // src/server/index.ts
 var getProvider = async (req, owner) => {
@@ -2075,7 +2195,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 = path.join(os3.tmpdir(), "next-drive-uploads");
+        const systemTmpDir = path.join(os2.tmpdir(), "next-drive-uploads");
         if (!fs.existsSync(systemTmpDir)) fs.mkdirSync(systemTmpDir, { recursive: true });
         const form = formidable({
           multiples: false,
@@ -2111,7 +2231,7 @@ var driveAPIHandler = async (req, res) => {
         }
         const { chunkIndex, totalChunks, driveId, fileName, fileSize: fileSizeInBytes, fileType, folderId } = uploadData.data;
         let currentUploadId = driveId;
-        const tempBaseDir = path.join(os3.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) {
@@ -2259,7 +2379,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 = path.join(os3.tmpdir(), "next-drive-uploads", id);
+        const tempUploadDir = path.join(os2.tmpdir(), "next-drive-uploads", id);
         if (fs.existsSync(tempUploadDir)) {
           try {
             fs.rmSync(tempUploadDir, { recursive: true, force: true });
@@ -2404,6 +2524,6 @@ var driveAPIHandler = async (req, res) => {
   }
 };
 
-export { driveAPIHandler, driveConfiguration, driveDelete, driveFilePath, driveFileSchemaZod, driveGetUrl, driveInfo, driveList, driveReadFile, driveUpload, getDriveConfig, getDriveInformation };
-//# sourceMappingURL=chunk-CR3QW3QN.js.map
-//# sourceMappingURL=chunk-CR3QW3QN.js.map
+export { driveAPIHandler, driveCleanup, driveConfiguration, driveDelete, driveFilePath, driveFileSchemaZod, driveGetUrl, driveInfo, driveList, driveListFiles, driveReadFile, driveUpload, drive_default, getDriveConfig, getDriveInformation };
+//# sourceMappingURL=chunk-R43JCXQB.js.map
+//# sourceMappingURL=chunk-R43JCXQB.js.map