fastify 2.7.1 → 2.11.0

package/docs/Hooks.md

@@ -2,222 +2,170 @@
 
 ## Hooks
 
-Hooks are registered with the `fastify.addHook` method and allow you to listen to specific events in the application or request/response lifecycle. You have to register a hook before the event is triggered otherwise the event is lost.
+Hooks are registered with the `fastify.addHook` method and allow you to listen to specific events in the application or request/response lifecycle. You have to register a hook before the event is triggered, otherwise the event is lost.
 
-## Request/Response Hooks
+By using hooks you can interact directly with the lifecycle of Fastify. There are Request/Reply hooks and application hooks:
 
-By using the hooks you can interact directly inside the lifecycle of Fastify. There are seven different Hooks that you can use *(in order of execution)*:
-- `'onRequest'`
-- `'preParsing'`
-- `'preValidation'`
-- `'preHandler'`
-- `'preSerialization'`
-- `'onError'`
-- `'onSend'`
-- `'onResponse'`
+- [Request/Reply Hooks](#requestreply-hooks)
+  - [onRequest](#onrequest)
+  - [preParsing](#preparsing)
+  - [preValidation](#prevalidation)
+  - [preHandler](#prehandler)
+  - [preSerialization](#preserialization)
+  - [onError](#onerror)
+  - [onSend](#onsend)
+  - [onResponse](#onresponse)
+- [Application Hooks](#application-hooks)
+  - [onClose](#onclose)
+  - [onRoute](#onroute)
+  - [onRegister](#onregister)
 
-Example:
-```js
-fastify.addHook('onRequest', (request, reply, done) => {
-  // some code
-  done()
-})
+**Notice:** the `done` callback is not available when using `async`/`await` or returning a `Promise`. If you do invoke a `done` callback in this situation unexpected behaviour may occur, e.g. duplicate invocation of handlers.
 
-fastify.addHook('preParsing', (request, reply, done) => {
-  // some code
-  done()
-})
+## Request/Reply Hooks
 
-fastify.addHook('preValidation', (request, reply, done) => {
-  // some code
-  done()
-})
-
-fastify.addHook('preHandler', (request, reply, done) => {
-  // some code
-  done()
-})
-
-fastify.addHook('preSerialization', (request, reply, payload, done) => {
-  // some code
-  done()
-})
+[Request](https://github.com/fastify/fastify/blob/master/docs/Request.md) and [Reply](https://github.com/fastify/fastify/blob/master/docs/Reply.md) are the core Fastify objects.<br/>
+`done` is the function to continue with the [lifecycle](https://github.com/fastify/fastify/blob/master/docs/Lifecycle.md).
 
-fastify.addHook('onError', (request, reply, error, done) => {
-  // some code
-  done()
-})
+It is pretty easy to understand where each hook is executed by looking at the [lifecycle page](https://github.com/fastify/fastify/blob/master/docs/Lifecycle.md).<br>
+Hooks are affected by Fastify's encapsulation, and can thus be applied to selected routes. See the [Scopes](#scope) section for more information.
 
-fastify.addHook('onSend', (request, reply, payload, done) => {
-  // some code
-  done()
-})
+There are eight different hooks that you can use in Request/Reply *(in order of execution)*:
 
-fastify.addHook('onResponse', (request, reply, done) => {
-  // some code
+### onRequest
+```js
+fastify.addHook('onRequest', (request, reply, done) => {
+  // Some code
   done()
 })
 ```
-Or `async/await`
+Or `async/await`:
 ```js
 fastify.addHook('onRequest', async (request, reply) => {
-  // some code
+  // Some code
   await asyncMethod()
-  // error occurred
+  // Error occurred
   if (err) {
-    throw new Error('some errors occurred.')
+    throw new Error('Some errors occurred.')
   }
   return
 })
+```
 
-fastify.addHook('preParsing', async (request, reply) => {
-  // some code
-  await asyncMethod()
-  // error occurred
-  if (err) {
-    throw new Error('some errors occurred.')
-  }
-  return
-})
+**Notice:** in the [onRequest](#onRequest) hook, `request.body` will always be `null`, because the body parsing happens before the [preHandler](#preHandler) hook.
 
-fastify.addHook('preValidation', async (request, reply) => {
-  // some code
-  await asyncMethod()
-  // error occurred
-  if (err) {
-    throw new Error('some errors occurred.')
-  }
-  return
+### preParsing
+```js
+fastify.addHook('preParsing', (request, reply, done) => {
+  // Some code
+  done()
 })
-
-fastify.addHook('preHandler', async (request, reply) => {
-  // some code
+```
+Or `async/await`:
+```js
+fastify.addHook('preParsing', async (request, reply) => {
+  // Some code
   await asyncMethod()
-  // error occurred
+  // Error occurred
   if (err) {
-    throw new Error('some errors occurred.')
+    throw new Error('Some errors occurred.')
   }
   return
 })
-
-fastify.addHook('preSerialization', async (request, reply, payload) => {
-  // some code
-  await asyncMethod()
-  // error occurred
-  if (err) {
-    throw new Error('some errors occurred.')
-  }
-  return payload
-})
-
-fastify.addHook('onError', async (request, reply, error) => {
-  // useful for custom error logging
-  // you should not use this hook to update the error
+```
+### preValidation
+```js
+fastify.addHook('preValidation', (request, reply, done) => {
+  // Some code
+  done()
 })
-
-fastify.addHook('onSend', async (request, reply, payload) => {
-  // some code
+```
+Or `async/await`:
+```js
+fastify.addHook('preValidation', async (request, reply) => {
+  // Some code
   await asyncMethod()
-  // error occurred
+  // Error occurred
   if (err) {
-    throw new Error('some errors occurred.')
+    throw new Error('Some errors occurred.')
   }
   return
 })
+```
+**Notice:** in the [preValidation](#preValidation) hook, `request.body` will always be `null`, because the body parsing happens before the [preHandler](#preHandler) hook.
 
-fastify.addHook('onResponse', async (request, reply) => {
+### preHandler
+```js
+fastify.addHook('preHandler', (request, reply, done) => {
   // some code
+  done()
+})
+```
+Or `async/await`:
+```js
+fastify.addHook('preHandler', async (request, reply) => {
+  // Some code
   await asyncMethod()
-  // error occurred
+  // Error occurred
   if (err) {
-    throw new Error('some errors occurred.')
+    throw new Error('Some errors occurred.')
   }
   return
 })
 ```
+### preSerialization
 
-**Notice:** the `done` callback is not available when using `async`/`await` or returning a `Promise`. If you do invoke a `done` callback in this situation unexpected behavior may occur, e.g. duplicate invocation of handlers.
-
-**Notice:** in the `onRequest` and `preValidation` hooks, `request.body` will always be `null`, because the body parsing happens before the `preHandler` hook.
-
-[Request](https://github.com/fastify/fastify/blob/master/docs/Request.md) and [Reply](https://github.com/fastify/fastify/blob/master/docs/Reply.md) are the core Fastify objects.<br/>
-`done` is the function to continue with the [lifecycle](https://github.com/fastify/fastify/blob/master/docs/Lifecycle.md).
-
-It is pretty easy to understand where each hook is executed by looking at the [lifecycle page](https://github.com/fastify/fastify/blob/master/docs/Lifecycle.md).<br>
-Hooks are affected by Fastify's encapsulation, and can thus be applied to selected routes. See the [Scopes](#scope) section for more information.
-
-If you get an error during the execution of your hook, just pass it to `done()` and Fastify will automatically close the request and send the appropriate error code to the user.
+If you are using the `preSerialization` hook, you can change (or replace) the payload before it is serialized. For example:
 
 ```js
-fastify.addHook('onRequest', (request, reply, done) => {
-  done(new Error('some error'))
+fastify.addHook('preSerialization', (request, reply, payload, done) => {
+  const err = null;
+  const newPayload = { wrapped: payload }
+  done(err, newPayload)
 })
 ```
-
-If you want to pass a custom error code to the user, just use `reply.code()`:
+Or `async/await`
 ```js
-fastify.addHook('preHandler', (request, reply, done) => {
-  reply.code(400)
-  done(new Error('some error'))
+fastify.addHook('preSerialization', async (request, reply, payload) => {
+  return { wrapped: payload }
 })
 ```
 
-*The error will be handled by [`Reply`](https://github.com/fastify/fastify/blob/master/docs/Reply.md#errors).*
-
-#### The `onError` Hook
-
-This hook is useful if you need to do some custom error logging or add some specific header in case of error.<br/>
-It is not intended for changing the error, and calling `reply.send` will throw an exception.<br/>
-This hook will be executed only after the `customErrorHandler` has been executed, and only if the `customErrorHandler` sends back an error to the user *(Note that the default `customErrorHandler` always send back the error to the user)*.<br/>
-**Notice:** unlike the other hooks, pass an error to the `done` function is not supported.
+Note: the hook is NOT called if the payload is a `string`, a `Buffer`, a `stream` or `null`.
 
+### onError
 ```js
 fastify.addHook('onError', (request, reply, error, done) => {
-  // apm stands for Application Performance Monitoring
-  apm.sendError(error)
+  // Some code
   done()
 })
-
-// Or async
-fastify.addHook('onError', async (request, reply, error) => {
-  // apm stands for Application Performance Monitoring
-  apm.sendError(error)
-})
 ```
-
-#### The `preSerialization` Hook
-
-If you are using the `preSerialization` hook, you can change (or replace) the payload before it is serialized. For example:
-
+Or `async/await`:
 ```js
-fastify.addHook('preSerialization', (request, reply, payload, done) => {
-  var err = null;
-  var newPayload = {wrapped: payload }
-  done(err, newPayload)
-})
-
-// Or async
-fastify.addHook('preSerialization', async (request, reply, payload) => {
-  return {wrapped: payload }
+fastify.addHook('onError', async (request, reply, error) => {
+  // Useful for custom error logging
+  // You should not use this hook to update the error
 })
 ```
+This hook is useful if you need to do some custom error logging or add some specific header in case of error.<br/>
+It is not intended for changing the error, and calling `reply.send` will throw an exception.<br/>
+This hook will be executed only after the `customErrorHandler` has been executed, and only if the `customErrorHandler` sends an error back to the user *(Note that the default `customErrorHandler` always sends the error back to the user)*.<br/>
+**Notice:** unlike the other hooks, pass an error to the `done` function is not supported.
 
-Note: the hook is NOT called if the payload is  a `string`, a `Buffer`, a `stream`, or `null`.
-
-#### The `onSend` Hook
-
+### onSend
 If you are using the `onSend` hook, you can change the payload. For example:
 
 ```js
 fastify.addHook('onSend', (request, reply, payload, done) => {
-  var err = null;
-  var newPayload = payload.replace('some-text', 'some-new-text')
+  const err = null;
+  const newPayload = payload.replace('some-text', 'some-new-text')
   done(err, newPayload)
 })
-
-// Or async
+```
+Or `async/await`:
+```js
 fastify.addHook('onSend', async (request, reply, payload) => {
-  var newPayload = payload.replace('some-text', 'some-new-text')
+  const newPayload = payload.replace('some-text', 'some-new-text')
   return newPayload
 })
 ```
@@ -236,15 +184,55 @@ fastify.addHook('onSend', (request, reply, payload, done) => {
 
 Note: If you change the payload, you may only change it to a `string`, a `Buffer`, a `stream`, or `null`.
 
-#### The `onResponse` Hook
-The `onResponse` hook is executed when a response has been sent, so you will not be able to send more data to the client, however you can use this hook to send some data to an external service or elaborate some statistics.
+
+### onResponse
+```js
+
+fastify.addHook('onResponse', (request, reply, done) => {
+  // Some code
+  done()
+})
+```
+Or `async/await`:
+```js
+fastify.addHook('onResponse', async (request, reply) => {
+  // Some code
+  await asyncMethod()
+  // Error occurred
+  if (err) {
+    throw new Error('Some errors occurred.')
+  }
+  return
+})
+```
+
+The `onResponse` hook is executed when a response has been sent, so you will not be able to send more data to the client. It can however be useful for sending data to external services, for example to gather statistics.
+
+### Manage Errors from a hook
+If you get an error during the execution of your hook, just pass it to `done()` and Fastify will automatically close the request and send the appropriate error code to the user.
+
+```js
+fastify.addHook('onRequest', (request, reply, done) => {
+  done(new Error('Some error'))
+})
+```
+
+If you want to pass a custom error code to the user, just use `reply.code()`:
+```js
+fastify.addHook('preHandler', (request, reply, done) => {
+  reply.code(400)
+  done(new Error('Some error'))
+})
+```
+
+*The error will be handled by [`Reply`](https://github.com/fastify/fastify/blob/master/docs/Reply.md#errors).*
 
 ### Respond to a request from a hook
-If needed, you can respond to a request before you reach the route handler. An example could be an authentication hook. If you are using `onRequest` or `preHandler` use `reply.send`; if you are using a middleware, `res.end`.
+If needed, you can respond to a request before you reach the route handler, for example when implementing an authentication hook. If you are using `onRequest` or `preHandler` use `reply.send`; if you are using a middleware, use `res.end`.
 
 ```js
 fastify.addHook('onRequest', (request, reply, done) => {
-  reply.send('early response')
+  reply.send('Early response')
 })
 
 // Works with async functions too
@@ -264,39 +252,55 @@ fastify.addHook('onRequest', (request, reply, done) => {
 
 ## Application Hooks
 
-You are able to hook into the application-lifecycle as well. It's important to note that these hooks aren't fully encapsulated. The `this` inside the hooks are encapsulated but the handlers can respond to an event outside the encapsulation boundaries.
+You can hook into the application-lifecycle as well. It's important to note that these hooks aren't fully encapsulated. The `this` inside the hooks are encapsulated but the handlers can respond to an event outside the encapsulation boundaries.
 
-- `'onClose'`
-- `'onRoute'`
-- `'onRegister'`
+- [onClose](#onclose)
+- [onRoute](#onroute)
+- [onRegister](#onregister)
 
 <a name="on-close"></a>
-**'onClose'**<br>
-Triggered when `fastify.close()` is invoked to stop the server. It is useful when [plugins](https://github.com/fastify/fastify/blob/master/docs/Plugins.md) need a "shutdown" event, such as a connection to a database.<br>
+
+### onClose
+Triggered when `fastify.close()` is invoked to stop the server. It is useful when [plugins](https://github.com/fastify/fastify/blob/master/docs/Plugins.md) need a "shutdown" event, for example to close an open connection to a database.<br>
 The first argument is the Fastify instance, the second one the `done` callback.
 ```js
 fastify.addHook('onClose', (instance, done) => {
-  // some code
+  // Some code
   done()
 })
 ```
 <a name="on-route"></a>
-**'onRoute'**<br>
+### onRoute
 Triggered when a new route is registered. Listeners are passed a `routeOptions` object as the sole parameter. The interface is synchronous, and, as such, the listeners do not get passed a callback.
 ```js
 fastify.addHook('onRoute', (routeOptions) => {
-  // some code
+  //Some code
   routeOptions.method
   routeOptions.schema
   routeOptions.url
   routeOptions.bodyLimit
   routeOptions.logLevel
+  routeOptions.logSerializers
   routeOptions.prefix
 })
 ```
+
+If you are authoring a plugin and you need to customize application routes, like modifying the options or adding new route hooks, this is the right place.
+
+```js
+fastify.addHook('onRoute', (routeOptions) => {
+  function onPreSerialization(request, reply, payload, done) {
+    // Your code
+    done(null, payload)
+  }
+  // preSerialization can be an array or undefined
+  routeOptions.preSerialization = [...(routeOptions.preSerialization || []), onPreSerialization]
+})
+```
+
 <a name="on-register"></a>
-**'onRegister'**<br>
-Triggered when a new plugin function is registered, and a new encapsulation context is created, the hook will be executed **before** the plugin code.<br/>
+### onRegister
+Triggered when a new plugin is registered and a new encapsulation context is created. The hook will be executed **before** the registered code.<br/>
 This hook can be useful if you are developing a plugin that needs to know when a plugin context is formed, and you want to operate in that specific context.<br/>
 **Note:** This hook will not be called if a plugin is wrapped inside [`fastify-plugin`](https://github.com/fastify/fastify-plugin).
 ```js
@@ -309,19 +313,22 @@ fastify.register(async (instance, opts) => {
   instance.register(async (instance, opts) => {
     instance.data.push('world')
     console.log(instance.data) // ['hello', 'world']
-  })
-})
+  }, { prefix: '/hola' })
+}, { prefix: '/ciao' })
 
 fastify.register(async (instance, opts) => {
   console.log(instance.data) // []
-})
+}, { prefix: '/hello' })
 
-fastify.addHook('onRegister', (instance) => {
-  // create a new array from the old one
+fastify.addHook('onRegister', (instance, opts) => {
+  // Create a new array from the old one
   // but without keeping the reference
   // allowing the user to have encapsulated
   // instances of the `data` property
   instance.data = instance.data.slice()
+
+  // the options of the new registered instance
+  console.log(opts.prefix)
 })
 ```
 
@@ -338,38 +345,42 @@ fastify.addHook('onRequest', function (request, reply, done) {
 Note: using an arrow function will break the binding of this to the Fastify instance.
 
 <a name="route-hooks"></a>
+
 ## Route level hooks
-You can declare one or more custom `onRequest`, `preParsing`, `preValidation`, `preHandler` and `preSerialization` hook(s) that will be **unique** for the route.
-If you do so, those hooks always be executed as last hook in their category. <br/>
-This can be useful if you need to run the authentication, and the `preParsing` or `preValidation` hooks are exactly what you need for doing that.
+You can declare one or more custom [onRequest](#onRequest), [onReponse](#onResponse), [preParsing](#preParsing), [preValidation](#preValidation), [preHandler](#preHandler) and [preSerialization](#preSerialization) hook(s) that will be **unique** for the route.
+If you do so, those hooks are always executed as the last hook in their category. <br/>
+This can be useful if you need to implement authentication, where the [preParsing](#preParsing) or [preValidation](#preValidation) hooks are exactly what you need.
 Multiple route-level hooks can also be specified as an array.
 
-Let's make an example:
-
 ```js
 fastify.addHook('onRequest', (request, reply, done) => {
+  // Your code
+  done()
+})
+
+fastify.addHook('onResponse', (request, reply, done) => {
   // your code
   done()
 })
 
 fastify.addHook('preParsing', (request, reply, done) => {
-  // your code
+  // Your code
   done()
 })
 
 fastify.addHook('preValidation', (request, reply, done) => {
-  // your code
+  // Your code
   done()
 })
 
 fastify.addHook('preHandler', (request, reply, done) => {
-  // your code
+  // Your code
   done()
 })
 
 fastify.addHook('preSerialization', (request, reply, payload, done) => {
-  // your code
-  done()
+  // Your code
+  done(null, payload)
 })
 
 fastify.route({
@@ -377,29 +388,33 @@ fastify.route({
   url: '/',
   schema: { ... },
   onRequest: function (request, reply, done) {
-    // this hook will always be executed after the shared `onRequest` hooks
+    // This hook will always be executed after the shared `onRequest` hooks
+    done()
+  },
+  onResponse: function (request, reply, done) {
+    // this hook will always be executed after the shared `onResponse` hooks
     done()
   },
   preParsing: function (request, reply, done) {
-    // this hook will always be executed after the shared `preParsing` hooks
+    // This hook will always be executed after the shared `preParsing` hooks
     done()
   },
   preValidation: function (request, reply, done) {
-    // this hook will always be executed after the shared `preValidation` hooks
+    // This hook will always be executed after the shared `preValidation` hooks
     done()
   },
   preHandler: function (request, reply, done) {
-    // this hook will always be executed after the shared `preHandler` hooks
+    // This hook will always be executed after the shared `preHandler` hooks
     done()
   },
   // // Example with an array. All hooks support this syntax.
   //
   // preHandler: [function (request, reply, done) {
-  //   // this hook will always be executed after the shared `preHandler` hooks
+  //   // This hook will always be executed after the shared `preHandler` hooks
   //   done()
   // }],
   preSerialization: (request, reply, payload, done) => {
-    // manipulate the payload
+    // This hook will always be executed after the shared `preSerialization` hooks
     done(null, payload)
   },
   handler: function (request, reply) {

package/docs/LTS.md

@@ -40,10 +40,9 @@ A "month" is to be a period of 30 consecutive days.
 
 ### CI tested operating systems
 
-| CI              | OS      | Version        | Package Manager | Node.js        |
-| :-------------- | :------ | :------------- | :-------------- | :------------- |
-| Travis          | Linux   | Ubuntu 14.04   | npm             | 6,8,9,10       |
-| Azure pipelines | Linux   | Ubuntu 16.04   | yarn            | ~~6¹~~,8,10,11 |
-| Azure pipelines | Windows | vs2017-win2016 | npm             | 6,8,10,11      |
-
-_¹ yarn supports only node >= 8_
+| CI             | OS      | Version                | Package Manager           | Node.js   |
+|----------------|---------|------------------------|---------------------------|-----------|
+| Github Actions | Linux   | Ubuntu 16.04           | npm                       | 6,8,10,12 |
+| Github Actions | Linux   | Ubuntu 16.04           | yarn,pnpm                 | 8,10      |
+| Github Actions | Windows | Windows Server 2016 R2 | npm                       | 6,8,10,12 |
+| Github Actions | MacOS   | macOS X Mojave 10.14   | npm                       | 6,8,10,12 |

package/docs/Logging.md

@@ -4,12 +4,12 @@
 
 Logging is disabled by default, and you can enable it by passing
 `{ logger: true }` or `{ logger: { level: 'info' } }` when you create
-the fastify instance. Note that if the logger is disabled, it is impossible to
+a fastify instance. Note that if the logger is disabled, it is impossible to
 enable it at runtime. We use
 [abstract-logging](https://www.npmjs.com/package/abstract-logging) for
 this purpose.
 
-Since Fastify is really focused on performances, it uses [pino](https://github.com/pinojs/pino) as its logger, with the default log level, when enabled, set to `'info'`.
+Since Fastify is focused on performance, it uses [pino](https://github.com/pinojs/pino) as its logger, with the default log level, when enabled, set to `'info'`.
 
 Enabling the logger is extremely easy:
 
@@ -24,14 +24,14 @@ fastify.get('/', options, function (request, reply) {
 })
 ```
 
-If you want to pass some options to the logger, just pass the logger option to Fastify.
-You can find all the options in the [Pino documentation](https://github.com/pinojs/pino/blob/master/docs/api.md#pinooptions-stream). If you want to specify a file destination, use:
+If you want to pass some options to the logger, just pass them to Fastify.
+You can find all available options in the [Pino documentation](https://github.com/pinojs/pino/blob/master/docs/api.md#pinooptions-stream). If you want to specify a file destination, use:
 
 ```js
 const fastify = require('fastify')({
   logger: {
     level: 'info',
-    file: '/path/to/file' // will use pino.destination()
+    file: '/path/to/file' // Will use pino.destination()
   }
 })
 
@@ -41,7 +41,7 @@ fastify.get('/', options, function (request, reply) {
 })
 ```
 
-If you want to pass a custom stream to the Pino instance, just add the stream field to the logger object.
+If you want to pass a custom stream to the Pino instance, just add a stream field to the logger object.
 
 ```js
 const split = require('split2')
@@ -57,9 +57,9 @@ const fastify = require('fastify')({
 
 <a name="logging-request-id"></a>
 
-By default fastify adds an id to every request for easier tracking. If the "request-id" header is present its value is used, otherwise a new incremental id is generated. See Fastify Factory [`requestIdHeader`](https://github.com/fastify/fastify/blob/master/docs/Server.md#factory-request-id-header) and Fastify Factory [`genReqId`](https://github.com/fastify/fastify/blob/master/docs/Server.md#gen-request-id) for customization options.
+By default, fastify adds an id to every request for easier tracking. If the "request-id" header is present its value is used, otherwise a new incremental id is generated. See Fastify Factory [`requestIdHeader`](https://github.com/fastify/fastify/blob/master/docs/Server.md#factory-request-id-header) and Fastify Factory [`genReqId`](https://github.com/fastify/fastify/blob/master/docs/Server.md#gen-request-id) for customization options.
 
-The default logger is configured with a set of standard serializers that serialize objects with `req`, `res`, and `err` properties. This behavior can be customized by specifying custom serializers.
+The default logger is configured with a set of standard serializers that serialize objects with `req`, `res`, and `err` properties. This behaviour can be customized by specifying custom serializers.
 ```js
 const fastify = require('fastify')({
   logger: {
@@ -79,7 +79,7 @@ const fastify = require('fastify')({
     prettyPrint: true,
     serializers: {
       res(res) {
-        // the default
+        // The default
         return {
           statusCode: res.statusCode
         }
@@ -103,7 +103,7 @@ const fastify = require('fastify')({
 ```
 **Note**: The body not can serialize inside `req` method, because the request is serialized when we create the child logger. At that time, the body is not parsed yet.
 
-See a approach to log `req.body`
+See an approach to log `req.body`
 
 ```js
 app.addHook('preHandler', function (req, reply, done) {