fastify 3.24.0 → 3.25.2

package/docs/{Getting-Started.md → Guides/Getting-Started.md}

@@ -1,12 +1,18 @@
 <h1 align="center">Fastify</h1>
 
 ## Getting Started
-Hello! Thank you for checking out Fastify!<br>
-This document aims to be a gentle introduction to the framework and its features. It is an elementary preface with examples and links to other parts of the documentation.<br>
+
+Hello! Thank you for checking out Fastify!
+
+This document aims to be a gentle introduction to the framework and its
+features. It is an elementary preface with examples and links to other parts of
+the documentation.
+
 Let's start!
 
-<a name="install"></a>
 ### Install
+<a id="install"></a>
+
 Install with npm:
 ```
 npm i fastify --save
@@ -16,8 +22,9 @@ Install with yarn:
 yarn add fastify
 ```
 
-<a name="first-server"></a>
 ### Your first server
+<a id="first-server"></a>
+
 Let's write our first server:
 ```js
 // Require the framework and instantiate it
@@ -47,8 +54,11 @@ fastify.listen(3000, function (err, address) {
 })
 ```
 
-Do you prefer to use `async/await`? Fastify supports it out-of-the-box.<br>
-*(We also suggest using [make-promises-safe](https://github.com/mcollina/make-promises-safe) to avoid file descriptor and memory leaks.)*
+Do you prefer to use `async/await`? Fastify supports it out-of-the-box.
+
+*(We also suggest using
+[make-promises-safe](https://github.com/mcollina/make-promises-safe) to avoid
+file descriptor and memory leaks.)*
 ```js
 // ESM
 import Fastify from 'fastify'
@@ -75,12 +85,21 @@ const start = async () => {
 start()
 ```
 
-Awesome, that was easy.<br>
-Unfortunately, writing a complex application requires significantly more code than this example. A classic problem when you are building a new application is how to handle multiple files, asynchronous bootstrapping, and the architecture of your code.<br>
-Fastify offers an easy platform that helps to solve all of the problems outlined above, and more!
+Awesome, that was easy.
+
+Unfortunately, writing a complex application requires significantly more code
+than this example. A classic problem when you are building a new application is
+how to handle multiple files, asynchronous bootstrapping, and the architecture
+of your code.
+
+Fastify offers an easy platform that helps to solve all of the problems outlined
+above, and more!
 
 > ## Note
-> The above examples, and subsequent examples in this document, default to listening *only* on the localhost `127.0.0.1` interface. To listen on all available IPv4 interfaces the example should be modified to listen on `0.0.0.0` like so:
+> The above examples, and subsequent examples in this document, default to
+> listening *only* on the localhost `127.0.0.1` interface. To listen on all
+> available IPv4 interfaces the example should be modified to listen on
+> `0.0.0.0` like so:
 >
 > ```js
 > fastify.listen(3000, '0.0.0.0', function (err, address) {
@@ -92,15 +111,24 @@ Fastify offers an easy platform that helps to solve all of the problems outlined
 > })
 > ```
 >
-> Similarly, specify `::1` to accept only local connections via IPv6. Or specify `::` to accept connections on all IPv6 addresses, and, if the operating system supports it, also on all IPv4 addresses.
+> Similarly, specify `::1` to accept only local connections via IPv6. Or specify
+> `::` to accept connections on all IPv6 addresses, and, if the operating system
+> supports it, also on all IPv4 addresses.
 >
-> When deploying to a Docker (or another type of) container using `0.0.0.0` or `::` would be the easiest method for exposing the application.
+> When deploying to a Docker (or another type of) container using `0.0.0.0` or
+> `::` would be the easiest method for exposing the application.
 
-<a name="first-plugin"></a>
 ### Your first plugin
-As with JavaScript, where everything is an object, with Fastify everything is a plugin.<br>
-Before digging into it, let's see how it works!<br>
-Let's declare our basic server, but instead of declaring the route inside the entry point, we'll declare it in an external file (check out the [route declaration](Routes.md) docs).
+<a id="first-plugin"></a>
+
+As with JavaScript, where everything is an object, with Fastify everything is a
+plugin.
+
+Before digging into it, let's see how it works!
+
+Let's declare our basic server, but instead of declaring the route inside the
+entry point, we'll declare it in an external file (check out the [route
+declaration](../Reference/Routes.md) docs).
 ```js
 // ESM
 import Fastify from 'fastify'
@@ -148,14 +176,24 @@ async function routes (fastify, options) {
 
 module.exports = routes
 ```
-In this example, we used the `register` API, which is the core of the Fastify framework. It is the only way to add routes, plugins, et cetera.
+In this example, we used the `register` API, which is the core of the Fastify
+framework. It is the only way to add routes, plugins, et cetera.
+
+At the beginning of this guide, we noted that Fastify provides a foundation that
+assists with asynchronous bootstrapping of your application. Why is this
+important?
+
+Consider the scenario where a database connection is needed to handle data
+storage. The database connection needs to be available before the server is
+accepting connections. How do we address this problem?
+
+A typical solution is to use a complex callback, or promises - a system that
+will mix the framework API with other libraries and the application code.
 
-At the beginning of this guide, we noted that Fastify provides a foundation that assists with asynchronous bootstrapping of your application. Why is this important?
-Consider the scenario where a database connection is needed to handle data storage. The database connection needs to be available before the server is accepting connections. How do we address this problem?<br>
-A typical solution is to use a complex callback, or promises - a system that will mix the framework API with other libraries and the application code.<br>
 Fastify handles this internally, with minimum effort!
 
-Let's rewrite the above example with a database connection.<br>
+Let's rewrite the above example with a database connection.
+
 
 First, install `fastify-plugin` and `fastify-mongodb`:
 
@@ -216,7 +254,7 @@ async function dbConnector (fastify, options) {
   })
 }
 
-// Wrapping a plugin function with fastify-plugin exposes the decorators	
+// Wrapping a plugin function with fastify-plugin exposes the decorators
 // and hooks, declared inside the plugin to the parent scope.
 module.exports = fastifyPlugin(dbConnector)
 
@@ -232,7 +270,7 @@ async function dbConnector (fastify, options) {
   })
 }
 
-// Wrapping a plugin function with fastify-plugin exposes the decorators	
+// Wrapping a plugin function with fastify-plugin exposes the decorators
 // and hooks, declared inside the plugin to the parent scope.
 module.exports = fastifyPlugin(dbConnector)
 
@@ -262,24 +300,61 @@ async function routes (fastify, options) {
     }
     return result
   })
+
+  const animalBodyJsonSchema = {
+    type: 'object',
+    required: ['animal'],
+    properties: {
+      animal: { type: 'string' },
+    },
+  }
+
+  const schema = {
+    body: animalBodyJsonSchema,
+  }
+
+  fastify.post('/animals', { schema }, async (request, reply) => {
+    // we can use the `request.body` object to get the data sent by the client
+    const result = await collection.insertOne({ animal: request.body.animal })
+    return result
+  })
 }
 
 module.exports = routes
 ```
 
-Wow, that was fast!<br>
-Let's recap what we have done here since we've introduced some new concepts.<br>
-As you can see, we used `register` for both the database connector and the registration of the routes.
-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()`
+Wow, that was fast!
+
+Let's recap what we have done here since we've introduced some new concepts.
+
+As you can see, we used `register` for both the database connector and the
+registration of the routes.
 
-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.
+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](../Reference/Plugins.md#handle-the-scope) to understand how to handle the
+scope of a plugin)*.
 
-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).
+Plugin loading starts when you call `fastify.listen()`, `fastify.inject()` or
+`fastify.ready()`
+
+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).
 
-<a name="plugin-loading-order"></a>
 ### Loading order of your plugins
-To guarantee consistent and predictable behavior of your application, we highly recommend to always load your code as shown below:
+<a id="plugin-loading-order"></a>
+
+To guarantee consistent and predictable behavior of your application, we highly
+recommend to always load your code as shown below:
 ```
 └── plugins (from the Fastify ecosystem)
 └── your plugins (your custom plugins)
@@ -287,8 +362,13 @@ To guarantee consistent and predictable behavior of your application, we highly
 └── hooks
 └── your services
 ```
-In this way, you will always have access to all of the properties declared in the current scope.<br/>
-As discussed previously, Fastify offers a solid encapsulation model, to help you build your application as single and independent services. If you want to register a plugin only for a subset of routes, you just have to replicate the above structure.
+In this way, you will always have access to all of the properties declared in
+the current scope.
+
+As discussed previously, Fastify offers a solid encapsulation model, to help you
+build your application as single and independent services. If you want to
+register a plugin only for a subset of routes, you just have to replicate the
+above structure.
 ```
 └── plugins (from the Fastify ecosystem)
 └── your plugins (your custom plugins)
@@ -311,10 +391,14 @@ As discussed previously, Fastify offers a solid encapsulation model, to help you
           └── your services
 ```
 
-<a name="validate-data"></a>
 ### Validate your data
-Data validation is extremely important and a core concept of the framework.<br>
-To validate incoming requests, Fastify uses [JSON Schema](https://json-schema.org/).
+<a id="validate-data"></a>
+
+Data validation is extremely important and a core concept of the framework.
+
+To validate incoming requests, Fastify uses [JSON
+Schema](https://json-schema.org/).
+
 (JTD schemas are loosely supported, but `jsonShorthand` must be disabled first)
 
 Let's look at an example demonstrating validation for routes:
@@ -335,13 +419,21 @@ fastify.post('/', opts, async (request, reply) => {
   return { hello: 'world' }
 })
 ```
-This example shows how to pass an options object to the route, which accepts a `schema` key that contains all of the schemas for route, `body`, `querystring`, `params`, and `headers`.<br>
-Read [Validation and Serialization](Validation-and-Serialization.md) to learn more.
+This example shows how to pass an options object to the route, which accepts a
+`schema` key that contains all of the schemas for route, `body`, `querystring`,
+`params`, and `headers`.
+
+Read [Validation and
+Serialization](../Reference/Validation-and-Serialization.md) to learn more.
 
-<a name="serialize-data"></a>
 ### Serialize your data
-Fastify has first class support for JSON. It is extremely optimized to parse JSON bodies and to serialize JSON output.<br>
-To speed up JSON serialization (yes, it is slow!) use the `response` key of the schema option as shown in the following example:
+<a id="serialize-data"></a>
+
+Fastify has first class support for JSON. It is extremely optimized to parse
+JSON bodies and to serialize JSON output.
+
+To speed up JSON serialization (yes, it is slow!) use the `response` key of the
+schema option as shown in the following example:
 ```js
 const opts = {
   schema: {
@@ -360,12 +452,19 @@ fastify.get('/', opts, async (request, reply) => {
   return { hello: 'world' }
 })
 ```
-By specifying a schema as shown, you can speed up serialization by a factor of 2-3. This also helps to protect against leakage of potentially sensitive data, since Fastify will serialize only the data present in the response schema.
-Read [Validation and Serialization](Validation-and-Serialization.md) to learn more.
+By specifying a schema as shown, you can speed up serialization by a factor of
+2-3. This also helps to protect against leakage of potentially sensitive data,
+since Fastify will serialize only the data present in the response schema. Read
+[Validation and Serialization](../Reference/Validation-and-Serialization.md) to
+learn more.
 
-<a name="request-payload"></a>
 ### Parsing request payloads
-Fastify parses `'application/json'` and `'text/plain'` request payloads natively, with the result accessible from the [Fastify request](Request.md) object at `request.body`.<br>
+<a id="request-payload"></a>
+
+Fastify parses `'application/json'` and `'text/plain'` request payloads
+natively, with the result accessible from the [Fastify
+request](../Reference/Request.md) object at `request.body`.
+
 The following example returns the parsed body of a request back to the client:
 
 ```js
@@ -375,21 +474,33 @@ fastify.post('/', opts, async (request, reply) => {
 })
 ```
 
-Read [Content Type Parser](ContentTypeParser.md) to learn more about Fastify's default parsing functionality and how to support other content types.
+Read [Content-Type Parser](../Reference/ContentTypeParser.md) to learn more
+about Fastify's default parsing functionality and how to support other content
+types.
 
-<a name="extend-server"></a>
 ### Extend your server
-Fastify is built to be extremely extensible and minimal, we believe that a bare-bones framework is all that is necessary to make great applications possible.<br>
-In other words, Fastify is not a "batteries included" framework, and relies on an amazing [ecosystem](Ecosystem.md)!
+<a id="extend-server"></a>
+
+Fastify is built to be extremely extensible and minimal, we believe that a
+bare-bones framework is all that is necessary to make great applications
+possible.
+
+In other words, Fastify is not a "batteries included" framework, and relies on
+an amazing [ecosystem](./Ecosystem.md)!
 
-<a name="test-server"></a>
 ### Test your server
-Fastify does not offer a testing framework, but we do recommend a way to write your tests that uses the features and architecture of Fastify.<br>
-Read the [testing](Testing.md) documentation to learn more!
+<a id="test-server"></a>
+
+Fastify does not offer a testing framework, but we do recommend a way to write
+your tests that uses the features and architecture of Fastify.
+
+Read the [testing](./Testing.md) documentation to learn more!
 
-<a name="cli"></a>
 ### Run your server from CLI
-Fastify also has CLI integration thanks to [fastify-cli](https://github.com/fastify/fastify-cli).
+<a id="cli"></a>
+
+Fastify also has CLI integration thanks to
+[fastify-cli](https://github.com/fastify/fastify-cli).
 
 First, install `fastify-cli`:
 
@@ -425,12 +536,21 @@ Then run your server with:
 npm start
 ```
 
-<a name="slides"></a>
 ### Slides and Videos
+<a id="slides"></a>
+
 - Slides
-  - [Take your HTTP server to ludicrous speed](https://mcollina.github.io/take-your-http-server-to-ludicrous-speed) by [@mcollina](https://github.com/mcollina)
-  - [What if I told you that HTTP can be fast](https://delvedor.github.io/What-if-I-told-you-that-HTTP-can-be-fast) by [@delvedor](https://github.com/delvedor)
+  - [Take your HTTP server to ludicrous
+    speed](https://mcollina.github.io/take-your-http-server-to-ludicrous-speed)
+    by [@mcollina](https://github.com/mcollina)
+  - [What if I told you that HTTP can be
+    fast](https://delvedor.github.io/What-if-I-told-you-that-HTTP-can-be-fast)
+    by [@delvedor](https://github.com/delvedor)
 
 - Videos
-  - [Take your HTTP server to ludicrous speed](https://www.youtube.com/watch?v=5z46jJZNe8k) by [@mcollina](https://github.com/mcollina)
-  - [What if I told you that HTTP can be fast](https://www.webexpo.net/prague2017/talk/what-if-i-told-you-that-http-can-be-fast/) by [@delvedor](https://github.com/delvedor)
+  - [Take your HTTP server to ludicrous
+    speed](https://www.youtube.com/watch?v=5z46jJZNe8k) by
+    [@mcollina](https://github.com/mcollina)
+  - [What if I told you that HTTP can be
+    fast](https://www.webexpo.net/prague2017/talk/what-if-i-told-you-that-http-can-be-fast/)
+    by [@delvedor](https://github.com/delvedor)

package/docs/Guides/Index.md

@@ -1,6 +1,32 @@
-# Guides
+<h1 align="center">Fastify</h1>
 
-## General
-<a id="guides-general"></a>
+## Guides Table Of Contents
+<a id="guides-toc"></a>
 
-* [Contributing To Fastify](./Contributing.md)
+This table of contents is in alphabetical order.
+
++ [Benchmarking](./Benchmarking.md): This guide introduces how to benchmark
+  applications based upon Fastify.
++ [Contributing](./Contributing.md): Details how to participate in the
+  development of Fastify, and shows how to setup an environment compatible with
+  the project's code style.
++ [Ecosystem](./Ecosystem.md): Lists all core plugins and many known community
+  plugins.
++ [Fluent Schema](./Fluent-Schema.md): Shows how writing JSON Schema can be
+  written with a fluent API and used in Fastify.
++ [Getting Started](./Getting-Started.md): Introduction tutorial for Fastify.
+  This is where beginners should start.
++ [Migration Guide (v3)](./Migration-Guide-V3.md): Details how to migrate to
+  Fastify v3 from earlier versions.
++ [Plugins Guide](./Plugins-Guide.md): An informal introduction to writing
+  Fastify plugins.
++ [Recommendations](./Recommendations.md): Recommendations for how to deploy
+  Fastify into production environments.
++ [Serverless](./Serverless.md): Details on how to deploy Fastify applications
+  in various Function as a Service (FaaS) environments.
++ [Style Guide](./Style-Guide.md): Explains the writing style we use for the
+  Fastify documentation for those who want to contribute documentation.
++ [Testing](./Testing.md): Explains how to write unit tests for Fastify
+  applications.
++ [Write Plugin](./Write-Plugin.md): A set of guidelines for what the Fastify
+  team considers good practices for writing a Fastify plugin.

package/docs/{Migration-Guide-V3.md → Guides/Migration-Guide-V3.md}

@@ -34,9 +34,9 @@ fastify.use(require('cors')());
 
 ### Changed logging serialization ([#2017](https://github.com/fastify/fastify/pull/2017))
 
-The logging [Serializers](Logging.md) have been updated to now Fastify
-[`Request`](Request.md) and [`Reply`](Reply.md) objects instead of
-native ones.
+The logging [Serializers](../Reference/Logging.md) have been updated to now
+Fastify [`Request`](../Reference/Request.md) and
+[`Reply`](../Reference/Reply.md) objects instead of native ones.
 
 Any custom serializers must be updated if they rely upon `request` or `reply`
 properties that are present on the native objects but not the Fastify objects.
@@ -79,8 +79,9 @@ const fastify = require('fastify')({
 
 The non-standard `replace-way` shared schema support has been removed. This
 feature has been replaced with JSON Schema specification compliant `$ref` based
-substitution. To help understand this change read
-[Validation and Serialization in Fastify v3](https://dev.to/eomm/validation-and-serialization-in-fastify-v3-2e8l).
+substitution. To help understand this change read [Validation and Serialization
+in Fastify
+v3](https://dev.to/eomm/validation-and-serialization-in-fastify-v3-2e8l).
 
 **v2:**
 
@@ -104,10 +105,10 @@ fastify.route({ method, url, schema, handler });
 
 ### Changed schema validation options ([#2023](https://github.com/fastify/fastify/pull/2023))
 
-The `setSchemaCompiler` and `setSchemaResolver` options have been replaced
-with the `setValidatorCompiler` to enable future tooling improvements.
-To help understand this change read
-[Validation and Serialization in Fastify v3](https://dev.to/eomm/validation-and-serialization-in-fastify-v3-2e8l).
+The `setSchemaCompiler` and `setSchemaResolver` options have been replaced with
+the `setValidatorCompiler` to enable future tooling improvements. To help
+understand this change read [Validation and Serialization in Fastify
+v3](https://dev.to/eomm/validation-and-serialization-in-fastify-v3-2e8l).
 
 **v2:**
 
@@ -136,22 +137,23 @@ fastify.setValidatorCompiler(({ schema, method, url, httpPart }) =>
 
 ### Changed preParsing hook behavior ([#2286](https://github.com/fastify/fastify/pull/2286))
 
-From Fastify v3, the behavior of the `preParsing` hook will change slightly
-in order to support request payload manipulation.
+From Fastify v3, the behavior of the `preParsing` hook will change slightly in
+order to support request payload manipulation.
 
 The hook now takes an additional argument, `payload`, and therefore the new hook
-signature is `fn(request, reply, payload, done)` or
-`async fn(request, reply, payload)`.
+signature is `fn(request, reply, payload, done)` or `async fn(request, reply,
+payload)`.
 
 The hook can optionally return a new stream via `done(null, stream)` or
 returning the stream in case of async functions.
 
-If the hook returns a new stream, it will be used instead of the original one in subsequent hooks. A sample use case for this is handling compressed requests.
+If the hook returns a new stream, it will be used instead of the original one in
+subsequent hooks. A sample use case for this is handling compressed requests.
 
 The new stream should add the `receivedEncodedLength` property to the stream
 that should reflect the actual data size received from the client. For instance,
-in a compressed request it should be the size of the compressed payload.
-This property can (and should) be dynamically updated during `data` events.
+in a compressed request it should be the size of the compressed payload. This
+property can (and should) be dynamically updated during `data` events.
 
 The old syntax of Fastify v2 without payload is supported but it is deprecated.
 
@@ -161,23 +163,24 @@ From Fastify v3, the behavior of `onRoute` and `onRegister` hooks will change
 slightly in order to support hook encapsulation.
 
 - `onRoute` - The hook will be called asynchronously. The hook is now inherited
-when registering a new plugin within the same encapsulation scope. Thus, this
-hook should be registered _before_ registering any plugins.
+  when registering a new plugin within the same encapsulation scope. Thus, this
+  hook should be registered _before_ registering any plugins.
 - `onRegister` - Same as the onRoute hook. The only difference is that now the
-very first call will no longer be the framework itself, but the first registered
-plugin.
+  very first call will no longer be the framework itself, but the first
+  registered plugin.
 
 ### Changed Content Type Parser syntax ([#2286](https://github.com/fastify/fastify/pull/2286))
 
 In Fastify v3 the content type parsers now have a single signature for parsers.
 
-The new signatures are `fn(request, payload, done)` or `async fn(request, payload)`.
-Note that `request` is now a Fastify request, not an `IncomingMessage`.
-The payload is by default a stream. If the `parseAs` option is used in
-`addContentTypeParser`, then `payload` reflects the option value (string or buffer).
+The new signatures are `fn(request, payload, done)` or `async fn(request,
+payload)`. Note that `request` is now a Fastify request, not an
+`IncomingMessage`. The payload is by default a stream. If the `parseAs` option
+is used in `addContentTypeParser`, then `payload` reflects the option value
+(string or buffer).
 
-The old signatures `fn(req, [done])` or `fn(req, payload, [done])`
-(where `req` is `IncomingMessage`) are still supported but are deprecated.
+The old signatures `fn(req, [done])` or `fn(req, payload, [done])` (where `req`
+is `IncomingMessage`) are still supported but are deprecated.
 
 ### Changed TypeScript support
 
@@ -267,15 +270,18 @@ fastify.get('/', (request, reply) => {
 ## Further additions and improvements
 
 - Hooks now have consistent context regardless of how they are registered
-([#2005](https://github.com/fastify/fastify/pull/2005))
-- Deprecated `request.req` and `reply.res` for [`request.raw`](Request.md) and
-[`reply.raw`](Reply.md) ([#2008](https://github.com/fastify/fastify/pull/2008))
-- Removed `modifyCoreObjects` option ([#2015](https://github.com/fastify/fastify/pull/2015))
-- Added [`connectionTimeout`](Server.md#factory-connection-timeout)
-option ([#2086](https://github.com/fastify/fastify/pull/2086))
-- Added [`keepAliveTimeout`](Server.md#factory-keep-alive-timeout)
-option ([#2086](https://github.com/fastify/fastify/pull/2086))
-- Added async-await support for [plugins](Plugins.md#async-await)
-([#2093](https://github.com/fastify/fastify/pull/2093))
+  ([#2005](https://github.com/fastify/fastify/pull/2005))
+- Deprecated `request.req` and `reply.res` for
+  [`request.raw`](../Reference/Request.md) and
+  [`reply.raw`](../Reference/Reply.md)
+  ([#2008](https://github.com/fastify/fastify/pull/2008))
+- Removed `modifyCoreObjects` option
+  ([#2015](https://github.com/fastify/fastify/pull/2015))
+- Added [`connectionTimeout`](../Reference/Server.md#factory-connection-timeout)
+  option ([#2086](https://github.com/fastify/fastify/pull/2086))
+- Added [`keepAliveTimeout`](../Reference/Server.md#factory-keep-alive-timeout)
+  option ([#2086](https://github.com/fastify/fastify/pull/2086))
+- Added async-await support for [plugins](../Reference/Plugins.md#async-await)
+  ([#2093](https://github.com/fastify/fastify/pull/2093))
 - Added the feature to throw object as error
-([#2134](https://github.com/fastify/fastify/pull/2134))
+  ([#2134](https://github.com/fastify/fastify/pull/2134))