fastify 4.28.0 → 5.0.0-alpha.3

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

@@ -3,25 +3,66 @@
 const { test } = require('tap')
 const Fastify = require('..')
 
-test('encapsulates an error handler', async t => {
+// Because of how error handlers wrap things, following the control flow can be tricky
+// In this test file numbered comments indicate the order statements are expected to execute
+
+test('encapsulates an asynchronous error handler', async t => {
   t.plan(3)
 
   const fastify = Fastify()
   fastify.register(async function (fastify) {
     fastify.setErrorHandler(async function a (err) {
-      t.equal(err.message, 'kaboom')
-      throw new Error('caught')
+      // 3. the inner error handler catches the error, and throws a new error
+      t.equal(err.message, 'from_endpoint')
+      throw new Error('from_inner')
+    })
+    fastify.get('/encapsulated', async () => {
+      // 2. the endpoint throws an error
+      throw new Error('from_endpoint')
     })
-    fastify.get('/encapsulated', async () => { throw new Error('kaboom') })
   })
 
   fastify.setErrorHandler(async function b (err) {
-    t.equal(err.message, 'caught')
-    throw new Error('wrapped')
+    // 4. the outer error handler catches the error thrown by the inner error handler
+    t.equal(err.message, 'from_inner')
+    // 5. the outer error handler throws a new error
+    throw new Error('from_outer')
   })
 
+  // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
-  t.equal(res.json().message, 'wrapped')
+  // 6. the default error handler returns the error from the outer error handler
+  t.equal(res.json().message, 'from_outer')
+})
+
+// See discussion in https://github.com/fastify/fastify/pull/5222#discussion_r1432573655
+test('encapsulates a synchronous error handler', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.register(async function (fastify) {
+    fastify.setErrorHandler(function a (err) {
+      // 3. the inner error handler catches the error, and throws a new error
+      t.equal(err.message, 'from_endpoint')
+      throw new Error('from_inner')
+    })
+    fastify.get('/encapsulated', async () => {
+      // 2. the endpoint throws an error
+      throw new Error('from_endpoint')
+    })
+  })
+
+  fastify.setErrorHandler(async function b (err) {
+    // 4. the outer error handler catches the error thrown by the inner error handler
+    t.equal(err.message, 'from_inner')
+    // 5. the outer error handler throws a new error
+    throw new Error('from_outer')
+  })
+
+  // 1. the endpoint is called
+  const res = await fastify.inject('/encapsulated')
+  // 6. the default error handler returns the error from the outer error handler
+  t.equal(res.json().message, 'from_outer')
 })
 
 test('onError hook nested', async t => {
@@ -30,21 +71,167 @@ test('onError hook nested', async t => {
   const fastify = Fastify()
   fastify.register(async function (fastify) {
     fastify.setErrorHandler(async function a (err) {
-      t.equal(err.message, 'kaboom')
-      throw new Error('caught')
+      // 4. the inner error handler catches the error, and throws a new error
+      t.equal(err.message, 'from_endpoint')
+      throw new Error('from_inner')
+    })
+    fastify.get('/encapsulated', async () => {
+      // 2. the endpoint throws an error
+      throw new Error('from_endpoint')
     })
-    fastify.get('/encapsulated', async () => { throw new Error('kaboom') })
   })
 
   fastify.setErrorHandler(async function b (err) {
-    t.equal(err.message, 'caught')
-    throw new Error('wrapped')
+    // 5. the outer error handler catches the error thrown by the inner error handler
+    t.equal(err.message, 'from_inner')
+    // 6. the outer error handler throws a new error
+    throw new Error('from_outer')
   })
 
   fastify.addHook('onError', async function (request, reply, err) {
-    t.equal(err.message, 'kaboom')
+    // 3. the hook receives the error
+    t.equal(err.message, 'from_endpoint')
+  })
+
+  // 1. the endpoint is called
+  const res = await fastify.inject('/encapsulated')
+  // 7. the default error handler returns the error from the outer error handler
+  t.equal(res.json().message, 'from_outer')
+})
+
+// See https://github.com/fastify/fastify/issues/5220
+test('encapuslates an error handler, for errors thrown in hooks', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.register(async function (fastify) {
+    fastify.setErrorHandler(function a (err) {
+      // 3. the inner error handler catches the error, and throws a new error
+      t.equal(err.message, 'from_hook')
+      throw new Error('from_inner')
+    })
+    fastify.addHook('onRequest', async () => {
+      // 2. the hook throws an error
+      throw new Error('from_hook')
+    })
+    fastify.get('/encapsulated', async () => {})
+  })
+
+  fastify.setErrorHandler(function b (err) {
+    // 4. the outer error handler catches the error thrown by the inner error handler
+    t.equal(err.message, 'from_inner')
+    // 5. the outer error handler throws a new error
+    throw new Error('from_outer')
   })
 
+  // 1. the endpoint is called
+  const res = await fastify.inject('/encapsulated')
+  // 6. the default error handler returns the error from the outer error handler
+  t.equal(res.json().message, 'from_outer')
+})
+
+// See https://github.com/fastify/fastify/issues/5220
+test('encapuslates many synchronous error handlers that rethrow errors', async t => {
+  const DEPTH = 100
+  t.plan(DEPTH + 2)
+
+  /**
+   * This creates a very nested set of error handlers, that looks like:
+   * plugin
+   * - error handler
+   * - plugin
+   *   - error handler
+   *   - plugin
+   *     ... {to DEPTH levels}
+   *       - plugin
+   *           - error handler
+   *           - GET /encapsulated
+   */
+  const createNestedRoutes = (fastify, depth) => {
+    if (depth < 0) {
+      throw new Error('Expected depth >= 0')
+    } else if (depth === 0) {
+      fastify.setErrorHandler(function a (err) {
+        // 3. innermost error handler catches the error, and throws a new error
+        t.equal(err.message, 'from_route')
+        throw new Error(`from_handler_${depth}`)
+      })
+      fastify.get('/encapsulated', async () => {
+        // 2. the endpoint throws an error
+        throw new Error('from_route')
+      })
+    } else {
+      fastify.setErrorHandler(function d (err) {
+        // 4 to {DEPTH+4}. error handlers each catch errors, and then throws a new error
+        t.equal(err.message, `from_handler_${depth - 1}`)
+        throw new Error(`from_handler_${depth}`)
+      })
+
+      fastify.register(async function (fastify) {
+        createNestedRoutes(fastify, depth - 1)
+      })
+    }
+  }
+
+  const fastify = Fastify()
+  createNestedRoutes(fastify, DEPTH)
+
+  // 1. the endpoint is called
+  const res = await fastify.inject('/encapsulated')
+  // {DEPTH+5}. the default error handler returns the error from the outermost error handler
+  t.equal(res.json().message, `from_handler_${DEPTH}`)
+})
+
+// See https://github.com/fastify/fastify/issues/5220
+// This was not failing previously, but we want to make sure the behavior continues to work in the same way across async and sync handlers
+// Plus, the current setup is somewhat fragile to tweaks to wrapThenable as that's what retries (by calling res.send(err) again)
+test('encapuslates many asynchronous error handlers that rethrow errors', async t => {
+  const DEPTH = 100
+  t.plan(DEPTH + 2)
+
+  /**
+   * This creates a very nested set of error handlers, that looks like:
+   * plugin
+   * - error handler
+   * - plugin
+   *   - error handler
+   *   - plugin
+   *     ... {to DEPTH levels}
+   *       - plugin
+   *           - error handler
+   *           - GET /encapsulated
+   */
+  const createNestedRoutes = (fastify, depth) => {
+    if (depth < 0) {
+      throw new Error('Expected depth >= 0')
+    } else if (depth === 0) {
+      fastify.setErrorHandler(async function a (err) {
+        // 3. innermost error handler catches the error, and throws a new error
+        t.equal(err.message, 'from_route')
+        throw new Error(`from_handler_${depth}`)
+      })
+      fastify.get('/encapsulated', async () => {
+        // 2. the endpoint throws an error
+        throw new Error('from_route')
+      })
+    } else {
+      fastify.setErrorHandler(async function m (err) {
+        // 4 to {DEPTH+4}. error handlers each catch errors, and then throws a new error
+        t.equal(err.message, `from_handler_${depth - 1}`)
+        throw new Error(`from_handler_${depth}`)
+      })
+
+      fastify.register(async function (fastify) {
+        createNestedRoutes(fastify, depth - 1)
+      })
+    }
+  }
+
+  const fastify = Fastify()
+  createNestedRoutes(fastify, DEPTH)
+
+  // 1. the endpoint is called
   const res = await fastify.inject('/encapsulated')
-  t.equal(res.json().message, 'wrapped')
+  // {DEPTH+5}. the default error handler returns the error from the outermost error handler
+  t.equal(res.json().message, `from_handler_${DEPTH}`)
 })

package/test/esm/index.test.js

@@ -1,18 +1,8 @@
 'use strict'
 
-const t = require('tap')
-const semver = require('semver')
-
-if (semver.lt(process.versions.node, '14.13.0')) {
-  t.skip('Skip named exports because Node version < 14.13.0')
-} else {
-  // Node v8 throw a `SyntaxError: Unexpected token import`
-  // even if this branch is never touch in the code,
-  // by using `eval` we can avoid this issue.
-  // eslint-disable-next-line
-  new Function('module', 'return import(module)')('./named-exports.mjs').catch((err) => {
+import('./named-exports.mjs')
+  .catch(err => {
     process.nextTick(() => {
       throw err
     })
   })
-}

package/test/findRoute.test.js

@@ -49,6 +49,22 @@ test('findRoute should return an immutable route to avoid leaking and runtime ro
   t.same(route.params, { artistId: ':artistId' })
 })
 
+test('findRoute should return null when when url is not passed', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.equal(fastify.findRoute({
+    method: 'POST'
+  }), null)
+})
+
 test('findRoute should return null when route cannot be found due to a different path', t => {
   t.plan(1)
   const fastify = Fastify()

package/test/genReqId.test.js

@@ -74,6 +74,15 @@ test('Custom genReqId function gets raw request as argument', t => {
   })
 })
 
+test('Should handle properly requestIdHeader option', t => {
+  t.plan(4)
+
+  t.equal(Fastify({ requestIdHeader: '' }).initialConfig.requestIdHeader, false)
+  t.equal(Fastify({ requestIdHeader: false }).initialConfig.requestIdHeader, false)
+  t.equal(Fastify({ requestIdHeader: true }).initialConfig.requestIdHeader, 'request-id')
+  t.equal(Fastify({ requestIdHeader: 'x-request-id' }).initialConfig.requestIdHeader, 'x-request-id')
+})
+
 test('Should accept option to set genReqId with setGenReqId option', t => {
   t.plan(9)
 

package/test/get.test.js

@@ -203,6 +203,18 @@ test('send a falsy boolean', t => {
   }
 })
 
+test('shorthand - get, set port', t => {
+  t.plan(1)
+  try {
+    fastify.get('/port', headersSchema, function (req, reply) {
+      reply.code(200).send({ port: req.port })
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
 fastify.listen({ port: 0 }, err => {
   t.error(err)
   t.teardown(() => { fastify.close() })
@@ -380,4 +392,20 @@ fastify.listen({ port: 0 }, err => {
       t.same(body.toString(), 'null')
     })
   })
+
+  test('shorthand - request get headers - test fall back port', t => {
+    t.plan(3)
+    sget({
+      method: 'GET',
+      headers: {
+        host: 'example.com'
+      },
+      json: true,
+      url: 'http://localhost:' + fastify.server.address().port + '/port'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(body.port, null)
+    })
+  })
 })

package/test/has-route.test.js

@@ -71,7 +71,7 @@ test('hasRoute', t => {
 
     t.equal(fastify.hasRoute({
       method: 'GET',
-      url: '/example/12345.png'
+      url: '/example/:file(^\\d+).png'
     }), true)
   })
 

package/test/helper.js

@@ -216,11 +216,7 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
 
       }, (err, response, body) => {
         t.error(err)
-        if (upMethod === 'OPTIONS') {
-          t.equal(response.statusCode, 200)
-        } else {
-          t.equal(response.statusCode, 415)
-        }
+        t.equal(response.statusCode, 415)
       })
     })
 

package/test/hooks.test.js

@@ -3216,8 +3216,6 @@ test('reply.send should throw if undefined error is thrown', t => {
 })
 
 test('reply.send should throw if undefined error is thrown at preParsing hook', t => {
-  /* eslint prefer-promise-reject-errors: ["error", {"allowEmptyReject": true}] */
-
   t.plan(3)
   const fastify = Fastify()
 
@@ -3245,8 +3243,6 @@ test('reply.send should throw if undefined error is thrown at preParsing hook',
 })
 
 test('reply.send should throw if undefined error is thrown at onSend hook', t => {
-  /* eslint prefer-promise-reject-errors: ["error", {"allowEmptyReject": true}] */
-
   t.plan(3)
   const fastify = Fastify()
 

package/test/http2/constraint.test.js

@@ -12,7 +12,7 @@ const { buildCertificate } = require('../build-certificate')
 t.before(buildCertificate)
 
 test('A route supports host constraints under http2 protocol and secure connection', (t) => {
-  t.plan(5)
+  t.plan(6)
 
   let fastify
   try {
@@ -45,6 +45,14 @@ test('A route supports host constraints under http2 protocol and secure connecti
       reply.code(200).send(beta)
     }
   })
+  fastify.route({
+    method: 'GET',
+    url: '/hostname_port',
+    constraints: { host: constrain },
+    handler: function (req, reply) {
+      reply.code(200).send({ ...beta, hostname: req.hostname })
+    }
+  })
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
@@ -87,5 +95,18 @@ test('A route supports host constraints under http2 protocol and secure connecti
 
       t.equal(res.headers[':status'], 404)
     })
+    t.test('https get request - constrain - verify hostname and port from request', async (t) => {
+      t.plan(1)
+
+      const url = `https://localhost:${fastify.server.address().port}/hostname_port`
+      const res = await h2url.concat({
+        url,
+        headers: {
+          ':authority': constrain
+        }
+      })
+      const body = JSON.parse(res.body)
+      t.equal(body.hostname, constrain)
+    })
   })
 })

package/test/http2/plain.test.js

@@ -20,8 +20,12 @@ fastify.get('/', function (req, reply) {
   reply.code(200).send(msg)
 })
 
-fastify.get('/hostname', function (req, reply) {
-  reply.code(200).send(req.hostname)
+fastify.get('/host', function (req, reply) {
+  reply.code(200).send(req.host)
+})
+
+fastify.get('/hostname_port', function (req, reply) {
+  reply.code(200).send({ hostname: req.hostname, port: req.port })
 })
 
 fastify.listen({ port: 0 }, err => {
@@ -40,14 +44,25 @@ fastify.listen({ port: 0 }, err => {
     t.same(JSON.parse(res.body), msg)
   })
 
-  test('http hostname', async (t) => {
+  test('http host', async (t) => {
     t.plan(1)
 
-    const hostname = `localhost:${fastify.server.address().port}`
+    const host = `localhost:${fastify.server.address().port}`
+
+    const url = `http://${host}/host`
+    const res = await h2url.concat({ url })
+
+    t.equal(res.body, host)
+  })
+  test('http hostname and port', async (t) => {
+    t.plan(2)
+
+    const host = `localhost:${fastify.server.address().port}`
 
-    const url = `http://${hostname}/hostname`
+    const url = `http://${host}/hostname_port`
     const res = await h2url.concat({ url })
 
-    t.equal(res.body, hostname)
+    t.equal(JSON.parse(res.body).hostname, host.split(':')[0])
+    t.equal(JSON.parse(res.body).port, parseInt(host.split(':')[1]))
   })
 })

package/test/http2/secure.test.js

@@ -10,7 +10,7 @@ const { buildCertificate } = require('../build-certificate')
 t.before(buildCertificate)
 
 test('secure', (t) => {
-  t.plan(4)
+  t.plan(5)
 
   let fastify
   try {
@@ -32,6 +32,9 @@ test('secure', (t) => {
   fastify.get('/proto', function (req, reply) {
     reply.code(200).send({ proto: req.protocol })
   })
+  fastify.get('/hostname_port', function (req, reply) {
+    reply.code(200).send({ hostname: req.hostname, port: req.port })
+  })
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
@@ -55,5 +58,13 @@ test('secure', (t) => {
       t.same(JSON.parse((await h2url.concat({ url })).body), { proto: 'https' })
       t.same(JSON.parse((await h2url.concat({ url, headers: { 'X-Forwarded-Proto': 'lorem' } })).body), { proto: 'https' })
     })
+    t.test('https get request - test hostname and port', async (t) => {
+      t.plan(2)
+
+      const url = `https://localhost:${fastify.server.address().port}/hostname_port`
+      const parsedbody = JSON.parse((await h2url.concat({ url })).body)
+      t.equal(parsedbody.hostname, 'localhost')
+      t.equal(parsedbody.port, fastify.server.address().port)
+    })
   })
 })

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')