fastify 4.27.0 → 5.0.0-alpha.2

package/test/https/https.test.js

@@ -74,3 +74,60 @@ test('https', (t) => {
     })
   })
 })
+
+test('https - headers', (t) => {
+  t.plan(4)
+  let fastify
+  try {
+    fastify = Fastify({
+      https: {
+        key: global.context.key,
+        cert: global.context.cert
+      }
+    })
+    t.pass('Key/cert successfully loaded')
+  } catch (e) {
+    t.fail('Key/cert loading failed', e)
+  }
+
+  fastify.get('/', function (req, reply) {
+    reply.code(200).send({ hello: 'world', hostname: req.hostname, port: req.port })
+  })
+
+  t.teardown(async () => { await fastify.close() })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    t.test('https get request', t => {
+      t.plan(4)
+      sget({
+        method: 'GET',
+        url: 'https://localhost:' + fastify.server.address().port,
+        rejectUnauthorized: false
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        const parsedBody = JSON.parse(body)
+        t.equal(parsedBody.hostname, 'localhost')
+        t.equal(parsedBody.port, fastify.server.address().port)
+      })
+    })
+    t.test('https get request - test port fall back', t => {
+      t.plan(3)
+      sget({
+        method: 'GET',
+        headers: {
+          host: 'example.com'
+        },
+        url: 'https://localhost:' + fastify.server.address().port,
+        rejectUnauthorized: false
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        const parsedBody = JSON.parse(body)
+        t.equal(parsedBody.port, null)
+      })
+    })
+  })
+})

package/test/inject.test.js

@@ -5,7 +5,6 @@ const test = t.test
 const Stream = require('node:stream')
 const util = require('node:util')
 const Fastify = require('..')
-const FormData = require('form-data')
 const { Readable } = require('node:stream')
 
 test('inject should exist', t => {
@@ -343,7 +342,7 @@ test('inject a multipart request using form-body', t => {
   })
 
   const form = new FormData()
-  form.append('my_field', 'my value')
+  form.set('my_field', 'my value')
 
   fastify.inject({
     method: 'POST',

package/test/internals/decorator.test.js

@@ -1,7 +1,5 @@
 'use strict'
 
-/* eslint no-prototype-builtins: 0 */
-
 const t = require('tap')
 const test = t.test
 const decorator = require('../../lib/decorate')

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 80 errors', t => {
+test('should expose 84 errors', t => {
   t.plan(1)
   const exportedKeys = Object.keys(errors)
   let counter = 0
@@ -14,11 +14,11 @@ test('should expose 80 errors', t => {
       counter++
     }
   }
-  t.equal(counter, 80)
+  t.equal(counter, 84)
 })
 
 test('ensure name and codes of Errors are identical', t => {
-  t.plan(80)
+  t.plan(84)
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -247,6 +247,16 @@ test('FST_ERR_DEC_AFTER_START', t => {
   t.ok(error instanceof Error)
 })
 
+test('FST_ERR_DEC_REFERENCE_TYPE', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_DEC_REFERENCE_TYPE()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_DEC_REFERENCE_TYPE')
+  t.equal(error.message, "The decorator '%s' of type '%s' is a reference type. Use the { getter, setter } interface instead.")
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof Error)
+})
+
 test('FST_ERR_HOOK_INVALID_TYPE', t => {
   t.plan(5)
   const error = new errors.FST_ERR_HOOK_INVALID_TYPE()
@@ -327,6 +337,36 @@ test('FST_ERR_LOG_INVALID_LOGGER', t => {
   t.ok(error instanceof TypeError)
 })
 
+test('FST_ERR_LOG_INVALID_LOGGER_INSTANCE', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_LOG_INVALID_LOGGER_INSTANCE()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_LOG_INVALID_LOGGER_INSTANCE')
+  t.equal(error.message, 'loggerInstance only accepts a logger instance.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
+test('FST_ERR_LOG_INVALID_LOGGER_CONFIG', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_LOG_INVALID_LOGGER_CONFIG()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_LOG_INVALID_LOGGER_CONFIG')
+  t.equal(error.message, 'logger options only accepts a configuration object.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
+test('FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED()
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED')
+  t.equal(error.message, 'You cannot provide both logger and loggerInstance. Please provide only one.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
 test('FST_ERR_REP_INVALID_PAYLOAD_TYPE', t => {
   t.plan(5)
   const error = new errors.FST_ERR_REP_INVALID_PAYLOAD_TYPE()
@@ -587,16 +627,6 @@ test('FST_ERR_ASYNC_CONSTRAINT', t => {
   t.ok(error instanceof Error)
 })
 
-test('FST_ERR_DEFAULT_ROUTE_INVALID_TYPE', t => {
-  t.plan(5)
-  const error = new errors.FST_ERR_DEFAULT_ROUTE_INVALID_TYPE()
-  t.equal(error.name, 'FastifyError')
-  t.equal(error.code, 'FST_ERR_DEFAULT_ROUTE_INVALID_TYPE')
-  t.equal(error.message, 'The defaultRoute type should be a function')
-  t.equal(error.statusCode, 500)
-  t.ok(error instanceof TypeError)
-})
-
 test('FST_ERR_INVALID_URL', t => {
   t.plan(5)
   const error = new errors.FST_ERR_INVALID_URL()
@@ -757,6 +787,16 @@ test('FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE', t => {
   t.ok(error instanceof Error)
 })
 
+test('FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER('easter-egg')
+  t.equal(error.name, 'FastifyError')
+  t.equal(error.code, 'FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER')
+  t.equal(error.message, 'The easter-egg plugin being registered mixes async and callback styles. Async plugin should not mix async and callback style.')
+  t.equal(error.statusCode, 500)
+  t.ok(error instanceof TypeError)
+})
+
 test('FST_ERR_PLUGIN_CALLBACK_NOT_FN', t => {
   t.plan(5)
   const error = new errors.FST_ERR_PLUGIN_CALLBACK_NOT_FN()
@@ -838,7 +878,7 @@ test('FST_ERR_ERROR_HANDLER_NOT_FN', t => {
 })
 
 test('Ensure that all errors are in Errors.md TOC', t => {
-  t.plan(80)
+  t.plan(84)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -850,7 +890,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(80)
+  t.plan(84)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = / {4}- \[([A-Z0-9_]+)\]\(#[a-z0-9_]+\)/g
@@ -863,7 +903,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(80)
+  t.plan(84)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -875,7 +915,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(80)
+  t.plan(84)
   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/handleRequest.test.js

@@ -94,7 +94,11 @@ test('handler function - reply', t => {
     preValidation: [],
     preHandler: [],
     onSend: [],
-    onError: []
+    onError: [],
+    config: {
+      url: '',
+      method: ''
+    }
   }
   buildSchema(context, schemaValidator)
   internals.handler({ [kRouteContext]: context }, new Reply(res, { [kRouteContext]: context }))

package/test/internals/initialConfig.test.js

@@ -45,11 +45,11 @@ test('without options passed to Fastify, initialConfig should expose default val
     onProtoPoisoning: 'error',
     onConstructorPoisoning: 'error',
     pluginTimeout: 10000,
-    requestIdHeader: 'request-id',
+    requestIdHeader: false,
     requestIdLogLabel: 'reqId',
     http2SessionTimeout: 72000,
     exposeHeadRoutes: true,
-    useSemicolonDelimiter: true
+    useSemicolonDelimiter: false
   }
 
   t.same(Fastify().initialConfig, fastifyDefaultOptions)
@@ -105,7 +105,7 @@ test('Fastify.initialConfig should expose all options', t => {
     genReqId: function (req) {
       return reqId++
     },
-    logger: pino({ level: 'info' }),
+    loggerInstance: pino({ level: 'info' }),
     constraints: {
       version: versionStrategy
     },
@@ -285,11 +285,11 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       onProtoPoisoning: 'error',
       onConstructorPoisoning: 'error',
       pluginTimeout: 10000,
-      requestIdHeader: 'request-id',
+      requestIdHeader: false,
       requestIdLogLabel: 'reqId',
       http2SessionTimeout: 72000,
       exposeHeadRoutes: true,
-      useSemicolonDelimiter: true
+      useSemicolonDelimiter: false
     })
   } catch (error) {
     t.fail()

package/test/internals/logger.test.js

@@ -46,13 +46,42 @@ test('The logger should add a unique id for every request', t => {
   }
 })
 
-test('The logger should reuse request id header for req.id', t => {
+test('The logger should not reuse request id header for req.id', t => {
   const fastify = Fastify()
   fastify.get('/', (req, reply) => {
     t.ok(req.id)
     reply.send({ id: req.id })
   })
 
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    fastify.inject({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: {
+        'Request-Id': 'request-id-1'
+      }
+    }, (err, res) => {
+      t.error(err)
+      const payload = JSON.parse(res.payload)
+      t.ok(payload.id !== 'request-id-1', 'the request id from the header should not be returned with default configuration')
+      t.ok(payload.id === 'req-1') // first request id when using the default configuration
+      fastify.close()
+      t.end()
+    })
+  })
+})
+
+test('The logger should reuse request id header for req.id if requestIdHeader is set', t => {
+  const fastify = Fastify({
+    requestIdHeader: 'request-id'
+  })
+  fastify.get('/', (req, reply) => {
+    t.ok(req.id)
+    reply.send({ id: req.id })
+  })
+
   fastify.listen({ port: 0 }, err => {
     t.error(err)
 
@@ -127,7 +156,7 @@ test('The serializer prevent fails if the request socket is undefined', t => {
     method: 'GET',
     url: '/',
     version: undefined,
-    hostname: undefined,
+    host: undefined,
     remoteAddress: undefined,
     remotePort: undefined
   })

package/test/internals/reply.test.js

@@ -19,7 +19,7 @@ const {
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
-const { FSTDEP010, FSTDEP019, FSTDEP020 } = require('../../lib/warnings')
+const { FSTDEP010, FSTDEP019, FSTDEP021 } = require('../../lib/warnings')
 
 const agent = new http.Agent({ keepAlive: false })
 
@@ -36,7 +36,7 @@ const doGet = function (url) {
 }
 
 test('Once called, Reply should return an object with methods', t => {
-  t.plan(16)
+  t.plan(15)
   const response = { res: 'res' }
   const context = { config: { onSend: [] }, schema: {} }
   const request = { [kRouteContext]: context, [kPublicRouteContext]: { config: context.config, schema: context.schema } }
@@ -49,7 +49,6 @@ test('Once called, Reply should return an object with methods', t => {
   t.equal(typeof reply.status, 'function')
   t.equal(typeof reply.header, 'function')
   t.equal(typeof reply.serialize, 'function')
-  t.equal(typeof reply.getResponseTime, 'function')
   t.equal(typeof reply[kReplyHeaders], 'object')
   t.same(reply.raw, response)
   t.equal(reply[kRouteContext], context)
@@ -250,7 +249,7 @@ test('within an instance', t => {
   })
 
   fastify.get('/redirect-code', function (req, reply) {
-    reply.redirect(301, '/')
+    reply.redirect('/', 301)
   })
 
   fastify.get('/redirect-code-before-call', function (req, reply) {
@@ -258,7 +257,7 @@ test('within an instance', t => {
   })
 
   fastify.get('/redirect-code-before-call-overwrite', function (req, reply) {
-    reply.code(307).redirect(302, '/')
+    reply.code(307).redirect('/', 302)
   })
 
   fastify.get('/custom-serializer', function (req, reply) {
@@ -1415,9 +1414,9 @@ test('.statusCode is getter and setter', t => {
   const fastify = Fastify()
 
   fastify.get('/', function (req, reply) {
-    t.ok(reply.statusCode, 200, 'default status value')
+    t.equal(reply.statusCode, 200, 'default status value')
     reply.statusCode = 418
-    t.ok(reply.statusCode, 418)
+    t.equal(reply.statusCode, 418)
     reply.send()
   })
 
@@ -1572,82 +1571,11 @@ test('should not throw error when attempting to set reply.sent if the underlinin
   })
 })
 
-test('reply.getResponseTime() should return 0 before the timer is initialised on the reply by setting up response listeners', t => {
+test('reply.elapsedTime should return 0 before the timer is initialised on the reply by setting up response listeners', t => {
   t.plan(1)
   const response = { statusCode: 200 }
   const reply = new Reply(response, null)
-  t.equal(reply.getResponseTime(), 0)
-})
-
-test('reply.getResponseTime() should return a number greater than 0 after the timer is initialised on the reply by setting up response listeners', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  fastify.route({
-    method: 'GET',
-    url: '/',
-    handler: (req, reply) => {
-      reply.send('hello world')
-    }
-  })
-
-  fastify.addHook('onResponse', (req, reply) => {
-    t.ok(reply.getResponseTime() > 0)
-    t.end()
-  })
-
-  fastify.inject({ method: 'GET', url: '/' })
-})
-
-test('should emit deprecation warning when trying to use reply.getResponseTime() and should return the time since a request started while inflight', t => {
-  t.plan(5)
-  const fastify = Fastify()
-  fastify.route({
-    method: 'GET',
-    url: '/',
-    handler: (req, reply) => {
-      reply.send('hello world')
-    }
-  })
-
-  process.removeAllListeners('warning')
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.equal(warning.name, 'DeprecationWarning')
-    t.equal(warning.code, FSTDEP020.code)
-  }
-
-  fastify.addHook('preValidation', (req, reply, done) => {
-    t.equal(reply.getResponseTime(), reply.getResponseTime())
-    done()
-  })
-
-  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
-    t.error(err)
-    t.pass()
-
-    process.removeListener('warning', onWarning)
-  })
-
-  FSTDEP020.emitted = false
-})
-
-test('reply.getResponseTime() should return the same value after a request is finished', t => {
-  t.plan(1)
-  const fastify = Fastify()
-  fastify.route({
-    method: 'GET',
-    url: '/',
-    handler: (req, reply) => {
-      reply.send('hello world')
-    }
-  })
-
-  fastify.addHook('onResponse', (req, reply) => {
-    t.equal(reply.getResponseTime(), reply.getResponseTime())
-    t.end()
-  })
-
-  fastify.inject({ method: 'GET', url: '/' })
+  t.equal(reply.elapsedTime, 0)
 })
 
 test('reply.elapsedTime should return a number greater than 0 after the timer is initialised on the reply by setting up response listeners', t => {
@@ -2094,6 +2022,36 @@ test('redirect to an invalid URL should not crash the server', async t => {
   await fastify.close()
 })
 
+test('redirect with deprecated signature should warn', t => {
+  t.plan(4)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP021.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.redirect(302, '/new')
+  })
+
+  fastify.get('/new', (req, reply) => {
+    reply.send('new')
+  })
+
+  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
+    t.error(err)
+    t.pass()
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP021.emitted = false
+})
+
 test('invalid response headers should not crash the server', async t => {
   const fastify = Fastify()
   fastify.route({

package/test/internals/request.test.js

@@ -60,7 +60,7 @@ test('Regular request', t => {
   t.equal(request.log, 'log')
   t.equal(request.ip, 'ip')
   t.equal(request.ips, undefined)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
   t.equal(request.body, undefined)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')
@@ -142,7 +142,7 @@ test('Request with undefined config', t => {
 })
 
 test('Regular request - hostname from authority', t => {
-  t.plan(2)
+  t.plan(3)
   const headers = {
     ':authority': 'authority'
   }
@@ -155,11 +155,12 @@ test('Regular request - hostname from authority', t => {
 
   const request = new Request('id', 'params', req, 'query', 'log')
   t.type(request, Request)
-  t.equal(request.hostname, 'authority')
+  t.equal(request.host, 'authority')
+  t.equal(request.port, null)
 })
 
 test('Regular request - host header has precedence over authority', t => {
-  t.plan(2)
+  t.plan(3)
   const headers = {
     host: 'hostname',
     ':authority': 'authority'
@@ -172,7 +173,8 @@ test('Regular request - host header has precedence over authority', t => {
   }
   const request = new Request('id', 'params', req, 'query', 'log')
   t.type(request, Request)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
+  t.equal(request.port, null)
 })
 
 test('Request with trust proxy', t => {
@@ -222,7 +224,7 @@ test('Request with trust proxy', t => {
   t.equal(request.log, 'log')
   t.equal(request.ip, '2.2.2.2')
   t.same(request.ips, ['ip', '1.1.1.1', '2.2.2.2'])
-  t.equal(request.hostname, 'example.com')
+  t.equal(request.host, 'example.com')
   t.equal(request.body, undefined)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')
@@ -272,7 +274,7 @@ test('Request with trust proxy - no x-forwarded-host header', t => {
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
 })
 
 test('Request with trust proxy - no x-forwarded-host header and fallback to authority', t => {
@@ -291,7 +293,7 @@ test('Request with trust proxy - no x-forwarded-host header and fallback to auth
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'authority')
+  t.equal(request.host, 'authority')
 })
 
 test('Request with trust proxy - x-forwarded-host header has precedence over host', t => {
@@ -311,7 +313,7 @@ test('Request with trust proxy - x-forwarded-host header has precedence over hos
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'example.com')
+  t.equal(request.host, 'example.com')
 })
 
 test('Request with trust proxy - handles multiple entries in x-forwarded-host/proto', t => {
@@ -330,7 +332,7 @@ test('Request with trust proxy - handles multiple entries in x-forwarded-host/pr
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.type(request, TpRequest)
-  t.equal(request.hostname, 'example.com')
+  t.equal(request.host, 'example.com')
   t.equal(request.protocol, 'https')
 })
 
@@ -373,7 +375,7 @@ test('Request with undefined socket', t => {
   t.equal(request.log, 'log')
   t.equal(request.ip, undefined)
   t.equal(request.ips, undefined)
-  t.equal(request.hostname, 'hostname')
+  t.equal(request.host, 'hostname')
   t.same(request.body, null)
   t.equal(request.method, 'GET')
   t.equal(request.url, '/')

package/test/listen.1.test.js

@@ -29,25 +29,15 @@ test('Async/await listen with arguments', async t => {
     t.fail('should not be deprecated')
   })
 
-  t.plan(1)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   const addr = await fastify.listen({ port: 0, host: '0.0.0.0' })
   const address = fastify.server.address()
-  t.equal(addr, `http://${address.address}:${address.port}`)
-})
-
-test('Promise listen with arguments', t => {
-  process.on('warning', () => {
-    t.fail('should not be deprecated')
-  })
-
-  t.plan(1)
-  const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({ port: 0, host: '0.0.0.0' }).then(addr => {
-    const address = fastify.server.address()
-    t.equal(addr, `http://${address.address}:${address.port}`)
+  t.equal(addr, `http://127.0.0.1:${address.port}`)
+  t.same(address, {
+    address: '0.0.0.0',
+    family: 'IPv4',
+    port: address.port
   })
 })