fastify 3.20.2 → 3.21.3

package/.taprc

@@ -3,3 +3,4 @@ jsx: false
 flow: false
 check-coverage: true
 coverage: true
+node-arg: --allow-natives-syntax

package/README.md

@@ -1,5 +1,7 @@
 <div align="center">
-<img src="https://github.com/fastify/graphics/raw/HEAD/fastify-landscape-outlined.svg" width="650" height="auto"/>
+  <a href="https://fastify.io/">
+    <img src="https://github.com/fastify/graphics/raw/HEAD/fastify-landscape-outlined.svg" width="650" height="auto"/>
+  </a>
 </div>
 
 <div align="center">
@@ -28,6 +30,19 @@ Disclosure](https://img.shields.io/badge/Security-Responsible%20Disclosure-yello
 An efficient server implies a lower cost of the infrastructure, a better responsiveness under load and happy users.
 How can you efficiently handle the resources of your server, knowing that you are serving the highest number of requests as possible, without sacrificing security validations and handy development?
 
+ - [Quick start](./README.md#quick-start)
+ - [Install](./README.md#install)
+ - [Example](./README.md#example)
+ - [Fastify v1.x and v2.x](./README.md#fastify-v1x-and-v2x)
+ - [Core features](./README.md#core-features)
+ - [Benchmarks](./README.md#benchmarks)
+ - [Documentation](./README.md#documentation)
+ - [Ecosystem](./README.md#ecosystem)
+ - [Support](./README.md#support)
+ - [Team](./README.md#team)
+ - [Hosted by](./README.md#hosted-by)
+ - [License](./README.md#license)
+
 Enter Fastify. Fastify is a web framework highly focused on providing the best developer experience with the least overhead and a powerful plugin architecture. It is inspired by Hapi and Express and as far as we know, it is one of the fastest web frameworks in town.
 
 ### Quick start
@@ -84,6 +99,13 @@ yarn add fastify
 
 ```js
 // Require the framework and instantiate it
+
+// ESM
+import Fastify from 'fastify'
+const fastify = Fastify({
+  logger: true
+})
+// CommonJs
 const fastify = require('fastify')({
   logger: true
 })
@@ -103,6 +125,12 @@ fastify.listen(3000, (err, address) => {
 with async-await:
 
 ```js
+// ESM
+import Fastify from 'fastify'
+const fastify = Fastify({
+  logger: true
+})
+// CommonJs
 const fastify = require('fastify')({
   logger: true
 })
@@ -162,6 +190,7 @@ matters to you.
 
 ## Documentation
 * <a href="./docs/Getting-Started.md"><code><b>Getting Started</b></code></a>
+* <a href="./docs/Guides/Index.md"><code><b>Guides</b></code></a>
 * <a href="./docs/Server.md"><code><b>Server</b></code></a>
 * <a href="./docs/Routes.md"><code><b>Routes</b></code></a>
 * <a href="./docs/Encapsulation.md"><code><b>Encapsulation</b></code></a>

package/docs/ContentTypeParser.md

@@ -85,7 +85,7 @@ fastify.addContentTypeParser('text/xml', function (request, payload, done) {
 })
 
 // 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'])
+fastify.removeContentTypeParser(['application/json', 'text/plain'])
 ```
 
 #### removeAllContentTypeParsers
@@ -97,7 +97,7 @@ Just like `removeContentTypeParser`, this API supports encapsulation. The API is
 [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.removeAllContentTypeParsers()
 
 fastify.addContentTypeParser('text/xml', function (request, payload, done) {
   xmlParser(payload, function (err, body) {

package/docs/Ecosystem.md

@@ -47,7 +47,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`@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).
+- [`fastify-websocket`](https://github.com/fastify/fastify-websocket) WebSocket support for Fastify. Built upon [ws](https://github.com/websockets/ws).
 - [`fastify-url-data`](https://github.com/fastify/fastify-url-data) Decorate the `Request` object with a method to access raw URL components.
 - [`point-of-view`](https://github.com/fastify/point-of-view) Templates rendering (_ejs, pug, handlebars, marko_) plugin support for Fastify.
 - [`under-pressure`](https://github.com/fastify/under-pressure) Measure process load with automatic handling of _"Service Unavailable"_ plugin for Fastify.
@@ -74,6 +74,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`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
+- [`fastify-appwrite`](https://github.com/Dev-Manny/fastify-appwrite) Fastify Plugin for interacting with Appwrite server.
 - [`fastify-auth0-verify`](https://github.com/nearform/fastify-auth0-verify): Auth0 verification plugin for Fastify, internally uses [fastify-jwt](https://npm.im/fastify-jwt) and [jsonwebtoken](https://npm.im/jsonwebtoken).
 - [`fastify-autocrud`](https://github.com/paranoiasystem/fastify-autocrud) Plugin to auto-generate CRUD routes as fast as possible.
 - [`fastify-autoroutes`](https://github.com/GiovanniCardamone/fastify-autoroutes) Plugin to scan and load routes based on filesystem path from a custom directory.
@@ -83,6 +84,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-blipp`](https://github.com/PavelPolyakov/fastify-blipp) Prints your routes to the console, so you definitely know which endpoints are available.
 - [`fastify-bookshelf`](https://github.com/butlerx/fastify-bookshelfjs) Fastify plugin to add [bookshelf.js](https://bookshelfjs.org/) ORM support.
 - [`fastify-boom`](https://github.com/jeromemacias/fastify-boom) Fastify plugin to add [boom](https://github.com/hapijs/boom) support.
+- [`fastify-bree`](https://github.com/climba03003/fastify-bree) Fastify plugin to add [bree](https://github.com/breejs/bree) support.
 - [`fastify-casbin`](https://github.com/nearform/fastify-casbin) Casbin support for Fastify.
 - [`fastify-casbin-rest`](https://github.com/nearform/fastify-casbin-rest) Casbin support for Fastify based on a RESTful model.
 - [`fastify-casl`](https://github.com/Inlecom/fastify-casl) Fastify [CASL](https://github.com/stalniy/casl) plugin that supports ACL-like protection of endpoints via either a preSerialization & preHandler hook, sanitizing the inputs and outputs of your application based on user rights.

package/docs/Getting-Started.md

@@ -21,6 +21,13 @@ yarn add fastify
 Let's write our first server:
 ```js
 // Require the framework and instantiate it
+
+// ESM
+import Fastify from 'fastify'
+const fastify = Fastify({
+  logger: true
+})
+// CommonJs
 const fastify = require('fastify')({
   logger: true
 })
@@ -36,13 +43,19 @@ fastify.listen(3000, function (err, address) {
     fastify.log.error(err)
     process.exit(1)
   }
-  fastify.log.info(`server listening on ${address}`)
+  // Server is now listening on ${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.)*
 ```js
+// ESM
+import Fastify from 'fastify'
+const fastify = Fastify({
+  logger: true
+})
+// CommonJs
 const fastify = require('fastify')({
   logger: true
 })
@@ -89,6 +102,26 @@ As with JavaScript, where everything is an object, with Fastify everything is a
 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).
 ```js
+// ESM
+import Fastify from 'fastify'
+import firstRoute from './our-first-route'
+const fastify = Fastify({
+  logger: true
+})
+
+fastify.register(firstRoute)
+
+fastify.listen(3000, function (err, address) {
+  if (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+  // Server is now listening on ${address}
+})
+```
+
+```js
+// CommonJs
 const fastify = require('fastify')({
   logger: true
 })
@@ -100,7 +133,7 @@ fastify.listen(3000, function (err, address) {
     fastify.log.error(err)
     process.exit(1)
   }
-  fastify.log.info(`server listening on ${address}`)
+  // Server is now listening on ${address}
 })
 ```
 
@@ -132,6 +165,28 @@ npm i --save fastify-plugin fastify-mongodb
 
 **server.js**
 ```js
+// ESM
+import Fastify from 'fastify'
+import dbConnector from './our-db-connector'
+import firstRoute from './our-first-route'
+
+const fastify = Fastify({
+  logger: true
+})
+fastify.register(dbConnector)
+fastify.register(firstRoute)
+
+fastify.listen(3000, function (err, address) {
+  if (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+  // Server is now listening on ${address}
+})
+```
+
+```js
+// CommonJs
 const fastify = require('fastify')({
   logger: true
 })
@@ -144,13 +199,31 @@ fastify.listen(3000, function (err, address) {
     fastify.log.error(err)
     process.exit(1)
   }
-  fastify.log.info(`server listening on ${address}`)
+  // Server is now listening on ${address}
 })
 
 ```
 
 **our-db-connector.js**
 ```js
+// ESM
+import fastifyPlugin from 'fastify-plugin'
+import fastifyMongo from 'fastify-mongodb'
+
+async function dbConnector (fastify, options) {
+  fastify.register(fastifyMongo, {
+    url: 'mongodb://localhost:27017/test_database'
+  })
+}
+
+// Wrapping a plugin function with fastify-plugin exposes the decorators	
+// and hooks, declared inside the plugin to the parent scope.
+module.exports = fastifyPlugin(dbConnector)
+
+```
+
+```js
+// CommonJs
 const fastifyPlugin = require('fastify-plugin')
 
 async function dbConnector (fastify, options) {

package/docs/Guides/Index.md

@@ -0,0 +1,6 @@
+# Guides
+
+## General
+<a id="guides-general"></a>
+
+* [Contributing To Fastify](./Contributing.md)

package/docs/Hooks.md

@@ -564,3 +564,45 @@ fastify.route({
 ```
 
 **Note**: both options also accept an array of functions.
+
+## Diagnostics Channel Hooks
+
+> **Note:** The `diagnostics_channel` is currently experimental on Node.js, so
+> its API is subject to change even in semver-patch releases of Node.js. For
+> versions of Node.js supported by Fastify where `diagnostics_channel` is
+> unavailable, the hook will use the
+> [polyfill](https://www.npmjs.com/package/diagnostics_channel) if it is
+> available. Otherwise this feature will not be present.
+
+Currently, one
+[`diagnostics_channel`](https://nodejs.org/api/diagnostics_channel.html) publish
+event, `'fastify.initialization'`, happens at initialization time. The Fastify
+instance is passed into the hook as a property of the object passed in. At this
+point, the instance can be interacted with to add hooks, plugins, routes or any
+other sort of modification.
+
+For example, a tracing package might do something like the following (which is,
+of course, a simplification). This would be in a file loaded in the
+initialization of the tracking package, in the typical "require instrumentation
+tools first" fashion.
+
+```js
+const tracer = /* retrieved from elsehwere in the package */
+const dc = require('diagnostics_channel')
+const channel = dc.channel('fastify.initialization')
+const spans = new WeakMap()
+
+channel.subscribe(function ({ fastify }) {
+  fastify.addHook('onRequest', (request, reply, done) => {
+    const span = tracer.startSpan('fastify.request')
+    spans.set(request, span)
+    done()
+  })
+
+  fastify.addHook('onResponse', (request, reply, done) => {
+    const span = spans.get(request)
+    span.finish()
+    done()
+  })
+})
+```

package/docs/Lifecycle.md

@@ -19,7 +19,7 @@ Incoming Request
                              │
                    4**/5** ◀─┴─▶ preValidation Hook
                                   │
-                            415 ◀─┴─▶ Validation
+                            400 ◀─┴─▶ Validation
                                         │
                               4**/5** ◀─┴─▶ preHandler Hook
                                               │

package/docs/Recommendations.md

@@ -39,7 +39,9 @@ For a concrete example, consider the situation where:
 
 There are many reverse proxy solutions available, and your environment may
 dictate the solution to use, e.g. AWS or GCP. Given the above, we could use
-[HAProxy][haproxy] to solve these requirements:
+[HAProxy][haproxy] or [Nginx][nginx] to solve these requirements:
+
+### HAProxy
 
 ```conf
 # The global section defines base HAProxy (engine) instance configuration.
@@ -161,6 +163,83 @@ backend static-backend
 [why-use]: https://web.archive.org/web/20190821102906/https://medium.com/intrinsic/why-should-i-use-a-reverse-proxy-if-node-js-is-production-ready-5a079408b2ca
 [haproxy]: https://www.haproxy.org/
 
+### Nginx
+
+```nginx
+upstream fastify_app {
+  # more info: http://nginx.org/en/docs/http/ngx_http_upstream_module.html
+  server 10.10.11.1:80;
+  server 10.10.11.2:80;
+  server 10.10.11.3:80 backup;
+}
+
+server {
+  # default server
+  listen 80 default_server;
+  listen [::]:80 default_server;
+  
+  # specify host
+  # listen 80;
+  # listen [::]:80;
+  # server_name example.tld;
+
+  location / {
+    return 301 https://$host$request_uri;
+  }
+}
+
+server {
+  # default server
+  listen 443 ssl http2 default_server;
+  listen [::]:443 ssl http2 default_server;
+  
+  # specify host
+  # listen 443 ssl http2;
+  # listen [::]:443 ssl http2;
+  # server_name example.tld;
+
+  # public private keys
+  ssl_certificate /path/to/fullchain.pem;
+  ssl_certificate_key /path/to/private.pem;
+  ssl_trusted_certificate /path/to/chain.pem;
+
+  # use https://ssl-config.mozilla.org/ for best practice configuration
+  ssl_session_timeout 1d;
+  ssl_session_cache shared:FastifyApp:10m;
+  ssl_session_tickets off;
+  
+  # modern configuration
+  ssl_protocols TLSv1.3;
+  ssl_prefer_server_ciphers off;
+  
+  # HSTS (ngx_http_headers_module is required) (63072000 seconds)
+  add_header Strict-Transport-Security "max-age=63072000" always;
+  
+  # OCSP stapling
+  ssl_stapling on;
+  ssl_stapling_verify on;
+
+  # custom resolver
+  # resolver 127.0.0.1;
+      
+  location / {
+    # more info: http://nginx.org/en/docs/http/ngx_http_proxy_module.html
+    proxy_http_version 1.1;
+    proxy_cache_bypass $http_upgrade;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection 'upgrade';
+    proxy_set_header Host $host;
+    proxy_set_header X-Real-IP $remote_addr;
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header X-Forwarded-Proto $scheme;
+    
+    proxy_pass http://fastify_app:3000;
+  }
+}
+```
+
+[nginx]: https://nginx.org/
+
 ## Kubernetes
 <a id="kubernetes"></a>
 

package/docs/Reply.md

@@ -335,7 +335,7 @@ If you pass to *send* an object that is an instance of *Error*, Fastify will aut
 }
 ```
 
-You can add some custom property to the Error object, such as `headers`, that will be used to enhance the HTTP response.<br>
+You can add custom properties to the Error object, such as `headers`, that will be used to enhance the HTTP response.<br>
 *Note: If you are passing an error to `send` and the statusCode is less than 400, Fastify will automatically set it at 500.*
 
 Tip: you can simplify errors by using the [`http-errors`](https://npm.im/http-errors) module or [`fastify-sensible`](https://github.com/fastify/fastify-sensible) plugin to generate errors:
@@ -376,7 +376,7 @@ fastify.get('/', {
 })
 ```
 
-If you want to completely customize the error handling, check out [`setErrorHandler`](Server.md#seterrorhandler) API.<br>
+If you want to customize error handling, check out [`setErrorHandler`](Server.md#seterrorhandler) API.<br>
 *Note: you are responsible for logging when customizing the error handler*
 
 API:

package/docs/Request.md

@@ -10,25 +10,25 @@ Request is a core Fastify object containing the following fields:
 - `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)
-- `id` - the request id
+- `id` - the request ID
 - `log` - the logger instance of the incoming request
 - `ip` - the IP address of the incoming request
 - `ips` - an array of the IP addresses, ordered from closest to furthest, in the `X-Forwarded-For` header of the incoming request (only when the [`trustProxy`](Server.md#factory-trust-proxy) option is enabled)
 - `hostname` - the hostname of the incoming request (derived from `X-Forwarded-Host` header when the [`trustProxy`](Server.md#factory-trust-proxy) option is enabled)
 - `protocol` - the protocol of the incoming request (`https` or `http`)
 - `method` - the method of the incoming request
-- `url` - the url of the incoming request
+- `url` - the URL of the incoming request
 - `routerMethod` - the method defined for the router that is handling the request
 - `routerPath` - the path pattern defined for the router that is handling the request
 - `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` - A Fastify internal object. You should not use it directly or modify it. It is useful 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.
+The `request.headers` is a getter that returns an Object with the headers of the incoming request.
 You can set custom headers like this:
 
 ```js

package/docs/Server.md

@@ -8,6 +8,38 @@ The Fastify module exports a factory function that is used to create new
 an options object which is used to customize the resulting instance. This
 document describes the properties available in that options object.
 
+- [http2](./Server.md#http2)
+- [https](./Server.md#https)
+- [connectionTimeout](./Server.md#connectiontimeout)
+- [keepAliveTimeout](./Server.md#keepalivetimeout)
+- [ignoreTrailingSlash](./Server.md#ignoretrailingslash)
+- [maxParamLength](./Server.md#maxparamlength)
+- [onProtoPoisoning](./Server.md#onprotopoisoning)
+- [onConstructorPoisoning](./Server.md#onconstructorpoisoning)
+- [logger](./Server.md#logger)
+- [serverFactory](./Server.md#serverfactory)
+- [jsonShorthand](./Server.md#jsonshorthand)
+- [caseSensitive](./Server.md#casesensitive)
+- [requestIdHeader](./Server.md#requestidheader)
+- [requestIdLogLabel](./Server.md#requestidloglabel)
+- [genReqId](./Server.md#genreqid)
+- [trustProxy](./Server.md#trustProxy)
+- [pluginTimeout](./Server.md#plugintimeout)
+- [querystringParser](./Server.md#querystringParser)
+- [exposeHeadRoutes](./Server.md#exposeheadroutes)
+- [constraints](./Server.md#constraints)
+- [return503OnClosing](./Server.md#return503onclosing)
+- [ajv](./Server.md#ajv)
+- [serializerOpts](./Server.md#serializeropts)
+- [http2SessionTimeout](./Server.md#http2sessiontimeout)
+- [frameworkErrors](./Server.md#frameworkerrors)
+- [clientErrorHandler](./Server.md#clienterrorhandler)
+- [rewriteUrl](./Server.md#rewriteurl)
+- [Instance](./Server.md#instance)
+- [Server Methods](./Server.md#server-methods)
+- [initialConfig](./Server.md#initialConfig)
+
+
 <a name="factory-http2"></a>
 ### `http2`
 
@@ -78,7 +110,7 @@ fastify.get('/bar', function (req, reply) {
 
 <a name="factory-max-param-length"></a>
 ### `maxParamLength`
-You can set a custom length for parameters in parametric (standard, regex, and multi) routes by using `maxParamLength` option, the default value is 100 characters.<br>
+You can set a custom length for parameters in parametric (standard, regex, and multi) routes by using `maxParamLength` option; the default value is 100 characters.<br>
 This can be useful especially if you have some regex based route, protecting you against [DoS attacks](https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS).<br>
 *If the maximum length limit is reached, the not found route will be invoked.*
 
@@ -135,7 +167,7 @@ are not present on the object, they will be added accordingly:
     * `level`: the minimum logging level. If not set, it will be set to `'info'`.
     * `serializers`: a hash of serialization functions. By default, serializers
       are added for `req` (incoming request objects), `res` (outgoing response
-      objets), and `err` (standard `Error` objects). When a log method receives
+      objects), and `err` (standard `Error` objects). When a log method receives
       an object with any of these properties then the respective serializer will
       be used for that property. For example:
         ```js
@@ -196,7 +228,7 @@ Please note that this setting will also disable an error log written by the defa
 <a name="custom-http-server"></a>
 ### `serverFactory`
 You can pass a custom HTTP server to Fastify by using the `serverFactory` option.<br/>
-`serverFactory` is a function that takes an `handler` parameter, which takes the `request` and `response` objects as parameters, and an options object, which is the same you have passed to Fastify.
+`serverFactory` is a function that takes a `handler` parameter, which takes the `request` and `response` objects as parameters, and an options object, which is the same you have passed to Fastify.
 
 ```js
 const serverFactory = (handler, opts) => {
@@ -223,7 +255,7 @@ Internally Fastify uses the API of Node core HTTP server, so if you are using a
 
 + Default: `true`
 
-Internally, and by default, Fastify will automatically infer the root properties of JSON Schemas if it doesn't find valid root properties according to the JSON Schema spec. If you wish to implement your own schema validation compiler, for example: to parse schemas as JTD instead of JSON Schema, then you can explicitly set this option to `false` to make sure the schemas you receive are unmodified and are not being treated internally as JSON Schema.
+Internally, and by default, Fastify will automatically infer the root properties of JSON Schemas if it does not find valid root properties according to the JSON Schema spec. If you wish to implement your own schema validation compiler, for example: to parse schemas as JTD instead of JSON Schema, then you can explicitly set this option to `false` to make sure the schemas you receive are unmodified and are not being treated internally as JSON Schema.
 
 ```js
 const AjvJTD = require('ajv/dist/jtd'/* only valid for AJV v7+ */)
@@ -301,7 +333,7 @@ const fastify = require('fastify')({
 <a name="factory-trust-proxy"></a>
 ### `trustProxy`
 
-By enabling the `trustProxy` option, Fastify will have knowledge that it's sitting behind a proxy and that the `X-Forwarded-*` header fields may be trusted, which otherwise may be easily spoofed.
+By enabling the `trustProxy` option, Fastify will know that it is sitting behind a proxy and that the `X-Forwarded-*` header fields may be trusted, which otherwise may be easily spoofed.
 
 ```js
 const fastify = Fastify({ trustProxy: true })
@@ -402,7 +434,7 @@ If `false`, the server routes the incoming request as usual.
 <a name="factory-ajv"></a>
 ### `ajv`
 
-Configure the Ajv instance used by Fastify without providing a custom one.
+Configure the Ajv v6 instance used by Fastify without providing a custom one.
 
 + Default:
 
@@ -426,8 +458,8 @@ const fastify = require('fastify')({
       nullable: false // Refer to [ajv options](https://ajv.js.org/#options)
     },
     plugins: [
-      require('ajv-merge-patch')
-      [require('ajv-keywords'), 'instanceof'];
+      require('ajv-merge-patch'),
+      [require('ajv-keywords'), 'instanceof']
       // Usage: [plugin, pluginOptions] - Plugin with options
       // Usage: plugin - Plugin without options
     ]
@@ -465,7 +497,7 @@ increased to fit the use case. Node core defaults this to `0`. `
 + Default: `null`
 
 Fastify provides default error handlers for the most common use cases.
-Using this option it is possible to override one or more of those handlers with custom code.
+It is possible to override one or more of those handlers with custom code using this option.
 
 *Note: Only `FST_ERR_BAD_URL` is implemented at the moment.*
 
@@ -487,7 +519,7 @@ const fastify = require('fastify')({
 
 Set a [clientErrorHandler](https://nodejs.org/api/http.html#http_event_clienterror) that listens to `error` events emitted by client connections and responds with a `400`.
 
-Using this option it is possible to override the default `clientErrorHandler`.
+It is possible to override the default `clientErrorHandler` using this option.
 
 + Default:
 ```js
@@ -617,7 +649,7 @@ fastify.ready().then(() => {
 
 <a name="listen"></a>
 #### listen
-Starts the server on the given port after all the plugins are loaded, internally waits for the `.ready()` event. The callback is the same as the Node core. By default, the server will listen on the address resolved by `localhost` when no specific address is provided (`127.0.0.1` or `::1` depending on the operating system). If listening on any available interface is desired, then specifying `0.0.0.0` for the address will listen on all IPv4 address. Using `::` for the address will listen on all IPv6 addresses, and, depending on OS, may also listen on all IPv4 addresses. Be careful when deciding to listen on all interfaces; it comes with inherent [security risks](https://web.archive.org/web/20170831174611/https://snyk.io/blog/mongodb-hack-and-secure-defaults/).
+Starts the server on the given port after all the plugins are loaded, internally waits for the `.ready()` event. The callback is the same as the Node core. By default, the server will listen on the address resolved by `localhost` when no specific address is provided (`127.0.0.1` or `::1` depending on the operating system). If listening on any available interface is desired, then specifying `0.0.0.0` for the address will listen on all IPv4 addresses. Using `::` for the address will listen on all IPv6 addresses and, depending on OS, may also listen on all IPv4 addresses. Be careful when deciding to listen on all interfaces; it comes with inherent [security risks](https://web.archive.org/web/20170831174611/https://snyk.io/blog/mongodb-hack-and-secure-defaults/).
 
 ```js
 fastify.listen(3000, (err, address) => {
@@ -895,6 +927,9 @@ It can be useful when your schemas are stored in another data structure that is
 See [issue #2446](https://github.com/fastify/fastify/issues/2446) for an example of what
 this property helps to resolve.
 
+Another use case is to tweak all the schemas processing.
+Doing so it is possible to use Ajv v8, instead of the default v6! We will see an example of this later.
+
 ```js
 const fastify = Fastify({
   schemaController: {
@@ -927,15 +962,15 @@ const fastify = Fastify({
     },
 
     /**
-     * The compilers factory let you to fully control the validator and serializer
+     * The compilers factory let you fully control the validator and serializer
      * in the Fastify's lifecycle, providing the encapsulation to your compilers.
      */
     compilersFactory: {
       /**
        * This factory is called whenever a new validator instance is needed.
-       * It may be called whenever `fastify.register()` is called only if new schemas has been added to the
+       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
        * encapsulation context.
-       * It may receive as input the schemas of the parent context if some schemas has been added.
+       * It may receive as input the schemas of the parent context if some schemas have been added.
        * @param {object} externalSchemas these schemas will be returned by the `bucket.getSchemas()`. Needed to resolve the external references $ref.
        * @param {object} ajvServerOption the server `ajv` options to build your compilers accordingly 
        */
@@ -950,9 +985,9 @@ const fastify = Fastify({
 
       /**
        * This factory is called whenever a new serializer instance is needed.
-       * It may be called whenever `fastify.register()` is called only if new schemas has been added to the
+       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
        * encapsulation context.
-       * It may receive as input the schemas of the parent context if some schemas has been added.
+       * It may receive as input the schemas of the parent context if some schemas have been added.
        * @param {object} externalSchemas these schemas will be returned by the `bucket.getSchemas()`. Needed to resolve the external references $ref.
        * @param {object} serializerOptsServerOption the server `serializerOpts` options to build your compilers accordingly 
        */
@@ -968,6 +1003,37 @@ const fastify = Fastify({
 });
 ```
 
+##### Ajv 8 as default schema validator
+
+Ajv 8 is the evolution of Ajv 6, and it has a lot of improvements and new features.
+To use the new Ajv 8 features such as JTD or the Standalone mode, refer to the [`@fastify/ajv-compiler` documentation](https://github.com/fastify/ajv-compiler#usage).
+
+To use Ajv 8 as default schema validator, you can use the following code:
+
+```js
+const AjvCompiler = require('@fastify/ajv-compiler') // It must be the v2.x.x version
+
+// Note that the `format` schema's keyword is no longer supported on Ajv 8 by default.
+// So you need to add it manually.
+const ajvFormats = require('ajv-formats')
+
+const app = fastify({
+  ajv: {
+    customOptions: {
+      validateFormats: true
+    },
+    plugins: [ajvFormats]
+  },
+  schemaController: {
+    compilersFactory: {
+      buildValidator: AjvCompiler()
+    }
+  }
+})
+
+// Done! You can now use Ajv 8 options and keywords in your schemas!
+```
+
 <a name="set-not-found-handler"></a>
 #### setNotFoundHandler