fastify 3.24.0 → 3.25.2

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

@@ -4,9 +4,10 @@
 - [Reply](#reply)
   - [Introduction](#introduction)
   - [.code(statusCode)](#codestatuscode)
-  - [.statusCode](#statusCode)
+  - [.statusCode](#statuscode)
   - [.server](#server)
   - [.header(key, value)](#headerkey-value)
+      - [set-cookie](#set-cookie)
   - [.headers(object)](#headersobject)
   - [.getHeader(key)](#getheaderkey)
   - [.getHeaders()](#getheaders)
@@ -16,10 +17,10 @@
   - [.callNotFound()](#callnotfound)
   - [.getResponseTime()](#getresponsetime)
   - [.type(contentType)](#typecontenttype)
-  - [.raw](#raw)
   - [.serializer(func)](#serializerfunc)
+  - [.raw](#raw)
   - [.sent](#sent)
-  - [.hijack](#hijack)
+  - [.hijack()](#hijack)
   - [.send(data)](#senddata)
     - [Objects](#objects)
     - [Strings](#strings)
@@ -28,13 +29,13 @@
     - [Errors](#errors)
     - [Type of the final payload](#type-of-the-final-payload)
     - [Async-Await and Promises](#async-await-and-promises)
-  - [.then](#then)
+  - [.then(fulfilled, rejected)](#thenfulfilled-rejected)
 
-<a name="introduction"></a>
 ### Introduction
-The second parameter of the handler function is `Reply`.
-Reply is a core Fastify object that exposes the following functions
-and properties:
+<a id="introduction"></a>
+
+The second parameter of the handler function is `Reply`. Reply is a core Fastify
+object that exposes the following functions and properties:
 
 - `.code(statusCode)` - Sets the status code.
 - `.status(statusCode)` - An alias for `.code(statusCode)`.
@@ -47,17 +48,26 @@ and properties:
 - `.removeHeader(key)` - Remove the value of a previously set header.
 - `.hasHeader(name)` - Determine if a header has been set.
 - `.type(value)` - Sets the header `Content-Type`.
-- `.redirect([code,] dest)` - Redirect to the specified url, the status code is optional (default to `302`).
+- `.redirect([code,] dest)` - Redirect to the specified url, the status code is
+  optional (default to `302`).
 - `.callNotFound()` - Invokes the custom not found handler.
-- `.serialize(payload)` - Serializes the specified payload using the default JSON serializer or using the custom serializer (if one is set) and returns the serialized payload.
+- `.serialize(payload)` - Serializes the specified payload using the default
+  JSON serializer or using the custom serializer (if one is set) and returns the
+  serialized payload.
 - `.serializer(function)` - Sets a custom serializer for the payload.
-- `.send(payload)` - Sends the payload to the user, could be a plain text, a buffer, JSON, stream, or an Error object.
-- `.sent` - A boolean value that you can use if you need to know if `send` has already been called.
-- `.raw` - The [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse) from Node core.
-- `.res` *(deprecated, use `.raw` instead)* - The [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse) from Node core.
+- `.send(payload)` - Sends the payload to the user, could be a plain text, a
+  buffer, JSON, stream, or an Error object.
+- `.sent` - A boolean value that you can use if you need to know if `send` has
+  already been called.
+- `.raw` - The
+  [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse)
+  from Node core.
+- `.res` *(deprecated, use `.raw` instead)* - The
+  [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse)
+  from Node core.
 - `.log` - The logger instance of the incoming request.
 - `.request` - The incoming request.
-- `.context` - Access the [Request's context](Request.md#Request) property.
+- `.context` - Access the [Request's context](./Request.md) property.
 
 ```js
 fastify.get('/', options, function (request, reply) {
@@ -77,22 +87,27 @@ fastify.get('/', {config: {foo: 'bar'}}, function (request, reply) {
 })
 ```
 
-<a name="code"></a>
 ### .code(statusCode)
+<a id="code"></a>
+
 If not set via `reply.code`, the resulting `statusCode` will be `200`.
 
-<a name="statusCode"></a>
 ### .statusCode
-This property reads and sets the HTTP status code. It is an alias for `reply.code()` when used as a setter.
+<a id="statusCode"></a>
+
+This property reads and sets the HTTP status code. It is an alias for
+`reply.code()` when used as a setter.
 ```js
 if (reply.statusCode >= 299) {
   reply.statusCode = 500
 }
 ```
 
-<a name="server"></a>
 ### .server
-The Fastify server instance, scoped to the current [encapsulation context](Encapsulation.md).
+<a id="server"></a>
+
+The Fastify server instance, scoped to the current [encapsulation
+context](./Encapsulation.md).
 
 ```js
 fastify.decorate('util', function util () {
@@ -104,16 +119,41 @@ fastify.get('/', async function (req, rep) {
 })
 ```
 
-<a name="header"></a>
 ### .header(key, value)
-Sets a response header. If the value is omitted or undefined, it is coerced
-to `''`.
+<a id="header"></a>
+
+Sets a response header. If the value is omitted or undefined, it is coerced to
+`''`.
+
+For more information, see
+[`http.ServerResponse#setHeader`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_response_setheader_name_value).
+
+- ### set-cookie
+  <a id="set-cookie"></a>
+
+    - When sending different values as a cookie with `set-cookie` as the key,
+      every value will be sent as a cookie instead of replacing the previous
+      value.
+
+    ```js
+    reply.header('set-cookie', 'foo');
+    reply.header('set-cookie', 'bar');
+    ```
+  - The browser will only consider the latest reference of a key for the
+    `set-cookie` header. This is done to avoid parsing the `set-cookie` header
+    when added to a reply and speeds up the serialization of the reply.
+
+  - To reset the `set-cookie` header, you need to make an explicit call to
+    `reply.removeHeader('set-cookie')`, read more about `.removeHeader(key)`
+    [here](#removeheaderkey).
+
 
-For more information, see [`http.ServerResponse#setHeader`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_response_setheader_name_value).
 
-<a name="headers"></a>
 ### .headers(object)
-Sets all the keys of the object as response headers. [`.header`](#headerkey-value) will be called under the hood.
+<a id="headers"></a>
+
+Sets all the keys of the object as response headers.
+[`.header`](#headerkey-value) will be called under the hood.
 ```js
 reply.headers({
   'x-foo': 'foo',
@@ -121,18 +161,21 @@ reply.headers({
 })
 ```
 
-<a name="getHeader"></a>
 ### .getHeader(key)
+<a id="getHeader"></a>
+
 Retrieves the value of a previously set header.
 ```js
 reply.header('x-foo', 'foo') // setHeader: key, value
 reply.getHeader('x-foo') // 'foo'
 ```
 
-<a name="getHeaders"></a>
 ### .getHeaders()
+<a id="getHeaders"></a>
 
-Gets a shallow copy of all current response headers, including those set via the raw `http.ServerResponse`. Note that headers set via Fastify take precedence over those set via `http.ServerResponse`.
+Gets a shallow copy of all current response headers, including those set via the
+raw `http.ServerResponse`. Note that headers set via Fastify take precedence
+over those set via `http.ServerResponse`.
 
 ```js
 reply.header('x-foo', 'foo')
@@ -141,8 +184,8 @@ reply.raw.setHeader('x-foo', 'foo2')
 reply.getHeaders() // { 'x-foo': 'foo', 'x-bar': 'bar' }
 ```
 
-<a name="getHeader"></a>
 ### .removeHeader(key)
+<a id="getHeader"></a>
 
 Remove the value of a previously set header.
 ```js
@@ -151,20 +194,25 @@ reply.removeHeader('x-foo')
 reply.getHeader('x-foo') // undefined
 ```
 
-<a name="hasHeader"></a>
 ### .hasHeader(key)
+<a id="hasHeader"></a>
+
 Returns a boolean indicating if the specified header has been set.
 
-<a name="redirect"></a>
 ### .redirect([code ,] dest)
-Redirects a request to the specified URL, the status code is optional, default to `302` (if status code is not already set by calling `code`).
+<a id="redirect"></a>
+
+Redirects a request to the specified URL, the status code is optional, default
+to `302` (if status code is not already set by calling `code`).
 
-Example (no `reply.code()` call) sets status code to `302` and redirects to `/home`
+Example (no `reply.code()` call) sets status code to `302` and redirects to
+`/home`
 ```js
 reply.redirect('/home')
 ```
 
-Example (no `reply.code()` call) sets status code to `303` and redirects to `/home`
+Example (no `reply.code()` call) sets status code to `303` and redirects to
+`/home`
 ```js
 reply.redirect(303, '/home')
 ```
@@ -179,36 +227,47 @@ Example (`reply.code()` call) sets status code to `302` and redirects to `/home`
 reply.code(303).redirect(302, '/home')
 ```
 
-<a name="call-not-found"></a>
 ### .callNotFound()
-Invokes the custom not found handler. Note that it will only call `preHandler` hook specified in [`setNotFoundHandler`](Server.md#set-not-found-handler).
+<a id="call-not-found"></a>
+
+Invokes the custom not found handler. Note that it will only call `preHandler`
+hook specified in [`setNotFoundHandler`](./Server.md#set-not-found-handler).
 
 ```js
 reply.callNotFound()
 ```
 
-<a name="getResponseTime"></a>
 ### .getResponseTime()
-Invokes the custom response time getter to calculate the amount of time passed since the request was started.
+<a id="getResponseTime"></a>
+
+Invokes the custom response time getter to calculate the amount of time passed
+since the request was started.
 
-Note that unless this function is called in the [`onResponse` hook](Hooks.md#onresponse) it will always return `0`.
+Note that unless this function is called in the [`onResponse`
+hook](./Hooks.md#onresponse) it will always return `0`.
 
 ```js
 const milliseconds = reply.getResponseTime()
 ```
 
-<a name="type"></a>
 ### .type(contentType)
-Sets the content type for the response.
-This is a shortcut for `reply.header('Content-Type', 'the/type')`.
+<a id="type"></a>
+
+Sets the content type for the response. This is a shortcut for
+`reply.header('Content-Type', 'the/type')`.
 
 ```js
 reply.type('text/html')
 ```
 
-<a name="serializer"></a>
 ### .serializer(func)
-`.send()` will by default JSON-serialize any value that is not one of: `Buffer`, `stream`, `string`, `undefined`, `Error`. If you need to replace the default serializer with a custom serializer for a particular request, you can do so with the `.serializer()` utility. Be aware that if you are using a custom serializer, you must set a custom `'Content-Type'` header.
+<a id="serializer"></a>
+
+`.send()` will by default JSON-serialize any value that is not one of: `Buffer`,
+`stream`, `string`, `undefined`, `Error`. If you need to replace the default
+serializer with a custom serializer for a particular request, you can do so with
+the `.serializer()` utility. Be aware that if you are using a custom serializer,
+you must set a custom `'Content-Type'` header.
 
 ```js
 reply
@@ -216,7 +275,9 @@ reply
   .serializer(protoBuf.serialize)
 ```
 
-Note that you don't need to use this utility inside a `handler` because Buffers, streams, and strings (unless a serializer is set) are considered to already be serialized.
+Note that you don't need to use this utility inside a `handler` because Buffers,
+streams, and strings (unless a serializer is set) are considered to already be
+serialized.
 
 ```js
 reply
@@ -224,11 +285,16 @@ reply
   .send(protoBuf.serialize(data))
 ```
 
-See [`.send()`](#send) for more information on sending different types of values.
+See [`.send()`](#send) for more information on sending different types of
+values.
 
-<a name="raw"></a>
 ### .raw
-This is the [`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse) from Node core. Whilst you are using the Fastify `Reply` object, the use of `Reply.raw` functions is at your own risk as you are skipping all the Fastify
+<a id="raw"></a>
+
+This is the
+[`http.ServerResponse`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_class_http_serverresponse)
+from Node core. Whilst you are using the Fastify `Reply` object, the use of
+`Reply.raw` functions is at your own risk as you are skipping all the Fastify
 logic of handling the HTTP response. e.g.:
 
 ```js
@@ -241,20 +307,20 @@ app.get('/cookie-2', (req, reply) => {
   reply.raw.end()
 })
 ```
-Another example of the misuse of `Reply.raw` is explained in [Reply](Reply.md#getheaders).
+Another example of the misuse of `Reply.raw` is explained in
+[Reply](#getheaders).
 
-<a name="sent"></a>
 ### .sent
+<a id="sent"></a>
 
-As the name suggests, `.sent` is a property to indicate if
-a response has been sent via `reply.send()`.
+As the name suggests, `.sent` is a property to indicate if a response has been
+sent via `reply.send()`.
 
-In case a route handler is defined as an async function or it
-returns a promise, it is possible to set `reply.sent = true`
-to indicate that the automatic invocation of `reply.send()` once the
-handler promise resolve should be skipped. By setting `reply.sent =
-true`, an application claims full responsibility for the low-level
-request and response. Moreover, hooks will not be invoked.
+In case a route handler is defined as an async function or it returns a promise,
+it is possible to set `reply.sent = true` to indicate that the automatic
+invocation of `reply.send()` once the handler promise resolve should be skipped.
+By setting `reply.sent = true`, an application claims full responsibility for
+the low-level request and response. Moreover, hooks will not be invoked.
 
 As an example:
 
@@ -269,39 +335,60 @@ app.get('/', (req, reply) => {
 
 If the handler rejects, the error will be logged.
 
-<a name="hijack"></a>
 ### .hijack()
-Sometimes you might need to halt the execution of the normal request lifecycle and handle sending the response manually.
+<a id="hijack"></a>
+
+Sometimes you might need to halt the execution of the normal request lifecycle
+and handle sending the response manually.
 
-To achieve this, Fastify provides the `reply.hijack()` method that can be called during the request lifecycle (At any point before `reply.send()` is called), and allows you to prevent Fastify from sending the response, and from running the remaining hooks (and user handler if the reply was hijacked before).
+To achieve this, Fastify provides the `reply.hijack()` method that can be called
+during the request lifecycle (At any point before `reply.send()` is called), and
+allows you to prevent Fastify from sending the response, and from running the
+remaining hooks (and user handler if the reply was hijacked before).
 
-NB (*): If `reply.raw` is used to send a response back to the user, `onResponse` hooks will still be executed
+NB (*): If `reply.raw` is used to send a response back to the user, `onResponse`
+hooks will still be executed
 
-<a name="send"></a>
 ### .send(data)
-As the name suggests, `.send()` is the function that sends the payload to the end user.
+<a id="send"></a>
+
+As the name suggests, `.send()` is the function that sends the payload to the
+end user.
 
-<a name="send-object"></a>
 #### Objects
-As noted above, if you are sending JSON objects, `send` will serialize the object with [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify) if you set an output schema, otherwise, `JSON.stringify()` will be used.
+<a id="send-object"></a>
+
+As noted above, if you are sending JSON objects, `send` will serialize the
+object with
+[fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify) if you
+set an output schema, otherwise, `JSON.stringify()` will be used.
 ```js
 fastify.get('/json', options, function (request, reply) {
   reply.send({ hello: 'world' })
 })
 ```
 
-<a name="send-string"></a>
 #### Strings
-If you pass a string to `send` without a `Content-Type`, it will be sent as `text/plain; charset=utf-8`. If you set the `Content-Type` header and pass a string to `send`, it will be serialized with the custom serializer if one is set, otherwise, it will be sent unmodified (unless the `Content-Type` header is set to `application/json; charset=utf-8`, in which case it will be JSON-serialized like an object — see the section above).
+<a id="send-string"></a>
+
+If you pass a string to `send` without a `Content-Type`, it will be sent as
+`text/plain; charset=utf-8`. If you set the `Content-Type` header and pass a
+string to `send`, it will be serialized with the custom serializer if one is
+set, otherwise, it will be sent unmodified (unless the `Content-Type` header is
+set to `application/json; charset=utf-8`, in which case it will be
+JSON-serialized like an object — see the section above).
 ```js
 fastify.get('/json', options, function (request, reply) {
   reply.send('plain string')
 })
 ```
 
-<a name="send-streams"></a>
 #### Streams
-*send* can also handle streams out of the box. If you are sending a stream and you have not set a `'Content-Type'` header, *send* will set it at `'application/octet-stream'`.
+<a id="send-streams"></a>
+
+*send* can also handle streams out of the box. If you are sending a stream and
+you have not set a `'Content-Type'` header, *send* will set it at
+`'application/octet-stream'`.
 ```js
 fastify.get('/streams', function (request, reply) {
   const fs = require('fs')
@@ -310,9 +397,11 @@ fastify.get('/streams', function (request, reply) {
 })
 ```
 
-<a name="send-buffers"></a>
 #### Buffers
-If you are sending a buffer and you have not set a `'Content-Type'` header, *send* will set it to `'application/octet-stream'`.
+<a id="send-buffers"></a>
+
+If you are sending a buffer and you have not set a `'Content-Type'` header,
+*send* will set it to `'application/octet-stream'`.
 ```js
 const fs = require('fs')
 fastify.get('/streams', function (request, reply) {
@@ -322,9 +411,11 @@ fastify.get('/streams', function (request, reply) {
 })
 ```
 
-<a name="errors"></a>
 #### Errors
-If you pass to *send* an object that is an instance of *Error*, Fastify will automatically create an error structured as the following:
+<a id="errors"></a>
+
+If you pass to *send* an object that is an instance of *Error*, Fastify will
+automatically create an error structured as the following:
 
 ```js
 {
@@ -335,10 +426,16 @@ If you pass to *send* an object that is an instance of *Error*, Fastify will aut
 }
 ```
 
-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.*
+You can add custom properties to the Error object, such as `headers`, that will
+be used to enhance the HTTP response.
+
+*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:
+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:
 
 ```js
 fastify.get('/', function (request, reply) {
@@ -351,7 +448,8 @@ To customize the JSON error output you can do it by:
 - setting a response JSON schema for the status code you need
 - add the additional properties to the `Error` instance
 
-Notice that if the returned status code is not in the response schema list, the default behaviour will be applied.
+Notice that if the returned status code is not in the response schema list, the
+default behaviour will be applied.
 
 ```js
 fastify.get('/', {
@@ -376,7 +474,9 @@ fastify.get('/', {
 })
 ```
 
-If you want to customize error handling, check out [`setErrorHandler`](Server.md#seterrorhandler) API.<br>
+If you want to customize error handling, check out
+[`setErrorHandler`](./Server.md#seterrorhandler) API.
+
 *Note: you are responsible for logging when customizing the error handler*
 
 API:
@@ -392,7 +492,8 @@ fastify.setErrorHandler(function (error, request, reply) {
 })
 ```
 
-The not found errors generated by the router will use the  [`setNotFoundHandler`](Server.md#setnotfoundhandler)
+The not found errors generated by the router will use the
+[`setNotFoundHandler`](./Server.md#setnotfoundhandler)
 
 API:
 
@@ -405,9 +506,12 @@ fastify.setNotFoundHandler(function (request, reply) {
 })
 ```
 
-<a name="payload-type"></a>
 #### Type of the final payload
-The type of the sent payload (after serialization and going through any [`onSend` hooks](Hooks.md#the-onsend-hook)) must be one of the following types, otherwise, an error will be thrown:
+<a id="payload-type"></a>
+
+The type of the sent payload (after serialization and going through any
+[`onSend` hooks](./Hooks.md#onsend)) must be one of the following
+types, otherwise, an error will be thrown:
 
 - `string`
 - `Buffer`
@@ -415,9 +519,11 @@ The type of the sent payload (after serialization and going through any [`onSend
 - `undefined`
 - `null`
 
-<a name="async-await-promise"></a>
 #### Async-Await and Promises
-Fastify natively handles promises and supports async-await.<br>
+<a id="async-await-promise"></a>
+
+Fastify natively handles promises and supports async-await.
+
 *Note that in the following examples we are not using reply.send.*
 ```js
 const delay = promisify(setTimeout)
@@ -432,7 +538,9 @@ fastify.get('/async-await', options, async function (request, reply) {
 })
 ```
 
-Rejected promises default to a `500` HTTP status code. Reject the promise, or `throw` in an `async function`, with an object that has `statusCode` (or `status`) and `message` properties to modify the reply.
+Rejected promises default to a `500` HTTP status code. Reject the promise, or
+`throw` in an `async function`, with an object that has `statusCode` (or
+`status`) and `message` properties to modify the reply.
 
 ```js
 fastify.get('/teapot', async function (request, reply) {
@@ -448,22 +556,25 @@ fastify.get('/botnet', async function (request, reply) {
 })
 ```
 
-If you want to know more please review [Routes#async-await](Routes.md#async-await).
+If you want to know more please review
+[Routes#async-await](./Routes.md#async-await).
 
-<a name="then"></a>
 ### .then(fulfilled, rejected)
+<a id="then"></a>
 
-As the name suggests, a `Reply` object can be awaited upon, i.e. `await reply` will wait until the reply is sent.
-The `await` syntax calls the `reply.then()`.
+As the name suggests, a `Reply` object can be awaited upon, i.e. `await reply`
+will wait until the reply is sent. The `await` syntax calls the `reply.then()`.
 
 `reply.then(fulfilled, rejected)` accepts two parameters:
 
 - `fulfilled` will be called when a response has been fully sent,
-- `rejected` will be called if the underlying stream had an error, e.g.
-the socket has been destroyed.
+- `rejected` will be called if the underlying stream had an error, e.g. the
+  socket has been destroyed.
 
 For more details, see:
 
-- https://github.com/fastify/fastify/issues/1864 for the discussion about this feature
+- https://github.com/fastify/fastify/issues/1864 for the discussion about this
+  feature
 - https://promisesaplus.com/ for the definition of thenables
-- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then for the signature
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then
+  for the signature

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

@@ -1,35 +1,50 @@
 <h1 align="center">Fastify</h1>
 
 ## Request
-The first parameter of the handler function is `Request`.<br>
+The first parameter of the handler function is `Request`.
+
 Request is a core Fastify object containing the following fields:
-- `query` - the parsed querystring, its format is specified by [`querystringParser`](Server.md#querystringparser)
-- `body` - the request payload, see [Content Type Parser](ContentTypeParser.md) for details on what request payloads Fastify natively parses and how to support other content types
+- `query` - the parsed querystring, its format is specified by
+  [`querystringParser`](./Server.md#querystringparser)
+- `body` - the request payload, see [Content-Type
+  Parser](./ContentTypeParser.md) for details on what request payloads Fastify
+  natively parses and how to support other content types
 - `params` - the params matching the URL
 - [`headers`](#headers) - the headers getter and setter
 - `raw` - the incoming HTTP request from Node core
-- `req` *(deprecated, use `.raw` instead)* - the incoming HTTP request from Node core
-- `server` - The Fastify server instance, scoped to the current [encapsulation context](Encapsulation.md)
+- `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
 - `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 host of the incoming request (derived from `X-Forwarded-Host` header when the [`trustProxy`](Server.md#factory-trust-proxy) option is enabled). For HTTP/2 compatibility it returns `:authority` if no host header exists.
+- `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 host of the incoming request (derived from `X-Forwarded-Host`
+  header when the [`trustProxy`](./Server.md#factory-trust-proxy) option is
+  enabled). For HTTP/2 compatibility it returns `:authority` if no host header
+  exists.
 - `protocol` - the protocol of the incoming request (`https` or `http`)
 - `method` - the method 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
+- `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.
+- `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 useful to access one special key:
-  - `context.config` - The route [`config`](Routes.md#routes-config) object.
+- `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 returns an Object with the headers of the incoming request.
-You can set custom headers like this:
+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
 request.headers = {
@@ -38,8 +53,9 @@ request.headers = {
 }
 ```
 
-This operation will add to the request headers the new values that can be read calling `request.headers.bar`.  
-Moreover, you can still access the standard request's headers with the `request.raw.headers` property.
+This operation will add to the request headers the new values that can be read
+calling `request.headers.bar`. Moreover, you can still access the standard
+request's headers with the `request.raw.headers` property.
 
 ```js
 fastify.post('/:params', options, function (request, reply) {