fastify 3.19.1 → 3.20.2

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

@@ -44,6 +44,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-routes`](https://github.com/fastify/fastify-routes) Plugin that provides a `Map` of routes.
 - [`fastify-schedule`](https://github.com/fastify/fastify-schedule) Plugin for scheduling periodic jobs, based on [toad-scheduler](https://github.com/kibertoad/toad-scheduler).
 - [`fastify-sensible`](https://github.com/fastify/fastify-sensible) Defaults for Fastify that everyone can agree on. It adds some useful decorators such as HTTP errors and assertions, but also more request and reply methods.
+- [`@fastify/session`](https://github.com/fastify/session) a session plugin for Fastify.
 - [`fastify-static`](https://github.com/fastify/fastify-static) Plugin for serving static files as fast as possible.
 - [`fastify-swagger`](https://github.com/fastify/fastify-swagger) Plugin for serving Swagger/OpenAPI documentation for Fastify, supporting dynamic generation.
 - [`fastify-websocket`](https://github.com/fastify/fastify-websocket) WebSocket support for Fastify. Built upon [websocket-stream](https://github.com/maxogden/websocket-stream).
@@ -69,6 +70,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`arecibo`](https://github.com/nucleode/arecibo) Fastify ping responder for Kubernetes Liveness and Readiness Probes.
 - [`cls-rtracer`](https://github.com/puzpuzpuz/cls-rtracer) Fastify middleware for CLS-based request ID generation. An out-of-the-box solution for adding request IDs into your logs.
 - [`fastify-405`](https://github.com/Eomm/fastify-405) Fastify plugin that adds 405 HTTP status to your routes
+- [`fastify-allow`](https://github.com/mattbishop/fastify-allow) Fastify plugin that automatically adds an Allow header to responses with routes. Also sends 405 responses for routes that have a handler but not for the request's method.
 - [`fastify-amqp`](https://github.com/RafaelGSS/fastify-amqp) Fastify AMQP connection plugin, to use with RabbitMQ or another connector. Just a wrapper to [`amqplib`](https://github.com/squaremo/amqp.node).
 - [`fastify-angular-universal`](https://github.com/exequiel09/fastify-angular-universal) Angular server-side rendering support using [`@angular/platform-server`](https://github.com/angular/angular/tree/master/packages/platform-server) for Fastify
 - [`fastify-api-key`](https://github.com/arkerone/fastify-api-key) Fastify plugin to authenticate HTTP requests based on api key and signature
@@ -162,6 +164,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.
@@ -176,7 +179,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-sentry`](https://github.com/alex-ppg/fastify-sentry) Fastify plugin to add the Sentry SDK error handler to requests.
 - [`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.
@@ -202,3 +205,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.
+- [`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
@@ -200,7 +200,7 @@ As you can see, we used `register` for both the database connector and the regis
 This is one of the best features of Fastify, it will load your plugins in the same order you declare them, and it will load the next plugin only once the current one has been loaded. In this way, we can register the database connector in the first plugin and use it in the second *(read [here](Plugins.md#handle-the-scope) to understand how to handle the scope of a plugin)*.
 Plugin loading starts when you call `fastify.listen()`, `fastify.inject()` or `fastify.ready()`
 
-We have also used the `decorate` API to add custom objects to the Fastify namespace, making them available for use everywhere. Use of this API is encouraged to facilitate easy code reuse and to decrease code or logic duplication.
+The MongoDB plugin uses the `decorate` API to add custom objects to the Fastify instance, making them available for use everywhere. Use of this API is encouraged to facilitate easy code reuse and to decrease code or logic duplication.
 
 To dig deeper into how Fastify plugins work, how to develop new plugins, and for details on how to use the whole Fastify API to deal with the complexity of asynchronously bootstrapping an application, read [the hitchhiker's guide to plugins](Plugins-Guide.md).
 

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

@@ -6,7 +6,7 @@ Request is a core Fastify object containing the following fields:
 - `query` - the parsed querystring
 - `body` - the body
 - `params` - the params matching the URL
-- `headers` - the headers
+- [`headers`](#headers) - the headers getter and setter
 - `raw` - the incoming HTTP request from Node core
 - `req` *(deprecated, use `.raw` instead)* - the incoming HTTP request from Node core
 - `server` - The Fastify server instance, scoped to the current [encapsulation context](Encapsulation.md)
@@ -23,7 +23,23 @@ 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.
 
+### Headers
+
+The `request.headers` is a getter that return an Object with the headers of the incoming request.
+You can set custom headers like this:
+
+```js
+request.headers = {
+  'foo': 'bar',
+  'baz': 'qux'
+}
+```
+
+This operation will add to the request headers the new values that can be read calling `request.headers.bar`.  
+Moreover, you can still access the standard request's headers with the `request.raw.headers` property.
 
 ```js
 fastify.post('/:params', options, function (request, reply) {
@@ -38,6 +54,9 @@ fastify.post('/:params', options, function (request, reply) {
   console.log(request.ips)
   console.log(request.hostname)
   console.log(request.protocol)
+  console.log(request.url)
+  console.log(request.routerMethod)
+  console.log(request.routerPath)
   request.log.info('some info')
 })
 ```

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

@@ -85,7 +85,7 @@ The type system heavily relies on generic properties to provide the most accurat
      'h-Custom': string;
    }
    ```
-3. Using the two interfaces, define a new API route and pass them as generics. The shorthand route methods (i.e. `.get`) accept a generic object `RequestGenericInterface` containing four named properties: `Body`, `Querystring`, `Params`, and `Headers`. The interfaces will be passed down through the route method into the route method handler `request` instance.
+3. Using the two interfaces, define a new API route and pass them as generics. The shorthand route methods (i.e. `.get`) accept a generic object `RouteGenericInterface` containing five named properties: `Body`, `Querystring`, `Params`, `Headers` and `Reply`. The interfaces `Body`, `Querystring`, `Params` and `Headers` will be passed down through the route method into the route method handler `request` instance and the `Reply` interface to the `reply` instance.
    ```typescript
    server.get<{
      Querystring: IQuerystring,
@@ -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: {
@@ -599,7 +599,7 @@ The Fastify API is powered by the `fastify()` method. In JavaScript you would im
      const f = fastify()
      f.listen(8080, () => { console.log('running') })
      ```
-   - Destructuring is still supported, but will also not resolve types
+   - Destructuring is supported and will resolve types properly
      ```typescript
      const { fastify } = require('fastify')
 

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

@@ -4,8 +4,9 @@ const Avvio = require('avvio')
 const http = require('http')
 const querystring = require('querystring')
 let lightMyRequest
+let version
+let versionLoaded = false
 
-const { version } = require('./package.json')
 const {
   kAvvioBoot,
   kChildren,
@@ -271,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,
@@ -322,6 +325,9 @@ function fastify (options) {
     },
     version: {
       get () {
+        if (versionLoaded === false) {
+          version = loadVersion()
+        }
         return version
       }
     },
@@ -535,9 +541,8 @@ function fastify (options) {
 
   function defaultClientErrorHandler (err, socket) {
     // In case of a connection reset, the socket has been destroyed and there is nothing that needs to be done.
-    // https://github.com/fastify/fastify/issues/2036
-    // https://github.com/nodejs/node/issues/33302
-    if (err.code === 'ECONNRESET') {
+    // https://nodejs.org/api/http.html#http_event_clienterror
+    if (err.code === 'ECONNRESET' || socket.destroyed) {
       return
     }
 
@@ -551,11 +556,14 @@ function fastify (options) {
     // In the vast majority of cases, it's a network error and/or some
     // config issue on the load balancer side.
     this.log.trace({ err }, 'client error')
+    // Copying standard node behaviour
+    // https://github.com/nodejs/node/blob/6ca23d7846cb47e84fd344543e394e50938540be/lib/_http_server.js#L666
 
     // If the socket is not writable, there is no reason to try to send data.
-    if (socket.writable) {
-      socket.end(`HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
+    if (socket.writable && socket.bytesWritten === 0) {
+      socket.write(`HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
     }
+    socket.destroy(err)
   }
 
   // If the router does not match any route, every request will land here
@@ -671,6 +679,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/request.js

@@ -162,7 +162,13 @@ Object.defineProperties(Request.prototype, {
   },
   headers: {
     get () {
+      if (this.additionalHeaders) {
+        return Object.assign({}, this.raw.headers, this.additionalHeaders)
+      }
       return this.raw.headers
+    },
+    set (headers) {
+      this.additionalHeaders = headers
     }
   },
   server: {

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.1",
+  "version": "3.20.2",
   "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",