fastify 3.24.0 → 3.25.2

package/docs/{Server.md → Reference/Server.md}

@@ -1,113 +1,162 @@
 <h1 align="center">Fastify</h1>
 
-<a name="factory"></a>
 ## Factory
+<a id="factory"></a>
 
 The Fastify module exports a factory function that is used to create new
-<code><b>Fastify server</b></code> instances. This factory function accepts
-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)
-- [maxRequestsPerSocket](./Server.md#maxRequestsPerSocket)
-- [requestTimeout](./Server.md#requestTimeout)
-- [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>
+<code><b>Fastify server</b></code> instances. This factory function accepts an
+options object which is used to customize the resulting instance. This document
+describes the properties available in that options object.
+
+- [Factory](#factory)
+  - [`http2`](#http2)
+  - [`https`](#https)
+  - [`connectionTimeout`](#connectiontimeout)
+  - [`keepAliveTimeout`](#keepalivetimeout)
+  - [`maxRequestsPerSocket`](#maxrequestspersocket)
+  - [`requestTimeout`](#requesttimeout)
+  - [`ignoreTrailingSlash`](#ignoretrailingslash)
+  - [`maxParamLength`](#maxparamlength)
+  - [`bodyLimit`](#bodylimit)
+  - [`onProtoPoisoning`](#onprotopoisoning)
+  - [`onConstructorPoisoning`](#onconstructorpoisoning)
+  - [`logger`](#logger)
+  - [`disableRequestLogging`](#disablerequestlogging)
+  - [`serverFactory`](#serverfactory)
+  - [`jsonShorthand`](#jsonshorthand)
+  - [`caseSensitive`](#casesensitive)
+  - [`requestIdHeader`](#requestidheader)
+  - [`requestIdLogLabel`](#requestidloglabel)
+  - [`genReqId`](#genreqid)
+  - [`trustProxy`](#trustproxy)
+  - [`pluginTimeout`](#plugintimeout)
+  - [`querystringParser`](#querystringparser)
+  - [`exposeHeadRoutes`](#exposeheadroutes)
+  - [`constraints`](#constraints)
+  - [`return503OnClosing`](#return503onclosing)
+  - [`ajv`](#ajv)
+  - [`serializerOpts`](#serializeropts)
+  - [`http2SessionTimeout`](#http2sessiontimeout)
+  - [`frameworkErrors`](#frameworkerrors)
+  - [`clientErrorHandler`](#clienterrorhandler)
+  - [`rewriteUrl`](#rewriteurl)
+- [Instance](#instance)
+  - [Server Methods](#server-methods)
+    - [server](#server)
+    - [after](#after)
+    - [ready](#ready)
+    - [listen](#listen)
+    - [getDefaultRoute](#getdefaultroute)
+    - [setDefaultRoute](#setdefaultroute)
+    - [routing](#routing)
+    - [route](#route)
+    - [close](#close)
+    - [decorate*](#decorate)
+    - [register](#register)
+    - [addHook](#addhook)
+    - [prefix](#prefix)
+    - [pluginName](#pluginname)
+    - [log](#log)
+    - [version](#version)
+    - [inject](#inject)
+    - [addSchema](#addschema)
+    - [getSchemas](#getschemas)
+    - [getSchema](#getschema)
+    - [setReplySerializer](#setreplyserializer)
+    - [setValidatorCompiler](#setvalidatorcompiler)
+    - [setSchemaErrorFormatter](#setschemaerrorformatter)
+    - [setSerializerCompiler](#setserializercompiler)
+    - [validatorCompiler](#validatorcompiler)
+    - [serializerCompiler](#serializercompiler)
+    - [schemaErrorFormatter](#schemaerrorformatter)
+    - [schemaController](#schemacontroller)
+      - [Ajv 8 as default schema validator](#ajv-8-as-default-schema-validator)
+    - [setNotFoundHandler](#setnotfoundhandler)
+    - [setErrorHandler](#seterrorhandler)
+    - [printRoutes](#printroutes)
+    - [printPlugins](#printplugins)
+    - [addContentTypeParser](#addcontenttypeparser)
+    - [getDefaultJsonParser](#getdefaultjsonparser)
+    - [defaultTextParser](#defaulttextparser)
+    - [errorHandler](#errorhandler)
+    - [initialConfig](#initialconfig)
+
 ### `http2`
+<a id="factory-http2"></a>
 
-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.
+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`
 
-<a name="factory-https"></a>
 ### `https`
+<a id="factory-https"></a>
 
 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-v14.x/docs/api/https.html#https_https_createserver_options_requestlistener).
+are the same as the Node.js core [`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
-<a href="./Server.md#factory-http2">
-<code><b>http2</b></code>
-</a> option is set.
+This option also applies when the [`http2`](#factory-http2) option is set.
 
 + Default: `null`
 
-<a name="factory-connection-timeout"></a>
 ### `connectionTimeout`
+<a id="factory-connection-timeout"></a>
 
 Defines the server timeout in milliseconds. See documentation for
-[`server.timeout` property](https://nodejs.org/api/http.html#http_server_timeout)
-to understand the effect of this option. When `serverFactory` option is
-specified, this option is ignored.
+[`server.timeout`
+property](https://nodejs.org/api/http.html#http_server_timeout) to understand
+the effect of this option. When `serverFactory` option is specified, this option
+is ignored.
 
 + Default: `0` (no timeout)
 
-<a name="factory-keep-alive-timeout"></a>
 ### `keepAliveTimeout`
+<a id="factory-keep-alive-timeout"></a>
 
 Defines the server keep-alive timeout in milliseconds. See documentation for
-[`server.keepAliveTimeout` property](https://nodejs.org/api/http.html#http_server_keepalivetimeout)
-to understand the effect of this option. This option only applies when HTTP/1
-is in use. Also, when `serverFactory` option is specified, this option is ignored.
+[`server.keepAliveTimeout`
+property](https://nodejs.org/api/http.html#http_server_keepalivetimeout) to
+understand the effect of this option. This option only applies when HTTP/1 is in
+use. Also, when `serverFactory` option is specified, this option is ignored.
 
 + Default: `5000` (5 seconds)
 
-<a name="factory-max-requests-per-socket"></a>
 ### `maxRequestsPerSocket`
+<a id="factory-max-requests-per-socket"></a>
 
-Defines the maximum number of requests socket can handle before closing keep alive connection. See documentation for
-[`server.maxRequestsPerSocket` property](https://nodejs.org/dist/latest/docs/api/http.html#http_server_maxrequestspersocket)
+Defines the maximum number of requests socket can handle before closing keep
+alive connection. See documentation for [`server.maxRequestsPerSocket`
+property](https://nodejs.org/dist/latest/docs/api/http.html#http_server_maxrequestspersocket)
 to understand the effect of this option. This option only applies when HTTP/1.1
-is in use. Also, when `serverFactory` option is specified, this option is ignored.
->  At the time of this writing, only node version greater or equal to 16.10.0 support this option. Check the Node.js documentation for availability in the version you are running.
+is in use. Also, when `serverFactory` option is specified, this option is
+ignored.
+>  At the time of this writing, only node version greater or equal to 16.10.0
+>  support this option. Check the Node.js documentation for availability in the
+>  version you are running.
 
 + Default: `0` (no limit)
 
-<a name="factory-request-timeout"></a>
 ### `requestTimeout`
-
-Defines the maximum number of milliseconds for receiving the entire request from the client.
-[`server.requestTimeout` property](https://nodejs.org/dist/latest/docs/api/http.html#http_server_requesttimeout)
-to understand the effect of this option. Also, when `serverFactory` option is specified, this option is ignored.
-It must be set to a non-zero value (e.g. 120 seconds) to protect against potential Denial-of-Service attacks in case the server is deployed without a reverse proxy in front.
->  At the time of this writing, only node version greater or equal to 14.11.0 support this option. Check the Node.js documentation for availability in the version you are running.
+<a id="factory-request-timeout"></a>
+
+Defines the maximum number of milliseconds for receiving the entire request from
+the client. [`server.requestTimeout`
+property](https://nodejs.org/dist/latest/docs/api/http.html#http_server_requesttimeout)
+to understand the effect of this option. Also, when `serverFactory` option is
+specified, this option is ignored. It must be set to a non-zero value (e.g. 120
+seconds) to protect against potential Denial-of-Service attacks in case the
+server is deployed without a reverse proxy in front.
+>  At the time of this writing, only node version greater or equal to 14.11.0
+>  support this option. Check the Node.js documentation for availability in the
+>  version you are running.
 
 + Default: `0` (no limit)
 
-<a name="factory-ignore-slash"></a>
 ### `ignoreTrailingSlash`
+<a id="factory-ignore-slash"></a>
 
 Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) to handle
 routing. This option may be set to `true` to ignore trailing slashes in routes.
@@ -132,47 +181,54 @@ 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>
-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>
+<a id="factory-max-param-length"></a>
+
+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.
+
+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).
+
 *If the maximum length limit is reached, the not found route will be invoked.*
 
-<a name="factory-body-limit"></a>
 ### `bodyLimit`
+<a id="factory-body-limit"></a>
 
 Defines the maximum payload, in bytes, the server is allowed to accept.
 
 + Default: `1048576` (1MiB)
 
-<a name="factory-on-proto-poisoning"></a>
 ### `onProtoPoisoning`
+<a id="factory-on-proto-poisoning"></a>
 
-Defines what action the framework must take when parsing a JSON object
-with `__proto__`. This functionality is provided by
-[secure-json-parse](https://github.com/fastify/secure-json-parse).
-See https://hueniverse.com/a-tale-of-prototype-poisoning-2610fa170061
-for more details about prototype poisoning attacks.
+Defines what action the framework must take when parsing a JSON object with
+`__proto__`. This functionality is provided by
+[secure-json-parse](https://github.com/fastify/secure-json-parse). See
+https://hueniverse.com/a-tale-of-prototype-poisoning-2610fa170061 for more
+details about prototype poisoning attacks.
 
 Possible values are `'error'`, `'remove'` and `'ignore'`.
 
 + Default: `'error'`
 
-<a name="factory-on-constructor-poisoning"></a>
 ### `onConstructorPoisoning`
+<a id="factory-on-constructor-poisoning"></a>
 
-Defines what action the framework must take when parsing a JSON object
-with `constructor`. This functionality is provided by
-[secure-json-parse](https://github.com/fastify/secure-json-parse).
-See https://hueniverse.com/a-tale-of-prototype-poisoning-2610fa170061
-for more details about prototype poisoning attacks.
+Defines what action the framework must take when parsing a JSON object with
+`constructor`. This functionality is provided by
+[secure-json-parse](https://github.com/fastify/secure-json-parse). See
+https://hueniverse.com/a-tale-of-prototype-poisoning-2610fa170061 for more
+details about prototype poisoning attacks.
 
 Possible values are `'error'`, `'remove'` and `'ignore'`.
 
 + Default: `'error'`
 
-<a name="factory-logger"></a>
 ### `logger`
+<a id="factory-logger"></a>
 
 Fastify includes built-in logging via the [Pino](https://getpino.io/) logger.
 This property is used to configure the internal logger instance.
@@ -180,15 +236,17 @@ This property is used to configure the internal logger instance.
 The possible values this property may have are:
 
 + Default: `false`. The logger is disabled. All logging methods will point to a
-null logger [abstract-logging](https://npm.im/abstract-logging) instance.
+  null logger [abstract-logging](https://npm.im/abstract-logging) instance.
 
 + `pinoInstance`: a previously instantiated instance of Pino. The internal
-logger will point to this instance.
-
-+ `object`: a standard Pino [options object](https://github.com/pinojs/pino/blob/c77d8ec5ce/docs/API.md#constructor).
-This will be passed directly to the Pino constructor. If the following properties
-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'`.
+  logger will point to this instance.
+
++ `object`: a standard Pino [options
+  object](https://github.com/pinojs/pino/blob/c77d8ec5ce/docs/API.md#constructor).
+  This will be passed directly to the Pino constructor. If the following
+  properties 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
       objects), and `err` (standard `Error` objects). When a log method receives
@@ -202,8 +260,9 @@ are not present on the object, they will be added accordingly:
         ```
       Any user-supplied serializer will override the default serializer of the
       corresponding property.
-+ `loggerInstance`: a custom logger instance. The logger must conform to the Pino
-interface by having the following methods: `info`, `error`, `debug`, `fatal`, `warn`, `trace`, `child`. For example:
++ `loggerInstance`: a custom logger instance. The logger must conform to the
+  Pino interface by having the following methods: `info`, `error`, `debug`,
+  `fatal`, `warn`, `trace`, `child`. For example:
   ```js
   const pino = require('pino')();
 
@@ -224,13 +283,14 @@ interface by having the following methods: `info`, `error`, `debug`, `fatal`, `w
   const fastify = require('fastify')({logger: customLogger});
   ```
 
-<a name="factory-disable-request-logging"></a>
 ### `disableRequestLogging`
+<a id="factory-disable-request-logging"></a>
+
 By default, when logging is enabled, Fastify will issue an `info` level log
 message when a request is received and when the response for that request has
-been sent. By setting this option to `true`, these log messages will be disabled.
-This allows for more flexible request start and end logging by attaching
-custom `onRequest` and `onResponse` hooks.
+been sent. By setting this option to `true`, these log messages will be
+disabled. This allows for more flexible request start and end logging by
+attaching custom `onRequest` and `onResponse` hooks.
 
 + Default: `false`
 
@@ -247,12 +307,18 @@ fastify.addHook('onResponse', (req, reply, done) => {
 })
 ```
 
-Please note that this setting will also disable an error log written by the default `onResponse` hook on reply callback errors.
+Please note that this setting will also disable an error log written by the
+default `onResponse` hook on reply callback errors.
 
-<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 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.
+<a id="custom-http-server"></a>
+
+You can pass a custom HTTP server to Fastify by using the `serverFactory`
+option.
+
+`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) => {
@@ -272,14 +338,23 @@ fastify.get('/', (req, reply) => {
 fastify.listen(3000)
 ```
 
-Internally Fastify uses the API of Node core HTTP server, so if you are using a custom server you must be sure to have the same API exposed. If not, you can enhance the server instance inside the `serverFactory` function before the `return` statement.<br/>
+Internally Fastify uses the API of Node core HTTP server, so if you are using a
+custom server you must be sure to have the same API exposed. If not, you can
+enhance the server instance inside the `serverFactory` function before the
+`return` statement.
+
 
-<a name="schema-json-shorthand"></a>
 ### `jsonShorthand`
+<a id="schema-json-shorthand"></a>
 
 + Default: `true`
 
-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.
+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+ */)
@@ -303,14 +378,21 @@ fastify.post('/', {
 })
 ```
 
-**Note: Fastify does not currently throw on invalid schemas, so if you turn this off in an existing project, you need to be careful that none of your existing schemas become invalid as a result, since they will be treated as a catch-all.**
+**Note: Fastify does not currently throw on invalid schemas, so if you turn this
+off in an existing project, you need to be careful that none of your existing
+schemas become invalid as a result, since they will be treated as a catch-all.**
 
-<a name="factory-case-sensitive"></a>
 ### `caseSensitive`
+<a id="factory-case-sensitive"></a>
 
-By default, value equal to `true`, routes are registered as case sensitive. That is, `/foo` is not equivalent to `/Foo`. When set to `false`, routes are registered in a fashion such that `/foo` is equivalent to `/Foo` which is equivalent to `/FOO`.
+By default, value equal to `true`, routes are registered as case sensitive. That
+is, `/foo` is not equivalent to `/Foo`. When set to `false`, routes are
+registered in a fashion such that `/foo` is equivalent to `/Foo` which is
+equivalent to `/FOO`.
 
-By setting `caseSensitive` to `false`, all paths will be matched as lowercase, but the route parameters or wildcards will maintain their original letter casing.
+By setting `caseSensitive` to `false`, all paths will be matched as lowercase,
+but the route parameters or wildcards will maintain their original letter
+casing.
 
 ```js
 fastify.get('/user/:username', (request, reply) => {
@@ -322,30 +404,37 @@ fastify.get('/user/:username', (request, reply) => {
 Please note that setting this option to `false` goes against
 [RFC3986](https://tools.ietf.org/html/rfc3986#section-6.2.2.1).
 
-Also note, this setting will not affect query strings. If you want to change the way query strings are handled take a look at [`querystringParser`](./Server.md#querystringparser).
+Also note, this setting will not affect query strings. If you want to change the
+way query strings are handled take a look at
+[`querystringParser`](#querystringparser).
 
-<a name="factory-request-id-header"></a>
 ### `requestIdHeader`
+<a id="factory-request-id-header"></a>
 
-The header name used to know the request-id. See [the request-id](Logging.md#logging-request-id) section.
+The header name used to know the request-id. See [the
+request-id](./Logging.md#logging-request-id) section.
 
 + Default: `'request-id'`
 
-<a name="factory-request-id-log-label"></a>
 ### `requestIdLogLabel`
+<a id="factory-request-id-log-label"></a>
 
 Defines the label used for the request identifier when logging the request.
 
 + Default: `'reqId'`
 
-<a name="factory-gen-request-id"></a>
 ### `genReqId`
+<a id="factory-gen-request-id"></a>
 
-Function for generating the request-id. It will receive the incoming request as a parameter.
+Function for generating the request-id. It will receive the incoming request as
+a parameter.
 
-+ Default: `value of 'request-id' header if provided or monotonically increasing integers`
++ Default: `value of 'request-id' header if provided or monotonically increasing
+  integers`
 
-Especially in distributed systems, you may want to override the default ID generation behavior as shown below. For generating `UUID`s you may want to check out [hyperid](https://github.com/mcollina/hyperid)
+Especially in distributed systems, you may want to override the default ID
+generation behavior as shown below. For generating `UUID`s you may want to check
+out [hyperid](https://github.com/mcollina/hyperid)
 
 ```js
 let i = 0
@@ -354,20 +443,26 @@ const fastify = require('fastify')({
 })
 ```
 
-**Note: genReqId will _not_ be called if the header set in <code>[requestIdHeader](#requestidheader)</code> is available (defaults to 'request-id').**
+**Note: genReqId will _not_ be called if the header set in
+<code>[requestIdHeader](#requestidheader)</code> is available (defaults to
+'request-id').**
 
-<a name="factory-trust-proxy"></a>
 ### `trustProxy`
+<a id="factory-trust-proxy"></a>
 
-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.
+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 })
 ```
 
 + Default: `false`
-+ `true/false`: Trust all proxies (`true`) or do not trust any proxies (`false`).
-+ `string`: Trust only given IP/CIDR (e.g. `'127.0.0.1'`). May be a list of comma separated values (e.g. `'127.0.0.1,192.168.1.1/24'`).
++ `true/false`: Trust all proxies (`true`) or do not trust any proxies
+  (`false`).
++ `string`: Trust only given IP/CIDR (e.g. `'127.0.0.1'`). May be a list of
+  comma separated values (e.g. `'127.0.0.1,192.168.1.1/24'`).
 + `Array<string>`: Trust only given IP/CIDR list (e.g. `['127.0.0.1']`).
 + `number`: Trust the nth hop from the front-facing proxy server as the client.
 + `Function`: Custom trust function that takes `address` as first arg
@@ -377,9 +472,11 @@ const fastify = Fastify({ trustProxy: true })
     }
     ```
 
-For more examples, refer to the [`proxy-addr`](https://www.npmjs.com/package/proxy-addr) package.
+For more examples, refer to the
+[`proxy-addr`](https://www.npmjs.com/package/proxy-addr) package.
 
-You may access the `ip`, `ips`, `hostname` and `protocol` values on the [`request`](Request.md) object.
+You may access the `ip`, `ips`, `hostname` and `protocol` values on the
+[`request`](./Request.md) object.
 
 ```js
 fastify.get('/', (request, reply) => {
@@ -390,22 +487,27 @@ fastify.get('/', (request, reply) => {
 })
 ```
 
-**Note: if a request contains multiple <code>x-forwarded-host</code> or <code>x-forwarded-proto</code> headers, it is only the last one that is used to derive <code>request.hostname</code> and <code>request.protocol</code>**
+**Note: if a request contains multiple <code>x-forwarded-host</code> or
+<code>x-forwarded-proto</code> headers, it is only the last one that is used to
+derive <code>request.hostname</code> and <code>request.protocol</code>**
 
-<a name="plugin-timeout"></a>
 ### `pluginTimeout`
+<a id="plugin-timeout"></a>
 
-The maximum amount of time in *milliseconds* in which a plugin can load.
-If not, [`ready`](Server.md#ready)
-will complete with an `Error` with code `'ERR_AVVIO_PLUGIN_TIMEOUT'`.
+The maximum amount of time in *milliseconds* in which a plugin can load. If not,
+[`ready`](#ready) will complete with an `Error` with code
+`'ERR_AVVIO_PLUGIN_TIMEOUT'`.
 
 + Default: `10000`
 
-<a name="factory-querystring-parser"></a>
 ### `querystringParser`
+<a id="factory-querystring-parser"></a>
+
+The default query string parser that Fastify uses is the Node.js's core
+`querystring` module.
 
-The default query string parser that Fastify uses is the Node.js's core `querystring` module.<br/>
-You can change this default setting by passing the option `querystringParser` and use a custom one, such as [`qs`](https://www.npmjs.com/package/qs).
+You can change this default setting by passing the option `querystringParser`
+and use a custom one, such as [`qs`](https://www.npmjs.com/package/qs).
 
 ```js
 const qs = require('qs')
@@ -414,7 +516,8 @@ const fastify = require('fastify')({
 })
 ```
 
-You can also use Fastify's default parser but change some handling behaviour, like the example below for case insensitive keys and values:
+You can also use Fastify's default parser but change some handling behaviour,
+like the example below for case insensitive keys and values:
 
 ```js
 const querystring = require('querystring')
@@ -423,19 +526,27 @@ const fastify = require('fastify')({
 })
 ```
 
-Note, if you only want the keys (and not the values) to be case insensitive we recommend using a custom parser to convert only the keys to lowercase.
+Note, if you only want the keys (and not the values) to be case insensitive we
+recommend using a custom parser to convert only the keys to lowercase.
 
-<a name="exposeHeadRoutes"></a>
 ### `exposeHeadRoutes`
+<a id="exposeHeadRoutes"></a>
 
-Automatically creates a sibling `HEAD` route for each `GET` route defined. If you want a custom `HEAD` handler without disabling this option, make sure to define it before the `GET` route.
+Automatically creates a sibling `HEAD` route for each `GET` route defined. If
+you want a custom `HEAD` handler without disabling this option, make sure to
+define it before the `GET` route.
 
 + Default: `false`
 
-<a name="constraints"></a>
 ### `constraints`
+<a id="constraints"></a>
 
-Fastify's built in route constraints are provided by `find-my-way`, which allow constraining routes by `version` or `host`. You are able to add new constraint strategies, or override the built in strategies by providing a `constraints` object with strategies for `find-my-way`. You can find more information on constraint strategies in the [find-my-way](https://github.com/delvedor/find-my-way) documentation.
+Fastify's built in route constraints are provided by `find-my-way`, which allow
+constraining routes by `version` or `host`. You are able to add new constraint
+strategies, or override the built in strategies by providing a `constraints`
+object with strategies for `find-my-way`. You can find more information on
+constraint strategies in the
+[find-my-way](https://github.com/delvedor/find-my-way) documentation.
 
 ```js
 const customVersionStrategy = {
@@ -460,16 +571,16 @@ const fastify = require('fastify')({
 })
 ```
 
-<a name="factory-return-503-on-closing"></a>
 ### `return503OnClosing`
+<a id="factory-return-503-on-closing"></a>
 
-Returns 503 after calling `close` server method.
-If `false`, the server routes the incoming request as usual.
+Returns 503 after calling `close` server method. If `false`, the server routes
+the incoming request as usual.
 
 + Default: `true`
 
-<a name="factory-ajv"></a>
 ### `ajv`
+<a id="factory-ajv"></a>
 
 Configure the Ajv v6 instance used by Fastify without providing a custom one.
 
@@ -504,10 +615,12 @@ const fastify = require('fastify')({
 })
 ```
 
-<a name="serializer-opts"></a>
 ### `serializerOpts`
+<a id="serializer-opts"></a>
 
-Customize the options of the default [`fast-json-stringify`](https://github.com/fastify/fast-json-stringify#options) instance that serialize the response's payload:
+Customize the options of the default
+[`fast-json-stringify`](https://github.com/fastify/fast-json-stringify#options)
+instance that serialize the response's payload:
 
 ```js
 const fastify = require('fastify')({
@@ -517,24 +630,27 @@ const fastify = require('fastify')({
 })
 ```
 
-<a name="http2-session-timeout"></a>
 ### `http2SessionTimeout`
+<a id="http2-session-timeout"></a>
 
 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.
+[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. 
-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`. ` 
+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`
+<a id="framework-errors"></a>
 
 + Default: `null`
 
-Fastify provides default error handlers for the most common use cases.
-It is possible to override one or more of those handlers with custom code using this option.
+Fastify provides default error handlers for the most common use cases. 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.*
 
@@ -551,10 +667,13 @@ const fastify = require('fastify')({
 })
 ```
 
-<a name="client-error-handler"></a>
 ### `clientErrorHandler`
+<a id="client-error-handler"></a>
 
-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`.
+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`.
 
 It is possible to override the default `clientErrorHandler` using this option.
 
@@ -578,7 +697,10 @@ function defaultClientErrorHandler (err, socket) {
 }
 ```
 
-*Note: `clientErrorHandler` operates with raw socket. The handler is expected to return a properly formed HTTP response that includes a status line, HTTP headers and a message body. Before attempting to write the socket, the handler should check if the socket is still writable as it may have already been destroyed.*
+*Note: `clientErrorHandler` operates with raw socket. The handler is expected to
+return a properly formed HTTP response that includes a status line, HTTP headers
+and a message body. Before attempting to write the socket, the handler should
+check if the socket is still writable as it may have already been destroyed.*
 
 ```js
 const fastify = require('fastify')({
@@ -599,10 +721,11 @@ const fastify = require('fastify')({
 })
 ```
 
-<a name="rewrite-url"></a>
 ### `rewriteUrl`
+<a id="rewrite-url"></a>
 
-Set a sync callback function that must return a string that allows rewriting URLs.
+Set a sync callback function that must return a string that allows rewriting
+URLs.
 
 > Rewriting a URL will modify the `url` property of the `req` object
 
@@ -612,21 +735,26 @@ function rewriteUrl (req) { // req is the Node.js HTTP request
 }
 ```
 
-Note that `rewriteUrl` is called _before_ routing, it is not encapsulated and it is an instance-wide configuration.
+Note that `rewriteUrl` is called _before_ routing, it is not encapsulated and it
+is an instance-wide configuration.
 
 ## Instance
 
 ### Server Methods
 
-<a name="server"></a>
 #### server
-`fastify.server`: The Node core [server](https://nodejs.org/api/http.html#http_class_http_server) object as returned by the [**`Fastify factory function`**](Server.md).
+<a id="server"></a>
+
+`fastify.server`: The Node core
+[server](https://nodejs.org/api/http.html#http_class_http_server) object as
+returned by the [**`Fastify factory function`**](#factory).
 
-<a name="after"></a>
 #### after
-Invoked when the current plugin and all the plugins
-that have been registered within it have finished loading.
-It is always executed before the method `fastify.ready`.
+<a id="after"></a>
+
+Invoked when the current plugin and all the plugins that have been registered
+within it have finished loading. It is always executed before the method
+`fastify.ready`.
 
 ```js
 fastify
@@ -665,10 +793,11 @@ await fastify.ready()
 console.log('Everything has been loaded')
 ```
 
-<a name="ready"></a>
 #### ready
-Function called when all the plugins have been loaded.
-It takes an error parameter if something went wrong.
+<a id="ready"></a>
+
+Function called when all the plugins have been loaded. It takes an error
+parameter if something went wrong.
 ```js
 fastify.ready(err => {
   if (err) throw err
@@ -684,9 +813,19 @@ 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 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/).
+<a id="listen"></a>
+
+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) => {
@@ -719,7 +858,9 @@ fastify.listen(3000, '127.0.0.1', 511, (err, address) => {
 })
 ```
 
-Specifying options is also supported; the object is same as [options](https://nodejs.org/api/net.html#net_server_listen_options_callback) in the Node.js server listen:
+Specifying options is also supported; the object is same as
+[options](https://nodejs.org/api/net.html#net_server_listen_options_callback) in
+the Node.js server listen:
 
 ```js
 fastify.listen({ port: 3000, host: '127.0.0.1', backlog: 511 }, (err) => {
@@ -763,7 +904,9 @@ fastify.listen({ port: 3000, host: '127.0.0.1', backlog: 511 })
   })
 ```
 
-When deploying to a Docker, and potentially other, containers, it is advisable to listen on `0.0.0.0` because they do not default to exposing mapped ports to `localhost`:
+When deploying to a Docker, and potentially other, containers, it is advisable
+to listen on `0.0.0.0` because they do not default to exposing mapped ports to
+`localhost`:
 
 ```js
 fastify.listen(3000, '0.0.0.0', (err, address) => {
@@ -774,7 +917,8 @@ fastify.listen(3000, '0.0.0.0', (err, address) => {
 })
 ```
 
-If the `port` is omitted (or is set to zero), a random available port is automatically chosen (later available via `fastify.server.address().port`).
+If the `port` is omitted (or is set to zero), a random available port is
+automatically chosen (later available via `fastify.server.address().port`).
 
 The default options of listen are:
 
@@ -789,16 +933,18 @@ fastify.listen({
 }, (err) => {})
 ```
 
-<a name="getDefaultRoute"></a>
 #### getDefaultRoute
+<a id="getDefaultRoute"></a>
+
 Method to get the `defaultRoute` for the server:
 
 ```js
 const defaultRoute = fastify.getDefaultRoute()
 ```
 
-<a name="setDefaultRoute"></a>
 #### setDefaultRoute
+<a id="setDefaultRoute"></a>
+
 Method to set the `defaultRoute` for the server:
 
 ```js
@@ -809,23 +955,31 @@ const defaultRoute = function (req, res) {
 fastify.setDefaultRoute(defaultRoute)
 ```
 
-<a name="routing"></a>
 #### routing
-Method to access the `lookup` method of the internal router and match the request to the appropriate handler:
+<a id="routing"></a>
+
+Method to access the `lookup` method of the internal router and match the
+request to the appropriate handler:
 
 ```js
 fastify.routing(req, res)
 ```
 
-<a name="route"></a>
 #### route
-Method to add routes to the server, it also has shorthand functions, check [here](Routes.md).
+<a id="route"></a>
+
+Method to add routes to the server, it also has shorthand functions, check
+[here](./Routes.md).
 
-<a name="close"></a>
 #### close
-`fastify.close(callback)`: call this function to close the server instance and run the [`'onClose'`](Hooks.md#on-close) hook.<br>
-Calling `close` will also cause the server to respond to every new incoming request with a `503` error and destroy that request.
-See [`return503OnClosing` flags](Server.md#factory-return-503-on-closing) for changing this behavior.
+<a id="close"></a>
+
+`fastify.close(callback)`: call this function to close the server instance and
+run the [`'onClose'`](./Hooks.md#on-close) hook.
+
+Calling `close` will also cause the server to respond to every new incoming
+request with a `503` error and destroy that request. See [`return503OnClosing`
+flags](#factory-return-503-on-closing) for changing this behavior.
 
 If it is called without any arguments, it will return a Promise:
 
@@ -837,21 +991,27 @@ fastify.close().then(() => {
 })
 ```
 
-<a name="decorate"></a>
 #### decorate*
-Function useful if you need to decorate the fastify instance, Reply or Request, check [here](Decorators.md).
+<a id="decorate"></a>
+
+Function useful if you need to decorate the fastify instance, Reply or Request,
+check [here](./Decorators.md).
 
-<a name="register"></a>
 #### register
-Fastify allows the user to extend its functionality with plugins.
-A plugin can be a set of routes, a server decorator, or whatever, check [here](Plugins.md).
+<a id="register"></a>
+
+Fastify allows the user to extend its functionality with plugins. A plugin can
+be a set of routes, a server decorator, or whatever, check [here](./Plugins.md).
 
-<a name="addHook"></a>
 #### addHook
-Function to add a specific hook in the lifecycle of Fastify, check [here](Hooks.md).
+<a id="addHook"></a>
+
+Function to add a specific hook in the lifecycle of Fastify, check
+[here](./Hooks.md).
 
-<a name="prefix"></a>
 #### prefix
+<a id="prefix"></a>
+
 The full path that will be prefixed to a route.
 
 Example:
@@ -878,47 +1038,75 @@ fastify.register(function (instance, opts, done) {
 }, { prefix: '/v1' })
 ```
 
-<a name="pluginName"></a>
 #### pluginName
+<a id="pluginName"></a>
+
 Name of the current plugin. There are three ways to define a name (in order).
 
-1. If you use [fastify-plugin](https://github.com/fastify/fastify-plugin) the metadata `name` is used.
+1. If you use [fastify-plugin](https://github.com/fastify/fastify-plugin) the
+   metadata `name` is used.
 2. If you `module.exports` a plugin the filename is used.
-3. If you use a regular [function declaration](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions#Defining_functions) the function name is used.
+3. If you use a regular [function
+   declaration](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions#Defining_functions)
+   the function name is used.
 
-*Fallback*: The first two lines of your plugin will represent the plugin name. Newlines are replaced by ` -- `. This will help to identify the root cause when you deal with many plugins.
+*Fallback*: The first two lines of your plugin will represent the plugin name.
+Newlines are replaced by ` -- `. This will help to identify the root cause when
+you deal with many plugins.
 
-Important: If you have to deal with nested plugins, the name differs with the usage of the [fastify-plugin](https://github.com/fastify/fastify-plugin) because no new scope is created and therefore we have no place to attach contextual data. In that case, the plugin name will represent the boot order of all involved plugins in the format of `plugin-A -> plugin-B`.
+Important: If you have to deal with nested plugins, the name differs with the
+usage of the [fastify-plugin](https://github.com/fastify/fastify-plugin) because
+no new scope is created and therefore we have no place to attach contextual
+data. In that case, the plugin name will represent the boot order of all
+involved plugins in the format of `plugin-A -> plugin-B`.
 
-<a name="log"></a>
 #### log
-The logger instance, check [here](Logging.md).
+<a id="log"></a>
+
+The logger instance, check [here](./Logging.md).
 
-<a name="version"></a>
 #### version
-Fastify version of the instance. Used for plugin support. See [Plugins](Plugins.md#handle-the-scope) for information on how the version is used by plugins.
+<a id="version"></a>
+
+Fastify version of the instance. Used for plugin support. See
+[Plugins](./Plugins.md#handle-the-scope) for information on how the version is
+used by plugins.
 
-<a name="inject"></a>
 #### inject
-Fake HTTP injection (for testing purposes) [here](Testing.md#inject).
+<a id="inject"></a>
+
+Fake HTTP injection (for testing purposes) [here](../Guides/Testing.md#benefits-of-using-fastifyinject).
 
-<a name="add-schema"></a>
 #### addSchema
-`fastify.addSchema(schemaObj)`, adds a JSON schema to the Fastify instance. This allows you to reuse it everywhere in your application just by using the standard `$ref` keyword.<br/>
-To learn more, read the [Validation and Serialization](Validation-and-Serialization.md) documentation.
+<a id="add-schema"></a>
+
+`fastify.addSchema(schemaObj)`, adds a JSON schema to the Fastify instance. This
+allows you to reuse it everywhere in your application just by using the standard
+`$ref` keyword.
+
+To learn more, read the [Validation and
+Serialization](./Validation-and-Serialization.md) documentation.
 
-<a name="get-schemas"></a>
 #### getSchemas
-`fastify.getSchemas()`, returns a hash of all schemas added via `.addSchema`. The keys of the hash are the `$id`s of the JSON Schema provided.
+<a id="get-schemas"></a>
+
+`fastify.getSchemas()`, returns a hash of all schemas added via `.addSchema`.
+The keys of the hash are the `$id`s of the JSON Schema provided.
 
-<a name="get-schema"></a>
 #### getSchema
-`fastify.getSchema(id)`, return the JSON schema added with `.addSchema` and the matching `id`. It returns `undefined` if it is not found.
+<a id="get-schema"></a>
+
+`fastify.getSchema(id)`, return the JSON schema added with `.addSchema` and the
+matching `id`. It returns `undefined` if it is not found.
 
-<a name="set-reply-serializer"></a>
 #### setReplySerializer
-Set the reply serializer for all the routes. This will be used as default if a [Reply.serializer(func)](Reply.md#serializerfunc) has not been set. The handler is fully encapsulated, so different plugins can set different error handlers.
-Note: the function parameter is called only for status `2xx`. Check out the [`setErrorHandler`](Server.md#seterrorhandler) for errors.
+<a id="set-reply-serializer"></a>
+
+Set the reply serializer for all the routes. This will be used as default if a
+[Reply.serializer(func)](./Reply.md#serializerfunc) has not been set. The
+handler is fully encapsulated, so different plugins can set different error
+handlers. Note: the function parameter is called only for status `2xx`. Check
+out the [`setErrorHandler`](#seterrorhandler) for errors.
 
 ```js
 fastify.setReplySerializer(function (payload, statusCode){
@@ -927,45 +1115,64 @@ fastify.setReplySerializer(function (payload, statusCode){
 })
 ```
 
-<a name="set-validator-compiler"></a>
 #### setValidatorCompiler
-Set the schema validator compiler for all routes. See [#schema-validator](Validation-and-Serialization.md#schema-validator).
+<a id="set-validator-compiler"></a>
+
+Set the schema validator compiler for all routes. See
+[#schema-validator](./Validation-and-Serialization.md#schema-validator).
 
-<a name="set-schema-error-formatter"></a>
 #### setSchemaErrorFormatter
-Set the schema error formatter for all routes. See [#error-handling](Validation-and-Serialization.md#schemaerrorformatter).
+<a id="set-schema-error-formatter"></a>
+
+Set the schema error formatter for all routes. See
+[#error-handling](./Validation-and-Serialization.md#schemaerrorformatter).
 
-<a name="set-serializer-resolver"></a>
 #### setSerializerCompiler
-Set the schema serializer compiler for all routes. See [#schema-serializer](Validation-and-Serialization.md#schema-serializer).
+<a id="set-serializer-resolver"></a>
+
+Set the schema serializer compiler for all routes. See
+[#schema-serializer](./Validation-and-Serialization.md#schema-serializer).
 **Note:** [`setReplySerializer`](#set-reply-serializer) has priority if set!
 
-<a name="validator-compiler"></a>
 #### validatorCompiler
-This property can be used to get the schema validator. If not set, it will be `null` until the server starts, then it will be a function with the signature `function ({ schema, method, url, httpPart })` that returns the input `schema` compiled to a function for validating data.
-The input `schema` can access all the shared schemas added with [`.addSchema`](#add-schema) function.
+<a id="validator-compiler"></a>
+
+This property can be used to get the schema validator. If not set, it will be
+`null` until the server starts, then it will be a function with the signature
+`function ({ schema, method, url, httpPart })` that returns the input `schema`
+compiled to a function for validating data. The input `schema` can access all
+the shared schemas added with [`.addSchema`](#add-schema) function.
 
-<a name="serializer-compiler"></a>
 #### serializerCompiler
-This property can be used to get the schema serializer. If not set, it will be `null` until the server starts, then it will be a function with the signature `function ({ schema, method, url, httpPart })` that returns the input `schema` compiled to a function for validating data.
-The input `schema` can access all the shared schemas added with [`.addSchema`](#add-schema) function.
+<a id="serializer-compiler"></a>
+
+This property can be used to get the schema serializer. If not set, it will be
+`null` until the server starts, then it will be a function with the signature
+`function ({ schema, method, url, httpPart })` that returns the input `schema`
+compiled to a function for validating data. The input `schema` can access all
+the shared schemas added with [`.addSchema`](#add-schema) function.
 
-<a name="schema-error-formatter"></a>
 #### schemaErrorFormatter
-This property can be used to set a function to format errors that happen while the `validationCompiler` fails to validate the schema. See [#error-handling](Validation-and-Serialization.md#schemaerrorformatter).
+<a id="schema-error-formatter"></a>
+
+This property can be used to set a function to format errors that happen while
+the `validationCompiler` fails to validate the schema. See
+[#error-handling](./Validation-and-Serialization.md#schemaerrorformatter).
 
-<a name="schema-controller"></a>
 #### schemaController
-This property can be used to fully manage: 
+<a id="schema-controller"></a>
+
+This property can be used to fully manage:
 - `bucket`: where the schemas of your application will be stored
 - `compilersFactory`: what module must compile the JSON schemas
 
-It can be useful when your schemas are stored in another data structure that is unknown to Fastify.
-See [issue #2446](https://github.com/fastify/fastify/issues/2446) for an example of what
+It can be useful when your schemas are stored in another data structure that is
+unknown to Fastify. 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.
+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({
@@ -1009,11 +1216,11 @@ const fastify = Fastify({
        * encapsulation context.
        * 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 
+       * @param {object} ajvServerOption the server `ajv` options to build your compilers accordingly
        */
       buildValidator: function factory (externalSchemas, ajvServerOption) {
         // This factory function must return a schema validator compiler.
-        // See [#schema-validator](Validation-and-Serialization.md#schema-validator) for details.
+        // See [#schema-validator](./Validation-and-Serialization.md#schema-validator) for details.
         const yourAjvInstance = new Ajv(ajvServerOption.customOptions)
         return function validatorCompiler ({ schema, method, url, httpPart }) {
           return yourAjvInstance.compile(schema)
@@ -1026,11 +1233,11 @@ const fastify = Fastify({
        * encapsulation context.
        * 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 
+       * @param {object} serializerOptsServerOption the server `serializerOpts` options to build your compilers accordingly
        */
       buildSerializer: function factory (externalSchemas, serializerOptsServerOption) {
         // This factory function must return a schema serializer compiler.
-        // See [#schema-serializer](Validation-and-Serialization.md#schema-serializer) for details.
+        // See [#schema-serializer](./Validation-and-Serialization.md#schema-serializer) for details.
         return function serializerCompiler ({ schema, method, url, httpStatus }) {
           return data => JSON.stringify(data)
         }
@@ -1042,8 +1249,10 @@ 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).
+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:
 
@@ -1071,14 +1280,25 @@ const app = fastify({
 // Done! You can now use Ajv 8 options and keywords in your schemas!
 ```
 
-<a name="set-not-found-handler"></a>
 #### setNotFoundHandler
+<a id="set-not-found-handler"></a>
 
-`fastify.setNotFoundHandler(handler(request, reply))`: set the 404 handler. This call is encapsulated by prefix, so different plugins can set different not found handlers if a different [`prefix` option](Plugins.md#route-prefixing-option) is passed to `fastify.register()`. The handler is treated as a regular route handler so requests will go through the full [Fastify lifecycle](Lifecycle.md#lifecycle).
+`fastify.setNotFoundHandler(handler(request, reply))`: set the 404 handler. This
+call is encapsulated by prefix, so different plugins can set different not found
+handlers if a different [`prefix` option](./Plugins.md#route-prefixing-option)
+is passed to `fastify.register()`. The handler is treated as a regular route
+handler so requests will go through the full [Fastify
+lifecycle](./Lifecycle.md#lifecycle).
 
-You can also register [`preValidation`](https://www.fastify.io/docs/latest/Hooks/#route-hooks) and [`preHandler`](https://www.fastify.io/docs/latest/Hooks/#route-hooks) hooks for the 404 handler.
+You can also register
+[`preValidation`](./Hooks.md#route-hooks) and
+[`preHandler`](./Hooks.md#route-hooks) hooks for
+the 404 handler.
 
-_Note: The `preValidation` hook registered using this method will run for a route that Fastify does not recognize and **not** when a route handler manually calls [`reply.callNotFound`](Reply.md#call-not-found)_. In which case, only preHandler will be run.
+_Note: The `preValidation` hook registered using this method will run for a
+route that Fastify does not recognize and **not** when a route handler manually
+calls [`reply.callNotFound`](./Reply.md#call-not-found)_. In which case, only
+preHandler will be run.
 
 ```js
 fastify.setNotFoundHandler({
@@ -1103,13 +1323,22 @@ fastify.register(function (instance, options, done) {
 }, { prefix: '/v1' })
 ```
 
-Fastify calls setNotFoundHandler to add a default 404 handler at startup before plugins are registered. If you would like to augment the behavior of the default 404 handler, for example with plugins, you can call setNotFoundHandler with no arguments `fastify.setNotFoundHandler()` within the context of these registered plugins.
+Fastify calls setNotFoundHandler to add a default 404 handler at startup before
+plugins are registered. If you would like to augment the behavior of the default
+404 handler, for example with plugins, you can call setNotFoundHandler with no
+arguments `fastify.setNotFoundHandler()` within the context of these registered
+plugins.
 
-<a name="set-error-handler"></a>
 #### setErrorHandler
+<a id="set-error-handler"></a>
 
-`fastify.setErrorHandler(handler(error, request, reply))`: Set a function that will be called whenever an error happens. The handler is bound to the Fastify instance and is fully encapsulated, so different plugins can set different error handlers. *async-await* is supported as well.<br>
-*Note: If the error `statusCode` is less than 400, Fastify will automatically set it at 500 before calling the error handler.*
+`fastify.setErrorHandler(handler(error, request, reply))`: Set a function that
+will be called whenever an error happens. The handler is bound to the Fastify
+instance and is fully encapsulated, so different plugins can set different error
+handlers. *async-await* is supported as well.
+
+*Note: If the error `statusCode` is less than 400, Fastify will automatically
+set it at 500 before calling the error handler.*
 
 ```js
 fastify.setErrorHandler(function (error, request, reply) {
@@ -1120,7 +1349,9 @@ fastify.setErrorHandler(function (error, request, reply) {
 })
 ```
 
-Fastify is provided with a default function that is called if no error handler is set. It can be accessed using `fastify.errorHandler` and it logs the error with respect to its `statusCode`.
+Fastify is provided with a default function that is called if no error handler
+is set. It can be accessed using `fastify.errorHandler` and it logs the error
+with respect to its `statusCode`.
 
 ```js
 var statusCode = error.statusCode
@@ -1133,10 +1364,13 @@ if (statusCode >= 500) {
 }
 ```
 
-<a name="print-routes"></a>
 #### printRoutes
+<a id="print-routes"></a>
+
+`fastify.printRoutes()`: Prints the representation of the internal radix tree
+used by the router, useful for debugging. Alternatively, `fastify.printRoutes({
+commonPrefix: false })` can be used to print the flattened routes tree.
 
-`fastify.printRoutes()`: Prints the representation of the internal radix tree used by the router, useful for debugging. Alternatively, `fastify.printRoutes({ commonPrefix: false })` can be used to print the flattened routes tree.<br/>
 *Remember to call it inside or after a `ready` call.*
 
 ```js
@@ -1160,11 +1394,15 @@ fastify.ready(() => {
   //     │   └── /hello (GET)
   //     ├── hello/world (GET)
   //     └── helicopter (GET)
-  
+
 })
 ```
 
-`fastify.printRoutes({ includeMeta: (true | []) })` will display properties from the `route.store` object for each displayed route. This can be an `array` of keys (e.g. `['onRequest', Symbol('key')]`), or `true` to display all properties. A shorthand option, `fastify.printRoutes({ includeHooks: true })` will include all [hooks](https://www.fastify.io/docs/latest/Hooks/).
+`fastify.printRoutes({ includeMeta: (true | []) })` will display properties from
+the `route.store` object for each displayed route. This can be an `array` of
+keys (e.g. `['onRequest', Symbol('key')]`), or `true` to display all properties.
+A shorthand option, `fastify.printRoutes({ includeHooks: true })` will include
+all [hooks](./Hooks.md).
 
 ```js
   console.log(fastify.printRoutes({ includeHooks: true, includeMeta: ['metaProperty'] }))
@@ -1181,7 +1419,7 @@ fastify.ready(() => {
   console.log(fastify.printRoutes({ includeHooks: true }))
   // └── /
   //     ├── test (GET)
-  //     │   • (onRequest) ["anonymous()","namedFunction()"]  
+  //     │   • (onRequest) ["anonymous()","namedFunction()"]
   //     │   └── /hello (GET)
   //     └── hel
   //         ├── lo/world (GET)
@@ -1189,10 +1427,12 @@ fastify.ready(() => {
   //         └── licopter (GET)
 ```
 
-<a name="print-plugins"></a>
 #### printPlugins
+<a id="print-plugins"></a>
+
+`fastify.printPlugins()`: Prints the representation of the internal plugin tree
+used by the avvio, useful for debugging require order issues.
 
-`fastify.printPlugins()`: Prints the representation of the internal plugin tree used by the avvio, useful for debugging require order issues.<br/>
 *Remember to call it inside or after a `ready` call.*
 
 ```js
@@ -1211,25 +1451,32 @@ fastify.ready(() => {
 })
 ```
 
-<a name="addContentTypeParser"></a>
 #### addContentTypeParser
+<a id="addContentTypeParser"></a>
 
-`fastify.addContentTypeParser(content-type, options, parser)` is used to pass custom parser for a given content type. Useful for adding parsers for custom content types, e.g. `text/json, application/vnd.oasis.opendocument.text`. `content-type` can be a string, string array or RegExp.
+`fastify.addContentTypeParser(content-type, options, parser)` is used to pass
+custom parser for a given content type. Useful for adding parsers for custom
+content types, e.g. `text/json, application/vnd.oasis.opendocument.text`.
+`content-type` can be a string, string array or RegExp.
 
 ```js
-// The two arguments passed to getDefaultJsonParser are for ProtoType poisoning and Constructor Poisoning configuration respectively. The possible values are 'ignore', 'remove', 'error'. ignore  skips all validations and it is similar to calling JSON.parse() directly. See the <a href="https://github.com/fastify/secure-json-parse#api">`secure-json-parse` documentation</a> for more information.
+// The two arguments passed to getDefaultJsonParser are for ProtoType poisoning and Constructor Poisoning configuration respectively. The possible values are 'ignore', 'remove', 'error'. ignore  skips all validations and it is similar to calling JSON.parse() directly. See the [`secure-json-parse` documentation](https://github.com/fastify/secure-json-parse#api) for more information.
 
 fastify.addContentTypeParser('text/json', { asString: true }, fastify.getDefaultJsonParser('ignore', 'ignore'))
 ```
 
-<a name="getDefaultJsonParser"></a>
 #### getDefaultJsonParser
+<a id="getDefaultJsonParser"></a>
 
-`fastify.getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)` takes two arguments. First argument is ProtoType poisoning configuration and second argument is constructor poisoning configuration. See the <a href="https://github.com/fastify/secure-json-parse#api">`secure-json-parse` documentation</a> for more information.
+`fastify.getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)` takes
+two arguments. First argument is ProtoType poisoning configuration and second
+argument is constructor poisoning configuration. See the [`secure-json-parse`
+documentation](https://github.com/fastify/secure-json-parse#api) for more
+information.
 
 
-<a name="defaultTextParser"></a>
 #### defaultTextParser
+<a id="defaultTextParser"></a>
 
 `fastify.defaultTextParser()` can be used to parse content as plain text.
 
@@ -1237,10 +1484,11 @@ fastify.addContentTypeParser('text/json', { asString: true }, fastify.getDefault
 fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser())
 ```
 
-<a name="errorHandler"></a>
 #### errorHandler
+<a id="errorHandler"></a>
 
-`fastify.errorHandler` can be used to handle errors using fastify's default error handler.
+`fastify.errorHandler` can be used to handle errors using fastify's default
+error handler.
 
 ```js
 fastify.get('/', {
@@ -1255,11 +1503,11 @@ fastify.get('/', {
 }, handler)
 ```
 
-<a name="initial-config"></a>
 #### initialConfig
+<a id="initial-config"></a>
 
-`fastify.initialConfig`: Exposes a frozen read-only object registering the initial
-options passed down by the user to the Fastify instance.
+`fastify.initialConfig`: Exposes a frozen read-only object registering the
+initial options passed down by the user to the Fastify instance.
 
 Currently the properties that can be exposed are:
 - connectionTimeout
@@ -1267,7 +1515,8 @@ Currently the properties that can be exposed are:
 - bodyLimit
 - caseSensitive
 - http2
-- https (it will return `false`/`true` or `{ allowHTTP1: true/false }` if explicitly passed)
+- https (it will return `false`/`true` or `{ allowHTTP1: true/false }` if
+  explicitly passed)
 - ignoreTrailingSlash
 - disableRequestLogging
 - maxParamLength