# multer

***

**1. Single File Upload**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });

app.post('/upload', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**2. Multiple File Upload**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });

app.post('/upload-multiple', upload.array('files'), (req, res) => {
  res.send(`Files uploaded successfully: ${req.files.map(f => f.filename)}`);
});
```

**3. File Size Limit**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage, limits: { fileSize: 1000000 } }); // 1MB

app.post('/upload-limit', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**4. File Type Filter**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const fileFilter = (req, file, cb) => {
  if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png') {
    cb(null, true);
  } else {
    cb(new Error('Only JPEG and PNG files are allowed!'), false);
  }
};
const upload = multer({ storage, fileFilter });

app.post('/upload-filter', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**5. Rename Filename**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const fileFilter = (req, file, cb) => { cb(null, true); };
const filename = (req, file, cb) => { cb(null, Date.now() + '-' + file.originalname); };
const upload = multer({ storage, fileFilter, filename });

app.post('/upload-rename', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**6. Use In-Memory Storage**

```js
const multer = require('multer');
const upload = multer({ storage: multer.memoryStorage() });

app.post('/upload-memory', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.buffer.toString()}`);
});
```

**7. Custom Destination Function**

```js
const multer = require('multer');
const storage = multer.diskStorage({
  destination: (req, file, cb) => { cb(null, './uploads/' + req.query.folder); },
});
const upload = multer({ storage });

app.post('/upload-custom-destination', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**8. Progress Events**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });

app.post('/upload-progress', upload.single('file'), (req, res, next) => {
  req.on('progress', (progress) => {
    console.log(`Progress: ${progress.total}`);
  });
});
```

**9. Multer With Express Middleware**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });

app.use('/upload', express.static('./uploads'));
app.post('/upload', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**10. Multer With Node.js API**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });
const fs = require('fs');

app.post('/upload-api', upload.single('file'), (req, res) => {
  const file = fs.readFileSync(req.file.path);
  res.send(`File data: ${file.toString()}`);
});
```

**11. Multer With File Analyzer**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });
const fileAnalyzer = require('file-analyzer');

app.post('/upload-analyze', upload.single('file'), async (req, res) => {
  const file = await fileAnalyzer.analyzeFile(req.file.path);
  res.send(`File analysis: ${JSON.stringify(file)}`);
});
```

**12. Multer With Database Storage**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });
const mongo = require('mongodb');

app.post('/upload-mongo', upload.single('file'), async (req, res) => {
  const client = await mongo.connect('mongodb://localhost:27017');
  const db = client.db('uploads');
  const filesCollection = db.collection('files');
  const fileInfo = {
    filename: req.file.filename,
    data: fs.readFileSync(req.file.path),
  };
  await filesCollection.insertOne(fileInfo);
  client.close();
  res.send(`File uploaded to MongoDB: ${req.file.filename}`);
});
```

**13. Multer With Cloud Storage**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });
const gcs = require('@google-cloud/storage');
const storageClient = new gcs.Storage();

app.post('/upload-gcs', upload.single('file'), async (req, res) => {
  const bucketName = 'my-bucket';
  const fileName = req.file.filename;
  const gcsFile = storageClient.bucket(bucketName).file(fileName);
  const fileData = fs.readFileSync(req.file.path);
  await gcsFile.save(fileData);
  res.send(`File uploaded to GCS: ${fileName}`);
});
```

**14. Multer With File Validation**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const fileFilter = (req, file, cb) => {
  const allowedMimeTypes = ['image/jpeg', 'image/png', 'application/pdf'];
  if (allowedMimeTypes.includes(file.mimetype)) {
    cb(null, true);
  } else {
    cb(new Error('Only JPEG, PNG, and PDF files are allowed!'), false);
  }
};
const upload = multer({ storage, fileFilter });

app.post('/upload-validate', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**15. Multer With File Size Limits**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const limits = { fileSize: 1000000 }; // 1MB
const upload = multer({ storage, limits });

app.post('/upload-limit-size', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**16. Multer With Custom File Name**

```js
const multer = require('multer');
const storage = multer.diskStorage({
  destination: './uploads/',
  filename: (req, file, cb) => {
    const fileName = Date.now() + '-' + file.originalname;
    cb(null, fileName);
  },
});
const upload = multer({ storage });

app.post('/upload-custom-name', upload.single('file'), (req, res) => {
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**17. Multer With Multiple File Upload**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });

app.post('/upload-multiple', upload.array('files'), (req, res) => {
  res.send(`Files uploaded successfully: ${req.files.map(f => f.filename)}`);
});
```

**18. Multer With Error Handling**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });

app.post('/upload', upload.single('file'), (req, res, err) => {
  if (err) {
    res.status(500).send(err.message);
  } else {
    res.send(`File uploaded successfully: ${req.file.filename}`);
  }
});
```

**19. Multer With File Preview**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });
const fs = require('fs');
const sharp = require('sharp');

app.post('/upload', upload.single('file'), async (req, res) => {
  const thumbnail = await sharp(req.file.path).resize(200, 200).toBuffer();
  fs.writeFileSync('./uploads/thumbnail-' + req.file.filename, thumbnail);
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**20. Multer With File Conversion**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const ffmpeg = require('ffmpeg');

app.post('/upload', multer({ storage }).single('file'), async (req, res) => {
  if (req.file.mimetype === 'video/mp4') {
    const converted = ffmpeg(req.file.path).output('./uploads/converted-' + req.file.filename + '.gif');
    await converted.run();
  }
  res.send(`File uploaded successfully: ${req.file.filename}`);
});
```

**21. Multer With File Encryption**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const crypto = require('crypto');

const key = 'my-secret-key';
const iv = 'my-initialization-vector';

const encrypt = (data) => {
  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
  return cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
};

app.post('/upload', multer({ storage }).single('file'), async (req, res) => {
  const encrypted = encrypt(fs.readFileSync(req.file.path, 'utf8'));
  fs.writeFileSync('./uploads/encrypted-' + req.file.filename, encrypted);
  res.send(`File uploaded and encrypted: ${req.file.filename}`);
});
```

**22. Multer With File Compression**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const zlib = require('zlib');

app.post('/upload', multer({ storage }).single('file'), async (req, res) => {
  if (req.file.mimetype === 'image/png') {
    const compressed = await zlib.deflate(fs.readFileSync(req.file.path));
    fs.writeFileSync('./uploads/compressed-' + req.file.filename, compressed);
  }
  res.send(`File uploaded and compressed: ${req.file.filename}`);
});
```

**23. Multer With File Verification**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const crypto = require('crypto');

const verify = (file) => {
  const hash = crypto.createHash('sha256');
  const checksum = hash.update(fs.readFileSync(file.path)).digest('hex');
  return checksum === file.checksum;
};

app.post('/upload', multer({ storage, limits: { fileSize: 1000000 }, verify }).single('file'), (req, res) => {
  res.send(`File uploaded and verified: ${req.file.filename}`);
});
```

**24. Multer With File Metadata**

```js
const multer = require('multer');
const storage = multer.diskStorage({ destination: './uploads/' });
const path = require('path');

app.post('/upload', multer({ storage }).single('file'), (req, res) => {
  const file = req.file;
  const metadata = {
    size: file.size,
    mimetype: file.mimetype,
    filename: file.filename,
    extension: path.extname(file.filename),
  };
  res.send(`File uploaded with metadata: ${metadata}`);
});
```

**25. Multer With Cloudinary Integration**

```js
const multer = require('multer');
const cloudinary = require('cloudinary');

cloudinary.config({
  cloud_name: 'my-cloud-name',
  api_key: 'my-api-key',
  api_secret: 'my-api-secret',
});

const storage = multer.diskStorage({ destination: './uploads/' });
const upload = multer({ storage });

app.post('/upload-cloudinary', upload.single('file'), async (req, res) => {
  const result = await cloudinary.v2.uploader.upload(req.file.path);
  res.send(`File uploaded to Cloudinary: ${result.secure_url}`);
});
```