Where Are Uploaded Files Stored Node.js

Multer

Multer is a node.js middleware for handling multipart/grade-data, which is primarily used for uploading files. It is written on top of busboy for maximum efficiency.

Notation: Multer will not process any form which is non multipart (multipart/form-data).

Translations

This README is also bachelor in other languages:

Español (Spanish)
简体中文 (Chinese)
한국어 (Korean)
Русский язык (Russian)
Việt Nam (Vietnam)
Português (Portuguese Brazil)

Installation

          $ npm install --save multer

Usage

Multer adds a body object and a file or files object to the request object. The body object contains the values of the text fields of the form, the file or files object contains the files uploaded via the form.

Bones usage instance:

Don't forget the enctype="multipart/form-data" in your course.

          <class action="/profile" method="postal service" enctype="multipart/form-data">   <input blazon="file" name="avatar" /> </form>

          const express = require('limited') const multer  = require('multer') const upload = multer({ dest: 'uploads/' })  const app = limited()  app.post('/profile', upload.single('avatar'), office (req, res, next) {   // req.file is the `avatar` file   // req.body will hold the text fields, if there were whatsoever })  app.post('/photos/upload', upload.assortment('photos', 12), function (req, res, side by side) {   // req.files is array of `photos` files   // req.trunk will contain the text fields, if there were whatever })  const cpUpload = upload.fields([{ name: 'avatar', maxCount: one }, { name: 'gallery', maxCount: 8 }]) app.mail service('/cool-profile', cpUpload, function (req, res, next) {   // req.files is an object (String -> Assortment) where fieldname is the fundamental, and the value is array of files   //   // east.g.   //  req.files['avatar'][0] -> File   //  req.files['gallery'] -> Array   //   // req.body volition contain the text fields, if there were any })

In case yous need to handle a text-only multipart grade, you should use the .none() method:

          const express = require('express') const app = limited() const multer  = require('multer') const upload = multer()  app.postal service('/profile', upload.none(), function (req, res, next) {   // req.body contains the text fields })

Here's an example on how multer is used an HTML grade. Take special annotation of the enctype="multipart/form-data" and name="uploaded_file" fields:

          <class action="/stats" enctype="multipart/form-information" method="post">   <div class="form-group">     <input type="file" class="form-control-file" name="uploaded_file">     <input type="text" class="class-control" placeholder="Number of speakers" name="nspeakers">     <input type="submit" value="Become me the stats!" class="btn btn-default">               </div> </form>

Then in your javascript file yous would add these lines to access both the file and the body. It is important that you utilise the proper name field value from the form in your upload office. This tells multer which field on the request it should wait for the files in. If these fields aren't the same in the HTML grade and on your server, your upload will fail:

          const multer  = require('multer') const upload = multer({ dest: './public/information/uploads/' }) app.post('/stats', upload.single('uploaded_file'), role (req, res) {    // req.file is the name of your file in the grade above, here 'uploaded_file'    // req.body will agree the text fields, if there were whatever     console.log(req.file, req.body) });

API

File information

Each file contains the following information:

Cardinal	Description	Notation
`fieldname`	Field name specified in the form
`originalname`	Name of the file on the user's computer
`encoding`	Encoding type of the file
`mimetype`	Mime type of the file
`size`	Size of the file in bytes
`destination`	The folder to which the file has been saved	`DiskStorage`
`filename`	The name of the file within the `destination`	`DiskStorage`
`path`	The full path to the uploaded file	`DiskStorage`
`buffer`	A `Buffer` of the entire file	`MemoryStorage`

`multer(opts)`

Multer accepts an options object, the most bones of which is the dest property, which tells Multer where to upload the files. In instance you lot omit the options object, the files volition be kept in memory and never written to disk.

By default, Multer will rename the files so equally to avert naming conflicts. The renaming function can be customized according to your needs.

The following are the options that tin exist passed to Multer.

Key	Description
`dest` or `storage`	Where to store the files
`fileFilter`	Function to control which files are accepted
`limits`	Limits of the uploaded data
`preservePath`	Continue the full path of files instead of simply the base name

In an average web app, but dest might be required, and configured as shown in the following example.

          const upload = multer({ dest: 'uploads/' })

If you want more control over your uploads, you'll desire to utilize the storage option instead of dest. Multer ships with storage engines DiskStorage and MemoryStorage; More engines are available from third parties.

`.single(fieldname)`

Accept a unmarried file with the name fieldname. The unmarried file will exist stored in req.file.

`.array(fieldname[, maxCount])`

Take an array of files, all with the name fieldname. Optionally error out if more than than maxCount files are uploaded. The assortment of files will be stored in req.files.

`.fields(fields)`

Accept a mix of files, specified by fields. An object with arrays of files will be stored in req.files.

fields should be an array of objects with name and optionally a maxCount. Instance:

          [   { name: 'avatar', maxCount: 1 },   { name: 'gallery', maxCount: 8 } ]

`.none()`

Have only text fields. If any file upload is fabricated, error with code "LIMIT_UNEXPECTED_FILE" will be issued.

`.any()`

Accepts all files that comes over the wire. An array of files volition be stored in req.files.

WARNING: Make sure that y'all always handle the files that a user uploads. Never add multer every bit a global middleware since a malicious user could upload files to a road that you didn't anticipate. Only use this function on routes where you are handling the uploaded files.

`storage`

`DiskStorage`

The disk storage engine gives y'all full control on storing files to disk.

          const storage = multer.diskStorage({   destination: role (req, file, cb) {     cb(null, '/tmp/my-uploads')   },   filename: function (req, file, cb) {     const uniqueSuffix = Date.at present() + '-' + Math.round(Math.random() * 1E9)     cb(null, file.fieldname + '-' + uniqueSuffix)   } })  const upload = multer({ storage: storage })

There are two options available, destination and filename. They are both functions that determine where the file should be stored.

destination is used to determine within which folder the uploaded files should exist stored. This can also be given equally a string (e.g. '/tmp/uploads'). If no destination is given, the operating arrangement'south default directory for temporary files is used.

Note: You are responsible for creating the directory when providing destination as a role. When passing a string, multer will make certain that the directory is created for you.

filename is used to determine what the file should be named within the binder. If no filename is given, each file will be given a random name that doesn't include any file extension.

Note: Multer volition not append any file extension for you, your part should return a filename complete with an file extension.

Each part gets passed both the request (req) and some information about the file (file) to help with the decision.

Note that req.body might not have been fully populated yet. Information technology depends on the order that the customer transmits fields and files to the server.

For understanding the calling convention used in the callback (needing to pass null every bit the offset param), refer to Node.js mistake handling

`MemoryStorage`

The retention storage engine stores the files in memory as Buffer objects. It doesn't accept any options.

          const storage = multer.memoryStorage() const upload = multer({ storage: storage })

When using memory storage, the file info will incorporate a field chosen buffer that contains the unabridged file.

Alert: Uploading very big files, or relatively modest files in large numbers very quickly, tin crusade your application to run out of memory when retentiveness storage is used.

`limits`

An object specifying the size limits of the following optional properties. Multer passes this object into busboy directly, and the details of the properties can exist found on busboy'south page.

The following integer values are available:

Primal	Description	Default
`fieldNameSize`	Max field name size	100 bytes
`fieldSize`	Max field value size (in bytes)	1MB
`fields`	Max number of non-file fields	Infinity
`fileSize`	For multipart forms, the max file size (in bytes)	Infinity
`files`	For multipart forms, the max number of file fields	Infinity
`parts`	For multipart forms, the max number of parts (fields + files)	Infinity
`headerPairs`	For multipart forms, the max number of header key=>value pairs to parse	2000

Specifying the limits tin help protect your site confronting denial of service (DoS) attacks.

`fileFilter`

Set this to a function to command which files should be uploaded and which should be skipped. The function should await like this:

          function fileFilter (req, file, cb) {    // The function should call `cb` with a boolean   // to point if the file should be accepted    // To reject this file pass `imitation`, like then:   cb(aught, fake)    // To accept the file laissez passer `truthful`, like so:   cb(null, true)    // You tin can always pass an fault if something goes incorrect:   cb(new Error('I don\'t have a clue!'))  }

Fault handling

When encountering an error, Multer will delegate the error to Limited. You tin can display a dainty error folio using the standard limited way.

If you want to grab errors specifically from Multer, you lot tin call the middleware function by yourself. As well, if you lot want to catch only the Multer errors, you can use the MulterError course that is attached to the multer object itself (eastward.g. err instanceof multer.MulterError).

          const multer = crave('multer') const upload = multer().single('avatar')  app.mail('/profile', function (req, res) {   upload(req, res, office (err) {     if (err instanceof multer.MulterError) {       // A Multer mistake occurred when uploading.     } else if (err) {       // An unknown mistake occurred when uploading.     }      // Everything went fine.   }) })

Custom storage engine

For information on how to build your own storage engine, see Multer Storage Engine.

License

MIT