fastify 3.19.0 → 3.20.1

package/docs/ContentTypeParser.md

@@ -1,7 +1,7 @@
 <h1 align="center">Fastify</h1>
 
 ## `Content-Type` Parser
-Natively, Fastify only supports `'application/json'` and `'text/plain'` content types. The default charset is `utf-8`. If you need to support different content types, you can use the `addContentTypeParser` API. *The default JSON and/or plain text parser can be changed.*
+Natively, Fastify only supports `'application/json'` and `'text/plain'` content types. The default charset is `utf-8`. If you need to support different content types, you can use the `addContentTypeParser` API. *The default JSON and/or plain text parser can be changed or removed.*
 
 *Note: If you decide to specify your own content type with the `Content-Type` header, UTF-8 will not be the default. Be sure to include UTF-8 like this `text/html; charset=utf-8`.*
 
@@ -56,7 +56,11 @@ fastify.addContentTypeParser('application/vnd.custom', (request, body, done) =>
 fastify.addContentTypeParser('application/vnd.custom+xml', (request, body, done) => {} )
 ```
 
-You can also use the `hasContentTypeParser` API to find if a specific content type parser already exists.
+Besides the `addContentTypeParser` API there are further APIs that can be used. These are `hasContentTypeParser`, `removeContentTypeParser` and `removeAllContentTypeParsers`.
+
+#### hasContentTypeParser
+
+You can use the `hasContentTypeParser` API to find if a specific content type parser already exists.
 
 ```js
 if (!fastify.hasContentTypeParser('application/jsoff')){
@@ -68,6 +72,40 @@ if (!fastify.hasContentTypeParser('application/jsoff')){
 }
 ```
 
+#### removeContentTypeParser
+
+With `removeContentTypeParser` a single or an array of content types can be removed. The method supports `string` and
+`RegExp` content types.
+
+```js
+fastify.addContentTypeParser('text/xml', function (request, payload, done) {
+  xmlParser(payload, function (err, body) {
+    done(err, body)
+  })
+})
+
+// Removes the both built-in content type parsers so that only the content type parser for text/html is available
+fastiy.removeContentTypeParser(['application/json', 'text/plain'])
+```
+
+#### removeAllContentTypeParsers
+
+In the example from just above, it is noticeable that we need to specify each content type that we want to remove.
+To solve this problem Fastify provides the `removeAllContentTypeParsers` API. This can be used to remove all currently existing content type parsers.
+In the example below we achieve exactly the same as in the example above except that we do not need to specify each content type to delete.
+Just like `removeContentTypeParser`, this API supports encapsulation. The API is especially useful if you want to register a 
+[catch-all content type parser](#Catch-All) that should be executed for every content type and the built-in parsers should be ignored as well.
+
+```js
+fastiy.removeAllContentTypeParsers()
+
+fastify.addContentTypeParser('text/xml', function (request, payload, done) {
+  xmlParser(payload, function (err, body) {
+    done(err, body)
+  })
+})
+```
+
 **Notice**: The old syntaxes `function(req, done)` and `async function(req)` for the parser are still supported but they are deprecated.
 
 #### Body Parser
@@ -140,3 +178,19 @@ fastify.route({
  ```
 
 For piping file uploads you may want to check out [this plugin](https://github.com/fastify/fastify-multipart).
+
+If you really want the content type parser to be executed on all content types and not only on those that don't have a 
+specific one, you should call the `removeAllContentTypeParsers` method first.
+
+```js
+// Without this call, the request body with the content type application/json would be processed by the built in json parser
+fastify.removeAllContentTypeParsers()
+
+fastify.addContentTypeParser('*', function (request, payload, done) {
+  var data = ''
+  payload.on('data', chunk => { data += chunk })
+  payload.on('end', () => {
+    done(null, data)
+  })
+})
+```

package/docs/Decorators.md

@@ -117,6 +117,9 @@ upon "greet" and "log" decorators:
 fastify.decorate('utility', fn, ['greet', 'log'])
 ```
 
+Note: using an arrow function will break the binding of `this` to the
+`FastifyInstance`.
+
 If a dependency is not satisfied, the `decorate` method will throw an exception.
 The dependency check is performed before the server instance is booted. Thus,
 it cannot occur during runtime.

package/docs/Ecosystem.md

@@ -102,6 +102,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-file-upload`](https://github.com/huangang/fastify-file-upload) Fastify plugin for uploading files.
 - [`fastify-firebase`](https://github.com/now-ims/fastify-firebase) Fastify plugin for [Firebase Admin SDK](https://firebase.google.com/docs/admin/setup) to Fastify so you can easily use Firebase Auth, Firestore, Cloud Storage, Cloud Messaging, and more.
 - [`fastify-firebase-auth`](https://github.com/oxsav/fastify-firebase-auth) Firebase Authentication for Fastify supporting all of the methods relating to the authentication API.
+- [`fastify-formidable`](https://github.com/climba03003/fastify-formidable) Handy plugin to provide multipart support and fastify-swagger integration.
 - [`fastify-gcloud-trace`](https://github.com/mkinoshi/fastify-gcloud-trace) [Google Cloud Trace API](https://cloud.google.com/trace/docs/reference) Connector for Fastify.
 - [`fastify-get-head`](https://github.com/MetCoder95/fastify-get-head) Small plugin to set a new HEAD route handler for each GET route previously registered in Fastify.
 - [`fastify-good-sessions`](https://github.com/Phara0h/fastify-good-sessions) A good Fastify sessions plugin focused on speed.
@@ -161,6 +162,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-qs`](https://github.com/webdevium/fastify-qs) A plugin for Fastify that adds support for parsing URL query parameters with [qs](https://github.com/ljharb/qs).
 - [`fastify-raw-body`](https://github.com/Eomm/fastify-raw-body) Add the `request.rawBody` field.
 - [`fastify-rbac`](https://gitlab.com/m03geek/fastify-rbac) Fastify role-based access control plugin.
+- [`fastify-recaptcha`](https://github.com/qwertyforce/fastify-recaptcha) Fastify plugin for recaptcha verification.
 - [`fastify-redis-channels`](https://github.com/hearit-io/fastify-redis-channels) A plugin for fast, reliable, and scalable channels implementation based on Redis streams.
 - [`fastify-register-routes`](https://github.com/israeleriston/fastify-register-routes) Plugin to automatically load routes from a specified path and optionally limit loaded file names by a regular expression.
 - [`fastify-response-time`](https://github.com/lolo32/fastify-response-time) Add `X-Response-Time` header at each request for Fastify, in milliseconds.
@@ -168,6 +170,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-resty`](https://github.com/FastifyResty/fastify-resty) Fastify-based web framework with REST API routes auto-generation for TypeORM entities using DI and decorators.
 - [`fastify-reverse-routes`](https://github.com/dimonnwc3/fastify-reverse-routes) Fastify reverse routes plugin, allows to defined named routes and build path using name and parameters.
 - [`fastify-rob-config`](https://github.com/jeromemacias/fastify-rob-config) Fastify Rob-Config integration.
+- [`fastify-route-group`](https://github.com/TakNePoidet/fastify-route-group) Convenient grouping and inheritance of routes
 - [`fastify-schema-constraint`](https://github.com/Eomm/fastify-schema-constraint) Choose the JSON schema to use based on request parameters.
 - [`fastify-schema-to-typescript`](https://github.com/thomasthiebaud/fastify-schema-to-typescript) Generate typescript types based on your JSON/YAML validation schemas so they are always in sync.
 - [`fastify-secure-session`](https://github.com/mcollina/fastify-secure-session) Create a secure stateless cookie session for Fastify.
@@ -175,6 +178,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-sequelize`](https://github.com/lyquocnam/fastify-sequelize) Fastify plugin work with Sequelize (adapter for NodeJS -> Sqlite, Mysql, Mssql, Postgres).
 - [`fastify-server-session`](https://github.com/jsumners/fastify-server-session) A session plugin with support for arbitrary backing caches via `fastify-caching`.
 - [`fastify-session`](https://github.com/SerayaEryn/fastify-session) a session plugin for Fastify.
+- [`fastify-slonik`](https://github.com/Unbuttun/fastify-slonik) Fastify Slonik plugin, with this you can use slonik in every part of your server.
 - [`fastify-soap-client`](https://github.com/fastify/fastify-soap-client) a SOAP client plugin for Fastify.
 - [`fastify-socket.io`](https://github.com/alemagio/fastify-socket.io) a Socket.io plugin for Fastify.
 - [`fastify-sse`](https://github.com/lolo32/fastify-sse) to provide Server-Sent Events with `reply.sse( … )` to Fastify.
@@ -200,4 +204,4 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`nstats`](https://github.com/Phara0h/nstats) A fast and compact way to get all your network and process stats for your node application. Websocket, HTTP/S, and prometheus compatible!
 - [`oas-fastify`](https://github.com/ahmadnassri/node-oas-fastify) OAS 3.x to Fastify routes automation. Automatically generates route handlers with fastify configuration and validation.
 - [`openapi-validator-middleware`](https://github.com/PayU/openapi-validator-middleware#fastify) Swagger and OpenAPI 3.0 spec-based request validation middleware that supports Fastify.
-- [`fastify-route-group`](https://github.com/TakNePoidet/fastify-route-group) Convenient grouping and inheritance of routes
+- [`sequelize-fastify`](https://github.com/hsynlms/sequelize-fastify) A simple and lightweight Sequelize plugin for Fastify.

package/docs/Getting-Started.md

@@ -184,7 +184,7 @@ async function routes (fastify, options) {
 
   fastify.get('/animals/:animal', async (request, reply) => {
     const result = await collection.findOne({ animal: request.params.animal })
-    if (result === null) {
+    if (!result) {
       throw new Error('Invalid value')
     }
     return result

package/docs/Reply.md

@@ -53,10 +53,11 @@ and properties:
 - `.serializer(function)` - Sets a custom serializer for the payload.
 - `.send(payload)` - Sends the payload to the user, could be a plain text, a buffer, JSON, stream, or an Error object.
 - `.sent` - A boolean value that you can use if you need to know if `send` has already been called.
-- `.raw` - The [`http.ServerResponse`](https://nodejs.org/dist/latest/docs/api/http.html#http_class_http_serverresponse) from Node core.
-- `.res` *(deprecated, use `.raw` instead)* - The [`http.ServerResponse`](https://nodejs.org/dist/latest/docs/api/http.html#http_class_http_serverresponse) from Node core.
+- `.raw` - The [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse) from Node core.
+- `.res` *(deprecated, use `.raw` instead)* - The [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse) from Node core.
 - `.log` - The logger instance of the incoming request.
 - `.request` - The incoming request.
+- `.context` - Access the [Request's context](Request.md#Request) property.
 
 ```js
 fastify.get('/', options, function (request, reply) {
@@ -108,7 +109,7 @@ fastify.get('/', async function (req, rep) {
 Sets a response header. If the value is omitted or undefined, it is coerced
 to `''`.
 
-For more information, see [`http.ServerResponse#setHeader`](https://nodejs.org/dist/latest/docs/api/http.html#http_response_setheader_name_value).
+For more information, see [`http.ServerResponse#setHeader`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_response_setheader_name_value).
 
 <a name="headers"></a>
 ### .headers(object)
@@ -227,7 +228,7 @@ See [`.send()`](#send) for more information on sending different types of values
 
 <a name="raw"></a>
 ### .raw
-This is the [`http.ServerResponse`](https://nodejs.org/dist/latest/docs/api/http.html#http_class_http_serverresponse) from Node core. Whilst you are using the Fastify `Reply` object, the use of `Reply.raw` functions is at your own risk as you are skipping all the Fastify
+This is the [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse) from Node core. Whilst you are using the Fastify `Reply` object, the use of `Reply.raw` functions is at your own risk as you are skipping all the Fastify
 logic of handling the HTTP response. e.g.:
 
 ```js
@@ -300,7 +301,7 @@ fastify.get('/json', options, function (request, reply) {
 
 <a name="send-streams"></a>
 #### Streams
-*send* can also handle streams out of the box, internally uses [pump](https://www.npmjs.com/package/pump) to avoid leaks of file descriptors. If you are sending a stream and you have not set a `'Content-Type'` header, *send* will set it at `'application/octet-stream'`.
+*send* can also handle streams out of the box. If you are sending a stream and you have not set a `'Content-Type'` header, *send* will set it at `'application/octet-stream'`.
 ```js
 fastify.get('/streams', function (request, reply) {
   const fs = require('fs')

package/docs/Request.md

@@ -23,6 +23,8 @@ Request is a core Fastify object containing the following fields:
 - `is404` - true if request is being handled by 404 handler, false if it is not
 - `connection` - Deprecated, use `socket` instead. The underlying connection of the incoming request.
 - `socket` - the underlying connection of the incoming request
+- `context` - A Fastify internal object. You should not use it directly or modify it. It is usefull to access one special key:
+  - `context.config` - The route [`config`](Routes.md#routes-config) object.
 
 
 ```js

package/docs/Routes.md

@@ -427,7 +427,7 @@ Fastify will require a request `Accept-Version` header to be set if the route ha
 fastify.route({
   method: 'GET',
   url: '/',
-  { constraints: { version: '1.2.0'} },
+  constraints: { version: '1.2.0' },
   handler: function (request, reply) {
     reply.send({ hello: 'world' })
   }
@@ -475,7 +475,7 @@ You can provide a `host` key in the `constraints` route option for to limit that
 fastify.route({
   method: 'GET',
   url: '/',
-  { constraints: { host: 'auth.fastify.io' } },
+  constraints: { host: 'auth.fastify.io' },
   handler: function (request, reply) {
     reply.send('hello world from auth.fastify.io')
   }
@@ -508,7 +508,7 @@ RegExp `host` constraints can also be specified allowing constraining to hosts m
 fastify.route({
   method: 'GET',
   url: '/',
-  { constraints: { host: /.*\.fastify\.io/ } }, // will match any subdomain of fastify.io
+  constraints: { host: /.*\.fastify\.io/ }, // will match any subdomain of fastify.io
   handler: function (request, reply) {
     reply.send('hello world from ' + request.headers.host)
   }

package/docs/Server.md

@@ -11,7 +11,7 @@ document describes the properties available in that options object.
 <a name="factory-http2"></a>
 ### `http2`
 
-If `true` Node.js core's [HTTP/2](https://nodejs.org/dist/latest-v8.x/docs/api/http2.html) module is used for binding the socket.
+If `true` Node.js core's [HTTP/2](https://nodejs.org/dist/latest-v14.x/docs/api/http2.html) module is used for binding the socket.
 
 + Default: `false`
 
@@ -20,7 +20,7 @@ If `true` Node.js core's [HTTP/2](https://nodejs.org/dist/latest-v8.x/docs/api/h
 
 An object used to configure the server's listening socket for TLS. The options
 are the same as the Node.js core
-[`createServer` method](https://nodejs.org/dist/latest-v8.x/docs/api/https.html#https_https_createserver_options_requestlistener).
+[`createServer` method](https://nodejs.org/dist/latest-v14.x/docs/api/https.html#https_https_createserver_options_requestlistener).
 When this property is `null`, the socket will not be configured for TLS.
 
 This option also applies when the
@@ -113,7 +113,7 @@ for more details about prototype poisoning attacks.
 
 Possible values are `'error'`, `'remove'` and `'ignore'`.
 
-+ Default: `'ignore'`
++ Default: `'error'`
 
 <a name="factory-logger"></a>
 ### `logger`
@@ -454,8 +454,10 @@ const fastify = require('fastify')({
 Set a default
 [timeout](https://nodejs.org/api/http2.html#http2_http2session_settimeout_msecs_callback) to every incoming HTTP/2 session. The session will be closed on the timeout. Default: `5000` ms.
 
-Note that this is needed to offer the graceful "close" experience when
-using HTTP/2. Node core defaults this to `0`.
+Note that this is needed to offer the graceful "close" experience when using HTTP/2. 
+The low default has been chosen to mitigate denial of service attacks. 
+When the server is behind a load balancer or can scale automatically this value can be 
+increased to fit the use case. Node core defaults this to `0`. ` 
 
 <a name="framework-errors"></a>
 ### `frameworkErrors`

package/docs/TypeScript.md

@@ -164,7 +164,7 @@ When you want to use it for validation of some payload in a fastify route you ca
     ```typescript
     const app = fastify();
 
-    app.post<{ Body: UserType; Response: UserType }>(
+    app.post<{ Body: UserType; Reply: UserType }>(
       "/",
       {
         schema: {

package/fastify.d.ts

@@ -14,6 +14,7 @@ import { FastifyReply } from './types/reply'
 import { FastifySchemaValidationError } from './types/schema'
 import { ConstructorAction, ProtoAction } from "./types/content-type-parser";
 import { Socket } from 'net'
+import { Options as FJSOptions } from 'fast-json-stringify'
 
 /**
  * Fastify factory function for the standard fastify http, https, or http2 server instance.
@@ -102,6 +103,7 @@ export type FastifyServerOptions<
   onProtoPoisoning?: ProtoAction,
   onConstructorPoisoning?: ConstructorAction,
   logger?: boolean | FastifyLoggerOptions<RawServer> | Logger,
+  serializerOpts?: FJSOptions | Record<string, unknown>,
   serverFactory?: FastifyServerFactory<RawServer>,
   caseSensitive?: boolean,
   requestIdHeader?: string,
@@ -122,7 +124,7 @@ export type FastifyServerOptions<
     deriveVersion<Context>(req: Object, ctx?: Context): string // not a fan of using Object here. Also what is Context? Can either of these be better defined?
   },
   constraints?: {
-    [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>>,
+    [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
   },
   return503OnClosing?: boolean,
   ajv?: {
@@ -163,7 +165,7 @@ export type { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRe
 export { FastifyRequest, RequestGenericInterface } from './types/request'
 export { FastifyReply } from './types/reply'
 export { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
-export { FastifyInstance } from './types/instance'
+export { FastifyInstance, PrintRoutesOptions } from './types/instance'
 export { FastifyLoggerOptions, FastifyLoggerInstance, FastifyLogFn, LogLevel } from './types/logger'
 export { FastifyContext, FastifyContextConfig } from './types/context'
 export { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'

package/fastify.js

@@ -2,11 +2,11 @@
 
 const Avvio = require('avvio')
 const http = require('http')
-const path = require('path')
 const querystring = require('querystring')
 let lightMyRequest
+let version
+let versionLoaded = false
 
-const { version } = require(path.join(__dirname, 'package.json'))
 const {
   kAvvioBoot,
   kChildren,
@@ -272,6 +272,8 @@ function fastify (options) {
     hasContentTypeParser: ContentTypeParser.helpers.hasContentTypeParser,
     getDefaultJsonParser: ContentTypeParser.defaultParsers.getDefaultJsonParser,
     defaultTextParser: ContentTypeParser.defaultParsers.defaultTextParser,
+    removeContentTypeParser: ContentTypeParser.helpers.removeContentTypeParser,
+    removeAllContentTypeParsers: ContentTypeParser.helpers.removeAllContentTypeParsers,
     // Fastify architecture methods (initialized by Avvio)
     register: null,
     after: null,
@@ -323,6 +325,9 @@ function fastify (options) {
     },
     version: {
       get () {
+        if (versionLoaded === false) {
+          version = loadVersion()
+        }
         return version
       }
     },
@@ -672,6 +677,20 @@ function wrapRouting (httpHandler, { rewriteUrl, logger }) {
   }
 }
 
+function loadVersion () {
+  versionLoaded = true
+  const fs = require('fs')
+  const path = require('path')
+  try {
+    const pkgPath = path.join(__dirname, 'package.json')
+    fs.accessSync(pkgPath, fs.constants.R_OK)
+    const pkg = JSON.parse(fs.readFileSync(pkgPath))
+    return pkg.name === 'fastify' ? pkg.version : undefined
+  } catch (e) {
+    return undefined
+  }
+}
+
 /**
  * These export configurations enable JS and TS developers
  * to consumer fastify in whatever way best suits their needs.

package/lib/contentTypeParser.js

@@ -116,6 +116,27 @@ ContentTypeParser.prototype.getParser = function (contentType) {
   return this.customParsers['']
 }
 
+ContentTypeParser.prototype.removeAll = function () {
+  this.customParsers = {}
+  this.parserRegExpList = []
+  this.parserList = []
+  this.cache = lru(100)
+}
+
+ContentTypeParser.prototype.remove = function (contentType) {
+  if (!(typeof contentType === 'string' || contentType instanceof RegExp)) throw new FST_ERR_CTP_INVALID_TYPE()
+
+  delete this.customParsers[contentType]
+
+  const parsers = typeof contentType === 'string' ? this.parserList : this.parserRegExpList
+
+  const idx = parsers.findIndex(ct => ct.toString() === contentType.toString())
+
+  if (idx > -1) {
+    parsers.splice(idx, 1)
+  }
+}
+
 ContentTypeParser.prototype.run = function (contentType, handler, request, reply) {
   const parser = this.cache.get(contentType) || this.getParser(contentType)
 
@@ -297,11 +318,35 @@ function hasContentTypeParser (contentType) {
   return this[kContentTypeParser].hasParser(contentType)
 }
 
+function removeContentTypeParser (contentType) {
+  if (this[kState].started) {
+    throw new Error('Cannot call "removeContentTypeParser" when fastify instance is already started!')
+  }
+
+  if (Array.isArray(contentType)) {
+    for (const type of contentType) {
+      this[kContentTypeParser].remove(type)
+    }
+  } else {
+    this[kContentTypeParser].remove(contentType)
+  }
+}
+
+function removeAllContentTypeParsers () {
+  if (this[kState].started) {
+    throw new Error('Cannot call "removeAllContentTypeParsers" when fastify instance is already started!')
+  }
+
+  this[kContentTypeParser].removeAll()
+}
+
 module.exports = ContentTypeParser
 module.exports.helpers = {
   buildContentTypeParser,
   addContentTypeParser,
-  hasContentTypeParser
+  hasContentTypeParser,
+  removeContentTypeParser,
+  removeAllContentTypeParsers
 }
 module.exports.defaultParsers = {
   getDefaultJsonParser,

package/lib/logger.js

@@ -35,7 +35,7 @@ function createPinoLogger (opts, stream) {
     if (prevLogger[serializersSym]) {
       opts.serializers = Object.assign({}, opts.serializers, prevLogger[serializersSym])
     }
-    logger = prevLogger.child(opts)
+    logger = prevLogger.child({}, opts)
     opts.logger = prevLogger
     opts.genReqId = prevGenReqId
   } else {

package/lib/pluginUtils.js

@@ -109,7 +109,9 @@ function registerPluginName (fn) {
 
 function registerPlugin (fn) {
   registerPluginName.call(this, fn)
-  checkVersion.call(this, fn)
+  if (this.version !== undefined) {
+    checkVersion.call(this, fn)
+  }
   checkDecorators.call(this, fn)
   checkDependencies.call(this, fn)
   return shouldSkipOverride(fn)

package/lib/reply.js

@@ -548,8 +548,12 @@ function handleError (reply, error, cb) {
     reply[kReplyErrorHandlerCalled] = true
     reply[kReplyHeaders]['content-length'] = undefined
     const result = errorHandler(error, reply.request, reply)
-    if (result && typeof result.then === 'function') {
-      wrapThenable(result, reply)
+    if (result !== undefined) {
+      if (result !== null && typeof result.then === 'function') {
+        wrapThenable(result, reply)
+      } else {
+        reply.send(result)
+      }
     }
     return
   }

package/lib/route.js

@@ -247,7 +247,7 @@ function buildRouting (options) {
         opts.schemaErrorFormatter || this[kSchemaErrorFormatter]
       )
 
-      const headRouteExists = router.find('HEAD', path) != null
+      const headRouteExists = router.find('HEAD', url) != null
 
       try {
         router.on(opts.method, opts.url, { constraints }, routeHandler, context)
@@ -345,15 +345,18 @@ function buildRouting (options) {
 
     const id = req.headers[requestIdHeader] || genReqId(req)
 
+    const loggerBinding = {
+      [requestIdLogLabel]: id
+    }
+
     const loggerOpts = {
-      [requestIdLogLabel]: id,
       level: context.logLevel
     }
 
     if (context.logSerializers) {
       loggerOpts.serializers = context.logSerializers
     }
-    const childLogger = logger.child(loggerOpts)
+    const childLogger = logger.child(loggerBinding, loggerOpts)
     childLogger[kDisableRequestLogging] = disableRequestLogging
 
     const queryPrefix = req.url.indexOf('?')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.19.0",
+  "version": "3.20.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -164,7 +164,7 @@
     "tap": "^15.0.5",
     "tap-mocha-reporter": "^5.0.1",
     "then-sleep": "^1.0.1",
-    "tsd": "^0.14.0",
+    "tsd": "^0.17.0",
     "typescript": "^4.0.2",
     "undici": "^3.3.5",
     "x-xss-protection": "^2.0.0",
@@ -177,10 +177,10 @@
     "fast-json-stringify": "^2.5.2",
     "fastify-error": "^0.3.0",
     "fastify-warning": "^0.2.0",
-    "find-my-way": "^4.0.0",
+    "find-my-way": "^4.1.0",
     "flatstr": "^1.0.12",
     "light-my-request": "^4.2.0",
-    "pino": "^6.2.1",
+    "pino": "^6.13.0",
     "proxy-addr": "^2.0.7",
     "readable-stream": "^3.4.0",
     "rfdc": "^1.1.4",

package/test/async-await.test.js

@@ -646,6 +646,79 @@ test('customErrorHandler only called if reply not already sent', t => {
   })
 })
 
+// See https://github.com/fastify/fastify/issues/3209
+test('setNotFoundHandler should accept return value', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/', async () => ({ hello: 'world' }))
+
+  fastify.setNotFoundHandler((req, reply) => {
+    reply.code(404)
+    return {
+      error: statusCodes['404'],
+      message: 'lost',
+      statusCode: 404
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/elsewhere'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 404)
+    t.same(
+      {
+        error: statusCodes['404'],
+        message: 'lost',
+        statusCode: 404
+      },
+      JSON.parse(res.payload)
+    )
+  })
+})
+
+// See https://github.com/fastify/fastify/issues/3209
+test('customErrorHandler should accept return value', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', async (req, reply) => {
+    const error = new Error('ouch')
+    error.statusCode = 400
+    throw error
+  })
+
+  fastify.setErrorHandler((err, req, reply) => {
+    t.equal(err.message, 'ouch')
+    reply.code(401)
+    return {
+      error: statusCodes['401'],
+      message: 'kaboom',
+      statusCode: 401
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 401)
+    t.same(
+      {
+        error: statusCodes['401'],
+        message: 'kaboom',
+        statusCode: 401
+      },
+      JSON.parse(res.payload)
+    )
+  })
+})
+
 test('await self', async t => {
   const app = Fastify()
   t.equal(await app, app)