fastify 4.25.2 → 4.26.1

package/test/genReqId.test.js

@@ -2,6 +2,7 @@
 
 const { Readable } = require('node:stream')
 const { test } = require('tap')
+const fp = require('fastify-plugin')
 const Fastify = require('..')
 
 test('Should accept a custom genReqId function', t => {
@@ -72,3 +73,394 @@ test('Custom genReqId function gets raw request as argument', t => {
     })
   })
 })
+
+test('Should accept option to set genReqId with setGenReqId option', t => {
+  t.plan(9)
+
+  const fastify = Fastify({
+    genReqId: function (req) {
+      return 'base'
+    }
+  })
+
+  fastify.register(function (instance, opts, next) {
+    instance.setGenReqId(function (req) {
+      return 'foo'
+    })
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }, { prefix: 'foo' })
+
+  fastify.register(function (instance, opts, next) {
+    instance.setGenReqId(function (req) {
+      return 'bar'
+    })
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }, { prefix: 'bar' })
+
+  fastify.get('/', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'base')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/bar'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'bar')
+    fastify.close()
+  })
+})
+
+test('Should encapsulate setGenReqId', t => {
+  t.plan(12)
+
+  const fastify = Fastify({
+    genReqId: function (req) {
+      return 'base'
+    }
+  })
+
+  const bazInstance = function (instance, opts, next) {
+    instance.register(barInstance, { prefix: 'baz' })
+
+    instance.setGenReqId(function (req) {
+      return 'baz'
+    })
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  const barInstance = function (instance, opts, next) {
+    instance.setGenReqId(function (req) {
+      return 'bar'
+    })
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  const fooInstance = function (instance, opts, next) {
+    instance.register(bazInstance, { prefix: 'baz' })
+    instance.register(barInstance, { prefix: 'bar' })
+
+    instance.setGenReqId(function (req) {
+      return 'foo'
+    })
+
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  fastify.register(fooInstance, { prefix: 'foo' })
+
+  fastify.get('/', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'base')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo/bar'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'bar')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo/baz'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'baz')
+    fastify.close()
+  })
+})
+
+test('Should encapsulate setGenReqId', t => {
+  t.plan(12)
+
+  const fastify = Fastify({
+    genReqId: function (req) {
+      return 'base'
+    }
+  })
+
+  const bazInstance = function (instance, opts, next) {
+    instance.register(barInstance, { prefix: 'baz' })
+
+    instance.setGenReqId(function (req) {
+      return 'baz'
+    })
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  const barInstance = function (instance, opts, next) {
+    instance.setGenReqId(function (req) {
+      return 'bar'
+    })
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  const fooInstance = function (instance, opts, next) {
+    instance.register(bazInstance, { prefix: 'baz' })
+    instance.register(barInstance, { prefix: 'bar' })
+
+    instance.setGenReqId(function (req) {
+      return 'foo'
+    })
+
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  fastify.register(fooInstance, { prefix: 'foo' })
+
+  fastify.get('/', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'base')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo/bar'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'bar')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo/baz'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'baz')
+    fastify.close()
+  })
+})
+
+test('Should not alter parent of genReqId', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  const fooInstance = function (instance, opts, next) {
+    instance.setGenReqId(function (req) {
+      return 'foo'
+    })
+
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  fastify.register(fooInstance, { prefix: 'foo' })
+
+  fastify.get('/', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'req-1')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+    fastify.close()
+  })
+})
+
+test('Should have child instance user parent genReqId', t => {
+  t.plan(6)
+
+  const fastify = Fastify({
+    genReqId: function (req) {
+      return 'foo'
+    }
+  })
+
+  const fooInstance = function (instance, opts, next) {
+    instance.get('/', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    next()
+  }
+
+  fastify.register(fooInstance, { prefix: 'foo' })
+
+  fastify.get('/', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/foo'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+    fastify.close()
+  })
+})
+
+test('genReqId set on root scope when using fastify-plugin', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.register(fp(function (fastify, options, done) {
+    fastify.setGenReqId(function (req) {
+      return 'not-encapsulated'
+    })
+    fastify.get('/not-encapsulated-1', (req, reply) => {
+      t.ok(req.id)
+      reply.send({ id: req.id })
+    })
+    done()
+  }))
+
+  fastify.get('/not-encapsulated-2', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/not-encapsulated-1'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'not-encapsulated')
+    fastify.close()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/not-encapsulated-2'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'not-encapsulated')
+    fastify.close()
+  })
+})

package/test/hooks.on-listen.test.js

@@ -5,9 +5,7 @@ const Fastify = require('../fastify')
 const fp = require('fastify-plugin')
 const split = require('split2')
 const helper = require('./helper')
-
-// fix citgm @aix72-ppc64
-const LISTEN_READYNESS = process.env.CITGM ? 250 : 50
+const { kState } = require('../lib/symbols')
 
 let localhost
 before(async function () {
@@ -274,8 +272,8 @@ test('localhost Register onListen hook after a plugin inside a plugin should log
   })
 })
 
-test('localhost onListen encapsulation should be called in order', t => {
-  t.plan(6)
+test('localhost onListen encapsulation should be called in order', async t => {
+  t.plan(8)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
@@ -287,20 +285,75 @@ test('localhost onListen encapsulation should be called in order', t => {
     done()
   })
 
-  fastify.register(async (childOne, o) => {
+  await fastify.register(async (childOne, o) => {
     childOne.addHook('onListen', function (done) {
       t.equal(++order, 2, 'called in childOne')
       t.equal(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
       done()
     })
-    childOne.register(async (childTwo, o) => {
+
+    await childOne.register(async (childTwo, o) => {
       childTwo.addHook('onListen', async function () {
         t.equal(++order, 3, 'called in childTwo')
         t.equal(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
       })
     })
+
+    await childOne.register(async (childTwoPeer, o) => {
+      childTwoPeer.addHook('onListen', async function () {
+        t.equal(++order, 4, 'called second in childTwo')
+        t.equal(this.pluginName, childTwoPeer.pluginName, 'the this binding is the right instance')
+      })
+    })
   })
-  fastify.listen({
+  await fastify.listen({
+    host: 'localhost',
+    port: 0
+  })
+})
+
+test('localhost onListen encapsulation with only nested hook', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  await fastify.register(async (child) => {
+    await child.register(async (child2) => {
+      child2.addHook('onListen', function (done) {
+        t.pass()
+        done()
+      })
+    })
+  })
+
+  await fastify.listen({
+    host: 'localhost',
+    port: 0
+  })
+})
+
+test('localhost onListen peer encapsulations with only nested hooks', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  await fastify.register(async (child) => {
+    await child.register(async (child2) => {
+      child2.addHook('onListen', function (done) {
+        t.pass()
+        done()
+      })
+    })
+
+    await child.register(async (child2) => {
+      child2.addHook('onListen', function (done) {
+        t.pass()
+        done()
+      })
+    })
+  })
+
+  await fastify.listen({
     host: 'localhost',
     port: 0
   })
@@ -1056,36 +1109,35 @@ test('async onListen does not need to be awaited', t => {
 
 test('onListen hooks do not block /1', t => {
   t.plan(2)
+
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
   fastify.addHook('onListen', function (done) {
-    setTimeout(done, 500)
+    t.equal(fastify[kState].listening, true)
+    done()
   })
 
-  const startDate = new Date()
   fastify.listen({
     host: 'localhost',
     port: 0
   }, err => {
     t.error(err)
-    t.ok(new Date() - startDate < LISTEN_READYNESS)
   })
 })
 
 test('onListen hooks do not block /2', async t => {
   t.plan(1)
+
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
   fastify.addHook('onListen', async function () {
-    await new Promise(resolve => setTimeout(resolve, 500))
+    t.equal(fastify[kState].listening, true)
   })
 
-  const startDate = new Date()
   await fastify.listen({
     host: 'localhost',
     port: 0
   })
-  t.ok(new Date() - startDate < LISTEN_READYNESS)
 })

package/test/hooks.on-ready.test.js

@@ -295,7 +295,7 @@ t.test('onReady cannot add lifecycle hooks', t => {
       t.ok(error)
       t.equal(error.message, 'Root plugin has already booted')
       // TODO: look where the error pops up
-      t.equal(error.code, 'AVV_ERR_PLUGIN_NOT_VALID')
+      t.equal(error.code, 'AVV_ERR_ROOT_PLG_BOOTED')
       done(error)
     }
   })

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-test('should expose 78 errors', t => {
+test('should expose 79 errors', t => {
   t.plan(1)
   const exportedKeys = Object.keys(errors)
   let counter = 0
@@ -14,11 +14,11 @@ test('should expose 78 errors', t => {
       counter++
     }
   }
-  t.equal(counter, 78)
+  t.equal(counter, 79)
 })
 
 test('ensure name and codes of Errors are identical', t => {
-  t.plan(78)
+  t.plan(79)
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -337,6 +337,16 @@ test('FST_ERR_REP_INVALID_PAYLOAD_TYPE', t => {
   t.ok(error instanceof TypeError)
 })
 
+test('FST_ERR_REP_RESPONSE_BODY_CONSUMED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_REP_RESPONSE_BODY_CONSUMED()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_REP_RESPONSE_BODY_CONSUMED')
+  t.equal(error.message, 'Response.body is already consumed.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof Error)
+})
+
 test('FST_ERR_REP_ALREADY_SENT', t => {
   t.plan(5)
   const error = new errors.FST_ERR_REP_ALREADY_SENT('/hello', 'GET')
@@ -818,7 +828,7 @@ test('FST_ERR_LISTEN_OPTIONS_INVALID', t => {
 })
 
 test('Ensure that all errors are in Errors.md TOC', t => {
-  t.plan(78)
+  t.plan(79)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -830,7 +840,7 @@ test('Ensure that all errors are in Errors.md TOC', t => {
 })
 
 test('Ensure that non-existing errors are not in Errors.md TOC', t => {
-  t.plan(78)
+  t.plan(79)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = / {4}- \[([A-Z0-9_]+)\]\(#[a-z0-9_]+\)/g
@@ -843,7 +853,7 @@ test('Ensure that non-existing errors are not in Errors.md TOC', t => {
 })
 
 test('Ensure that all errors are in Errors.md documented', t => {
-  t.plan(78)
+  t.plan(79)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -855,7 +865,7 @@ test('Ensure that all errors are in Errors.md documented', t => {
 })
 
 test('Ensure that non-existing errors are not in Errors.md documented', t => {
-  t.plan(78)
+  t.plan(79)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = /<a id="[0-9a-zA-Z_]+">([0-9a-zA-Z_]+)<\/a>/g

package/test/internals/initialConfig.test.js

@@ -48,14 +48,15 @@ test('without options passed to Fastify, initialConfig should expose default val
     requestIdHeader: 'request-id',
     requestIdLogLabel: 'reqId',
     http2SessionTimeout: 72000,
-    exposeHeadRoutes: true
+    exposeHeadRoutes: true,
+    useSemicolonDelimiter: true
   }
 
   t.same(Fastify().initialConfig, fastifyDefaultOptions)
 })
 
 test('Fastify.initialConfig should expose all options', t => {
-  t.plan(21)
+  t.plan(22)
 
   const serverFactory = (handler, opts) => {
     const server = http.createServer((req, res) => {
@@ -99,6 +100,7 @@ test('Fastify.initialConfig should expose all options', t => {
     allowUnsafeRegex: false,
     requestIdHeader: 'request-id-alt',
     pluginTimeout: 20000,
+    useSemicolonDelimiter: false,
     querystringParser: str => str,
     genReqId: function (req) {
       return reqId++
@@ -123,6 +125,7 @@ test('Fastify.initialConfig should expose all options', t => {
   t.equal(fastify.initialConfig.bodyLimit, 1049600)
   t.equal(fastify.initialConfig.onProtoPoisoning, 'remove')
   t.equal(fastify.initialConfig.caseSensitive, true)
+  t.equal(fastify.initialConfig.useSemicolonDelimiter, false)
   t.equal(fastify.initialConfig.allowUnsafeRegex, false)
   t.equal(fastify.initialConfig.requestIdHeader, 'request-id-alt')
   t.equal(fastify.initialConfig.pluginTimeout, 20000)
@@ -285,7 +288,8 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       requestIdHeader: 'request-id',
       requestIdLogLabel: 'reqId',
       http2SessionTimeout: 72000,
-      exposeHeadRoutes: true
+      exposeHeadRoutes: true,
+      useSemicolonDelimiter: true
     })
   } catch (error) {
     t.fail()