fastify 4.27.0 → 5.0.0-alpha.2

package/test/diagnostics-channel/sync-request-reply.test.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const t = require('tap')
+const diagnostics = require('dc-polyfill')
+const test = t.test
+const sget = require('simple-get').concat
+const Fastify = require('../..')
+const { getServerUrl } = require('../helper')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel sync events fire in expected order', t => {
+  t.plan(10)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.equal(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.ok(msg.request instanceof Request)
+    t.ok(msg.reply instanceof Reply)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.ok(msg.request instanceof Request)
+    t.ok(msg.reply instanceof Reply)
+    t.equal(callOrder++, 1)
+    t.equal(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: function (req, reply) {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    if (err) t.error(err)
+
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'GET',
+      url: getServerUrl(fastify) + '/'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(JSON.parse(body), { hello: 'world' })
+    })
+  })
+})

package/test/diagnostics-channel/sync-request.test.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const t = require('tap')
+const diagnostics = require('dc-polyfill')
+const test = t.test
+const sget = require('simple-get').concat
+const Fastify = require('../..')
+const { getServerUrl } = require('../helper')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel sync events fire in expected order', t => {
+  t.plan(13)
+  let callOrder = 0
+  let firstEncounteredMessage
+
+  diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.equal(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.ok(msg.request instanceof Request)
+    t.ok(msg.reply instanceof Reply)
+    t.ok(msg.route)
+    t.equal(msg.route.url, '/:id')
+    t.equal(msg.route.method, 'GET')
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.ok(msg.request instanceof Request)
+    t.ok(msg.reply instanceof Reply)
+    t.equal(callOrder++, 1)
+    t.equal(msg, firstEncounteredMessage)
+  })
+
+  diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.fail('should not trigger error channel')
+  })
+
+  const fastify = Fastify()
+  fastify.route({
+    method: 'GET',
+    url: '/:id',
+    handler: function (req, reply) {
+      return { hello: 'world' }
+    }
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    if (err) t.error(err)
+
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'GET',
+      url: getServerUrl(fastify) + '/7'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(JSON.parse(body), { hello: 'world' })
+    })
+  })
+})

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

@@ -5,7 +5,7 @@ const test = t.test
 const Fastify = require('../fastify')
 
 test('hasRoute', t => {
-  t.plan(4)
+  t.plan(5)
   const test = t.test
   const fastify = Fastify()
 
@@ -71,7 +71,23 @@ test('hasRoute', t => {
 
     t.equal(fastify.hasRoute({
       method: 'GET',
-      url: '/example/12345.png'
+      url: '/example/:file(^\\d+).png'
+    }), true)
+  })
+
+  test('hasRoute - finds a route even if method is not uppercased', t => {
+    t.plan(1)
+    fastify.route({
+      method: 'GET',
+      url: '/equal',
+      handler: function (req, reply) {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    t.equal(fastify.hasRoute({
+      method: 'get',
+      url: '/equal'
     }), 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)
+    })
   })
 })