feat: return values from saveRequestFiles (#612)

Author: mcollina

README.md

@@ -186,15 +186,16 @@ This will store all files in the operating system's default directory for tempor
 
 ```js
 fastify.post('/upload/files', async function (req, reply) {
-  // stores files to tmp dir and return files
-  const files = await req.saveRequestFiles()
+  // stores files to tmp dir and returns files + parsed values
+  const { files, values } = await req.saveRequestFiles()
   files[0].type // "file"
   files[0].filepath
   files[0].fieldname
   files[0].filename
   files[0].encoding
   files[0].mimetype
   files[0].fields // other parsed parts
+  values.hello?.value // non-file fields are available even if no file was uploaded
 
   reply.send()
 })

index.js

@@ -16,6 +16,7 @@ const secureJSON = require('secure-json-parse')
 
 const kMultipart = Symbol('multipart')
 const kMultipartHandler = Symbol('multipartHandler')
+const kSavedRequestFilesResult = Symbol('savedRequestFilesResult')
 
 const PartsLimitError = createError('FST_PARTS_LIMIT', 'reach parts limit', 413)
 const FilesLimitError = createError('FST_FILES_LIMIT', 'reach files limit', 413)
@@ -184,6 +185,7 @@ function fastifyMultipart (fastify, options, done) {
   fastify.addContentTypeParser('multipart/form-data', setMultipart)
   fastify.decorateRequest(kMultipart, false)
   fastify.decorateRequest(kMultipartHandler, handleMultipart)
+  fastify.decorateRequest(kSavedRequestFilesResult, null)
 
   fastify.decorateRequest('parts', getMultipartIterator)
 
@@ -450,37 +452,51 @@ function fastifyMultipart (fastify, options, done) {
 
   async function saveRequestFiles (options) {
     // Checks if this has already been run
-    if (this.savedRequestFiles) {
-      return this.savedRequestFiles
+    if (this[kSavedRequestFilesResult]) {
+      return this[kSavedRequestFilesResult]
     }
-    let files
-    if (attachFieldsToBody === true) {
-      // Skip the whole process if the body is empty
-      if (!this.body) {
-        return []
-      }
-      files = filesFromFields.call(this, this.body)
+
+    let parts
+    let values = {}
+
+    if (attachFieldsToBody === true || attachFieldsToBody === 'keyValues') {
+      parts = this.body ? filesFromFields.call(this, this.body) : []
+      values = this.body || {}
     } else {
-      files = await this.files(options)
+      parts = this.parts(options)
     }
+
     this.savedRequestFiles = []
     const tmpdir = options?.tmpdir || os.tmpdir()
     this.tmpUploads = []
     let i = 0
-    for await (const file of files) {
-      const filepath = path.join(tmpdir, generateId() + path.extname(file.filename || ('file' + i++)))
+    for await (const part of parts) {
+      values = part.fields
+
+      if (!part.file) {
+        continue
+      }
+
+      const filepath = path.join(tmpdir, generateId() + path.extname(part.filename || ('file' + i++)))
       const target = createWriteStream(filepath)
       try {
         this.tmpUploads.push(filepath)
-        await pump(file.file, target)
-        this.savedRequestFiles.push({ ...file, filepath })
+        await pump(part.file, target)
+        this.savedRequestFiles.push({ ...part, filepath })
       } catch (err) {
+        target.destroy()
+        await this.cleanRequestFiles()
         this.log.error({ err }, 'save request file')
         throw err
       }
     }
 
-    return this.savedRequestFiles
+    this[kSavedRequestFilesResult] = {
+      files: this.savedRequestFiles,
+      values
+    }
+
+    return this[kSavedRequestFilesResult]
   }
 
   function * filesFromFields (container) {

test/fix-313.test.js

@@ -26,7 +26,7 @@ test('should store file on disk, remove on response when attach fields to body i
   fastify.post('/', async function (req, reply) {
     t.assert.ok(req.isMultipart())
 
-    const files = await req.saveRequestFiles()
+    const { files } = await req.saveRequestFiles()
 
     t.assert.ok(files[0].filepath)
     t.assert.strictEqual(files[0].type, 'file')

test/multipart-ajv-file.test.js

@@ -12,7 +12,7 @@ const test = require('node:test')
 const filePath = path.join(__dirname, '../README.md')
 
 test('show modify the generated schema', async t => {
-  t.plan(4)
+  t.plan(6)
 
   const fastify = Fastify({
     ajv: {
@@ -52,29 +52,16 @@ test('show modify the generated schema', async t => {
 
   await fastify.ready()
 
-  t.assert.deepStrictEqual(fastify.swagger().paths, {
-    '/': {
-      post: {
-        operationId: 'test',
-        requestBody: {
-          content: {
-            'multipart/form-data': {
-              schema: {
-                type: 'object',
-                properties: {
-                  field: { type: 'string', format: 'binary' }
-                }
-              }
-            }
-          },
-          required: true,
-        },
-        responses: {
-          200: { description: 'Default Response' }
-        }
-      }
+  const { post } = fastify.swagger().paths['/']
+
+  t.assert.strictEqual(post.operationId, 'test')
+  t.assert.deepStrictEqual(post.requestBody.content['multipart/form-data'].schema, {
+    type: 'object',
+    properties: {
+      field: { type: 'string', format: 'binary' }
     }
   })
+  t.assert.strictEqual(post.responses[200].description, 'Default Response')
 
   await fastify.listen({ port: 0 })
 

test/multipart-disk.test.js

@@ -27,7 +27,7 @@ test('should store file on disk, remove on response', async function (t) {
   fastify.post('/', async function (req, reply) {
     t.assert.ok(req.isMultipart())
 
-    const files = await req.saveRequestFiles()
+    const { files } = await req.saveRequestFiles()
 
     t.assert.ok(files[0].filepath)
     t.assert.strictEqual(files[0].fieldname, 'upload')
@@ -135,6 +135,96 @@ test('should store file on disk, remove on response error', async function (t) {
   await once(ee, 'response')
 })
 
+test('should return saved files and values from saveRequestFiles', async function (t) {
+  t.plan(8)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register(multipart)
+
+  fastify.post('/', async function (req, reply) {
+    const { files, values } = await req.saveRequestFiles()
+
+    t.assert.ok(Array.isArray(files))
+    t.assert.strictEqual(files.length, 1)
+    t.assert.strictEqual(files[0].fieldname, 'upload')
+    t.assert.strictEqual(values.hello.value, 'world')
+    t.assert.strictEqual(values.count.value, '42')
+    t.assert.ok(values.upload)
+
+    reply.code(200).send()
+  })
+
+  await fastify.listen({ port: 0 })
+
+  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)
+  form.append('hello', 'world')
+  form.append('count', '42')
+  form.append('upload', fs.createReadStream(filePath))
+
+  form.pipe(req)
+
+  const [res] = await once(req, 'response')
+  t.assert.strictEqual(res.statusCode, 200)
+  res.resume()
+  await once(res, 'end')
+  t.assert.ok('res ended successfully')
+})
+
+test('should return values when saveRequestFiles receives only fields', async function (t) {
+  t.plan(6)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register(multipart)
+
+  fastify.post('/', async function (req, reply) {
+    const { files, values } = await req.saveRequestFiles()
+
+    t.assert.ok(Array.isArray(files))
+    t.assert.strictEqual(files.length, 0)
+    t.assert.strictEqual(values.hello.value, 'world')
+    t.assert.strictEqual(values.count.value, '42')
+
+    reply.code(200).send()
+  })
+
+  await fastify.listen({ port: 0 })
+
+  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)
+  form.append('hello', 'world')
+  form.append('count', '42')
+  form.pipe(req)
+
+  const [res] = await once(req, 'response')
+  t.assert.strictEqual(res.statusCode, 200)
+  res.resume()
+  await once(res, 'end')
+  t.assert.ok('res ended successfully')
+})
+
 test('should throw on file limit error', async function (t) {
   t.plan(4)
 

test/multipart-duplicate-save-request-file.test.js

@@ -13,7 +13,7 @@ const { once } = EventEmitter
 const filePath = path.join(__dirname, '../README.md')
 
 test('should store file on disk, remove on response', async function (t) {
-  t.plan(3)
+  t.plan(4)
 
   const fastify = Fastify()
   t.after(() => fastify.close())
@@ -23,11 +23,12 @@ test('should store file on disk, remove on response', async function (t) {
   await fastify.post('/', async function (req, reply) {
     t.assert.ok(req.isMultipart())
 
-    const files = await req.saveRequestFiles()
-    const files2 = await req.saveRequestFiles()
+    const { files, values } = await req.saveRequestFiles()
+    const { files: files2, values: values2 } = await req.saveRequestFiles()
 
     // If it really reused the previously response, their filepath should be the same
     t.assert.strictEqual(files[0].filepath, files2[0].filepath)
+    t.assert.strictEqual(values, values2)
 
     reply.code(200).send()
   })

test/multipart-empty-body.test.js

@@ -8,7 +8,7 @@ const http = require('node:http')
 const { once } = require('node:events')
 
 test('should not break with a empty request body when attachFieldsToBody is true', async function (t) {
-  t.plan(5)
+  t.plan(6)
 
   const fastify = Fastify()
   t.after(() => fastify.close())
@@ -18,10 +18,11 @@ test('should not break with a empty request body when attachFieldsToBody is true
   fastify.post('/', async function (req, reply) {
     t.assert.ok(req.isMultipart())
 
-    const files = await req.saveRequestFiles()
+    const { files, values } = await req.saveRequestFiles()
 
     t.assert.ok(Array.isArray(files))
     t.assert.strictEqual(files.length, 0)
+    t.assert.deepStrictEqual(values, {})
 
     reply.code(200).send()
   })
@@ -50,7 +51,7 @@ test('should not break with a empty request body when attachFieldsToBody is true
 })
 
 test('should not break with a empty request body when attachFieldsToBody is keyValues', async function (t) {
-  t.plan(5)
+  t.plan(6)
 
   const fastify = Fastify()
   t.after(() => fastify.close())
@@ -60,10 +61,11 @@ test('should not break with a empty request body when attachFieldsToBody is keyV
   fastify.post('/', async function (req, reply) {
     t.assert.ok(req.isMultipart())
 
-    const files = await req.saveRequestFiles()
+    const { files, values } = await req.saveRequestFiles()
 
     t.assert.ok(Array.isArray(files))
     t.assert.strictEqual(files.length, 0)
+    t.assert.deepStrictEqual(values, {})
 
     reply.code(200).send()
   })

types/index.d.ts

@@ -25,7 +25,7 @@ declare module 'fastify' {
     // Disk mode
     saveRequestFiles: (
       options?: Omit<BusboyConfig, 'headers'> & { tmpdir?: string }
-    ) => Promise<Array<fastifyMultipart.SavedMultipartFile>>;
+    ) => Promise<fastifyMultipart.SavedMultipartFilesResult>;
     cleanRequestFiles: () => Promise<void>;
     tmpUploads: Array<string> | null;
     /** This will get populated as soon as a call to `saveRequestFiles` gets resolved. Avoiding any future duplicate work */
@@ -72,6 +72,11 @@ declare namespace fastifyMultipart {
     filepath: string;
   }
 
+  export interface SavedMultipartFilesResult {
+    files: Array<SavedMultipartFile>;
+    values: MultipartFields | Record<string, unknown>;
+  }
+
   export type Multipart = MultipartFile | MultipartValue
 
   export interface MultipartFile {

types/index.test-d.ts

@@ -138,15 +138,16 @@ const runServer = async () => {
 
   // upload files to disk and work with temporary file paths
   app.post('/upload/files', async function (req, reply) {
-    // stores files to tmp dir and return files
-    const files = await req.saveRequestFiles()
+    // stores files to tmp dir and return files + values
+    const { files, values } = await req.saveRequestFiles()
     files[0].type // "file"
     files[0].filepath
     files[0].fieldname
     files[0].filename
     files[0].encoding
     files[0].mimetype
     files[0].fields // other parsed parts
+    values.foo
 
     reply.send()
   })