multermate 1.1.1 → 2.1.0

package/dist/esm/index.js

@@ -2,22 +2,148 @@ import fs from 'fs/promises';
 import multer from 'multer';
 import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
-// Define allowed MIME types
+// 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: ["image/jpeg", "image/jpg", "image/png", "image/gif"],
-    videos: ["video/mp4", "video/mpeg", "video/ogg", "video/webm", "video/avi"],
+    // 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: [
-        "image/jpeg",
-        "image/jpg",
-        "image/png",
-        "image/gif",
-        "video/mp4",
-        "video/mpeg",
-        "video/ogg",
-        "video/webm",
-        "video/avi",
-        "application/pdf",
+        // 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"
     ],
 };
 /**
@@ -28,36 +154,65 @@ const ALLOWED_MIME_TYPES = {
  */
 const configureStorage = (destination) => {
     return multer.diskStorage({
-        destination: (_req, _file, cb) => {
-            cb(null, destination || "uploads"); // Default folder is "uploads" if none is provided.
+        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) => {
-            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.
+            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.
+ * @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) => {
-        if (allowedMimeTypes.includes(file.mimetype)) {
-            cb(null, true); // Allow the file if its MIME type is allowed.
+        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);
+            }
         }
-        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.
+        catch (error) {
+            cb(new MultermateError('File filter error', 'FILTER_ERROR'));
         }
     };
 };
@@ -68,32 +223,37 @@ const configureFileFilter = (allowedMimeTypes) => {
  * @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;
+    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');
     }
-    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.
@@ -102,28 +262,53 @@ const configureMulter = ({ destination, filename, fileTypes = [], customMimeType
  * @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;
-                }
+    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 });
             }
-            next();
-        });
-    };
+            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.
@@ -132,48 +317,86 @@ export function uploadSingle(options = {}) {
  * @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]);
+    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 });
             }
-        });
-    });
-    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;
-                }
+            catch (error) {
+                // Directory might already exist, ignore error
             }
-            next();
-        });
-    };
+            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
@@ -183,20 +406,37 @@ export function uploadMultiple(options) {
  */
 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) {
-        console.error(`Error deleting file: ${error.message}`);
-        return false;
+        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,
-    ALLOWED_FILE_TYPES
+    MultermateError,
+    ALLOWED_FILE_TYPES,
+    MIME_TYPES
 };

package/index.d.ts

@@ -1 +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

@@ -1,2 +1,9 @@
 // CommonJS entry point
-module.exports = require("./dist/cjs/index");
+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

@@ -1,15 +1,6 @@
 // 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;
+// Default export for better compatibility
+import multermateDefault from "./dist/esm/index.js";
+export default multermateDefault;