fastify 5.11.2 → 6.0.0-alpha.0

package/test/internals/initial-config.test.js

@@ -36,20 +36,21 @@ test('without options passed to Fastify, initialConfig should expose default val
     requestTimeout: 0,
     handlerTimeout: 0,
     bodyLimit: 1024 * 1024,
-    caseSensitive: true,
-    allowUnsafeRegex: false,
-    disableRequestLogging: false,
-    ignoreTrailingSlash: false,
-    ignoreDuplicateSlashes: false,
-    maxParamLength: 100,
     onProtoPoisoning: 'error',
     onConstructorPoisoning: 'error',
     pluginTimeout: 10000,
     requestIdHeader: false,
-    requestIdLogLabel: 'reqId',
     http2SessionTimeout: 72000,
     exposeHeadRoutes: true,
-    useSemicolonDelimiter: false
+    routerOptions: {
+      allowUnsafeRegex: false,
+      caseSensitive: true,
+      constraints: undefined,
+      ignoreTrailingSlash: false,
+      ignoreDuplicateSlashes: false,
+      maxParamLength: 100,
+      useSemicolonDelimiter: false
+    }
   }
 
   t.assert.deepStrictEqual(Fastify().initialConfig, fastifyDefaultOptions)
@@ -88,65 +89,79 @@ test('Fastify.initialConfig should expose all options', t => {
       key: global.context.key,
       cert: global.context.cert
     },
-    ignoreTrailingSlash: true,
-    ignoreDuplicateSlashes: true,
-    maxParamLength: 200,
     connectionTimeout: 0,
     keepAliveTimeout: 72000,
     bodyLimit: 1049600,
     onProtoPoisoning: 'remove',
     serverFactory,
-    caseSensitive: true,
-    allowUnsafeRegex: false,
     requestIdHeader: 'request-id-alt',
     pluginTimeout: 20000,
-    useSemicolonDelimiter: false,
-    querystringParser: str => str,
     genReqId: function (req) {
       return reqId++
     },
     loggerInstance: pino({ level: 'info' }),
-    constraints: {
-      version: versionStrategy
-    },
     trustProxy: function myTrustFn (address, hop) {
       return address === '1.2.3.4' || hop === 1
+    },
+    routerOptions: {
+      allowUnsafeRegex: false,
+      caseSensitive: true,
+      constraints: {
+        version: versionStrategy
+      },
+      ignoreTrailingSlash: true,
+      ignoreDuplicateSlashes: true,
+      maxParamLength: 200,
+      querystringParser: str => str,
+      useSemicolonDelimiter: false
     }
   }
 
   const fastify = Fastify(options)
+
   t.assert.strictEqual(fastify.initialConfig.http2, true)
   t.assert.strictEqual(fastify.initialConfig.https, true, 'for security reason the key cert is hidden')
-  t.assert.strictEqual(fastify.initialConfig.ignoreTrailingSlash, true)
-  t.assert.strictEqual(fastify.initialConfig.ignoreDuplicateSlashes, true)
-  t.assert.strictEqual(fastify.initialConfig.maxParamLength, 200)
   t.assert.strictEqual(fastify.initialConfig.connectionTimeout, 0)
   t.assert.strictEqual(fastify.initialConfig.keepAliveTimeout, 72000)
   t.assert.strictEqual(fastify.initialConfig.bodyLimit, 1049600)
   t.assert.strictEqual(fastify.initialConfig.onProtoPoisoning, 'remove')
-  t.assert.strictEqual(fastify.initialConfig.caseSensitive, true)
-  t.assert.strictEqual(fastify.initialConfig.useSemicolonDelimiter, false)
-  t.assert.strictEqual(fastify.initialConfig.allowUnsafeRegex, false)
   t.assert.strictEqual(fastify.initialConfig.requestIdHeader, 'request-id-alt')
   t.assert.strictEqual(fastify.initialConfig.pluginTimeout, 20000)
-  t.assert.ok(fastify.initialConfig.constraints.version)
 
   // obfuscated options:
   t.assert.strictEqual(fastify.initialConfig.serverFactory, undefined)
   t.assert.strictEqual(fastify.initialConfig.trustProxy, undefined)
   t.assert.strictEqual(fastify.initialConfig.genReqId, undefined)
   t.assert.strictEqual(fastify.initialConfig.childLoggerFactory, undefined)
-  t.assert.strictEqual(fastify.initialConfig.querystringParser, undefined)
   t.assert.strictEqual(fastify.initialConfig.logger, undefined)
   t.assert.strictEqual(fastify.initialConfig.trustProxy, undefined)
+
+  // router options
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.allowUnsafeRegex, false)
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.caseSensitive, true)
+  t.assert.ok(fastify.initialConfig.routerOptions.constraints.version)
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.ignoreTrailingSlash, true)
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.ignoreDuplicateSlashes, true)
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.maxParamLength, 200)
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.querystringParser, undefined)
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.useSemicolonDelimiter, false)
 })
 
 test('Should throw if you try to modify Fastify.initialConfig', t => {
-  t.plan(4)
+  t.plan(8)
 
-  const fastify = Fastify({ ignoreTrailingSlash: true })
+  const fastify = Fastify({ keepAliveTimeout: 1, routerOptions: { ignoreTrailingSlash: true } })
   try {
-    fastify.initialConfig.ignoreTrailingSlash = false
+    fastify.initialConfig.keepAliveTimeout = 2
+    t.assert.fail()
+  } catch (error) {
+    t.assert.ok(error instanceof TypeError)
+    t.assert.strictEqual(error.message, "Cannot assign to read only property 'keepAliveTimeout' of object '#<Object>'")
+    t.assert.ok(error.stack)
+    t.assert.ok(true)
+  }
+  try {
+    fastify.initialConfig.routerOptions.ignoreTrailingSlash = false
     t.assert.fail()
   } catch (error) {
     t.assert.ok(error instanceof TypeError)
@@ -252,10 +267,12 @@ test('Should not have issues when passing stream options to Pino.js', (t, done)
   const stream = split(JSON.parse)
 
   const originalOptions = {
-    ignoreTrailingSlash: true,
     logger: {
       level: 'trace',
       stream
+    },
+    routerOptions: {
+      ignoreTrailingSlash: true
     }
   }
 
@@ -276,20 +293,21 @@ test('Should not have issues when passing stream options to Pino.js', (t, done)
       requestTimeout: 0,
       handlerTimeout: 0,
       bodyLimit: 1024 * 1024,
-      caseSensitive: true,
-      allowUnsafeRegex: false,
-      disableRequestLogging: false,
-      ignoreTrailingSlash: true,
-      ignoreDuplicateSlashes: false,
-      maxParamLength: 100,
       onProtoPoisoning: 'error',
       onConstructorPoisoning: 'error',
       pluginTimeout: 10000,
       requestIdHeader: false,
-      requestIdLogLabel: 'reqId',
       http2SessionTimeout: 72000,
       exposeHeadRoutes: true,
-      useSemicolonDelimiter: false
+      routerOptions: {
+        allowUnsafeRegex: false,
+        caseSensitive: true,
+        constraints: undefined,
+        ignoreTrailingSlash: true,
+        ignoreDuplicateSlashes: false,
+        maxParamLength: 100,
+        useSemicolonDelimiter: false
+      }
     })
   } catch (error) {
     t.assert.fail()

package/test/internals/logger.test.js

@@ -277,6 +277,19 @@ test('defaultErrorLog should log error for 5xx errors', t => {
   logController.defaultErrorLog(err, request, reply)
 })
 
+test('routeNotFound should not log when logging is disabled', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: request => request.skipLogging })
+  const request = {
+    skipLogging: true,
+    log: {
+      info: () => { t.assert.fail('info should not be called') }
+    }
+  }
+  logController.routeNotFound(request, {})
+  t.assert.ok(true, 'logger was not called')
+})
+
 test('writeHeadError should not log when logging is disabled (boolean)', t => {
   t.plan(1)
   const logController = new LogController({ disableRequestLogging: true })
@@ -369,7 +382,7 @@ test('createLogController should use LogController instance directly', t => {
 
 test('createLogController should create default when no instance provided', t => {
   t.plan(2)
-  const dispatcher = createLogController({ disableRequestLogging: false, requestIdLogLabel: 'reqId' })
+  const dispatcher = createLogController({})
   t.assert.ok(dispatcher instanceof LogController)
   t.assert.strictEqual(dispatcher.requestIdLogLabel, 'reqId')
 })
@@ -377,20 +390,20 @@ test('createLogController should create default when no instance provided', t =>
 test('createLogController should throw on invalid type', t => {
   t.plan(1)
   t.assert.throws(() => {
-    createLogController({ disableRequestLogging: false, logController: 'bad' })
+    createLogController({ logController: 'bad' })
   }, { code: 'FST_ERR_LOG_INVALID_LOG_CONTROLLER' })
 })
 
 test('createLogController should throw when plain object is provided', t => {
   t.plan(1)
   t.assert.throws(() => {
-    createLogController({ disableRequestLogging: false, logController: { incomingRequest: () => { } } })
+    createLogController({ logController: { incomingRequest: () => { } } })
   }, { code: 'FST_ERR_LOG_INVALID_LOG_CONTROLLER' })
 })
 
 test('createLogController should accept null', t => {
   t.plan(1)
-  const logController = createLogController({ disableRequestLogging: false, logController: null })
+  const logController = createLogController({ logController: null })
   t.assert.ok(logController)
 })
 

package/test/internals/reply.test.js

@@ -1625,7 +1625,7 @@ test('cannot set the replySerializer when the server is running', (t, done) => {
       fastify.setReplySerializer(() => { })
       t.assert.fail('this serializer should not be setup')
     } catch (e) {
-      t.assert.strictEqual(e.code, 'FST_ERR_INSTANCE_ALREADY_LISTENING')
+      t.assert.strictEqual(e.code, 'FST_ERR_INSTANCE_ALREADY_STARTED')
     } finally {
       done()
     }

package/test/internals/request.test.js

@@ -40,9 +40,7 @@ test('Regular request', t => {
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      },
+      [kOptions]: {},
       server: {}
     }
   })
@@ -94,9 +92,7 @@ test('Request with undefined config', t => {
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      },
+      [kOptions]: {},
       server: {}
     }
   })
@@ -155,9 +151,7 @@ test('Regular request - hostname from authority', t => {
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      },
+      [kOptions]: {},
       server: {}
     }
   })
@@ -198,9 +192,7 @@ test('Regular request - host header has precedence over authority', t => {
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      },
+      [kOptions]: {},
       server: {}
     }
   })
@@ -240,9 +232,7 @@ test('Request with trust proxy', t => {
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      }
+      [kOptions]: {}
     }
   })
 
@@ -317,9 +307,7 @@ test('Request with trust proxy - no x-forwarded-host header', t => {
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      },
+      [kOptions]: {},
       server: {}
     }
   })
@@ -360,9 +348,7 @@ test('Request with trust proxy - no x-forwarded-host header and fallback to auth
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      },
+      [kOptions]: {},
       server: {}
     }
   })
@@ -463,9 +449,7 @@ test('Request with undefined socket', t => {
     server: {
       [kReply]: {},
       [kRequest]: Request,
-      [kOptions]: {
-        requestIdLogLabel: 'reqId'
-      },
+      [kOptions]: {},
       server: {}
     }
   })

package/test/logger/logging.test.js

@@ -9,7 +9,7 @@ const pino = require('pino')
 const Fastify = require('../../fastify')
 const { LogController } = require('../../lib/log-controller')
 const helper = require('../helper')
-const { once, on } = stream
+const { on } = stream
 const { request } = require('./logger-test-utils')
 const { partialDeepStrictEqual } = require('../toolkit')
 
@@ -17,7 +17,7 @@ t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost
   let localhostForURL
 
-  t.plan(16)
+  t.plan(11)
 
   t.before(async function () {
     [localhost, localhostForURL] = await helper.getLoopbackHost()
@@ -289,92 +289,6 @@ t.test('logging', { timeout: 60000 }, async (t) => {
     }
   })
 
-  await t.test('should not log incoming request and outgoing response when disabled', async (t) => {
-    t.plan(1)
-    const stream = split(JSON.parse)
-    const fastify = Fastify({ disableRequestLogging: true, logger: { level: 'info', stream } })
-    t.after(() => fastify.close())
-
-    fastify.get('/500', (req, reply) => {
-      reply.code(500).send(Error('500 error'))
-    })
-
-    await fastify.ready()
-
-    await fastify.inject({ method: 'GET', url: '/500' })
-
-    // no more readable data
-    t.assert.strictEqual(stream.readableLength, 0)
-  })
-
-  await t.test('should not log incoming request, outgoing response  and route not found for 404 onBadUrl when disabled', async (t) => {
-    t.plan(1)
-    const stream = split(JSON.parse)
-    const fastify = Fastify({ disableRequestLogging: true, logger: { level: 'info', stream } })
-    t.after(() => fastify.close())
-
-    await fastify.ready()
-
-    await fastify.inject({ method: 'GET', url: '/%c0' })
-
-    // no more readable data
-    t.assert.strictEqual(stream.readableLength, 0)
-  })
-
-  await t.test('should not log incoming request, outgoing response and route not found for 414 onMaxParamLength when disabled', async (t) => {
-    t.plan(1)
-    const stream = split(JSON.parse)
-    const fastify = Fastify({ disableRequestLogging: true, logger: { level: 'info', stream } })
-    t.after(() => fastify.close())
-
-    await fastify.ready()
-
-    await fastify.inject({
-      method: 'GET',
-      url: `/${'1234567890'.repeat(12)}`
-    })
-
-    // no more readable data
-    t.assert.strictEqual(stream.readableLength, 0)
-  })
-
-  await t.test('should log incoming request and outgoing response based on disableRequestLogging function', async (t) => {
-    const lines = [
-      'incoming request',
-      'request completed'
-    ]
-    t.plan(lines.length)
-
-    const stream = split(JSON.parse)
-    const loggerInstance = pino(stream)
-
-    const fastify = Fastify({
-      disableRequestLogging: (request) => {
-        return request.url !== '/not-logged'
-      },
-      loggerInstance
-    })
-    t.after(() => fastify.close())
-
-    fastify.get('/logged', (req, reply) => {
-      return reply.code(200).send({})
-    })
-
-    fastify.get('/not-logged', (req, reply) => {
-      return reply.code(200).send({})
-    })
-
-    await fastify.ready()
-
-    await fastify.inject({ method: 'GET', url: '/not-logged' })
-    await fastify.inject({ method: 'GET', url: '/logged' })
-
-    for await (const [line] of on(stream, 'data')) {
-      t.assert.strictEqual(line.msg, lines.shift())
-      if (lines.length === 0) break
-    }
-  })
-
   await t.test('defaults to info level', async (t) => {
     const lines = [
       { req: { method: 'GET' }, msg: 'incoming request' },
@@ -480,37 +394,4 @@ t.test('logging', { timeout: 60000 }, async (t) => {
       if (lines.length === 0) break
     }
   })
-
-  await t.test('should not log the error if request logging is disabled', async (t) => {
-    t.plan(4)
-
-    const stream = split(JSON.parse)
-    const fastify = Fastify({
-      logger: {
-        stream,
-        level: 'info'
-      },
-      disableRequestLogging: true
-    })
-    t.after(() => fastify.close())
-
-    fastify.get('/error', function (req, reply) {
-      t.assert.ok(req.log)
-      reply.send(new Error('a generic error'))
-    })
-
-    await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
-
-    await request(`http://${localhostForURL}:` + fastify.server.address().port + '/error')
-
-    {
-      const [line] = await once(stream, 'data')
-      t.assert.ok(typeof line.msg === 'string')
-      t.assert.ok(line.msg.startsWith('Server listening at'), 'message is set')
-    }
-
-    // no more readable data
-    t.assert.strictEqual(stream.readableLength, 0)
-  })
 })

package/test/logger/request.test.js

@@ -14,7 +14,7 @@ const { partialDeepStrictEqual } = require('../toolkit')
 t.test('request', { timeout: 60000 }, async (t) => {
   let localhost
 
-  t.plan(7)
+  t.plan(6)
   t.before(async function () {
     [localhost] = await helper.getLoopbackHost()
   })
@@ -180,41 +180,6 @@ t.test('request', { timeout: 60000 }, async (t) => {
     }
   })
 
-  await t.test('The request id log label can be changed', async (t) => {
-    const REQUEST_ID = '42'
-    const matches = [
-      { traceId: REQUEST_ID, msg: 'incoming request' },
-      { traceId: REQUEST_ID, msg: 'some log message' },
-      { traceId: REQUEST_ID, msg: 'request completed' }
-    ]
-    t.plan(matches.length + 2)
-
-    const stream = split(JSON.parse)
-    const fastify = Fastify({
-      logger: { stream, level: 'info' },
-      requestIdHeader: 'my-custom-request-id',
-      requestIdLogLabel: 'traceId'
-    })
-    t.after(() => fastify.close())
-
-    fastify.get('/one', (req, reply) => {
-      t.assert.strictEqual(req.id, REQUEST_ID)
-      req.log.info('some log message')
-      reply.send({ id: req.id })
-    })
-
-    {
-      const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'my-custom-request-id': REQUEST_ID } })
-      const body = await response.json()
-      t.assert.strictEqual(body.id, REQUEST_ID)
-    }
-
-    for await (const [line] of on(stream, 'data')) {
-      t.assert.ok(partialDeepStrictEqual(line, matches.shift()))
-      if (matches.length === 0) break
-    }
-  })
-
   await t.test('should redact the authorization header if so specified', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({

package/test/plugin.4.test.js

@@ -3,7 +3,6 @@
 const { test, describe } = require('node:test')
 const Fastify = require('../fastify')
 const fp = require('fastify-plugin')
-const fakeTimer = require('@sinonjs/fake-timers')
 const { FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER } = require('../lib/errors')
 
 test('pluginTimeout', (t, testDone) => {
@@ -46,12 +45,14 @@ test('pluginTimeout - named function', (t, testDone) => {
 
 test('pluginTimeout default', (t, testDone) => {
   t.plan(5)
-  const clock = fakeTimer.install({ shouldClearNativeTimers: true })
+  t.mock.timers.enable({
+    apis: ['setTimeout', 'Date']
+  })
 
   const fastify = Fastify()
   fastify.register(function (app, opts, done) {
     // default time elapsed without calling done
-    clock.tick(10000)
+    t.mock.timers.tick(10000)
   })
 
   fastify.ready((err) => {
@@ -64,7 +65,7 @@ test('pluginTimeout default', (t, testDone) => {
     testDone()
   })
 
-  t.after(clock.uninstall)
+  t.after(() => t.mock.timers.reset())
 })
 
 test('plugin metadata - version', (t, testDone) => {

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()
   })
 })