multermate 1.0.1 → 1.1.0

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/babel.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+  presets: [
+    [
+      "@babel/preset-env",
+      {
+        targets: {
+          node: "current",
+        },
+      },
+    ],
+  ],
+};

package/{index.js → dist/index.cjs.js}

@@ -1,193 +1,197 @@
-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.
-      const fileName = `${uniqueName}-${fieldName}${extension}`;
-      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 = 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),
+};

package/dist/index.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.uploadSingle = exports.uploadMultiple = exports.uploadFields = exports.configureStorage = exports.configureMulter = exports.configureFileFilter = exports.ALLOWED_FILE_TYPES = void 0;
+var _multer = _interopRequireDefault(require("multer"));
+var _path = _interopRequireDefault(require("path"));
+var _uuid = require("uuid");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// 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.default.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.default.extname(sanitizedFilename);
+      const fieldName = file.fieldname || "file"; // Use the field name as part of the filename.
+      const uniqueName = (0, _uuid.v4)(); // 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.
+ */
+exports.configureStorage = configureStorage;
+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.
+ */
+exports.configureFileFilter = configureFileFilter;
+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 (0, _multer.default)({
+    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.
+ */
+exports.configureMulter = configureMulter;
+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
+exports.uploadFields = uploadFields;
+const uploadSingle = (options = {}) => {
+  const multerInstance = configureMulter(options);
+  return multerInstance.single(options.filename || "file");
+};
+exports.uploadSingle = uploadSingle;
+const uploadMultiple = (options = {}) => {
+  const multerInstance = configureMulter(options);
+  return multerInstance.fields(options.fields || []);
+};
+exports.uploadMultiple = uploadMultiple;
+const ALLOWED_FILE_TYPES = exports.ALLOWED_FILE_TYPES = Object.keys(ALLOWED_MIME_TYPES);

package/dist/index.mjs

@@ -0,0 +1,167 @@
+import multer from "multer";
+import path from "path";
+import { v4 as uuidv4 } from "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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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
+export const uploadSingle = (options = {}) => {
+  const multerInstance = configureMulter(options);
+  return multerInstance.single(options.filename || "file");
+};
+
+export const uploadMultiple = (options = {}) => {
+  const multerInstance = configureMulter(options);
+  return multerInstance.fields(options.fields || []);
+};
+
+export const ALLOWED_FILE_TYPES = Object.keys(ALLOWED_MIME_TYPES);

package/package.json

@@ -1,30 +1,23 @@
 {
   "name": "multermate",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "A flexible and customizable npm package for configuring Multer",
-  "main": "index.js",
+  "main": "./dist/index.cjs.js",
+  "module": "./dist/index.mjs",
   "scripts": {
+    "build:cjs": "babel src --out-dir dist --extensions \".js\" --plugins=@babel/plugin-transform-modules-commonjs",
+    "build:esm": "babel src --out-dir dist --extensions \".js\"",
+    "build": "npm run build:cjs && npm run build:esm",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "keywords": [
-    "multer",
-    "file upload",
-    "middleware",
-    "node.js",
-    "configurable"
-  ],
-  "author": "Wasim Zaman",
-  "license": "MIT",
   "dependencies": {
     "multer": "1.4.5-lts.1",
     "uuid": "^10.0.0"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Wasim-Zaman/multermate.git"
-  },
-  "bugs": {
-    "url": "https://github.com/Wasim-Zaman/multermate/issues"
-  },
-  "homepage": "https://github.com/Wasim-Zaman/multermate#readme"
+  "devDependencies": {
+    "@babel/cli": "^7.25.6",
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-transform-modules-commonjs": "^7.24.8",
+    "@babel/preset-env": "^7.25.4"
+  }
 }

package/{README.md → readme.md}

@@ -1,159 +1,159 @@
-# 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.
+# 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.

package/src/index.js

@@ -0,0 +1,167 @@
+import multer from "multer";
+import path from "path";
+import { v4 as uuidv4 } from "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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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
+export const uploadSingle = (options = {}) => {
+  const multerInstance = configureMulter(options);
+  return multerInstance.single(options.filename || "file");
+};
+
+export const uploadMultiple = (options = {}) => {
+  const multerInstance = configureMulter(options);
+  return multerInstance.fields(options.fields || []);
+};
+
+export const ALLOWED_FILE_TYPES = Object.keys(ALLOWED_MIME_TYPES);