multermate 1.0.5 → 1.1.1

package/dist/cjs/index.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_FILE_TYPES = void 0;
+exports.uploadSingle = uploadSingle;
+exports.uploadMultiple = uploadMultiple;
+exports.deleteFile = deleteFile;
+const promises_1 = __importDefault(require("fs/promises"));
+const multer_1 = __importDefault(require("multer"));
+const path_1 = __importDefault(require("path"));
+const uuid_1 = require("uuid");
+// Define 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 destination - The destination folder where files will be stored.
+ * @returns Multer storage configuration object.
+ */
+const configureStorage = (destination) => {
+    return multer_1.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_1.default.extname(sanitizedFilename);
+            const fieldName = file.fieldname || "file"; // Use the field name as part of the filename.
+            const uniqueName = (0, uuid_1.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 allowedMimeTypes - Array of allowed MIME types.
+ * @returns 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 {
+            const error = new Error("Invalid file type. Only specified file types are allowed.");
+            error.code = 'INVALID_FILE_TYPE';
+            cb(error); // Reject the file if its MIME type is not allowed.
+        }
+    };
+};
+/**
+ * Function to configure Multer with the provided options.
+ *
+ * @param options - Configuration options for Multer.
+ * @returns 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 (0, multer_1.default)({
+        storage,
+        fileFilter,
+        limits: { fileSize: fileSizeLimit || 1024 * 1024 * 50 }, // Default 50MB file size limit
+        preservePath,
+    });
+};
+/**
+ * Function to handle a single file upload.
+ *
+ * @param options - Configuration options for the single file upload.
+ * @returns Multer middleware configured for single file upload.
+ */
+function uploadSingle(options = {}) {
+    // Create destination directory if it doesn't exist
+    const destination = options.destination || 'uploads';
+    const multerInstance = configureMulter(options);
+    const middleware = multerInstance.single(options.filename || "file");
+    return (req, res, next) => {
+        // Make sure the destination directory exists
+        require('fs').mkdirSync(destination, { recursive: true });
+        middleware(req, res, (err) => {
+            if (err) {
+                if (err.code === 'LIMIT_FILE_SIZE') {
+                    req.fileValidationError = 'File size limit exceeded';
+                }
+                else if (err.code === 'INVALID_FILE_TYPE') {
+                    req.fileValidationError = 'Invalid file type';
+                }
+                else {
+                    req.fileValidationError = err.message;
+                }
+            }
+            next();
+        });
+    };
+}
+/**
+ * Function to handle multiple file uploads across multiple fields.
+ *
+ * @param options - Configuration options for multiple file uploads.
+ * @returns Multer middleware configured for multiple file uploads.
+ */
+function uploadMultiple(options) {
+    const destination = options.destination || 'uploads';
+    // Map fields configuration to multer format
+    const fieldConfigs = options.fields.map(field => ({
+        name: field.name,
+        maxCount: field.maxCount || 10, // Default maxCount is 10 if not specified.
+    }));
+    let allowedFileTypes = [];
+    options.fields.forEach((field) => {
+        const types = field.fileTypes || [];
+        types.forEach((type) => {
+            if (ALLOWED_MIME_TYPES[type]) {
+                allowedFileTypes = allowedFileTypes.concat(ALLOWED_MIME_TYPES[type]);
+            }
+        });
+    });
+    const multerConfig = {
+        destination,
+        fileTypes: [],
+        customMimeTypes: options.customMimeTypes || [],
+        fileSizeLimit: options.fileSizeLimit,
+        preservePath: options.preservePath
+    };
+    const multerInstance = configureMulter(multerConfig);
+    const middleware = multerInstance.fields(fieldConfigs);
+    return (req, res, next) => {
+        // Make sure the destination directory exists
+        require('fs').mkdirSync(destination, { recursive: true });
+        middleware(req, res, (err) => {
+            if (err) {
+                if (err.code === 'LIMIT_FILE_SIZE') {
+                    req.fileValidationError = 'File size limit exceeded';
+                }
+                else if (err.code === 'INVALID_FILE_TYPE') {
+                    req.fileValidationError = 'Invalid file type';
+                }
+                else {
+                    req.fileValidationError = err.message;
+                }
+            }
+            next();
+        });
+    };
+}
+/**
+ * Utility function to delete a file from the filesystem
+ *
+ * @param filePath - The path to the file that needs to be deleted
+ * @returns Promise that resolves to true if deletion was successful, false otherwise
+ */
+async function deleteFile(filePath) {
+    try {
+        await promises_1.default.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        console.error(`Error deleting file: ${error.message}`);
+        return false;
+    }
+}
+// Export the allowed file types for reference
+exports.ALLOWED_FILE_TYPES = Object.keys(ALLOWED_MIME_TYPES);
+// Export your functions
+exports.default = {
+    uploadSingle,
+    uploadMultiple,
+    deleteFile,
+    ALLOWED_FILE_TYPES: exports.ALLOWED_FILE_TYPES
+};

package/dist/esm/index.js

@@ -0,0 +1,202 @@
+import fs from 'fs/promises';
+import multer from 'multer';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+// Define 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 destination - The destination folder where files will be stored.
+ * @returns 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 allowedMimeTypes - Array of allowed MIME types.
+ * @returns 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 {
+            const error = new Error("Invalid file type. Only specified file types are allowed.");
+            error.code = 'INVALID_FILE_TYPE';
+            cb(error); // Reject the file if its MIME type is not allowed.
+        }
+    };
+};
+/**
+ * Function to configure Multer with the provided options.
+ *
+ * @param options - Configuration options for Multer.
+ * @returns 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 a single file upload.
+ *
+ * @param options - Configuration options for the single file upload.
+ * @returns Multer middleware configured for single file upload.
+ */
+export function uploadSingle(options = {}) {
+    // Create destination directory if it doesn't exist
+    const destination = options.destination || 'uploads';
+    const multerInstance = configureMulter(options);
+    const middleware = multerInstance.single(options.filename || "file");
+    return (req, res, next) => {
+        // Make sure the destination directory exists
+        require('fs').mkdirSync(destination, { recursive: true });
+        middleware(req, res, (err) => {
+            if (err) {
+                if (err.code === 'LIMIT_FILE_SIZE') {
+                    req.fileValidationError = 'File size limit exceeded';
+                }
+                else if (err.code === 'INVALID_FILE_TYPE') {
+                    req.fileValidationError = 'Invalid file type';
+                }
+                else {
+                    req.fileValidationError = err.message;
+                }
+            }
+            next();
+        });
+    };
+}
+/**
+ * Function to handle multiple file uploads across multiple fields.
+ *
+ * @param options - Configuration options for multiple file uploads.
+ * @returns Multer middleware configured for multiple file uploads.
+ */
+export function uploadMultiple(options) {
+    const destination = options.destination || 'uploads';
+    // Map fields configuration to multer format
+    const fieldConfigs = options.fields.map(field => ({
+        name: field.name,
+        maxCount: field.maxCount || 10, // Default maxCount is 10 if not specified.
+    }));
+    let allowedFileTypes = [];
+    options.fields.forEach((field) => {
+        const types = field.fileTypes || [];
+        types.forEach((type) => {
+            if (ALLOWED_MIME_TYPES[type]) {
+                allowedFileTypes = allowedFileTypes.concat(ALLOWED_MIME_TYPES[type]);
+            }
+        });
+    });
+    const multerConfig = {
+        destination,
+        fileTypes: [],
+        customMimeTypes: options.customMimeTypes || [],
+        fileSizeLimit: options.fileSizeLimit,
+        preservePath: options.preservePath
+    };
+    const multerInstance = configureMulter(multerConfig);
+    const middleware = multerInstance.fields(fieldConfigs);
+    return (req, res, next) => {
+        // Make sure the destination directory exists
+        require('fs').mkdirSync(destination, { recursive: true });
+        middleware(req, res, (err) => {
+            if (err) {
+                if (err.code === 'LIMIT_FILE_SIZE') {
+                    req.fileValidationError = 'File size limit exceeded';
+                }
+                else if (err.code === 'INVALID_FILE_TYPE') {
+                    req.fileValidationError = 'Invalid file type';
+                }
+                else {
+                    req.fileValidationError = err.message;
+                }
+            }
+            next();
+        });
+    };
+}
+/**
+ * Utility function to delete a file from the filesystem
+ *
+ * @param filePath - The path to the file that needs to be deleted
+ * @returns Promise that resolves to true if deletion was successful, false otherwise
+ */
+export async function deleteFile(filePath) {
+    try {
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        console.error(`Error deleting file: ${error.message}`);
+        return false;
+    }
+}
+// Export the allowed file types for reference
+export const ALLOWED_FILE_TYPES = Object.keys(ALLOWED_MIME_TYPES);
+// Export your functions
+export default {
+    uploadSingle,
+    uploadMultiple,
+    deleteFile,
+    ALLOWED_FILE_TYPES
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/index.d.ts

@@ -0,0 +1 @@
+export * from './types/index';

package/index.js

@@ -1,217 +1,2 @@
-const path = require("path");
-const multer = require("multer");
-const { v4: uuidv4 } = require("uuid");
-const fs = require("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;
-  }
-};
-
-// 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),
-
-  // Add the delete file utility
-  deleteFile,
-};
+// CommonJS entry point
+module.exports = require("./dist/cjs/index");

package/index.mjs

@@ -0,0 +1,15 @@
+// ES Module entry point
+export * from "./dist/esm/index.js";
+
+// This pattern ensures better compatibility with various Node.js environments
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const multermate = require("./dist/cjs/index.js");
+
+// Re-export everything from the CJS module
+export const uploadSingle = multermate.uploadSingle;
+export const uploadMultiple = multermate.uploadMultiple;
+export const deleteFile = multermate.deleteFile;
+
+// Default export
+export default multermate;

package/package.json

@@ -1,9 +1,31 @@
 {
   "name": "multermate",
-  "version": "1.0.5",
-  "description": "A flexible and customizable npm package for configuring Multer",
+  "version": "1.1.1",
+  "description": "A flexible and customizable file upload utility built on top of Multer with TypeScript support",
   "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "types": "./types/index.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "types/",
+    "index.js",
+    "index.mjs",
+    "index.d.ts"
+  ],
   "scripts": {
+    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types",
+    "build:cjs": "tsc --module commonjs --outDir dist/cjs",
+    "build:esm": "tsc --module ES2020 --outDir dist/esm && echo '{\"type\": \"module\"}' > dist/esm/package.json",
+    "build:types": "tsc --emitDeclarationOnly",
+    "clean": "node -e \"const fs=require('fs'); ['dist', 'types'].forEach(dir => { try { fs.rmSync(dir, {recursive: true, force: true}); } catch(e){} })\"",
+    "prepublishOnly": "npm run build",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
@@ -19,6 +41,13 @@
     "multer": "1.4.5-lts.1",
     "uuid": "^10.0.0"
   },
+  "devDependencies": {
+    "@types/multer": "^1.4.11",
+    "@types/node": "^20.10.5",
+    "@types/uuid": "^9.0.7",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Wasim-Zaman/multermate.git"

package/readme.md

@@ -1,6 +1,6 @@
 # Multer Mate
 
-A robust and flexible file upload utility built on top of Multer, providing advanced file handling capabilities for Node.js applications.
+A robust and flexible file upload utility built on top of Multer, providing advanced file handling capabilities for Node.js applications. Now with full TypeScript support!
 
 ## Features
 
@@ -14,6 +14,8 @@ A robust and flexible file upload utility built on top of Multer, providing adva
 - 🔄 Unique file naming with UUID
 - 🛡️ Path sanitization
 - 📝 Comprehensive error handling
+- 🔌 Works with CommonJS, ES Modules, and TypeScript
+- 📘 Full TypeScript definitions and type safety
 
 ## Installation
 
@@ -23,10 +25,37 @@ npm install multermate
 
 ## Basic Usage
 
+### CommonJS
+
 ```javascript
 const { uploadSingle, uploadMultiple, deleteFile } = require("multermate");
 ```
 
+### ES Modules
+
+```javascript
+import { uploadSingle, uploadMultiple, deleteFile } from "multermate";
+```
+
+### TypeScript
+
+```typescript
+import {
+  uploadSingle,
+  uploadMultiple,
+  deleteFile,
+  UploadSingleOptions,
+  UploadMultipleOptions,
+} from "multermate";
+
+// With type definitions
+const options: UploadSingleOptions = {
+  destination: "uploads/images",
+  fileTypes: ["images"],
+  fileSizeLimit: 5 * 1024 * 1024,
+};
+```
+
 ## Upload Configurations
 
 ### Single File Upload
@@ -99,7 +128,10 @@ app.post(
       "text/csv",
     ],
     fileSizeLimit: 1024 * 1024, // 1MB
-  })
+  }),
+  (req, res) => {
+    res.json({ file: req.file });
+  }
 );
 ```
 
@@ -167,11 +199,12 @@ Configures multiple file uploads with the following options:
 
 #### Field Configuration
 
-| Option    | Type     | Default | Description           |
-| --------- | -------- | ------- | --------------------- |
-| name      | string   | -       | Field name (required) |
-| maxCount  | number   | 10      | Max files per field   |
-| fileTypes | string[] | ['all'] | Allowed types         |
+| Option        | Type     | Default | Description           |
+| ------------- | -------- | ------- | --------------------- |
+| name          | string   | -       | Field name (required) |
+| maxCount      | number   | 10      | Max files per field   |
+| fileTypes     | string[] | ['all'] | Allowed types         |
+| fileSizeLimit | number   | 50MB    | Max file size         |
 
 ### deleteFile(filePath)
 
@@ -182,18 +215,32 @@ Deletes a file from the filesystem:
 | filePath  | string           | Path to file     |
 | Returns   | Promise<boolean> | Deletion success |
 
-### Supported File Types
+### Supported MIME Types
 
 ```javascript
-const ALLOWED_FILE_TYPES = {
-  images: ["jpeg", "jpg", "png", "gif"],
-  videos: ["mp4", "mpeg", "ogg", "webm", "avi"],
-  pdfs: ["pdf"],
+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",
+  ],
 };
 ```
 
 ## Error Handling
 
+MulterMate adds a `fileValidationError` property to the request object when validation fails:
+
 ```javascript
 app.post("/upload", uploadSingle(), (req, res) => {
   try {
@@ -229,6 +276,37 @@ app.post("/upload", uploadSingle(), (req, res) => {
 });
 ```
 
+## TypeScript Support
+
+MulterMate includes complete TypeScript definitions for all functions and options:
+
+```typescript
+// Type definitions for all options
+import {
+  UploadSingleOptions,
+  UploadMultipleOptions,
+  FieldConfig,
+} from "multermate";
+
+// Using with Express and TypeScript
+import express from "express";
+import { uploadSingle } from "multermate";
+
+const app = express();
+
+app.post(
+  "/upload",
+  uploadSingle({
+    destination: "uploads/typescript",
+    fileTypes: ["images"],
+    fileSizeLimit: 5 * 1024 * 1024,
+  }),
+  (req, res) => {
+    res.json({ success: true, file: req.file });
+  }
+);
+```
+
 ## Best Practices
 
 1. Always implement proper error handling
@@ -237,6 +315,8 @@ app.post("/upload", uploadSingle(), (req, res) => {
 4. Use custom storage destinations for different file types
 5. Implement file cleanup mechanisms
 6. Consider implementing file type verification beyond MIME types
+7. Create upload directories if they don't exist (MulterMate does this automatically)
+8. Use TypeScript types for better development experience
 
 ## License
 
@@ -248,8 +328,8 @@ Contributions are welcome! Please feel free to submit issues and pull requests.
 
 ## Author
 
-Your Name
+Wasim Zaman
 
 ## Support
 
-For support, please open an issue in the GitHub repository.
+For support, please open an issue in the GitHub repository: https://github.com/Wasim-Zaman/multermate

package/types/index.d.ts

@@ -0,0 +1,58 @@
+import { NextFunction, Request, Response } from 'express';
+export interface UploadSingleOptions {
+    destination?: string;
+    filename?: string;
+    fileTypes?: string[];
+    customMimeTypes?: string[];
+    fileSizeLimit?: number;
+    preservePath?: boolean;
+}
+export interface FieldConfig {
+    name: string;
+    maxCount?: number;
+    fileTypes?: string[];
+    fileSizeLimit?: number;
+}
+export interface UploadMultipleOptions {
+    fields: FieldConfig[];
+    destination?: string;
+    customMimeTypes?: string[];
+    fileSizeLimit?: number;
+    preservePath?: boolean;
+}
+/**
+ * Function to handle a single file upload.
+ *
+ * @param options - Configuration options for the single file upload.
+ * @returns Multer middleware configured for single file upload.
+ */
+export declare function uploadSingle(options?: UploadSingleOptions): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Function to handle multiple file uploads across multiple fields.
+ *
+ * @param options - Configuration options for multiple file uploads.
+ * @returns Multer middleware configured for multiple file uploads.
+ */
+export declare function uploadMultiple(options: UploadMultipleOptions): (req: Request, res: Response, next: NextFunction) => void;
+/**
+ * Utility function to delete a file from the filesystem
+ *
+ * @param filePath - The path to the file that needs to be deleted
+ * @returns Promise that resolves to true if deletion was successful, false otherwise
+ */
+export declare function deleteFile(filePath: string): Promise<boolean>;
+declare global {
+    namespace Express {
+        interface Request {
+            fileValidationError?: string;
+        }
+    }
+}
+export declare const ALLOWED_FILE_TYPES: string[];
+declare const _default: {
+    uploadSingle: typeof uploadSingle;
+    uploadMultiple: typeof uploadMultiple;
+    deleteFile: typeof deleteFile;
+    ALLOWED_FILE_TYPES: string[];
+};
+export default _default;