multermate 1.1.1 → 2.1.1

package/package.json

@@ -1,29 +1,34 @@
 {
   "name": "multermate",
-  "version": "1.1.1",
-  "description": "A flexible and customizable file upload utility built on top of Multer with TypeScript support",
+  "version": "2.1.1",
+  "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": {
     ".": {
-      "require": "./dist/cjs/index.js",
+      "types": "./types/index.d.ts",
       "import": "./dist/esm/index.js",
-      "types": "./types/index.d.ts"
-    }
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "dist/",
     "types/",
     "index.js",
     "index.mjs",
-    "index.d.ts"
+    "index.d.ts",
+    "LICENSE",
+    "readme.md"
   ],
   "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",
+    "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"
@@ -33,7 +38,14 @@
     "file upload",
     "middleware",
     "node.js",
-    "configurable"
+    "typescript",
+    "express",
+    "file handling",
+    "form data",
+    "multipart",
+    "configurable",
+    "file validation",
+    "error handling"
   ],
   "author": "Wasim Zaman",
   "license": "MIT",
@@ -42,9 +54,11 @@
     "uuid": "^10.0.0"
   },
   "devDependencies": {
+    "@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"
   },

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. Now with full TypeScript support!
+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, universal JavaScript compatibility, and comprehensive error handling!
 
 ## Features
 
@@ -13,9 +13,13 @@ A robust and flexible file upload utility built on top of Multer, providing adva
 - 🎨 Custom MIME type support
 - 🔄 Unique file naming with UUID
 - 🛡️ Path sanitization
-- 📝 Comprehensive error handling
-- 🔌 Works with CommonJS, ES Modules, and TypeScript
+- 📝 Comprehensive error handling with MultermateError
+- 🔌 **Universal JavaScript compatibility** (CommonJS, ES Modules, TypeScript)
 - 📘 Full TypeScript definitions and type safety
+- 🌐 **Accept ANY file type** when no restrictions are specified
+- 🎪 **Enhanced file type categories** (fonts, archives, CAD files, 3D models, etc.)
+- 🚨 **Custom error classes** for better error handling
+- 🔧 **Fixed form data processing** issues
 
 ## Installation
 
@@ -23,18 +27,30 @@ A robust and flexible file upload utility built on top of Multer, providing adva
 npm install multermate
 ```
 
-## Basic Usage
+## Universal JavaScript Compatibility
+
+MulterMate works seamlessly across all JavaScript environments:
 
 ### CommonJS
 
 ```javascript
-const { uploadSingle, uploadMultiple, deleteFile } = require("multermate");
+const {
+  uploadSingle,
+  uploadMultiple,
+  deleteFile,
+  MultermateError,
+} = require("multermate");
 ```
 
 ### ES Modules
 
 ```javascript
-import { uploadSingle, uploadMultiple, deleteFile } from "multermate";
+import {
+  uploadSingle,
+  uploadMultiple,
+  deleteFile,
+  MultermateError,
+} from "multermate";
 ```
 
 ### TypeScript
@@ -44,6 +60,7 @@ import {
   uploadSingle,
   uploadMultiple,
   deleteFile,
+  MultermateError,
   UploadSingleOptions,
   UploadMultipleOptions,
 } from "multermate";
@@ -58,15 +75,42 @@ const options: UploadSingleOptions = {
 
 ## Upload Configurations
 
+### Accept ANY File Type
+
+By default, when no `fileTypes` or `customMimeTypes` are specified, MulterMate accepts **ALL file types**:
+
+```javascript
+// Accept any file type - no restrictions!
+app.post("/upload", uploadSingle(), (req, res) => {
+  res.json({ file: req.file });
+});
+
+// Also works with destination
+app.post(
+  "/upload-any",
+  uploadSingle({
+    destination: "uploads/any-files",
+    filename: "uploaded-file",
+    // No fileTypes specified = accept all file types
+  }),
+  (req, res) => {
+    res.json({ file: req.file });
+  }
+);
+```
+
 ### Single File Upload
 
 ```javascript
 // Basic single file upload
 app.post("/upload", uploadSingle(), (req, res) => {
+  if (req.fileValidationError) {
+    return res.status(400).json({ error: req.fileValidationError });
+  }
   res.json({ file: req.file });
 });
 
-// Advanced single file upload
+// Advanced single file upload with specific file types
 app.post(
   "/upload/advanced",
   uploadSingle({
@@ -98,12 +142,11 @@ app.post(
       {
         name: "documents",
         maxCount: 5,
-        fileTypes: ["pdfs"],
+        fileTypes: ["documents", "text"],
       },
       {
-        name: "media",
+        name: "any-files", // No fileTypes = accept any file type
         maxCount: 3,
-        fileTypes: ["images", "videos"],
       },
     ],
     destination: "uploads/mixed",
@@ -115,6 +158,36 @@ app.post(
 );
 ```
 
+### Enhanced File Type Categories
+
+MulterMate now supports comprehensive file type categories:
+
+```javascript
+app.post(
+  "/upload-comprehensive",
+  uploadSingle({
+    destination: "uploads/comprehensive",
+    fileTypes: [
+      "images", // JPEG, PNG, GIF, WebP, SVG, etc.
+      "videos", // MP4, AVI, MOV, WebM, etc.
+      "audio", // MP3, WAV, FLAC, AAC, etc.
+      "documents", // PDF, DOC, DOCX, XLS, XLSX, PPT, etc.
+      "text", // TXT, CSV, HTML, CSS, JS, MD, etc.
+      "archives", // ZIP, RAR, 7Z, TAR, GZIP, etc.
+      "fonts", // WOFF, WOFF2, TTF, OTF, etc.
+      "code", // JSON, XML, JS, TS, Python, etc.
+      "spreadsheets", // Excel, CSV files
+      "presentations", // PowerPoint, etc.
+      "cad", // CAD files
+      "models", // 3D model files
+    ],
+  }),
+  (req, res) => {
+    res.json({ file: req.file });
+  }
+);
+```
+
 ### Custom MIME Types
 
 ```javascript
@@ -126,6 +199,7 @@ app.post(
       "application/vnd.ms-excel",
       "application/json",
       "text/csv",
+      "application/x-custom-type",
     ],
     fileSizeLimit: 1024 * 1024, // 1MB
   }),
@@ -135,36 +209,81 @@ app.post(
 );
 ```
 
-### File Deletion
+## Enhanced Error Handling
+
+MulterMate now includes a custom `MultermateError` class for better error handling:
 
 ```javascript
-// Simple file deletion
-app.delete("/files/:filename", async (req, res) => {
-  const isDeleted = await deleteFile(`uploads/${req.params.filename}`);
-  res.json({ success: isDeleted });
+app.post("/upload", uploadSingle(), (req, res) => {
+  // Handle validation errors
+  if (req.fileValidationError) {
+    return res.status(400).json({
+      error: req.fileValidationError,
+    });
+  }
+
+  // Handle missing files
+  if (!req.file) {
+    return res.status(400).json({
+      error: "No file uploaded",
+    });
+  }
+
+  // Success response
+  res.json({
+    success: true,
+    file: {
+      filename: req.file.filename,
+      path: req.file.path,
+      size: req.file.size,
+      mimetype: req.file.mimetype,
+    },
+  });
 });
 
-// Advanced file deletion with error handling
-app.delete("/files/:type/:filename", async (req, res) => {
-  try {
-    const filePath = path.join("uploads", req.params.type, req.params.filename);
-    const isDeleted = await deleteFile(filePath);
+// Global error handler for MultermateError
+app.use((err, req, res, next) => {
+  if (err instanceof MultermateError) {
+    return res.status(400).json({
+      success: false,
+      error: err.message,
+      code: err.code,
+      field: err.field,
+    });
+  }
 
-    if (isDeleted) {
-      res.json({
-        success: true,
-        message: "File deleted successfully",
-      });
-    } else {
-      res.status(404).json({
+  // Handle other errors
+  res.status(500).json({
+    success: false,
+    error: err.message,
+  });
+});
+```
+
+### File Deletion with Error Handling
+
+```javascript
+const { deleteFile, MultermateError } = require("multermate");
+
+app.delete("/files/:filename", async (req, res) => {
+  try {
+    await deleteFile(`uploads/${req.params.filename}`);
+    res.json({
+      success: true,
+      message: "File deleted successfully",
+    });
+  } catch (error) {
+    if (error instanceof MultermateError) {
+      return res.status(400).json({
         success: false,
-        message: "File not found or unable to delete",
+        error: error.message,
+        code: error.code,
       });
     }
-  } catch (error) {
+
     res.status(500).json({
       success: false,
-      message: error.message,
+      message: "Failed to delete file",
     });
   }
 });
@@ -176,14 +295,14 @@ app.delete("/files/:type/:filename", async (req, res) => {
 
 Configures single file upload with the following options:
 
-| Option          | Type     | Default   | Description            |
-| --------------- | -------- | --------- | ---------------------- |
-| destination     | string   | 'uploads' | Upload directory path  |
-| filename        | string   | 'file'    | Form field name        |
-| fileTypes       | string[] | ['all']   | Allowed file types     |
-| customMimeTypes | string[] | []        | Custom MIME types      |
-| fileSizeLimit   | number   | 50MB      | Max file size in bytes |
-| preservePath    | boolean  | false     | Preserve original path |
+| Option          | Type     | Default   | Description                                |
+| --------------- | -------- | --------- | ------------------------------------------ |
+| destination     | string   | 'uploads' | Upload directory path                      |
+| filename        | string   | 'file'    | Form field name                            |
+| fileTypes       | string[] | []        | Allowed file type categories (empty = all) |
+| customMimeTypes | string[] | []        | Custom MIME types                          |
+| fileSizeLimit   | number   | 50MB      | Max file size in bytes                     |
+| preservePath    | boolean  | false     | Preserve original path                     |
 
 ### uploadMultiple(options)
 
@@ -199,12 +318,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         |
-| fileSizeLimit | number   | 50MB    | Max file size         |
+| Option        | Type     | Default | Description                              |
+| ------------- | -------- | ------- | ---------------------------------------- |
+| name          | string   | -       | Field name (required)                    |
+| maxCount      | number   | 10      | Max files per field                      |
+| fileTypes     | string[] | []      | Allowed types (empty = accept all types) |
+| fileSizeLimit | number   | 50MB    | Max file size                            |
 
 ### deleteFile(filePath)
 
@@ -215,108 +334,150 @@ Deletes a file from the filesystem:
 | filePath  | string           | Path to file     |
 | Returns   | Promise<boolean> | Deletion success |
 
-### Supported MIME Types
+### MultermateError Class
+
+Custom error class for better error handling:
+
+```typescript
+class MultermateError extends Error {
+  code?: string; // Error code (e.g., 'FILE_SIZE_LIMIT_EXCEEDED')
+  field?: string; // Field name that caused the error
+  storageErrors?: string[]; // Additional storage errors
+}
+```
+
+### Supported File Type Categories
 
 ```javascript
-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: [
+const SUPPORTED_CATEGORIES = {
+  images: [
     "image/jpeg",
-    "image/jpg",
     "image/png",
     "image/gif",
-    "video/mp4",
-    "video/mpeg",
-    "video/ogg",
-    "video/webm",
-    "video/avi",
-    "application/pdf",
+    "image/webp",
+    "image/svg+xml",
+    "...",
+  ],
+  videos: ["video/mp4", "video/avi", "video/mov", "video/webm", "..."],
+  audio: ["audio/mp3", "audio/wav", "audio/flac", "audio/aac", "..."],
+  documents: ["application/pdf", "application/msword", "..."],
+  text: ["text/plain", "text/csv", "text/html", "text/markdown", "..."],
+  archives: ["application/zip", "application/x-rar-compressed", "..."],
+  fonts: ["font/woff", "font/woff2", "font/ttf", "font/otf", "..."],
+  code: ["application/json", "text/javascript", "text/x-python", "..."],
+  spreadsheets: ["application/vnd.ms-excel", "text/csv", "..."],
+  presentations: ["application/vnd.ms-powerpoint", "..."],
+  cad: ["application/dwg", "application/dxf", "..."],
+  models: ["model/obj", "model/gltf+json", "..."],
+  pdfs: ["application/pdf"], // Backward compatibility
+  all: [
+    /* All supported MIME types */
   ],
 };
 ```
 
-## Error Handling
+## What's New in v2.1.0
+
+### 🚀 Major Improvements
+
+- **Universal JavaScript Compatibility**: Works seamlessly with CommonJS, ES Modules, and TypeScript
+- **Accept ANY File Type**: When no `fileTypes` or `customMimeTypes` are specified, ALL file types are accepted
+- **Enhanced File Categories**: Added support for fonts, CAD files, 3D models, and more
+- **Custom Error Handling**: Introduced `MultermateError` class for better error management
+- **Fixed Form Data Issues**: Resolved problems with form data processing
+
+### 🔧 Technical Enhancements
+
+- Improved module exports for better compatibility
+- Enhanced MIME type detection and handling
+- Better error propagation and handling
+- Automatic directory creation
+- More robust file filtering logic
+
+### 📁 New File Type Categories
 
-MulterMate adds a `fileValidationError` property to the request object when validation fails:
+- **Fonts**: WOFF, WOFF2, TTF, OTF, EOT
+- **CAD Files**: DWG, DXF, DWF
+- **3D Models**: OBJ, GLTF, STL, PLY
+- **Enhanced Archives**: 7Z, XZ, LZ4, LZMA
+- **More Audio Formats**: OPUS, AMR, M4A
+- **Extended Video Support**: MOV, WMV, FLV, MKV
+
+## Migration from v2.0.x
+
+The API remains backward compatible, but you can now take advantage of new features:
 
 ```javascript
-app.post("/upload", uploadSingle(), (req, res) => {
-  try {
-    // File size validation
-    if (req.fileValidationError) {
-      return res.status(400).json({
-        error: req.fileValidationError,
-      });
-    }
+// Old way (still works)
+const { uploadSingle } = require("multermate");
 
-    // File existence check
-    if (!req.file) {
-      return res.status(400).json({
-        error: "No file uploaded",
-      });
-    }
+// New way with error handling
+const { uploadSingle, MultermateError } = require("multermate");
 
-    // Success response
-    res.json({
-      success: true,
-      file: {
-        filename: req.file.filename,
-        path: req.file.path,
-        size: req.file.size,
-        mimetype: req.file.mimetype,
-      },
-    });
-  } catch (error) {
-    res.status(500).json({
-      error: error.message,
-    });
-  }
+// Accept any file type (new in v2.1.0)
+app.post("/upload-any", uploadSingle(), (req, res) => {
+  // No fileTypes specified = accepts ALL file types
+  res.json({ file: req.file });
 });
 ```
 
 ## TypeScript Support
 
-MulterMate includes complete TypeScript definitions for all functions and options:
+MulterMate includes complete TypeScript definitions:
 
 ```typescript
-// Type definitions for all options
 import {
+  uploadSingle,
+  uploadMultiple,
+  deleteFile,
+  MultermateError,
   UploadSingleOptions,
   UploadMultipleOptions,
   FieldConfig,
+  MIME_TYPES,
+  ALLOWED_FILE_TYPES,
 } from "multermate";
 
-// Using with Express and TypeScript
-import express from "express";
-import { uploadSingle } from "multermate";
-
-const app = express();
+// Type-safe configuration
+const uploadOptions: UploadSingleOptions = {
+  destination: "uploads/safe",
+  fileTypes: ["images", "documents"],
+  fileSizeLimit: 10 * 1024 * 1024,
+};
 
-app.post(
-  "/upload",
-  uploadSingle({
-    destination: "uploads/typescript",
-    fileTypes: ["images"],
-    fileSizeLimit: 5 * 1024 * 1024,
-  }),
-  (req, res) => {
-    res.json({ success: true, file: req.file });
+// Error handling with types
+try {
+  await deleteFile(filePath);
+} catch (error) {
+  if (error instanceof MultermateError) {
+    console.log(`Error ${error.code}: ${error.message}`);
   }
-);
+}
 ```
 
 ## Best Practices
 
-1. Always implement proper error handling
-2. Set appropriate file size limits
-3. Validate file types on the server
-4. Use custom storage destinations for different file types
-5. Implement file cleanup mechanisms
-6. Consider implementing file type verification beyond MIME types
-7. Create upload directories if they don't exist (MulterMate does this automatically)
-8. Use TypeScript types for better development experience
+1. **Always implement error handling** with MultermateError
+2. **Set appropriate file size limits** for your use case
+3. **Use specific file type restrictions** when security is important
+4. **Leverage "accept any file type"** for general upload scenarios
+5. **Implement proper file cleanup** mechanisms
+6. **Create upload directories** beforehand (MulterMate does this automatically)
+7. **Use TypeScript types** for better development experience
+8. **Test with different JavaScript environments** (CommonJS, ESM, TypeScript)
+
+## Testing
+
+```bash
+# Install dependencies
+npm install
+
+# Build the package
+npm run build
+
+# Run basic test
+node test-improved.js
+```
 
 ## License
 

package/types/index.d.ts

@@ -1,4 +1,10 @@
 import { NextFunction, Request, Response } from 'express';
+export declare class MultermateError extends Error {
+    code?: string;
+    field?: string;
+    storageErrors?: string[];
+    constructor(message: string, code?: string, field?: string);
+}
 export interface UploadSingleOptions {
     destination?: string;
     filename?: string;
@@ -49,10 +55,13 @@ declare global {
     }
 }
 export declare const ALLOWED_FILE_TYPES: string[];
+export declare const MIME_TYPES: Record<string, string[]>;
 declare const _default: {
     uploadSingle: typeof uploadSingle;
     uploadMultiple: typeof uploadMultiple;
     deleteFile: typeof deleteFile;
+    MultermateError: typeof MultermateError;
     ALLOWED_FILE_TYPES: string[];
+    MIME_TYPES: Record<string, string[]>;
 };
 export default _default;