fastify 5.3.3 → 5.4.0

package/test/set-error-handler.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const { FST_ERR_ERROR_HANDLER_NOT_FN } = require('../lib/errors')
+const { FST_ERR_ERROR_HANDLER_NOT_FN, FST_ERR_ERROR_HANDLER_ALREADY_SET } = require('../lib/errors')
 
 test('setErrorHandler should throw an error if the handler is not a function', t => {
   t.plan(1)
@@ -10,3 +10,60 @@ test('setErrorHandler should throw an error if the handler is not a function', t
 
   t.assert.throws(() => fastify.setErrorHandler('not a function'), new FST_ERR_ERROR_HANDLER_NOT_FN())
 })
+
+test('setErrorHandler can be set independently in parent and child scopes', async t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  t.assert.doesNotThrow(() => {
+    fastify.setErrorHandler(() => {})
+    fastify.register(async (child) => {
+      child.setErrorHandler(() => {})
+    })
+  })
+})
+
+test('setErrorHandler can be overriden if allowErrorHandlerOverride is set to true', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.register(async (child) => {
+    child.setErrorHandler(() => {})
+    t.assert.doesNotThrow(() => child.setErrorHandler(() => {}))
+  })
+
+  fastify.setErrorHandler(() => {})
+  t.assert.doesNotThrow(() => fastify.setErrorHandler(() => {}))
+
+  await fastify.ready()
+})
+
+test('if `allowErrorHandlerOverride` is disabled, setErrorHandler should throw if called more than once in the same scope', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    allowErrorHandlerOverride: false
+  })
+
+  fastify.setErrorHandler(() => {})
+  t.assert.throws(() => fastify.setErrorHandler(() => {}), new FST_ERR_ERROR_HANDLER_ALREADY_SET())
+})
+
+test('if `allowErrorHandlerOverride` is disabled, setErrorHandler should throw if called more than once in the same scope 2', async t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    allowErrorHandlerOverride: false
+  })
+  t.after(() => fastify.close())
+
+  fastify.register(async (child) => {
+    child.setErrorHandler(() => {})
+    t.assert.throws(() => child.setErrorHandler(() => {}), new FST_ERR_ERROR_HANDLER_ALREADY_SET())
+  })
+
+  await fastify.ready()
+})

package/test/skip-reply-send.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test, describe } = require('node:test')
 const split = require('split2')
 const net = require('node:net')
 const Fastify = require('../fastify')
@@ -19,7 +19,7 @@ const lifecycleHooks = [
   'onError'
 ]
 
-test('skip automatic reply.send() with reply.hijack and a body', (t) => {
+test('skip automatic reply.send() with reply.hijack and a body', async (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -28,8 +28,8 @@ test('skip automatic reply.send() with reply.hijack and a body', (t) => {
   })
 
   stream.on('data', (line) => {
-    t.not(line.level, 40) // there are no errors
-    t.not(line.level, 50) // there are no errors
+    t.assert.notStrictEqual(line.level, 40) // there are no errors
+    t.assert.notStrictEqual(line.level, 50) // there are no errors
   })
 
   app.get('/', (req, reply) => {
@@ -39,16 +39,16 @@ test('skip automatic reply.send() with reply.hijack and a body', (t) => {
     return Promise.resolve('this will be skipped')
   })
 
-  return app.inject({
+  await app.inject({
     method: 'GET',
     url: '/'
   }).then((res) => {
-    t.equal(res.statusCode, 200)
-    t.equal(res.body, 'hello world')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
   })
 })
 
-test('skip automatic reply.send() with reply.hijack and no body', (t) => {
+test('skip automatic reply.send() with reply.hijack and no body', async (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -57,8 +57,8 @@ test('skip automatic reply.send() with reply.hijack and no body', (t) => {
   })
 
   stream.on('data', (line) => {
-    t.not(line.level, 40) // there are no error
-    t.not(line.level, 50) // there are no error
+    t.assert.notStrictEqual(line.level, 40) // there are no error
+    t.assert.notStrictEqual(line.level, 50) // there are no error
   })
 
   app.get('/', (req, reply) => {
@@ -68,16 +68,16 @@ test('skip automatic reply.send() with reply.hijack and no body', (t) => {
     return Promise.resolve()
   })
 
-  return app.inject({
+  await app.inject({
     method: 'GET',
     url: '/'
   }).then((res) => {
-    t.equal(res.statusCode, 200)
-    t.equal(res.body, 'hello world')
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
   })
 })
 
-test('skip automatic reply.send() with reply.hijack and an error', (t) => {
+test('skip automatic reply.send() with reply.hijack and an error', async (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -90,8 +90,8 @@ test('skip automatic reply.send() with reply.hijack and an error', (t) => {
   stream.on('data', (line) => {
     if (line.level === 50) {
       errorSeen = true
-      t.equal(line.err.message, 'kaboom')
-      t.equal(line.msg, 'Promise errored, but reply.sent = true was set')
+      t.assert.strictEqual(line.err.message, 'kaboom')
+      t.assert.strictEqual(line.msg, 'Promise errored, but reply.sent = true was set')
     }
   })
 
@@ -102,13 +102,13 @@ test('skip automatic reply.send() with reply.hijack and an error', (t) => {
     return Promise.reject(new Error('kaboom'))
   })
 
-  return app.inject({
+  await app.inject({
     method: 'GET',
     url: '/'
   }).then((res) => {
-    t.equal(errorSeen, true)
-    t.equal(res.statusCode, 200)
-    t.equal(res.body, 'hello world')
+    t.assert.strictEqual(errorSeen, true)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.body, 'hello world')
   })
 })
 
@@ -117,11 +117,8 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
   const previousHooks = lifecycleHooks.slice(0, idx)
   const nextHooks = lifecycleHooks.slice(idx + 1)
 
-  test(`Hijacking inside ${hookOrHandler} skips all the following hooks and handler execution`, t => {
-    t.plan(4)
-    const test = t.test
-
-    test('Sending a response using reply.raw => onResponse hook is called', t => {
+  describe(`Hijacking inside ${hookOrHandler} skips all the following hooks and handler execution`, () => {
+    test('Sending a response using reply.raw => onResponse hook is called', async (t) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
@@ -130,11 +127,11 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
       })
 
       stream.on('data', (line) => {
-        t.not(line.level, 40) // there are no errors
-        t.not(line.level, 50) // there are no errors
+        t.assert.notStrictEqual(line.level, 40) // there are no errors
+        t.assert.notStrictEqual(line.level, 50) // there are no errors
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -146,41 +143,41 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           reply.hijack()
           reply.raw.end(`hello from ${hookOrHandler}`)
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
       nextHooks.forEach(h => {
         if (h === 'onResponse') {
-          app.addHook(h, async (req, reply) => t.pass(`${h} should be called`))
+          app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`))
         } else {
-          app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`))
+          app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`))
         }
       })
 
-      return app.inject({
+      await app.inject({
         method: 'GET',
         url: '/'
       }).then((res) => {
-        t.equal(res.statusCode, 200)
-        t.equal(res.body, `hello from ${hookOrHandler}`)
+        t.assert.strictEqual(res.statusCode, 200)
+        t.assert.strictEqual(res.body, `hello from ${hookOrHandler}`)
       })
     })
 
-    test('Sending a response using req.socket => onResponse not called', t => {
+    test('Sending a response using req.socket => onResponse not called', (t, testDone) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
           stream
         }
       })
-      t.teardown(() => app.close())
+      t.after(() => app.close())
 
       stream.on('data', (line) => {
-        t.not(line.level, 40) // there are no errors
-        t.not(line.level, 50) // there are no errors
+        t.assert.notStrictEqual(line.level, 40) // there are no errors
+        t.assert.notStrictEqual(line.level, 50) // there are no errors
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -196,13 +193,13 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           req.socket.write(`hello from ${hookOrHandler}`)
           req.socket.end()
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
-      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
 
       app.listen({ port: 0 }, err => {
-        t.error(err)
+        t.assert.ifError(err)
         const client = net.createConnection({ port: (app.server.address()).port }, () => {
           client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
@@ -213,36 +210,36 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           })
 
           client.on('end', function () {
-            t.match(chunks, new RegExp(`hello from ${hookOrHandler}`, 'i'))
-            t.end()
+            t.assert.match(chunks, new RegExp(`hello from ${hookOrHandler}`, 'i'))
+            testDone()
           })
         })
       })
     })
 
-    test('Throwing an error does not trigger any hooks', t => {
+    test('Throwing an error does not trigger any hooks', async (t) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
           stream
         }
       })
-      t.teardown(() => app.close())
+      t.after(() => app.close())
 
       let errorSeen = false
       stream.on('data', (line) => {
         if (hookOrHandler === 'handler') {
           if (line.level === 40) {
             errorSeen = true
-            t.equal(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+            t.assert.strictEqual(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
           }
         } else {
-          t.not(line.level, 40) // there are no errors
-          t.not(line.level, 50) // there are no errors
+          t.assert.notStrictEqual(line.level, 40) // there are no errors
+          t.assert.notStrictEqual(line.level, 50) // there are no errors
         }
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -254,23 +251,22 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           reply.hijack()
           throw new Error('This wil be skipped')
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
-      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
 
-      return Promise.race([
+      await Promise.race([
         app.inject({ method: 'GET', url: '/' }),
         new Promise((resolve, reject) => setTimeout(resolve, 1000))
-      ]).then((err, res) => {
-        t.error(err)
-        if (hookOrHandler === 'handler') {
-          t.equal(errorSeen, true)
-        }
-      })
+      ])
+
+      if (hookOrHandler === 'handler') {
+        t.assert.strictEqual(errorSeen, true)
+      }
     })
 
-    test('Calling reply.send() after hijacking logs a warning', t => {
+    test('Calling reply.send() after hijacking logs a warning', async (t) => {
       const stream = split(JSON.parse)
       const app = Fastify({
         logger: {
@@ -283,11 +279,11 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
       stream.on('data', (line) => {
         if (line.level === 40) {
           errorSeen = true
-          t.equal(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
+          t.assert.strictEqual(line.err.code, 'FST_ERR_REP_ALREADY_SENT')
         }
       })
 
-      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.pass(`${h} should be called`)))
+      previousHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.ok(`${h} should be called`)))
 
       if (hookOrHandler === 'handler') {
         app.get('/', (req, reply) => {
@@ -299,18 +295,17 @@ function testHandlerOrBeforeHandlerHook (test, hookOrHandler) {
           reply.hijack()
           return reply.send('hello from reply.send()')
         })
-        app.get('/', (req, reply) => t.fail('Handler should not be called'))
+        app.get('/', (req, reply) => t.assert.fail('Handler should not be called'))
       }
 
-      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.fail(`${h} should not be called`)))
+      nextHooks.forEach(h => app.addHook(h, async (req, reply) => t.assert.fail(`${h} should not be called`)))
 
-      return Promise.race([
+      await Promise.race([
         app.inject({ method: 'GET', url: '/' }),
         new Promise((resolve, reject) => setTimeout(resolve, 1000))
-      ]).then((err, res) => {
-        t.error(err)
-        t.equal(errorSeen, true)
-      })
+      ])
+
+      t.assert.strictEqual(errorSeen, true)
     })
   })
 }

package/test/trust-proxy.test.js

@@ -1,14 +1,10 @@
 'use strict'
 
 const { test, before } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('..')
 const helper = require('./helper')
-const { waitForCb } = require('./toolkit')
 
-const noop = () => {}
-
-const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) => {
+const fetchForwardedRequest = async (fastifyServer, forHeader, path, protoHeader) => {
   const headers = {
     'X-Forwarded-For': forHeader,
     'X-Forwarded-Host': 'example.com'
@@ -16,11 +12,10 @@ const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) =
   if (protoHeader) {
     headers['X-Forwarded-Proto'] = protoHeader
   }
-  sget({
-    method: 'GET',
-    headers,
-    url: 'http://localhost:' + app.server.address().port + path
-  }, testCaseDone || noop)
+
+  return fetch(fastifyServer + path, {
+    headers
+  })
 }
 
 const testRequestValues = (t, req, options) => {
@@ -52,8 +47,8 @@ before(async function () {
   [localhost] = await helper.getLoopbackHost()
 })
 
-test('trust proxy, not add properties to node req', (t, done) => {
-  t.plan(14)
+test('trust proxy, not add properties to node req', async t => {
+  t.plan(13)
   const app = fastify({
     trustProxy: true
   })
@@ -69,20 +64,14 @@ test('trust proxy, not add properties to node req', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    const completion = waitForCb({ steps: 2 })
-
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy', undefined, completion.stepIn)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined, completion.stepIn)
+  const fastifyServer = await app.listen({ port: 0 })
 
-    completion.patience.then(done)
-  })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxy', undefined)
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined)
 })
 
-test('trust proxy chain', (t, done) => {
-  t.plan(9)
+test('trust proxy chain', async t => {
+  t.plan(8)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
   })
@@ -93,14 +82,12 @@ test('trust proxy chain', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined)
 })
 
-test('trust proxy function', (t, done) => {
-  t.plan(9)
+test('trust proxy function', async t => {
+  t.plan(8)
   const app = fastify({
     trustProxy: (address) => address === localhost
   })
@@ -111,14 +98,12 @@ test('trust proxy function', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined)
 })
 
-test('trust proxy number', (t, done) => {
-  t.plan(10)
+test('trust proxy number', async t => {
+  t.plan(9)
   const app = fastify({
     trustProxy: 1
   })
@@ -129,14 +114,12 @@ test('trust proxy number', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined)
 })
 
-test('trust proxy IP addresses', (t, done) => {
-  t.plan(10)
+test('trust proxy IP addresses', async t => {
+  t.plan(9)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
   })
@@ -147,14 +130,12 @@ test('trust proxy IP addresses', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined)
 })
 
-test('trust proxy protocol', (t, done) => {
-  t.plan(31)
+test('trust proxy protocol', async t => {
+  t.plan(30)
   const app = fastify({
     trustProxy: true
   })
@@ -173,16 +154,9 @@ test('trust proxy protocol', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    const completion = waitForCb({ steps: 3 })
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocol', 'lorem', completion.stepIn)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxynoprotocol', undefined, completion.stepIn)
+  const fastifyServer = await app.listen({ port: 0 })
 
-    // Allow for sgetForwardedRequest requests above to finish
-    setTimeout(() => sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', completion.stepIn))
-
-    completion.patience.then(done)
-  })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocol', 'lorem')
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxynoprotocol', undefined)
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor')
 })

package/test/types/fastify.test-d.ts

@@ -273,3 +273,6 @@ expectType<FastifyErrorCodes>(fastify.errorCodes)
 fastify({ allowUnsafeRegex: true })
 fastify({ allowUnsafeRegex: false })
 expectError(fastify({ allowUnsafeRegex: 'invalid' }))
+
+expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: true }))
+expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: false }))

package/test/types/request.test-d.ts

@@ -78,6 +78,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifySchema | undefined>(request.routeOptions.schema)
   expectType<RouteHandlerMethod>(request.routeOptions.handler)
   expectType<string | undefined>(request.routeOptions.url)
+  expectType<string | undefined>(request.routeOptions.version)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
   request.headers = {}