fastify 5.11.2 → 5.12.0

package/test/reply-trailers.test.js

@@ -142,6 +142,37 @@ test('send trailers when payload is stream', (t, testDone) => {
   })
 })
 
+test('remove trailer while stream is being consumed', (t, testDone) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    const stream = Readable.from((function * () {
+      reply.removeTrailer('ETag')
+      yield 'hello'
+    })())
+
+    reply.trailer('ETag', function () {
+      t.assert.fail('removed trailer should not be called')
+    })
+
+    reply.send(stream)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, 'hello')
+    t.assert.strictEqual(res.headers.trailer, 'etag')
+    t.assert.strictEqual(res.trailers.etag, undefined)
+    testDone()
+  })
+})
+
 test('send trailers when using async-await', (t, testDone) => {
   t.plan(5)
 
@@ -395,10 +426,67 @@ test('remove all trailers', (t, testDone) => {
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
-    t.assert.ok(!res.headers.trailer)
-    t.assert.ok(!res.trailers.etag)
-    t.assert.ok(!res.trailers['should-not-call'])
-    t.assert.ok(!res.headers['content-length'])
+    t.assert.strictEqual(res.headers.trailer, undefined)
+    t.assert.strictEqual(res.trailers.etag, undefined)
+    t.assert.strictEqual(res.trailers['should-not-call'], undefined)
+    t.assert.strictEqual(res.headers['content-length'], '0')
+    testDone()
+  })
+})
+
+test('remove some trailers should keep trailer mode for the remaining ones', (t, testDone) => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function () {
+      t.assert.fail('removed trailer should not be called')
+    })
+    reply.removeTrailer('ETag')
+    reply.trailer('Content-MD5', function (reply, payload, done) {
+      done(null, 'custom-md5')
+    })
+    reply.send('hello')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers.trailer, 'content-md5')
+    t.assert.strictEqual(res.headers['transfer-encoding'], 'chunked')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+    t.assert.strictEqual(res.trailers['content-md5'], 'custom-md5')
+    testDone()
+  })
+})
+
+test('remove all trailers should behave like no trailers were registered', (t, testDone) => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function () {
+      t.assert.fail('removed trailer should not be called')
+    })
+    reply.removeTrailer('ETag')
+    reply.send('hello')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers.trailer, undefined)
+    t.assert.strictEqual(res.headers['transfer-encoding'], undefined)
+    t.assert.strictEqual(res.headers['content-length'], '5')
+    t.assert.strictEqual(res.trailers.etag, undefined)
     testDone()
   })
 })

package/test/route-prefix.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 test('Prefix options should add a prefix for all the routes inside a register / 1', (t, testDone) => {
   t.plan(6)

package/test/route.6.test.js

@@ -4,6 +4,7 @@ const stream = require('node:stream')
 const { ReadableStream } = require('node:stream/web')
 const { test } = require('node:test')
 const Fastify = require('..')
+const { assertNoWarning } = require('./helper')
 
 test('Creates a HEAD route for a GET one with prefixTrailingSlash', async (t) => {
   t.plan(1)
@@ -281,6 +282,8 @@ test('route onSend can be function or array of functions', async t => {
 })
 
 test('no warning for exposeHeadRoute', async t => {
+  assertNoWarning(t)
+
   const fastify = Fastify()
 
   fastify.route({
@@ -292,15 +295,5 @@ test('no warning for exposeHeadRoute', async t => {
     }
   })
 
-  const listener = (w) => {
-    t.assert.fail('no warning')
-  }
-
-  process.on('warning', listener)
-
-  await fastify.listen({ port: 0 })
-
-  process.removeListener('warning', listener)
-
-  await fastify.close()
+  await fastify.ready()
 })

package/test/schema-feature.test.js

@@ -1,13 +1,14 @@
 'use strict'
 
 const { test } = require('node:test')
-const Fastify = require('..')
 const fp = require('fastify-plugin')
+const { spyWarning } = require('process-warning')
+const Fastify = require('..')
 const deepClone = require('rfdc')({ circles: true, proto: false })
 const Ajv = require('ajv')
 const { kSchemaController } = require('../lib/symbols.js')
 const { FSTWRN001 } = require('../lib/warnings')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 const echoParams = (req, reply) => { reply.send(req.params) }
 const echoBody = (req, reply) => { reply.send(req.body) }
@@ -320,18 +321,10 @@ test('Should not change the input schemas', (t, testDone) => {
 
 test('Should emit warning if the schema headers is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
-
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -346,24 +339,18 @@ test('Should emit warning if the schema headers is undefined', (t, testDone) =>
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['headers', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit warning if the schema body is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
-
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -378,24 +365,18 @@ test('Should emit warning if the schema body is undefined', (t, testDone) => {
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['body', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit warning if the schema query is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
-
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -410,24 +391,18 @@ test('Should emit warning if the schema query is undefined', (t, testDone) => {
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['querystring', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit warning if the schema params is undefined', (t, testDone) => {
   t.plan(4)
-  const fastify = Fastify()
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-  }
-
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.post('/:id', {
     handler: echoParams,
@@ -442,31 +417,18 @@ test('Should emit warning if the schema params is undefined', (t, testDone) => {
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(spyData.calls, [{ arguments: ['params', 'POST', '/:id'], result: true }])
+    t.assert.strictEqual(spyData.callCount(), 1)
     testDone()
   })
 })
 
 test('Should emit a warning for every route with undefined schema', (t, testDone) => {
-  t.plan(16)
-  const fastify = Fastify()
-
-  let runs = 0
-  const expectedWarningEmitted = [0, 1, 2, 3]
-  // It emits 4 warnings:
-  // - 2 - GET and HEAD for /undefinedParams/:id
-  // - 2 - GET and HEAD for /undefinedBody/:id
-  // => 3 x 4 assertions = 12 assertions
-  function onWarning (warning) {
-    t.assert.strictEqual(warning.name, 'FastifyWarning')
-    t.assert.strictEqual(warning.code, FSTWRN001.code)
-    t.assert.strictEqual(runs++, expectedWarningEmitted.shift())
-  }
+  t.plan(9)
+  const spyData = spyWarning(FSTWRN001)
+  t.after(spyData.restore)
 
-  process.on('warning', onWarning)
-  t.after(() => {
-    process.removeListener('warning', onWarning)
-    FSTWRN001.emitted = false
-  })
+  const fastify = Fastify()
 
   fastify.get('/undefinedParams/:id', {
     handler: echoParams,
@@ -496,6 +458,15 @@ test('Should emit a warning for every route with undefined schema', (t, testDone
   }, (error, res) => {
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
+    // fastify.inject run in series
+    // last callback recieve all warnings at once
+    // GET /undefinedParams/123
+    t.assert.deepStrictEqual(spyData.calls[0], { arguments: ['params', 'GET', '/undefinedParams/:id'], result: true })
+    t.assert.deepStrictEqual(spyData.calls[1], { arguments: ['params', 'HEAD', '/undefinedParams/:id'], result: true })
+    // GET /undefinedBody/123
+    t.assert.deepStrictEqual(spyData.calls[2], { arguments: ['body', 'GET', '/undefinedBody/:id'], result: true })
+    t.assert.deepStrictEqual(spyData.calls[3], { arguments: ['body', 'HEAD', '/undefinedBody/:id'], result: true })
+    t.assert.strictEqual(spyData.callCount(), 4)
     testDone()
   })
 })

package/test/schema-serialization.test.js

@@ -3,7 +3,7 @@
 const { test } = require('node:test')
 const Fastify = require('..')
 const ContentType = require('../lib/content-type')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 const echoBody = (req, reply) => { reply.send(req.body) }
 

package/test/schema-special-usage.test.js

@@ -9,7 +9,7 @@ const Fastify = require('..')
 const ajvMergePatch = require('ajv-merge-patch')
 const ajvErrors = require('ajv-errors')
 const proxyquire = require('proxyquire')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 test('Ajv plugins array parameter', (t, testDone) => {
   t.plan(3)

package/test/schema-validation.test.js

@@ -5,7 +5,7 @@ const Fastify = require('..')
 
 const AJV = require('ajv')
 const Schema = require('fluent-json-schema')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 const { kRequestContentType } = require('../lib/symbols')
 
 const customSchemaCompilers = {

package/test/stream.2.test.js

@@ -7,7 +7,7 @@ const resolve = require('node:path').resolve
 const zlib = require('node:zlib')
 const pipeline = require('node:stream').pipeline
 const Fastify = require('..')
-const { waitForCb } = require('./toolkit')
+const { waitForCb } = require('./helper')
 
 test('onSend hook stream', t => {
   t.plan(4)

package/types/logger.d.ts

@@ -124,7 +124,7 @@ export declare class LogController {
   isLogDisabled (request: FastifyRequest): boolean
   incomingRequest (request: FastifyRequest, reply: FastifyReply, metadata?: Record<string, unknown>): void
   requestCompleted (
-    error: Error | null,
+    error: Error | null | undefined,
     request: FastifyRequest,
     reply: FastifyReply,
     metadata?: Record<string, unknown>

package/.pi/bash-confirm-whitelist.json

@@ -1,180 +0,0 @@
-{
-  "entries": [
-    {
-      "type": "exact",
-      "value": "git fetch --all --prune --quiet && echo FETCH_OK || echo FETCH_FAILED",
-      "addedAt": "2026-02-07T10:03:03.909Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "npm install --ignore-scripts",
-      "addedAt": "2026-02-07T10:21:13.104Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "npm run coverage:ci-check-coverage",
-      "addedAt": "2026-02-07T15:10:08.412Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "node --test test/web-api.test.js",
-      "addedAt": "2026-02-07T15:24:46.872Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "gpg --list-secret-keys --keyid-format=long || true && git config --get user.signingkey && git config --get commit.gpgsign",
-      "addedAt": "2026-02-11T04:42:44.716Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && npm run test:typescript",
-      "addedAt": "2026-02-19T20:22:59.298Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && git checkout -- types/route.d.ts",
-      "addedAt": "2026-02-19T20:23:45.912Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && git status --short && git diff -- types/route.d.ts test/types/route.test-d.ts | sed -n '1,220p'",
-      "addedAt": "2026-02-19T20:25:10.175Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && git checkout -- types/route.d.ts test/types/route.test-d.ts && npm run test:typescript",
-      "addedAt": "2026-02-19T20:25:56.421Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && npm run lint:eslint -- types/route.d.ts test/types/route.test-d.ts",
-      "addedAt": "2026-02-19T20:27:12.547Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && git checkout -b fix/6513-route-hook-meta-return",
-      "addedAt": "2026-02-19T20:27:31.569Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && git add types/route.d.ts test/types/route.test-d.ts && git commit -m \"fix(types): allow async route hooks in shorthand options\"",
-      "addedAt": "2026-02-19T20:27:35.261Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && npx tsc /tmp/ctx-test2.ts --noEmit --strict",
-      "addedAt": "2026-02-19T20:44:45.451Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && npx tsd --files test/types/hooks.test-d.ts",
-      "addedAt": "2026-02-19T20:47:16.815Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && npx tsd --files test/types/route.test-d.ts",
-      "addedAt": "2026-02-19T20:47:37.607Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && npx tsd",
-      "addedAt": "2026-02-19T20:48:17.812Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "cd /home/matteo/repositories/fastify && npm run lint:eslint -- types/route.d.ts && npx tsd --files test/types/hooks.test-d.ts && npx tsd --files test/types/route.test-d.ts",
-      "addedAt": "2026-02-19T20:51:05.173Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "which gh && gh --version && gh auth status",
-      "addedAt": "2026-02-20T07:03:43.023Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "gh api repos/fastify/fastify/rulesets",
-      "addedAt": "2026-02-22T22:29:22.020Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "node --test test/fastify-instance.test.js",
-      "addedAt": "2026-02-23T07:23:34.147Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "exact",
-      "value": "nl -ba scripts/validate-ecosystem-links.js | sed -n '1,220p'",
-      "addedAt": "2026-02-23T07:23:55.927Z",
-      "note": "Always accept",
-      "source": "user"
-    },
-    {
-      "type": "pattern",
-      "value": "^npx\\s+eslint\\s+[\\w./~-]+\\s+[\\w./~-]+\\s+[\\w./~-]+\\s+[\\w./~-]+$",
-      "addedAt": "2026-03-09T12:41:11.065Z",
-      "note": "Always accept generic",
-      "source": "ai"
-    },
-    {
-      "type": "pattern",
-      "value": "^node\\s+--test\\s+[\\w./~-]+\\s+[\\w./~-]+$",
-      "addedAt": "2026-03-09T12:41:58.425Z",
-      "note": "Always accept generic",
-      "source": "ai"
-    },
-    {
-      "type": "pattern",
-      "value": "^npm\\s+run\\s+test:typescript$",
-      "addedAt": "2026-03-09T12:42:48.283Z",
-      "note": "Always accept generic",
-      "source": "ai"
-    },
-    {
-      "type": "exact",
-      "value": "gh search code \"request.host org:fastify\" --limit 20 --json repository,path,url",
-      "addedAt": "2026-03-09T21:03:22.953Z",
-      "note": "Always accept exact",
-      "source": "user"
-    }
-  ],
-  "version": 2
-}

package/test/toolkit.js

@@ -1,63 +0,0 @@
-'use strict'
-
-exports.waitForCb = function (options) {
-  let count = null
-  let done = false
-  let iResolve
-  let iReject
-
-  function stepIn () {
-    if (done) {
-      iReject(new Error('Unexpected done call'))
-      return
-    }
-
-    if (--count) {
-      return
-    }
-
-    done = true
-    iResolve()
-  }
-
-  const patience = new Promise((resolve, reject) => {
-    iResolve = resolve
-    iReject = reject
-  })
-
-  count = options.steps || 1
-  done = false
-
-  return { stepIn, patience }
-}
-
-exports.partialDeepStrictEqual = function partialDeepStrictEqual (actual, expected) {
-  if (typeof expected !== 'object' || expected === null) {
-    return actual === expected
-  }
-
-  if (typeof actual !== 'object' || actual === null) {
-    return false
-  }
-
-  if (Array.isArray(expected)) {
-    if (!Array.isArray(actual)) return false
-    if (expected.length > actual.length) return false
-
-    for (let i = 0; i < expected.length; i++) {
-      if (!partialDeepStrictEqual(actual[i], expected[i])) {
-        return false
-      }
-    }
-    return true
-  }
-
-  for (const key of Object.keys(expected)) {
-    if (!(key in actual)) return false
-    if (!partialDeepStrictEqual(actual[key], expected[key])) {
-      return false
-    }
-  }
-
-  return true
-}