fix: file size limit (#198)

* fix: add error option for throwing file size limit reached

* chore: update typings

* docs: handle file size limit

* docs: add missing options

* feat: throwFileSizeLimit default to true

* chore: update package command

- use glob provided by tap to prevent different behavior based on enviornment
- increase test coverage target to 90

* feat: remove req.multipartIterator

* test: fix test command

- single quote is not available in windows

* refactor: remove duplicate code

Author: climba03003

README.md

@@ -179,11 +179,14 @@ fastify.post('/upload/files', async function (req, reply) {
 
 ## Handle file size limitation
 
-If you set a `fileSize` limit `req.saveRequestFiles()` is able to throw an `RequestFileTooLargeError` error.
+If you set a `fileSize` limit, it is able to throw an `RequestFileTooLargeError` error when limit reached.
 
 ```js
 fastify.post('/upload/files', async function (req, reply) {
   try {
+    //const file = await req.file({ limits: { fileSize: 17000 } })
+    //const files = await req.files({ limits: { fileSize: 17000 } })
+    //const parts = await req.parts({ limits: { fileSize: 17000 } })
     const files = await req.saveRequestFiles({ limits: { fileSize: 17000 } })
     reply.send()
   } catch (error) {
@@ -192,6 +195,22 @@ fastify.post('/upload/files', async function (req, reply) {
 })
 ```
 
+If you want to fallback to the handling before `4.0.0`, you can disable the throwing behavior by passing `throwFileSizeLimit`.
+Note: It will not affect the behavior of `saveRequestFiles()`
+
+```js
+// globally disable
+fastify.register(fastifyMultipart, { throwFileSizeLimit: false })
+
+fastify.post('/upload/file', async function (req, reply) {
+  const file = await req.file({ throwFileSizeLimit: false, limits: { fileSize: 17000 } })
+  //const files = await req.files({ throwFileSizeLimit: false, limits: { fileSize: 17000 } })
+  //const parts = await req.parts({ throwFileSizeLimit: false, limits: { fileSize: 17000 } })
+  //const files = await req.saveRequestFiles({ throwFileSizeLimit: false, limits: { fileSize: 17000 } })
+  reply.send()
+})
+```
+
 ## Parse all fields and assign them to the body
 
 This allows you to parse all fields automatically and assign them to the `request.body`. By default files are accumulated in memory (Be careful!) to buffer objects. Uncaught errors are [handled](https://github.com/fastify/fastify/blob/master/docs/Hooks.md#manage-errors-from-a-hook) by fastify.

index.d.ts

@@ -92,6 +92,11 @@ export interface FastifyMultipartOptions {
      */
     sharedSchemaId?: string;
 
+    /**
+     * Allow throwing error when file size limit reached.
+     */
+    throwFileSizeLimit?: boolean
+
     /**
      * Manage the file stream like you need
      */

index.js

@@ -149,6 +149,11 @@ function fastifyMultipart (fastify, options, done) {
     })
   }
 
+  let throwFileSizeLimit = true
+  if (typeof options.throwFileSizeLimit === 'boolean') {
+    throwFileSizeLimit = options.throwFileSizeLimit
+  }
+
   const PartsLimitError = createError('FST_PARTS_LIMIT', 'reach parts limit', 413)
   const FilesLimitError = createError('FST_FILES_LIMIT', 'reach files limit', 413)
   const FieldsLimitError = createError('FST_FIELDS_LIMIT', 'reach fields limit', 413)
@@ -169,9 +174,6 @@ function fastifyMultipart (fastify, options, done) {
   fastify.decorateRequest(kMultipartHandler, handleMultipart)
 
   fastify.decorateRequest('parts', getMultipartIterator)
-  // keeping multipartIterator to avoid bumping a major
-  // TODO remove on 4.x
-  fastify.decorateRequest('multipartIterator', getMultipartIterator)
 
   fastify.decorateRequest('isMultipart', isMultipart)
   fastify.decorateRequest('tmpUploads', null)
@@ -400,6 +402,10 @@ function fastifyMultipart (fastify, options, done) {
         return
       }
 
+      if (typeof opts.throwFileSizeLimit === 'boolean') {
+        throwFileSizeLimit = opts.throwFileSizeLimit
+      }
+
       const value = {
         fieldname: name,
         filename,
@@ -420,6 +426,15 @@ function fastifyMultipart (fastify, options, done) {
           return this._buf
         }
       }
+
+      if (throwFileSizeLimit) {
+        file.on('limit', function () {
+          const err = new RequestFileTooLargeError()
+          err.part = value
+          onError(err)
+        })
+      }
+
       if (body[name] === undefined) {
         body[name] = value
       } else if (Array.isArray(body[name])) {
@@ -461,12 +476,6 @@ function fastifyMultipart (fastify, options, done) {
         await pump(file.file, target)
         requestFiles.push({ ...file, filepath })
         this.tmpUploads.push(filepath)
-        // busboy set truncated to true when the configured file size limit was reached
-        if (file.file.truncated) {
-          const err = new RequestFileTooLargeError()
-          err.part = file
-          throw err
-        }
       } catch (err) {
         this.log.error({ err }, 'save request file')
         throw err

package.json

@@ -38,10 +38,10 @@
   },
   "scripts": {
     "lint": "standard | snazzy",
-    "unit": "tap test/**/*.test.js test/*.test.js -t 60",
+    "unit": "tap \"test/**/*.test.js\" -t 90",
     "typescript": "tsd",
     "test": "npm run lint && npm run unit && npm run typescript",
-    "coverage": "tap test/**/*.test.js test/*.test.js --coverage-report=html",
+    "coverage": "tap \"test/**/*.test.js\" --coverage-report=html",
     "start": "CLIMEM=8999 node -r climem ./examples/example",
     "climem": "climem 8999 localhost"
   },

test/big.test.js

@@ -25,7 +25,7 @@ test('should upload a big file in constant memory', { skip: process.env.CI }, fu
   fastify.post('/', async function (req, reply) {
     t.ok(req.isMultipart())
 
-    for await (const part of req.multipartIterator()) {
+    for await (const part of req.parts()) {
       if (part.file) {
         t.equal(part.fieldname, 'upload')
         t.equal(part.filename, 'random-data')

test/index.test-d.ts

@@ -14,6 +14,7 @@ const runServer = async () => {
   app.register(fastifyMultipart, {
     addToBody: true,
     sharedSchemaId: 'sharedId',
+    throwFileSizeLimit: false,
     // stream should be of type streams.Readable
     // body should be of type fastifyMulipart.Record<string, BodyEntry>
     onFile: (fieldName: string, stream: any, filename: string, encoding: string, mimetype: string, body: Record<string, any>) => {

test/multipart.test.js

@@ -477,33 +477,71 @@ test('should throw error due to partsLimit (The max number of parts (fields + fi
   })
 })
 
-test('should also work with multipartIterator', function (t) {
-  t.plan(8)
+test('should throw error due to file size limit exceed (Default: true)', function (t) {
+  t.plan(4)
 
   const fastify = Fastify()
   t.tearDown(fastify.close.bind(fastify))
 
-  fastify.register(multipart)
+  fastify.register(multipart, { limits: { fileSize: 1 } })
 
   fastify.post('/', async function (req, reply) {
-    for await (const part of req.multipartIterator()) {
-      if (part.file) {
-        t.equal(part.fieldname, 'upload')
-        t.equal(part.filename, 'README.md')
-        t.equal(part.encoding, '7bit')
-        t.equal(part.mimetype, 'text/markdown')
-        t.ok(part.fields.upload)
-
-        const original = fs.readFileSync(filePath, 'utf8')
-        await pump(
-          part.file,
-          concat(function (buf) {
-            t.equal(buf.toString(), original)
-          })
-        )
+    try {
+      const parts = await req.files()
+      for await (const part of parts) {
+        t.ok(part.file)
+        await sendToWormhole(part.file)
       }
+      reply.code(200).send()
+    } catch (error) {
+      t.true(error instanceof fastify.multipartErrors.RequestFileTooLargeError)
+      reply.code(500).send()
+    }
+  })
+
+  fastify.listen(0, async function () {
+    // request
+    const form = new FormData()
+    const opts = {
+      protocol: 'http:',
+      hostname: 'localhost',
+      port: fastify.server.address().port,
+      path: '/',
+      headers: form.getHeaders(),
+      method: 'POST'
     }
 
+    const req = http.request(opts, (res) => {
+      t.equal(res.statusCode, 500)
+      res.on('end', () => {
+        t.pass('res ended successfully')
+      })
+    })
+    form.append('upload', fs.createReadStream(filePath))
+    form.append('upload2', fs.createReadStream(filePath))
+
+    try {
+      await pump(form, req)
+    } catch (error) {
+      t.error(error, 'formData request pump: no err')
+    }
+  })
+})
+
+test('should not throw error due to file size limit exceed - files setting (Default: true)', function (t) {
+  t.plan(3)
+
+  const fastify = Fastify()
+  t.tearDown(fastify.close.bind(fastify))
+
+  fastify.register(multipart)
+
+  fastify.post('/', async function (req, reply) {
+    const parts = await req.files({ throwFileSizeLimit: false, limits: { fileSize: 1 } })
+    for await (const part of parts) {
+      t.ok(part.file)
+      await sendToWormhole(part.file)
+    }
     reply.code(200).send()
   })
 
@@ -521,16 +559,12 @@ test('should also work with multipartIterator', function (t) {
 
     const req = http.request(opts, (res) => {
       t.equal(res.statusCode, 200)
-      // consume all data without processing
-      res.resume()
       res.on('end', () => {
         t.pass('res ended successfully')
       })
     })
-    const rs = fs.createReadStream(filePath)
-    form.append('upload', rs)
-    form.append('hello', 'world')
-    form.append('willbe', 'dropped')
+    form.append('upload', fs.createReadStream(filePath))
+    form.append('upload2', fs.createReadStream(filePath))
 
     try {
       await pump(form, req)