multermate 1.0.2 → 1.0.4

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Wasim Zaman
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Wasim Zaman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.js

@@ -1,197 +1,208 @@
-const path = require("path");
-const multer = require("multer");
-const { v4: uuidv4 } = require("uuid");
-
-// Constants for allowed MIME types
-const ALLOWED_MIME_TYPES = {
-  images: ["image/jpeg", "image/jpg", "image/png", "image/gif"],
-  videos: ["video/mp4", "video/mpeg", "video/ogg", "video/webm", "video/avi"],
-  pdfs: ["application/pdf"],
-  all: [
-    "image/jpeg",
-    "image/jpg",
-    "image/png",
-    "image/gif",
-    "video/mp4",
-    "video/mpeg",
-    "video/ogg",
-    "video/webm",
-    "video/avi",
-    "application/pdf",
-  ],
-};
-
-/**
- * Function to configure storage for Multer.
- *
- * @param {string} destination - The destination folder where files will be stored. Default is "uploads".
- * @returns {object} - Multer storage configuration object.
- */
-const configureStorage = (destination) => {
-  return multer.diskStorage({
-    destination: (req, file, cb) => {
-      cb(null, destination || "uploads"); // Default folder is "uploads" if none is provided.
-    },
-    filename: (req, file, cb) => {
-      const sanitizedFilename = file.originalname.replace(/\\/g, "/");
-      const extension = path.extname(sanitizedFilename);
-      const fieldName = file.fieldname || "file"; // Use the field name as part of the filename.
-      const uniqueName = uuidv4(); // Generate a unique name using uuid.
-      let fileName = `${uniqueName}-${fieldName}${extension}`;
-
-      // Replace backslashes with forward slashes in the final filename
-      fileName = fileName.replace(/\\/g, "/");
-
-      cb(null, fileName); // Set the final filename.
-    },
-  });
-};
-
-/**
- * Function to configure file filter for Multer.
- *
- * @param {Array} allowedMimeTypes - Array of allowed MIME types.
- * @returns {function} - File filter function for Multer.
- */
-const configureFileFilter = (allowedMimeTypes) => {
-  return (req, file, cb) => {
-    if (allowedMimeTypes.includes(file.mimetype)) {
-      cb(null, true); // Allow the file if its MIME type is allowed.
-    } else {
-      cb(
-        new Error("Invalid file type. Only specified file types are allowed."),
-        false
-      ); // Reject the file if its MIME type is not allowed.
-    }
-  };
-};
-
-/**
- * Function to configure Multer with the provided options.
- *
- * @param {object} options - Configuration options for Multer.
- * @param {string} [options.destination] - Destination folder for files. Default is "uploads".
- * @param {string} [options.filename] - Custom filename template for saved files.
- * @param {Array<string>} [options.fileTypes] - Array of file types to allow (e.g., ['images', 'videos']).
- * @param {Array<string>} [options.customMimeTypes] - Array of custom MIME types to allow.
- * @param {number} [options.fileSizeLimit] - Maximum file size allowed (in bytes). Default is 50MB.
- * @param {boolean} [options.preservePath] - Preserve the full path of files. Default is false.
- * @returns {object} - Multer instance configured with the provided options.
- */
-const configureMulter = ({
-  destination,
-  filename,
-  fileTypes = [],
-  customMimeTypes = [],
-  fileSizeLimit,
-  preservePath = false,
-}) => {
-  const storage = configureStorage(destination);
-
-  // Combine allowed MIME types based on fileTypes array
-  let allowedMimeTypes = [];
-
-  if (customMimeTypes.length > 0) {
-    // Use custom MIME types if provided
-    allowedMimeTypes = customMimeTypes;
-  } else {
-    // Use default MIME types for specified fileTypes
-    fileTypes.forEach((type) => {
-      if (ALLOWED_MIME_TYPES[type]) {
-        allowedMimeTypes = allowedMimeTypes.concat(ALLOWED_MIME_TYPES[type]);
-      }
-    });
-
-    // If no specific file types are provided, use all allowed MIME types
-    if (allowedMimeTypes.length === 0) {
-      allowedMimeTypes = ALLOWED_MIME_TYPES.all;
-    }
-  }
-
-  const fileFilter = configureFileFilter(allowedMimeTypes);
-
-  return multer({
-    storage,
-    fileFilter,
-    limits: { fileSize: fileSizeLimit || 1024 * 1024 * 50 }, // Default 50MB file size limit
-    preservePath,
-  });
-};
-
-/**
- * Function to handle multiple fields in a single form submission.
- *
- * @param {Array} fields - Array of field configurations, each containing:
- *   @param {string} fields.name - The name of the form field.
- *   @param {number} [fields.maxCount=10] - The maximum number of files to accept per field.
- *   @param {Array<string>} [fields.fileTypes] - Array of file types to allow for this field (e.g., ['images']).
- * @returns {function} - Multer instance configured to handle multiple fields.
- */
-const uploadFields = (fields) => {
-  const fieldConfigs = fields.map((field) => ({
-    name: field.name,
-    maxCount: field.maxCount || 10, // Default maxCount is 10 if not specified.
-  }));
-
-  let allowedFileTypes = [];
-
-  fields.forEach((field) => {
-    const types = field.fileTypes || [];
-    types.forEach((type) => {
-      if (ALLOWED_MIME_TYPES[type]) {
-        allowedFileTypes = allowedFileTypes.concat(ALLOWED_MIME_TYPES[type]);
-      }
-    });
-  });
-
-  const multerInstance = configureMulter({
-    fileTypes: allowedFileTypes,
-    customMimeTypes: [],
-    fileSizeLimit: fields[0]?.fileSizeLimit, // Assuming all fields share the same limit.
-  });
-
-  return multerInstance.fields(fieldConfigs);
-};
-
-// Export functions to configure multer and available file types
-module.exports = {
-  /**
-   * Function to handle a single file upload.
-   *
-   * @param {object} options - Configuration options for the single file upload.
-   * @param {string} [options.destination] - Destination folder for the uploaded file.
-   * @param {string} [options.filename] - Custom filename template for the uploaded file.
-   * @param {Array<string>} [options.fileTypes] - Array of file types to allow (e.g., ['images']).
-   * @param {Array<string>} [options.customMimeTypes] - Array of custom MIME types to allow.
-   * @param {number} [options.fileSizeLimit] - Maximum file size allowed (in bytes). Default is 50MB.
-   * @param {boolean} [options.preservePath] - Preserve the full path of the uploaded file. Default is false.
-   * @returns {function} - Multer instance configured for single file upload.
-   */
-  uploadSingle: (options = {}) => {
-    const multerInstance = configureMulter(options);
-    return multerInstance.single(options.filename || "file");
-  },
-
-  /**
-   * Function to handle multiple file uploads across multiple fields.
-   *
-   * @param {object} options - Configuration options for multiple file uploads.
-   * @param {Array<object>} options.fields - Array of field configurations for multiple file uploads.
-   * @param {string} [options.destination] - Destination folder for the uploaded files.
-   * @param {Array<string>} [options.customMimeTypes] - Array of custom MIME types to allow.
-   * @param {number} [options.fileSizeLimit] - Maximum file size allowed (in bytes). Default is 50MB.
-   * @param {boolean} [options.preservePath] - Preserve the full path of the uploaded files. Default is false.
-   * @returns {function} - Multer instance configured for multiple file uploads.
-   */
-  uploadMultiple: (options = {}) => {
-    const multerInstance = configureMulter(options);
-    return multerInstance.fields(options.fields || []);
-  },
-
-  /**
-   * Export the allowed file types for reference.
-   *
-   * @type {Array<string>}
-   */
-  ALLOWED_FILE_TYPES: Object.keys(ALLOWED_MIME_TYPES),
-};
+const path =
+  typeof require !== "undefined"
+    ? require("path")
+    : (await import("path")).default;
+const multer =
+  typeof require !== "undefined"
+    ? require("multer")
+    : (await import("multer")).default;
+const { v4: uuidv4 } =
+  typeof require !== "undefined" ? require("uuid") : await import("uuid");
+const fs =
+  typeof require !== "undefined"
+    ? require("fs/promises")
+    : await import("fs/promises");
+
+// Constants for allowed MIME types
+const ALLOWED_MIME_TYPES = {
+  images: ["image/jpeg", "image/jpg", "image/png", "image/gif"],
+  videos: ["video/mp4", "video/mpeg", "video/ogg", "video/webm", "video/avi"],
+  pdfs: ["application/pdf"],
+  all: [
+    "image/jpeg",
+    "image/jpg",
+    "image/png",
+    "image/gif",
+    "video/mp4",
+    "video/mpeg",
+    "video/ogg",
+    "video/webm",
+    "video/avi",
+    "application/pdf",
+  ],
+};
+
+/**
+ * Function to configure storage for Multer.
+ *
+ * @param {string} destination - The destination folder where files will be stored. Default is "uploads".
+ * @returns {object} - Multer storage configuration object.
+ */
+const configureStorage = (destination) => {
+  return multer.diskStorage({
+    destination: (req, file, cb) => {
+      cb(null, destination || "uploads"); // Default folder is "uploads" if none is provided.
+    },
+    filename: (req, file, cb) => {
+      const sanitizedFilename = file.originalname.replace(/\\/g, "/");
+      const extension = path.extname(sanitizedFilename);
+      const fieldName = file.fieldname || "file"; // Use the field name as part of the filename.
+      const uniqueName = uuidv4(); // Generate a unique name using uuid.
+      let fileName = `${uniqueName}-${fieldName}${extension}`;
+
+      // Replace backslashes with forward slashes in the final filename
+      fileName = fileName.replace(/\\/g, "/");
+
+      cb(null, fileName); // Set the final filename.
+    },
+  });
+};
+
+/**
+ * Function to configure file filter for Multer.
+ *
+ * @param {Array} allowedMimeTypes - Array of allowed MIME types.
+ * @returns {function} - File filter function for Multer.
+ */
+const configureFileFilter = (allowedMimeTypes) => {
+  return (req, file, cb) => {
+    if (allowedMimeTypes.includes(file.mimetype)) {
+      cb(null, true); // Allow the file if its MIME type is allowed.
+    } else {
+      cb(
+        new Error("Invalid file type. Only specified file types are allowed."),
+        false
+      ); // Reject the file if its MIME type is not allowed.
+    }
+  };
+};
+
+/**
+ * Function to configure Multer with the provided options.
+ *
+ * @param {object} options - Configuration options for Multer.
+ * @param {string} [options.destination] - Destination folder for files. Default is "uploads".
+ * @param {string} [options.filename] - Custom filename template for saved files.
+ * @param {Array<string>} [options.fileTypes] - Array of file types to allow (e.g., ['images', 'videos']).
+ * @param {Array<string>} [options.customMimeTypes] - Array of custom MIME types to allow.
+ * @param {number} [options.fileSizeLimit] - Maximum file size allowed (in bytes). Default is 50MB.
+ * @param {boolean} [options.preservePath] - Preserve the full path of files. Default is false.
+ * @returns {object} - Multer instance configured with the provided options.
+ */
+const configureMulter = ({
+  destination,
+  filename,
+  fileTypes = [],
+  customMimeTypes = [],
+  fileSizeLimit,
+  preservePath = false,
+}) => {
+  const storage = configureStorage(destination);
+
+  // Combine allowed MIME types based on fileTypes array
+  let allowedMimeTypes = [];
+
+  if (customMimeTypes.length > 0) {
+    // Use custom MIME types if provided
+    allowedMimeTypes = customMimeTypes;
+  } else {
+    // Use default MIME types for specified fileTypes
+    fileTypes.forEach((type) => {
+      if (ALLOWED_MIME_TYPES[type]) {
+        allowedMimeTypes = allowedMimeTypes.concat(ALLOWED_MIME_TYPES[type]);
+      }
+    });
+
+    // If no specific file types are provided, use all allowed MIME types
+    if (allowedMimeTypes.length === 0) {
+      allowedMimeTypes = ALLOWED_MIME_TYPES.all;
+    }
+  }
+
+  const fileFilter = configureFileFilter(allowedMimeTypes);
+
+  return multer({
+    storage,
+    fileFilter,
+    limits: { fileSize: fileSizeLimit || 1024 * 1024 * 50 }, // Default 50MB file size limit
+    preservePath,
+  });
+};
+
+/**
+ * Function to handle multiple fields in a single form submission.
+ *
+ * @param {Array} fields - Array of field configurations, each containing:
+ *   @param {string} fields.name - The name of the form field.
+ *   @param {number} [fields.maxCount=10] - The maximum number of files to accept per field.
+ *   @param {Array<string>} [fields.fileTypes] - Array of file types to allow for this field (e.g., ['images']).
+ * @returns {function} - Multer instance configured to handle multiple fields.
+ */
+const uploadFields = (fields) => {
+  const fieldConfigs = fields.map((field) => ({
+    name: field.name,
+    maxCount: field.maxCount || 10, // Default maxCount is 10 if not specified.
+  }));
+
+  let allowedFileTypes = [];
+
+  fields.forEach((field) => {
+    const types = field.fileTypes || [];
+    types.forEach((type) => {
+      if (ALLOWED_MIME_TYPES[type]) {
+        allowedFileTypes = allowedFileTypes.concat(ALLOWED_MIME_TYPES[type]);
+      }
+    });
+  });
+
+  const multerInstance = configureMulter({
+    fileTypes: allowedFileTypes,
+    customMimeTypes: [],
+    fileSizeLimit: fields[0]?.fileSizeLimit, // Assuming all fields share the same limit.
+  });
+
+  return multerInstance.fields(fieldConfigs);
+};
+
+/**
+ * Utility function to delete a file from the filesystem
+ *
+ * @param {string} filePath - The path to the file that needs to be deleted
+ * @returns {Promise<boolean>} - Returns true if deletion was successful, false otherwise
+ */
+const deleteFile = async (filePath) => {
+  try {
+    await fs.unlink(filePath);
+    return true;
+  } catch (error) {
+    console.error(`Error deleting file: ${error.message}`);
+    return false;
+  }
+};
+
+const exportObject = {
+  uploadSingle: (options = {}) => {
+    const multerInstance = configureMulter(options);
+    return multerInstance.single(options.filename || "file");
+  },
+
+  uploadMultiple: (options = {}) => {
+    const multerInstance = configureMulter(options);
+    return multerInstance.fields(options.fields || []);
+  },
+
+  ALLOWED_FILE_TYPES: Object.keys(ALLOWED_MIME_TYPES),
+  deleteFile,
+};
+
+// Dual export support
+if (typeof module !== "undefined" && module.exports) {
+  module.exports = exportObject;
+} else {
+  Object.assign(globalThis, {
+    uploadSingle: exportObject.uploadSingle,
+    uploadMultiple: exportObject.uploadMultiple,
+    ALLOWED_FILE_TYPES: exportObject.ALLOWED_FILE_TYPES,
+    deleteFile: exportObject.deleteFile,
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multermate",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A flexible and customizable npm package for configuring Multer",
   "main": "index.js",
   "scripts": {
@@ -26,5 +26,12 @@
   "bugs": {
     "url": "https://github.com/Wasim-Zaman/multermate/issues"
   },
-  "homepage": "https://github.com/Wasim-Zaman/multermate#readme"
+  "homepage": "https://github.com/Wasim-Zaman/multermate#readme",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.js"
+    }
+  }
 }

package/readme.md

@@ -0,0 +1,259 @@
+# Multer Mate
+
+A robust and flexible file upload utility built on top of Multer, providing advanced file handling capabilities for Node.js applications.
+
+## Features
+
+- 📁 Flexible file storage configuration
+- 🔒 Built-in file type validation
+- 📦 Single and multiple file uploads
+- 🎯 Field-specific file type restrictions
+- 🗑️ File deletion utility
+- ⚡ Configurable file size limits
+- 🎨 Custom MIME type support
+- 🔄 Unique file naming with UUID
+- 🛡️ Path sanitization
+- 📝 Comprehensive error handling
+
+## Installation
+
+```bash
+npm install multermate
+```
+
+## Basic Usage
+
+```javascript
+// CommonJS
+const { uploadSingle, uploadMultiple, deleteFile } = require("multermate");
+
+// ES Modules
+import { uploadSingle, uploadMultiple, deleteFile } from "multermate";
+```
+
+## Upload Configurations
+
+### Single File Upload
+
+```javascript
+// Basic single file upload
+app.post("/upload", uploadSingle(), (req, res) => {
+  res.json({ file: req.file });
+});
+
+// Advanced single file upload
+app.post(
+  "/upload/advanced",
+  uploadSingle({
+    destination: "uploads/images",
+    filename: "profile",
+    fileTypes: ["images"],
+    fileSizeLimit: 5 * 1024 * 1024, // 5MB
+    preservePath: false,
+  }),
+  (req, res) => {
+    res.json({ file: req.file });
+  }
+);
+```
+
+### Multiple Files Upload
+
+```javascript
+// Multiple fields with different configurations
+app.post(
+  "/upload/multiple",
+  uploadMultiple({
+    fields: [
+      {
+        name: "avatar",
+        maxCount: 1,
+        fileTypes: ["images"],
+      },
+      {
+        name: "documents",
+        maxCount: 5,
+        fileTypes: ["pdfs"],
+      },
+      {
+        name: "media",
+        maxCount: 3,
+        fileTypes: ["images", "videos"],
+      },
+    ],
+    destination: "uploads/mixed",
+    fileSizeLimit: 10 * 1024 * 1024, // 10MB per file
+  }),
+  (req, res) => {
+    res.json({ files: req.files });
+  }
+);
+```
+
+### Custom MIME Types
+
+```javascript
+app.post(
+  "/upload/custom",
+  uploadSingle({
+    destination: "uploads/custom",
+    customMimeTypes: [
+      "application/vnd.ms-excel",
+      "application/json",
+      "text/csv",
+    ],
+    fileSizeLimit: 1024 * 1024, // 1MB
+  })
+);
+```
+
+### File Deletion
+
+```javascript
+// Simple file deletion
+app.delete("/files/:filename", async (req, res) => {
+  const isDeleted = await deleteFile(`uploads/${req.params.filename}`);
+  res.json({ success: isDeleted });
+});
+
+// Advanced file deletion with error handling
+app.delete("/files/:type/:filename", async (req, res) => {
+  try {
+    const filePath = path.join("uploads", req.params.type, req.params.filename);
+    const isDeleted = await deleteFile(filePath);
+
+    if (isDeleted) {
+      res.json({
+        success: true,
+        message: "File deleted successfully",
+      });
+    } else {
+      res.status(404).json({
+        success: false,
+        message: "File not found or unable to delete",
+      });
+    }
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      message: error.message,
+    });
+  }
+});
+```
+
+## API Reference
+
+### uploadSingle(options)
+
+Configures single file upload with the following options:
+
+| Option          | Type     | Default   | Description            |
+| --------------- | -------- | --------- | ---------------------- |
+| destination     | string   | 'uploads' | Upload directory path  |
+| filename        | string   | 'file'    | Form field name        |
+| fileTypes       | string[] | ['all']   | Allowed file types     |
+| customMimeTypes | string[] | []        | Custom MIME types      |
+| fileSizeLimit   | number   | 50MB      | Max file size in bytes |
+| preservePath    | boolean  | false     | Preserve original path |
+
+### uploadMultiple(options)
+
+Configures multiple file uploads with the following options:
+
+| Option          | Type     | Default   | Description          |
+| --------------- | -------- | --------- | -------------------- |
+| fields          | Field[]  | []        | Field configurations |
+| destination     | string   | 'uploads' | Upload directory     |
+| customMimeTypes | string[] | []        | Custom MIME types    |
+| fileSizeLimit   | number   | 50MB      | Max file size        |
+| preservePath    | boolean  | false     | Preserve paths       |
+
+#### Field Configuration
+
+| Option    | Type     | Default | Description           |
+| --------- | -------- | ------- | --------------------- |
+| name      | string   | -       | Field name (required) |
+| maxCount  | number   | 10      | Max files per field   |
+| fileTypes | string[] | ['all'] | Allowed types         |
+
+### deleteFile(filePath)
+
+Deletes a file from the filesystem:
+
+| Parameter | Type             | Description      |
+| --------- | ---------------- | ---------------- |
+| filePath  | string           | Path to file     |
+| Returns   | Promise<boolean> | Deletion success |
+
+### Supported File Types
+
+```javascript
+const ALLOWED_FILE_TYPES = {
+  images: ["jpeg", "jpg", "png", "gif"],
+  videos: ["mp4", "mpeg", "ogg", "webm", "avi"],
+  pdfs: ["pdf"],
+};
+```
+
+## Error Handling
+
+```javascript
+app.post("/upload", uploadSingle(), (req, res) => {
+  try {
+    // File size validation
+    if (req.fileValidationError) {
+      return res.status(400).json({
+        error: req.fileValidationError,
+      });
+    }
+
+    // File existence check
+    if (!req.file) {
+      return res.status(400).json({
+        error: "No file uploaded",
+      });
+    }
+
+    // Success response
+    res.json({
+      success: true,
+      file: {
+        filename: req.file.filename,
+        path: req.file.path,
+        size: req.file.size,
+        mimetype: req.file.mimetype,
+      },
+    });
+  } catch (error) {
+    res.status(500).json({
+      error: error.message,
+    });
+  }
+});
+```
+
+## Best Practices
+
+1. Always implement proper error handling
+2. Set appropriate file size limits
+3. Validate file types on the server
+4. Use custom storage destinations for different file types
+5. Implement file cleanup mechanisms
+6. Consider implementing file type verification beyond MIME types
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit issues and pull requests.
+
+## Author
+
+Wasim Zaman
+
+## Support
+
+For support, please open an issue in the GitHub repository.

package/README.md

@@ -1,159 +0,0 @@
-# Multer Mate
-
-`multermate` is a flexible and customizable npm package for configuring Multer, a Node.js middleware for handling `multipart/form-data` (file uploads). This package allows you to easily configure Multer for various use cases, including storing files in different directories and specifying allowed file types.
-
-## Features
-
-- Customizable storage destinations
-- Unique file naming using `uuid`
-- Support for various file types (images, videos, PDFs, etc.)
-- Configurable file size limits
-- Single and multiple file uploads
-- Specify custom MIME types within broader categories
-- Default behavior for allowing all MIME types if none specified
-
-## Installation
-
-Install the package using npm:
-
-```bash
-npm install multermate
-```
-
-## Usage
-
-### Import the package
-
-```javascript
-const {
-  uploadSingle,
-  uploadMultiple,
-  ALLOWED_FILE_TYPES,
-} = require("multermate");
-```
-
-### Single File Upload
-
-```javascript
-const express = require("express");
-const { uploadSingle } = require("multermate");
-
-const app = express();
-
-app.post(
-  "/upload/single",
-  uploadSingle({
-    destination: "uploads/images",
-    filename: "image",
-    fileTypes: ["images"],
-    fileSizeLimit: 1024 * 1024 * 10, // 10MB limit
-  }),
-  (req, res) => {
-    res.send("Single file uploaded!");
-  }
-);
-
-app.listen(3000, () => {
-  console.log("Server started on http://localhost:3000");
-});
-```
-
-### Multiple Files Upload (Mixed File Types)
-
-```javascript
-const express = require("express");
-const { uploadMultiple } = require("multermate");
-
-const app = express();
-
-app.post(
-  "/upload/multiple",
-  uploadMultiple({
-    fields: [
-      { name: "media", maxCount: 1, fileTypes: ["images", "videos"] },
-      { name: "pdf", maxCount: 1, fileTypes: ["pdfs"] },
-    ],
-  }),
-  (req, res) => {
-    res.send("Multiple files uploaded!");
-  }
-);
-
-app.listen(3000, () => {
-  console.log("Server started on http://localhost:3000");
-});
-```
-
-### Custom MIME Types (e.g., Only PNGs and PDFs)
-
-```javascript
-const express = require("express");
-const { uploadSingle, uploadMultiple } = require("multermate");
-
-const app = express();
-
-// Single PNG or PDF file upload
-app.post(
-  "/upload-custom",
-  uploadSingle({
-    destination: "uploads/custom",
-    customMimeTypes: ["image/png", "application/pdf"],
-    fileSizeLimit: 1024 * 1024 * 15, // 15MB limit
-  }),
-  (req, res) => {
-    res.send("PNG or PDF file uploaded!");
-  }
-);
-
-// Multiple PNGs or PDFs upload
-app.post(
-  "/upload-custom-multiple",
-  uploadMultiple({
-    fields: [
-      { name: "images", maxCount: 5, customMimeTypes: ["image/png"] },
-      { name: "pdfs", maxCount: 2, customMimeTypes: ["application/pdf"] },
-    ],
-  }),
-  (req, res) => {
-    res.send("PNG images and PDF files uploaded!");
-  }
-);
-
-app.listen(3000, () => {
-  console.log("Server started on http://localhost:3000");
-});
-```
-
-### Default Behavior (Allow All MIME Types)
-
-```javascript
-const express = require("express");
-const { uploadSingle, uploadMultiple } = require("multermate");
-
-const app = express();
-
-// Single file upload (default behavior allows all MIME types)
-app.post("/upload", uploadSingle(), (req, res) => {
-  res.send("File uploaded!");
-});
-
-// Multiple files upload (default behavior allows all MIME types)
-app.post("/upload-multiple", uploadMultiple(), (req, res) => {
-  res.send("Files uploaded!");
-});
-
-app.listen(3000, () => {
-  console.log("Server started on http://localhost:3000");
-});
-```
-
-### Exported Constants
-
-```javascript
-const { ALLOWED_FILE_TYPES } = require("multermate");
-console.log(ALLOWED_FILE_TYPES); // ['images', 'videos', 'pdfs', 'all']
-```
-
-## Conclusion
-
-multermate provides a flexible and easy-to-use configuration for handling file uploads in Node.js applications. Whether you need to handle single or multiple file uploads, restrict uploads to certain file types, or specify custom MIME types, this package has you covered.