multermate 1.1.0 → 2.1.0

package/dist/esm/index.js

@@ -0,0 +1,442 @@
+import fs from 'fs/promises';
+import multer from 'multer';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+// Custom error class for MulterMate
+export class MultermateError extends Error {
+    constructor(message, code, field) {
+        super(message);
+        this.name = 'MultermateError';
+        this.code = code;
+        this.field = field;
+        // Maintains proper stack trace for where our error was thrown (only available on V8)
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, MultermateError);
+        }
+    }
+}
+// Define allowed MIME types - comprehensive list including all common file types
+const ALLOWED_MIME_TYPES = {
+    // Images (all common image formats)
+    images: [
+        "image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp",
+        "image/svg+xml", "image/bmp", "image/tiff", "image/ico", "image/avif",
+        "image/heic", "image/heif", "image/x-icon", "image/vnd.microsoft.icon"
+    ],
+    // Videos (all common video formats)
+    videos: [
+        "video/mp4", "video/mpeg", "video/ogg", "video/webm", "video/avi",
+        "video/mov", "video/wmv", "video/flv", "video/mkv", "video/m4v", "video/3gp",
+        "video/quicktime", "video/x-msvideo", "video/x-ms-wmv", "video/x-flv"
+    ],
+    // Audio (all common audio formats)
+    audio: [
+        "audio/mpeg", "audio/wav", "audio/ogg", "audio/aac", "audio/flac",
+        "audio/m4a", "audio/wma", "audio/mp3", "audio/webm", "audio/x-wav",
+        "audio/x-m4a", "audio/x-aac", "audio/opus", "audio/amr"
+    ],
+    // Documents (all common document formats)
+    documents: [
+        "application/pdf", "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "application/rtf", "application/vnd.oasis.opendocument.text",
+        "application/vnd.oasis.opendocument.spreadsheet", "application/vnd.oasis.opendocument.presentation",
+        "application/vnd.apple.pages", "application/vnd.apple.numbers", "application/vnd.apple.keynote"
+    ],
+    // Text files (all common text formats)
+    text: [
+        "text/plain", "text/csv", "text/html", "text/css", "text/javascript",
+        "text/xml", "text/markdown", "text/x-python", "text/x-java-source",
+        "text/x-c", "text/x-c++", "text/x-php", "text/x-ruby", "text/x-go",
+        "text/x-rust", "text/x-typescript", "text/x-swift", "text/x-kotlin",
+        "text/x-scala", "text/x-perl", "text/x-shell", "text/x-sh", "text/x-bash",
+        "text/x-yaml", "text/yaml", "text/x-toml", "text/x-ini", "text/x-log"
+    ],
+    // Archives (all common archive formats)
+    archives: [
+        "application/zip", "application/x-rar-compressed", "application/x-tar",
+        "application/gzip", "application/x-7z-compressed", "application/x-bzip2",
+        "application/x-xz", "application/x-compress", "application/x-lz4",
+        "application/x-lzma", "application/vnd.rar"
+    ],
+    // Code files (programming language files)
+    code: [
+        "application/json", "application/xml", "application/javascript",
+        "application/typescript", "text/x-python", "text/x-java-source",
+        "text/x-c", "text/x-c++", "text/x-php", "text/x-ruby", "text/x-go",
+        "text/x-rust", "text/x-swift", "text/x-kotlin", "text/x-scala",
+        "text/x-csharp", "text/x-vb", "text/x-sql", "application/sql"
+    ],
+    // Spreadsheets (separate category)
+    spreadsheets: [
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "text/csv", "application/csv"
+    ],
+    // Presentations (separate category)
+    presentations: [
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "application/vnd.oasis.opendocument.presentation"
+    ],
+    // Fonts (font files)
+    fonts: [
+        "font/woff", "font/woff2", "font/ttf", "font/otf", "font/eot",
+        "application/font-woff", "application/font-woff2", "application/x-font-ttf",
+        "application/x-font-otf", "application/vnd.ms-fontobject"
+    ],
+    // CAD files
+    cad: [
+        "application/dwg", "application/dxf", "model/vnd.dwf",
+        "application/acad", "image/vnd.dwg"
+    ],
+    // 3D models
+    models: [
+        "model/obj", "model/gltf+json", "model/gltf-binary", "model/x3d+xml",
+        "model/stl", "model/ply", "application/x-blender"
+    ],
+    // PDFs (separate category for backward compatibility)
+    pdfs: ["application/pdf"],
+    // All allowed types - comprehensive list (this is for backward compatibility)
+    all: [
+        // Images
+        "image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp",
+        "image/svg+xml", "image/bmp", "image/tiff", "image/ico", "image/avif",
+        "image/heic", "image/heif", "image/x-icon", "image/vnd.microsoft.icon",
+        // Videos
+        "video/mp4", "video/mpeg", "video/ogg", "video/webm", "video/avi",
+        "video/mov", "video/wmv", "video/flv", "video/mkv", "video/m4v", "video/3gp",
+        "video/quicktime", "video/x-msvideo", "video/x-ms-wmv", "video/x-flv",
+        // Audio
+        "audio/mpeg", "audio/wav", "audio/ogg", "audio/aac", "audio/flac",
+        "audio/m4a", "audio/wma", "audio/mp3", "audio/webm", "audio/x-wav",
+        "audio/x-m4a", "audio/x-aac", "audio/opus", "audio/amr",
+        // Documents
+        "application/pdf", "application/msword",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "application/vnd.ms-excel",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        "application/vnd.ms-powerpoint",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        "application/rtf", "application/vnd.oasis.opendocument.text",
+        "application/vnd.oasis.opendocument.spreadsheet", "application/vnd.oasis.opendocument.presentation",
+        "application/vnd.apple.pages", "application/vnd.apple.numbers", "application/vnd.apple.keynote",
+        // Text files
+        "text/plain", "text/csv", "text/html", "text/css", "text/javascript",
+        "text/xml", "text/markdown", "text/x-python", "text/x-java-source",
+        "text/x-c", "text/x-c++", "text/x-php", "text/x-ruby", "text/x-go",
+        "text/x-rust", "text/x-typescript", "text/x-swift", "text/x-kotlin",
+        "text/x-scala", "text/x-perl", "text/x-shell", "text/x-sh", "text/x-bash",
+        "text/x-yaml", "text/yaml", "text/x-toml", "text/x-ini", "text/x-log",
+        // Archives
+        "application/zip", "application/x-rar-compressed", "application/x-tar",
+        "application/gzip", "application/x-7z-compressed", "application/x-bzip2",
+        "application/x-xz", "application/x-compress", "application/x-lz4",
+        "application/x-lzma", "application/vnd.rar",
+        // Code/Data
+        "application/json", "application/xml", "application/javascript",
+        "application/typescript", "text/x-csharp", "text/x-vb", "text/x-sql", "application/sql",
+        // Fonts
+        "font/woff", "font/woff2", "font/ttf", "font/otf", "font/eot",
+        "application/font-woff", "application/font-woff2", "application/x-font-ttf",
+        "application/x-font-otf", "application/vnd.ms-fontobject"
+    ],
+};
+/**
+ * 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) => {
+            const dir = destination || "uploads";
+            // Create directory synchronously to avoid callback issues
+            try {
+                require('fs').mkdirSync(dir, { recursive: true });
+                cb(null, dir);
+            }
+            catch (error) {
+                // Directory might already exist, that's okay
+                if (error.code === 'EEXIST') {
+                    cb(null, dir);
+                }
+                else {
+                    cb(new MultermateError(`Failed to create destination directory: ${dir}`, 'DESTINATION_ERROR'), '');
+                }
+            }
+        },
+        filename: (_req, file, cb) => {
+            try {
+                const sanitizedFilename = file.originalname.replace(/\\/g, "/");
+                const extension = path.extname(sanitizedFilename);
+                const fieldName = file.fieldname || "file";
+                const uniqueName = uuidv4();
+                let fileName = `${uniqueName}-${fieldName}${extension}`;
+                // Replace backslashes with forward slashes in the final filename
+                fileName = fileName.replace(/\\/g, "/");
+                cb(null, fileName);
+            }
+            catch (error) {
+                cb(new MultermateError('Failed to generate filename', 'FILENAME_ERROR'), '');
+            }
+        },
+    });
+};
+/**
+ * Function to configure file filter for Multer.
+ *
+ * @param allowedMimeTypes - Array of allowed MIME types. Empty array means allow all file types.
+ * @returns File filter function for Multer.
+ */
+const configureFileFilter = (allowedMimeTypes) => {
+    return (_req, file, cb) => {
+        try {
+            // If no specific file types are restricted, allow ALL file types
+            if (allowedMimeTypes.length === 0) {
+                cb(null, true);
+                return;
+            }
+            // Check if the file's MIME type is in the allowed list
+            if (allowedMimeTypes.includes(file.mimetype)) {
+                cb(null, true);
+            }
+            else {
+                const error = new MultermateError(`Invalid file type: ${file.mimetype}. Allowed types: ${allowedMimeTypes.join(', ')}`, 'INVALID_FILE_TYPE', file.fieldname);
+                cb(error);
+            }
+        }
+        catch (error) {
+            cb(new MultermateError('File filter error', 'FILTER_ERROR'));
+        }
+    };
+};
+/**
+ * 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, }) => {
+    try {
+        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 if (fileTypes.length > 0) {
+            // Use default MIME types for specified fileTypes
+            fileTypes.forEach((type) => {
+                if (ALLOWED_MIME_TYPES[type]) {
+                    allowedMimeTypes = allowedMimeTypes.concat(ALLOWED_MIME_TYPES[type]);
+                }
+            });
+        }
+        // If neither customMimeTypes nor fileTypes are provided, allowedMimeTypes remains empty
+        // This means ALL file types are allowed (no restrictions)
+        // Remove duplicates
+        allowedMimeTypes = [...new Set(allowedMimeTypes)];
+        const fileFilter = configureFileFilter(allowedMimeTypes);
+        return multer({
+            storage,
+            fileFilter,
+            limits: { fileSize: fileSizeLimit || 1024 * 1024 * 50 }, // Default 50MB file size limit
+            preservePath,
+        });
+    }
+    catch (error) {
+        throw new MultermateError('Failed to configure multer', 'CONFIGURATION_ERROR');
+    }
+};
+/**
+ * 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 = {}) {
+    try {
+        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
+            try {
+                require('fs').mkdirSync(destination, { recursive: true });
+            }
+            catch (error) {
+                // Directory might already exist, ignore error
+            }
+            middleware(req, res, (err) => {
+                if (err) {
+                    let errorMessage = 'Unknown upload error';
+                    let errorCode = 'UPLOAD_ERROR';
+                    if (err instanceof MultermateError) {
+                        // Our custom error
+                        req.fileValidationError = err.message;
+                        return next(err);
+                    }
+                    else if (err.code === 'LIMIT_FILE_SIZE') {
+                        errorMessage = `File size limit exceeded. Maximum allowed size: ${options.fileSizeLimit || '50MB'}`;
+                        errorCode = 'FILE_SIZE_LIMIT_EXCEEDED';
+                    }
+                    else if (err.code === 'INVALID_FILE_TYPE') {
+                        errorMessage = 'Invalid file type. Please check allowed file types.';
+                        errorCode = 'INVALID_FILE_TYPE';
+                    }
+                    else if (err.code === 'LIMIT_UNEXPECTED_FILE') {
+                        errorMessage = 'Unexpected field';
+                        errorCode = 'UNEXPECTED_FIELD';
+                    }
+                    else {
+                        errorMessage = err.message || 'Upload failed';
+                    }
+                    const multermateError = new MultermateError(errorMessage, errorCode);
+                    req.fileValidationError = errorMessage;
+                    return next(multermateError);
+                }
+                next();
+            });
+        };
+    }
+    catch (error) {
+        throw new MultermateError('Failed to create upload middleware', 'MIDDLEWARE_CREATION_ERROR');
+    }
+}
+/**
+ * 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) {
+    try {
+        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.
+        }));
+        // Collect all allowed file types from fields
+        let allowedFileTypes = [];
+        if (options.customMimeTypes && options.customMimeTypes.length > 0) {
+            // Use custom MIME types if provided at the global level
+            allowedFileTypes = options.customMimeTypes;
+        }
+        else {
+            // Collect file types from individual fields
+            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: allowedFileTypes.length > 0 ? allowedFileTypes : [],
+            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
+            try {
+                require('fs').mkdirSync(destination, { recursive: true });
+            }
+            catch (error) {
+                // Directory might already exist, ignore error
+            }
+            middleware(req, res, (err) => {
+                if (err) {
+                    let errorMessage = 'Unknown upload error';
+                    let errorCode = 'UPLOAD_ERROR';
+                    if (err instanceof MultermateError) {
+                        // Our custom error
+                        req.fileValidationError = err.message;
+                        return next(err);
+                    }
+                    else if (err.code === 'LIMIT_FILE_SIZE') {
+                        errorMessage = `File size limit exceeded. Maximum allowed size: ${options.fileSizeLimit || '50MB'}`;
+                        errorCode = 'FILE_SIZE_LIMIT_EXCEEDED';
+                    }
+                    else if (err.code === 'INVALID_FILE_TYPE') {
+                        errorMessage = 'Invalid file type. Please check allowed file types.';
+                        errorCode = 'INVALID_FILE_TYPE';
+                    }
+                    else if (err.code === 'LIMIT_UNEXPECTED_FILE') {
+                        errorMessage = 'Unexpected field';
+                        errorCode = 'UNEXPECTED_FIELD';
+                    }
+                    else if (err.code === 'LIMIT_FILE_COUNT') {
+                        errorMessage = 'Too many files';
+                        errorCode = 'FILE_COUNT_LIMIT_EXCEEDED';
+                    }
+                    else {
+                        errorMessage = err.message || 'Upload failed';
+                    }
+                    const multermateError = new MultermateError(errorMessage, errorCode);
+                    req.fileValidationError = errorMessage;
+                    return next(multermateError);
+                }
+                next();
+            });
+        };
+    }
+    catch (error) {
+        throw new MultermateError('Failed to create multiple upload middleware', 'MIDDLEWARE_CREATION_ERROR');
+    }
+}
+/**
+ * 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 {
+        if (!filePath || typeof filePath !== 'string') {
+            throw new MultermateError('Invalid file path provided', 'INVALID_PATH');
+        }
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof MultermateError) {
+            throw error;
+        }
+        if (error.code === 'ENOENT') {
+            throw new MultermateError(`File not found: ${filePath}`, 'FILE_NOT_FOUND');
+        }
+        else if (error.code === 'EACCES') {
+            throw new MultermateError(`Permission denied: ${filePath}`, 'PERMISSION_DENIED');
+        }
+        else {
+            throw new MultermateError(`Failed to delete file: ${error.message}`, 'DELETE_ERROR');
+        }
+    }
+}
+// Export the allowed file types for reference
+export const ALLOWED_FILE_TYPES = Object.keys(ALLOWED_MIME_TYPES);
+// Export MIME types for external use
+export const MIME_TYPES = ALLOWED_MIME_TYPES;
+// Export your functions
+export default {
+    uploadSingle,
+    uploadMultiple,
+    deleteFile,
+    MultermateError,
+    ALLOWED_FILE_TYPES,
+    MIME_TYPES
+};

package/dist/esm/package.json

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

package/index.d.ts

@@ -0,0 +1,6 @@
+// Main type definitions - re-export everything from types directory
+export * from './types/index';
+
+// Default export for CommonJS compatibility
+import multermateDefault from './types/index';
+export default multermateDefault;

package/index.js

@@ -0,0 +1,9 @@
+// CommonJS entry point
+try {
+  module.exports = require("./dist/cjs/index.js");
+} catch (error) {
+  // Fallback if dist is not built yet
+  throw new Error(
+    'MulterMate: Please run "npm run build" to build the package before using it.'
+  );
+}

package/index.mjs

@@ -0,0 +1,6 @@
+// ES Module entry point
+export * from "./dist/esm/index.js";
+
+// Default export for better compatibility
+import multermateDefault from "./dist/esm/index.js";
+export default multermateDefault;

package/package.json

@@ -1,23 +1,73 @@
 {
   "name": "multermate",
-  "version": "1.1.0",
-  "description": "A flexible and customizable npm package for configuring Multer",
-  "main": "./dist/index.cjs.js",
-  "module": "./dist/index.mjs",
+  "version": "2.1.0",
+  "description": "A powerful and flexible file upload utility built on top of Multer with TypeScript support, comprehensive file type handling, custom error classes, and universal JavaScript module compatibility",
+  "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/",
+    "types/",
+    "index.js",
+    "index.mjs",
+    "index.d.ts",
+    "LICENSE",
+    "readme.md"
+  ],
   "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",
+    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types && npm run build:entries",
+    "build:cjs": "tsc --module commonjs --outDir dist/cjs --target ES2018",
+    "build:esm": "tsc --module ES2020 --outDir dist/esm --target ES2020 && echo '{\"type\": \"module\"}' > dist/esm/package.json",
+    "build:types": "tsc --emitDeclarationOnly --outDir types",
+    "build:entries": "node -e \"console.log('Build entries completed')\"",
+    "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": [
+    "multer",
+    "file upload",
+    "middleware",
+    "node.js",
+    "typescript",
+    "express",
+    "file handling",
+    "form data",
+    "multipart",
+    "configurable",
+    "file validation",
+    "error handling"
+  ],
+  "author": "Wasim Zaman",
+  "license": "MIT",
   "dependencies": {
     "multer": "1.4.5-lts.1",
     "uuid": "^10.0.0"
   },
   "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"
-  }
+    "@types/express": "^5.0.3",
+    "@types/multer": "^1.4.11",
+    "@types/node": "^20.10.5",
+    "@types/uuid": "^9.0.7",
+    "express": "^5.1.0",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3"
+  },
+  "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"
 }