fastify 5.12.3 → 5.12.5

package/docs/Reference/Reply.md

@@ -277,8 +277,9 @@ requires heavy resources to be sent after the `data`, for example,
 as soon as possible.
 
 > ℹ️ Note:
-> The header `Transfer-Encoding: chunked` will be added once you use
-> the trailer. It is a hard requirement for using trailer in Node.js.
+> For HTTP/1 responses, the header `Transfer-Encoding: chunked` will be added
+> once you use a trailer. HTTP/2 does not use chunked transfer encoding and
+> sends trailers using its native trailing headers support.
 
 > ℹ️ Note:
 > Any error passed to `done` callback will be ignored. If you are interested

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.12.2'
+const VERSION = '5.12.5'
 
 const Avvio = require('avvio')
 const http = require('node:http')

package/lib/content-type-parser.js

@@ -140,6 +140,7 @@ ContentTypeParser.prototype.getParser = function (contentType) {
   // with that type.
   parser = this.customParsers.get(contentType.mediaType)
   if (parser !== undefined) {
+    this.cache.set(ct, parser)
     return parser
   }
 
@@ -203,7 +204,12 @@ ContentTypeParser.prototype.run = function (contentType, handler, request, reply
   }
 
   const resource = new AsyncResource('content-type-parser:run', request)
-  const done = resource.bind(onDone)
+
+  // Preserve the request's async context without the per-request function
+  // properties and wrappers created by AsyncResource.bind().
+  function done (error, body) {
+    resource.runInAsyncScope(onDone, undefined, error, body)
+  }
 
   if (parser.asString === true || parser.asBuffer === true) {
     rawBody(

package/lib/reply.js

@@ -606,8 +606,11 @@ function onSendEnd (reply, payload) {
       header += trailerName
     }
     if (header !== '') {
-      // it must be chunked for trailer to work
-      reply.header('Transfer-Encoding', 'chunked')
+      // HTTP/1 must use chunked encoding for trailers. HTTP/2 forbids
+      // the transfer-encoding header and handles trailers natively.
+      if (!isHttp2Reply(reply)) {
+        reply.header('Transfer-Encoding', 'chunked')
+      }
       reply.header('Trailer', header.trim())
     } else {
       reply[kReplyTrailers] = null

package/lib/validation.js

@@ -284,19 +284,21 @@ function compileSchemasForValidation (context, compile, isCustom) {
 }
 
 function validateParam (validatorFunction, request, paramName) {
-  const isUndefined = request[paramName] === undefined
+  // The headers getter may allocate a new object, so only read it when needed.
+  if (validatorFunction == null) return false
+  const value = request[paramName]
   let ret
 
   try {
-    const data = isUndefined ? null : request[paramName]
+    const data = value === undefined ? null : value
     // Ajv can only mutate a root value when its parent is provided.
-    if (validatorFunction?.schemaEnv) {
+    if (validatorFunction.schemaEnv) {
       ret = validatorFunction(data, {
         parentData: request,
         parentDataProperty: paramName
       })
     } else {
-      ret = validatorFunction?.(data)
+      ret = validatorFunction(data)
     }
   } catch (err) {
     // If validator throws synchronously, ensure it propagates as an internal error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "5.12.3",
+  "version": "5.12.5",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

package/test/content-type-parser-async-context.test.js

@@ -0,0 +1,76 @@
+'use strict'
+
+const { AsyncLocalStorage, AsyncResource, createHook, executionAsyncId } = require('node:async_hooks')
+const { setImmediate: immediate } = require('node:timers/promises')
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('content type parser callbacks restore request context and destroy their resources', async t => {
+  const storage = new AsyncLocalStorage()
+  const external = new AsyncResource('external-parser')
+  const resources = new Set()
+  const destroyed = new Set()
+  const hook = createHook({
+    init (id, type) {
+      if (type === 'content-type-parser:run') resources.add(id)
+    },
+    destroy (id) {
+      if (resources.has(id)) destroyed.add(id)
+    }
+  }).enable()
+  const app = Fastify()
+  t.after(async () => {
+    hook.disable()
+    external.emitDestroy()
+    storage.disable()
+    await app.close()
+  })
+
+  app.addHook('onRequest', (request, reply, done) => {
+    storage.run({ id: request.headers['x-request-id'] }, done)
+  })
+
+  app.addContentTypeParser('application/custom', { parseAs: 'string' }, (request, body, done) => {
+    external.runInAsyncScope(() => {
+      t.assert.strictEqual(storage.getStore(), undefined)
+      setImmediate(() => {
+        if (body === 'error') {
+          done(new Error('parser failed'))
+        } else {
+          done(null, body)
+        }
+      })
+    })
+  })
+
+  function assertContext (request) {
+    t.assert.deepStrictEqual(storage.getStore(), { id: request.headers['x-request-id'] })
+    t.assert.ok(resources.has(executionAsyncId()))
+  }
+
+  app.setErrorHandler((error, request, reply) => {
+    assertContext(request)
+    reply.code(400).send({ error: error.message, id: storage.getStore().id })
+  })
+  app.post('/', (request, reply) => {
+    assertContext(request)
+    return { body: request.body, id: storage.getStore().id }
+  })
+
+  const responses = await Promise.all(['first', 'second', 'error'].map(id => app.inject({
+    method: 'POST',
+    url: '/',
+    headers: { 'content-type': 'application/custom', 'x-request-id': id },
+    payload: id
+  })))
+
+  t.assert.deepStrictEqual(responses.map(response => response.statusCode), [200, 200, 400])
+  t.assert.deepStrictEqual(responses.map(response => response.json()), [
+    { body: 'first', id: 'first' },
+    { body: 'second', id: 'second' },
+    { error: 'parser failed', id: 'error' }
+  ])
+  await immediate()
+  t.assert.strictEqual(resources.size, 3)
+  t.assert.deepStrictEqual(destroyed, resources)
+})

package/test/custom-parser.4.test.js

@@ -6,6 +6,46 @@ const jsonParser = require('fast-json-body')
 
 process.removeAllListeners('warning')
 
+test('parameterized parser matches preserve precedence and encapsulation on repeated requests', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.addContentTypeParser('application/custom', { parseAs: 'string' }, (request, body, done) => {
+    done(null, 'parent')
+  })
+  fastify.addContentTypeParser('application/custom; version=2', { parseAs: 'string' }, (request, body, done) => {
+    done(null, 'version 2')
+  })
+  fastify.post('/', request => request.body)
+
+  fastify.register(async child => {
+    child.removeContentTypeParser('application/custom')
+    child.addContentTypeParser('application/custom', { parseAs: 'string' }, (request, body, done) => {
+      done(null, 'child')
+    })
+    child.post('/child', request => request.body)
+  })
+
+  for (let i = 0; i < 3; i++) {
+    for (const [url, contentType, expected] of [
+      ['/', 'application/custom; charset=utf-8', 'parent'],
+      ['/child', 'application/custom; charset=utf-8', 'child'],
+      ['/', 'application/custom; version=2', 'version 2'],
+      ['/child', 'application/custom; version=2', 'version 2'],
+      ['/', 'Application/Custom ; Charset="utf-8"', 'parent']
+    ]) {
+      const response = await fastify.inject({
+        method: 'POST',
+        url,
+        headers: { 'content-type': contentType },
+        payload: 'body'
+      })
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.body, expected)
+    }
+  }
+})
+
 test('should prefer string content types over RegExp ones', async (t) => {
   t.plan(6)
   const fastify = Fastify()

package/test/http2/plain.test.js

@@ -68,6 +68,51 @@ test('http2 plain test', async t => {
   })
 })
 
+test('http2 response trailers do not use transfer-encoding', async t => {
+  const fastify = Fastify({ http2: true })
+
+  fastify.get('/', async (request, reply) => {
+    reply.trailer('x-checksum', async () => 'abc')
+    return 'hello'
+  })
+
+  await fastify.listen({ port: 0, host: '127.0.0.1' })
+
+  const client = http2.connect(`http://127.0.0.1:${fastify.server.address().port}`)
+  t.after(() => {
+    client.close()
+    return fastify.close()
+  })
+
+  const response = await new Promise((resolve, reject) => {
+    const request = client.request({
+      [http2.constants.HTTP2_HEADER_METHOD]: http2.constants.HTTP2_METHOD_GET,
+      [http2.constants.HTTP2_HEADER_PATH]: '/'
+    })
+    const result = { body: '' }
+
+    request.setEncoding('utf8')
+    request.on('response', headers => {
+      result.headers = headers
+    })
+    request.on('trailers', trailers => {
+      result.trailers = trailers
+    })
+    request.on('data', chunk => {
+      result.body += chunk
+    })
+    request.on('error', reject)
+    request.on('end', () => resolve(result))
+    request.end()
+  })
+
+  t.assert.strictEqual(response.headers[':status'], 200)
+  t.assert.strictEqual(response.headers['transfer-encoding'], undefined)
+  t.assert.strictEqual(response.headers.trailer, 'x-checksum')
+  t.assert.strictEqual(response.body, 'hello')
+  t.assert.strictEqual(response.trailers['x-checksum'], 'abc')
+})
+
 test('http2 large non-stream replies are sent completely', async t => {
   const modes = ['buffer', 'string']
 

package/test/internals/validation.test.js

@@ -10,6 +10,72 @@ const { normalizeSchema } = require('../../lib/schemas')
 const symbols = require('../../lib/validation').symbols
 const { kSchemaVisited } = require('../../lib/symbols')
 
+for (const [part, symbol] of [
+  ['params', symbols.paramsSchema],
+  ['body', symbols.bodySchema],
+  ['query', symbols.querystringSchema],
+  ['headers', symbols.headersSchema]
+]) {
+  for (const async of [false, true]) {
+    test(`validate reads only the validated ${part} once (${async ? 'async' : 'sync'})`, async t => {
+      const request = {}
+      const value = { hello: 'world' }
+      let reads = 0
+      let calls = 0
+
+      for (const name of ['params', 'body', 'query', 'headers']) {
+        Object.defineProperty(request, name, {
+          get () {
+            t.assert.strictEqual(name, part, 'unvalidated request parts must not be read')
+            reads++
+            return value
+          }
+        })
+      }
+
+      const context = {
+        [symbol]: data => {
+          calls++
+          t.assert.strictEqual(data, value)
+          return async ? Promise.resolve(data) : true
+        }
+      }
+
+      t.assert.strictEqual(await validation.validate(context, request), false)
+      t.assert.strictEqual(reads, 1)
+      t.assert.strictEqual(calls, 1)
+    })
+  }
+}
+
+test('validate skips a body without a matching content-type schema', t => {
+  const context = { [symbols.bodySchema]: { 'application/json': () => true } }
+  const request = {
+    mediaType: 'text/plain',
+    get body () {
+      t.assert.fail('an unvalidated body must not be read')
+    }
+  }
+
+  t.assert.strictEqual(validation.validate(context, request), false)
+})
+
+test('validate passes null for an undefined request part and preserves other values', t => {
+  for (const value of [undefined, null, false, 0, '']) {
+    let calls = 0
+    const context = {
+      [symbols.bodySchema]: data => {
+        calls++
+        t.assert.strictEqual(data, value === undefined ? null : value)
+        return true
+      }
+    }
+
+    t.assert.strictEqual(validation.validate(context, { body: value }), false)
+    t.assert.strictEqual(calls, 1)
+  }
+})
+
 test('Symbols', t => {
   t.plan(5)
   t.assert.strictEqual(typeof symbols.responseSchema, 'symbol')