fastify 2.4.1 → 2.7.1

package/README.md

@@ -204,12 +204,12 @@ Team members are listed in alphabetical order.
 ### Collaborators
 Great contributors on a specific area in the Fastify ecosystem will be invited to join this group by Lead Maintainers.
 
-* [__Trivikram Kamat__](https://github.com/trivikr), <https://twitter.com/trivikram>, <https://www.npmjs.com/~trivikr>
 * [__Luciano Mammino__](https://github.com/lmammino), <https://twitter.com/loige>, <https://www.npmjs.com/~lmammino>
 * [__Evan Shortiss__](https://github.com/evanshortiss), <https://twitter.com/evanshortiss>, <https://www.npmjs.com/~evanshortiss>
 
 **Past Collaborators**
 * [__Çağatay Çalı__](https://github.com/cagataycali), <https://twitter.com/cagataycali>, <https://www.npmjs.com/~cagataycali>
+* [__Trivikram Kamat__](https://github.com/trivikr), <https://twitter.com/trivikram>, <https://www.npmjs.com/~trivikr>
 
 ## Acknowledgements
 

package/SECURITY.md

@@ -0,0 +1,33 @@
+# Security Policy
+
+This document describes the management of vulnerabilities for the Fastify project and it's officials' plugins.
+
+
+## Reporting vulnerabilities
+
+Individuals who find potential vulnerabilities in Fastify are invited to complete a vulnerability report via the dedicated HackerOne tool for Node.js modules: [https://hackerone.com/nodejs-ecosystem](https://hackerone.com/nodejs-ecosystem).
+
+### How to report a vulnerabiliy
+
+It is of the utmost importance that you read carefully [**HOW TO REPORT A VULNERABILIY**](https://github.com/nodejs/security-wg/blob/master/processes/third_party_vuln_process.md) written by the Security Working Group of Node.js.
+
+
+## Handling vulnerability reports
+
+When a potential vulnerability is reported and confirmed the Fastify Core Team will intervene in the
+`follow-up` stage of the process following the workflow and the timings described in the Security WG's document.
+
+### Vulnerabilities found outside this process
+
+⚠ The Fastify project does not support any reporting outside the HackerOne process.
+
+
+## The Fastify Core team
+
+The core team is responsible for the management of [this](https://github.com/nodejs/security-wg/blob/master/processes/third_party_vuln_process.md#handling-vulnerability-reports) process.
+
+Members of this team are expected to keep all information that they have privileged access to by being
+on the team completely private to the team. This includes agreeing to not notify anyone outside the
+team of issues that have not yet been disclosed publicly, including the existence of issues,
+expectations of upcoming releases, and patching of any issues other than in the process of their work
+as a member of the Fastify Core team.

package/build/build-validation.js

@@ -72,7 +72,7 @@ const schema = {
 
 const validate = ajv.compile(schema)
 
-let moduleCode = `// This file is autogenerated by ${__filename.replace(__dirname, 'build')}, do not edit
+const moduleCode = `// This file is autogenerated by ${__filename.replace(__dirname, 'build')}, do not edit
 /* istanbul ignore file */
 // constant needed for customRule0 to work
 const self = {}

package/docs/Decorators.md

@@ -137,9 +137,9 @@ As an example let's add a user property to the `Request` object:
 fastify.decorateRequest('user', '')
 
 // Update our property
-fastify.addHook('preHandler', (req, reply, next) => {
+fastify.addHook('preHandler', (req, reply, done) => {
   req.user = 'Bob Dylan'
-  next()
+  done()
 })
 // And finally access it
 fastify.get('/', (req, reply) => {

package/docs/Ecosystem.md

@@ -47,7 +47,9 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 
 - [`apollo-server-fastify`](https://github.com/apollographql/apollo-server/tree/master/packages/apollo-server-fastify) Run an [Apollo Server](https://github.com/apollographql/apollo-server) to serve GraphQL with Fastify.
 - [`arecibo`](https://github.com/nucleode/arecibo) Fastify ping responder for Kubernetes Liveness and Readiness Probes.
+- [`cls-rtracer`](https://github.com/puzpuzpuz/cls-rtracer) Fastify middleware for CLS-based request id generation. An out-of-the-box solution for adding request ids into your logs.
 - [`fastify-405`](https://github.com/Eomm/fastify-405) Fastify plugin that adds 405 HTTP status to your routes
+- [`fastify-amqp`](https://github.com/RafaelGSS/fastify-amqp) Fastify AMQP connection plugin, to use with RabbitMQ or another connector. Just a wrapper to [`amqplib`](https://github.com/squaremo/amqp.node).
 - [`fastify-angular-universal`](https://github.com/exequiel09/fastify-angular-universal) Angular server-side rendering support using [`@angular/platform-server`](https://github.com/angular/angular/tree/master/packages/platform-server) for Fastify
 - [`fastify-babel`](https://github.com/cfware/fastify-babel) Fastify plugin for development servers which require babel transformations of JavaScript sources.
 - [`fastify-blipp`](https://github.com/PavelPolyakov/fastify-blipp) Prints your routes to the console, so you definitely know which endpoints are available.
@@ -88,16 +90,18 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-mongoose-driver`](https://github.com/alex-ppg/fastify-mongoose) Fastify Mongoose plugin that connects to a MongoDB via the Mongoose plugin with support for Models.
 - [`fastify-multer`](https://github.com/fox1t/multer) Multer is a plugin for handling multipart/form-data, which is primarily used for uploading files.
 - [`fastify-nats`](https://github.com/mahmed8003/fastify-nats) Plugin to share [NATS](http://nats.io) client across Fastify.
+- [`fastify-no-additional-properties`](https://github.com/greguz/fastify-no-additional-properties) Add `additionalProperties: false` by default to your JSON Schemas.
 - [`fastify-no-icon`](https://github.com/jsumners/fastify-no-icon) Plugin to eliminate thrown errors for `/favicon.ico` requests.
 - [`fastify-nodemailer`](https://github.com/lependu/fastify-nodemailer) Plugin to share [nodemailer](http://nodemailer.com) transporter across Fastify.
 - [`fastify-normalize-request-reply`](https://github.com/ericrglass/fastify-normalize-request-reply) Plugin to normalize the request and reply to the Express version 4.x request and response, which allows use of middleware, like swagger-stats, that was originally written for Express.
-- [`fastify-nuxt`](https://github.com/lyquocnam/fastify-nuxt) VueJS server side rendering support for Fastify with [`NuxtJS`](https://nuxtjs.org/)
 - [`fastify-oas`](https://gitlab.com/m03geek/fastify-oas) Generates OpenAPI 3.0+ documentation from routes schemas for Fastify.
 - [`fastify-openapi-glue`](https://github.com/seriousme/fastify-openapi-glue) Glue for Open Api specifications in Fastify, autogenerates routes based on an Open Api Specification
 - [`fastify-oracle`](https://github.com/cemremengu/fastify-oracle) Attaches an [`oracledb`](https://github.com/oracle/node-oracledb) connection pool to a Fastify server instance.
 - [`fastify-orientdb`](https://github.com/mahmed8003/fastify-orientdb) Fastify OrientDB connection plugin, with which you can share the OrientDB connection across every part of your server.
+- [`fastify-rbac`](https://gitlab.com/m03geek/fastify-rbac) Fastify role-based access control plugin.
 - [`fastify-register-routes`](https://github.com/israeleriston/fastify-register-routes) Plugin to automatically load routes from a specified path and optionally limit loaded file names by a regular expression.
 - [`fastify-response-time`](https://github.com/lolo32/fastify-response-time) Add `X-Response-Time` header at each request for Fastify, in milliseconds.
+- [`fastify-reverse-routes`](https://github.com/dimonnwc3/fastify-reverse-routes) Fastify reverse routes plugin, allows to defined named routes and build path using name and parameters.
 - [`fastify-rob-config`](https://github.com/jeromemacias/fastify-rob-config) Fastify Rob-Config integration.
 - [`fastify-schema-constraint`](https://github.com/Eomm/fastify-schema-constraint) Choose the JSON schema to use based on request parameters.
 - [`fastify-sentry`](https://github.com/alex-ppg/fastify-sentry) Fastify plugin to add the Sentry SDK error handler to requests.

package/docs/Fluent-Schema.md

@@ -41,11 +41,12 @@ const paramsJsonSchema = S.object()
 const headersJsonSchema = S.object()
   .prop('x-foo', S.string().required())
 
+// note that there is no need to call `.valueOf()`!
 const schema = {
-  body: bodyJsonSchema.valueOf(),
-  querystring: queryStringJsonSchema.valueOf(),
-  params: paramsJsonSchema.valueOf(),
-  headers: headersJsonSchema.valueOf()
+  body: bodyJsonSchema,
+  querystring: queryStringJsonSchema, // (or) query: queryStringJsonSchema
+  params: paramsJsonSchema,
+  headers: headersJsonSchema
 }
 
 fastify.post('/the/url', { schema }, handler)
@@ -69,20 +70,17 @@ const addressSchema = S.object()
   .prop('country').required()
   .prop('city').required()
   .prop('zipcode').required()
-  .valueOf()
 
 const commonSchemas = S.object()
   .id('https://fastify/demo')
   .definition('addressSchema', addressSchema)
   .definition('otherSchema', otherSchema) // you can add any schemas you need
-  .valueOf()
 
 fastify.addSchema(commonSchemas)
 
 const bodyJsonSchema = S.object()
   .prop('residence', S.ref('https://fastify/demo#address')).required()
   .prop('office', S.ref('https://fastify/demo#/definitions/addressSchema')).required()
-  .valueOf()
 
 const schema = { body: bodyJsonSchema }
 

package/docs/Hooks.md

@@ -18,44 +18,44 @@ By using the hooks you can interact directly inside the lifecycle of Fastify. Th
 
 Example:
 ```js
-fastify.addHook('onRequest', (request, reply, next) => {
+fastify.addHook('onRequest', (request, reply, done) => {
   // some code
-  next()
+  done()
 })
 
-fastify.addHook('preParsing', (request, reply, next) => {
+fastify.addHook('preParsing', (request, reply, done) => {
   // some code
-  next()
+  done()
 })
 
-fastify.addHook('preValidation', (request, reply, next) => {
+fastify.addHook('preValidation', (request, reply, done) => {
   // some code
-  next()
+  done()
 })
 
-fastify.addHook('preHandler', (request, reply, next) => {
+fastify.addHook('preHandler', (request, reply, done) => {
   // some code
-  next()
+  done()
 })
 
-fastify.addHook('preSerialization', (request, reply, payload, next) => {
+fastify.addHook('preSerialization', (request, reply, payload, done) => {
   // some code
-  next()
+  done()
 })
 
-fastify.addHook('onError', (request, reply, error, next) => {
+fastify.addHook('onError', (request, reply, error, done) => {
   // some code
-  next()
+  done()
 })
 
-fastify.addHook('onSend', (request, reply, payload, next) => {
+fastify.addHook('onSend', (request, reply, payload, done) => {
   // some code
-  next()
+  done()
 })
 
-fastify.addHook('onResponse', (request, reply, next) => {
+fastify.addHook('onResponse', (request, reply, done) => {
   // some code
-  next()
+  done()
 })
 ```
 Or `async/await`
@@ -136,29 +136,29 @@ fastify.addHook('onResponse', async (request, reply) => {
 })
 ```
 
-**Notice:** the `next` callback is not available when using `async`/`await` or returning a `Promise`. If you do invoke a `next` callback in this situation unexpected behavior may occur, e.g. duplicate invocation of handlers.
+**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/>
-`next` is the function to continue with the [lifecycle](https://github.com/fastify/fastify/blob/master/docs/Lifecycle.md).
+`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 `next()` and Fastify will automatically close the request and send the appropriate error code to the user.
+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, next) => {
-  next(new Error('some error'))
+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, next) => {
+fastify.addHook('preHandler', (request, reply, done) => {
   reply.code(400)
-  next(new Error('some error'))
+  done(new Error('some error'))
 })
 ```
 
@@ -169,13 +169,13 @@ fastify.addHook('preHandler', (request, reply, next) => {
 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 `next` function is not supported.
+**Notice:** unlike the other hooks, pass an error to the `done` function is not supported.
 
 ```js
-fastify.addHook('onError', (request, reply, error, next) => {
+fastify.addHook('onError', (request, reply, error, done) => {
   // apm stands for Application Performance Monitoring
   apm.sendError(error)
-  next()
+  done()
 })
 
 // Or async
@@ -190,10 +190,10 @@ fastify.addHook('onError', async (request, reply, error) => {
 If you are using the `preSerialization` hook, you can change (or replace) the payload before it is serialized. For example:
 
 ```js
-fastify.addHook('preSerialization', (request, reply, payload, next) => {
+fastify.addHook('preSerialization', (request, reply, payload, done) => {
   var err = null;
   var newPayload = {wrapped: payload }
-  next(err, newPayload)
+  done(err, newPayload)
 })
 
 // Or async
@@ -209,10 +209,10 @@ Note: the hook is NOT called if the payload is  a `string`, a `Buffer`, a `strea
 If you are using the `onSend` hook, you can change the payload. For example:
 
 ```js
-fastify.addHook('onSend', (request, reply, payload, next) => {
+fastify.addHook('onSend', (request, reply, payload, done) => {
   var err = null;
   var newPayload = payload.replace('some-text', 'some-new-text')
-  next(err, newPayload)
+  done(err, newPayload)
 })
 
 // Or async
@@ -225,10 +225,10 @@ fastify.addHook('onSend', async (request, reply, payload) => {
 You can also clear the payload to send a response with an empty body by replacing the payload with `null`:
 
 ```js
-fastify.addHook('onSend', (request, reply, payload, next) => {
+fastify.addHook('onSend', (request, reply, payload, done) => {
   reply.code(304)
   const newPayload = null
-  next(null, newPayload)
+  done(null, newPayload)
 })
 ```
 
@@ -243,7 +243,7 @@ The `onResponse` hook is executed when a response has been sent, so you will not
 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`.
 
 ```js
-fastify.addHook('onRequest', (request, reply, next) => {
+fastify.addHook('onRequest', (request, reply, done) => {
   reply.send('early response')
 })
 
@@ -256,7 +256,7 @@ fastify.addHook('preHandler', async (request, reply) => {
 If you want to respond with a stream, you should avoid using an `async` function for the hook. If you must use an `async` function, your code will need to follow the pattern in [test/hooks-async.js](https://github.com/fastify/fastify/blob/94ea67ef2d8dce8a955d510cd9081aabd036fa85/test/hooks-async.js#L269-L275).
 
 ```js
-fastify.addHook('onRequest', (request, reply, next) => {
+fastify.addHook('onRequest', (request, reply, done) => {
   const stream = fs.createReadStream('some-file', 'utf8')
   reply.send(stream)
 })
@@ -330,16 +330,16 @@ fastify.addHook('onRegister', (instance) => {
 Except for [Application Hooks](#application-hooks), all hooks are encapsulated. This means that you can decide where your hooks should run by using `register` as explained in the [plugins guide](https://github.com/fastify/fastify/blob/master/docs/Plugins-Guide.md). If you pass a function, that function is bound to the right Fastify context and from there you have full access to the Fastify API.
 
 ```js
-fastify.addHook('onRequest', function (request, reply, next) {
+fastify.addHook('onRequest', function (request, reply, done) {
   const self = this // Fastify context
-  next()
+  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.
+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.
 Multiple route-level hooks can also be specified as an array.
@@ -367,7 +367,7 @@ fastify.addHook('preHandler', (request, reply, done) => {
   done()
 })
 
-fastify.addHook('preSerialization', (request, reply, done) => {
+fastify.addHook('preSerialization', (request, reply, payload, done) => {
   // your code
   done()
 })
@@ -398,9 +398,9 @@ fastify.route({
   //   // this hook will always be executed after the shared `preHandler` hooks
   //   done()
   // }],
-  preSerialization: (request, reply, payload, next) => {
+  preSerialization: (request, reply, payload, done) => {
     // manipulate the payload
-    next(null, payload)
+    done(null, payload)
   },
   handler: function (request, reply) {
     reply.send({ hello: 'world' })

package/docs/Logging.md

@@ -71,7 +71,7 @@ const fastify = require('fastify')({
   }
 })
 ```
-For example, the response payload and headers could be logged using the approach below (even if it is *not* recommended*):
+For example, the response payload and headers could be logged using the approach below (even if it is *not recommended*):
 
 ```js
 const fastify = require('fastify')({
@@ -90,11 +90,10 @@ const fastify = require('fastify')({
           url: req.url,
           path: req.path,
           parameters: req.parameters,
-          // Including the body and headers in the log could be in violation 
+          // Including the headers in the log could be in violation 
           // of privacy laws, e.g. GDPR. You should use the "redact" option to
           // remove sensitive fields. It could also leak authentication data in
           // the logs.
-          body: req.body,
           headers: req.headers
         };
       }
@@ -102,6 +101,19 @@ 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`
+
+```js
+app.addHook('preHandler', function (req, reply, done) {
+  if (req.body) {
+    req.log.info({ body: req.body }, 'parsed body')
+  }
+  done()
+})
+```
+
 
 *This option will be ignored by any logger other than Pino.*
 

package/docs/Plugins-Guide.md

@@ -35,20 +35,20 @@ Fastify helps you a lot in this direction, because thanks to the encapsulation m
 *Let's return to how to correctly use `register`.*<br>
 As you probably know, the required plugins must expose a single function with the following signature
 ```js
-module.exports = function (fastify, options, next) {}
+module.exports = function (fastify, options, done) {}
 ```
-Where `fastify` is (pretty obvious) the encapsulated Fastify instance, `options` is the options object and `next` is the function you **must** call when your plugin is ready.
+Where `fastify` is (pretty obvious) the encapsulated Fastify instance, `options` is the options object and `done` is the function you **must** call when your plugin is ready.
 
 Fastify's plugin model is fully reentrant and graph-based, it handles without any kind of problem asynchronous code and it guarantees the load order of the plugins, even the close order! *How?* Glad you asked, checkout [`avvio`](https://github.com/mcollina/avvio)! Fastify starts loading the plugin __after__ `.listen()`, `.inject()` or `.ready()` are called.
 
-Inside a plugin you can do whatever you want, register routes, utilities (we'll see this in a moment) and do nested registers, just remember to call `next` when everything is set up!
+Inside a plugin you can do whatever you want, register routes, utilities (we'll see this in a moment) and do nested registers, just remember to call `done` when everything is set up!
 ```js
-module.exports = function (fastify, options, next) {
+module.exports = function (fastify, options, done) {
   fastify.get('/plugin', (request, reply) => {
     reply.send({ hello: 'world' })
   })
 
-  next()
+  done()
 }
 ```
 
@@ -77,38 +77,38 @@ fastify.decorate('util', (a, b) => a + b)
 Now you can access your utility just by doing `fastify.util` whenever you need it, even inside your test.<br>
 And here's starts the magic; do you remember that few lines above we talked about encapsulation? Well, using `register` and `decorate` in conjunction enable exactly that, let me show you an example to clarify this:
 ```js
-fastify.register((instance, opts, next) => {
+fastify.register((instance, opts, done) => {
   instance.decorate('util', (a, b) => a + b)
   console.log(instance.util('that is ', ' awesome'))
 
-  next()
+  done()
 })
 
-fastify.register((instance, opts, next) => {
+fastify.register((instance, opts, done) => {
   console.log(instance.util('that is ', ' awesome')) // this will throw an error
 
-  next()
+  done()
 })
 ```
 Inside the second register call `instance.util` will throw an error, because `util` exists only inside the first register context.<br>
 Let's step back for a moment and get deeper on this: when using the `register` api you will create a new context every time and this avoids situations like the one mentioned few line above. But pay attention, the encapsulation works only for the ancestors and the brothers, but not for the sons.
 ```js
-fastify.register((instance, opts, next) => {
+fastify.register((instance, opts, done) => {
   instance.decorate('util', (a, b) => a + b)
   console.log(instance.util('that is ', ' awesome'))
 
-  fastify.register((instance, opts, next) => {
+  fastify.register((instance, opts, done) => {
     console.log(instance.util('that is ', ' awesome')) // this will not throw an error
-    next()
+    done()
   })
 
-  next()
+  done()
 })
 
-fastify.register((instance, opts, next) => {
+fastify.register((instance, opts, done) => {
   console.log(instance.util('that is ', ' awesome')) // this will throw an error
 
-  next()
+  done()
 })
 ```
 *Take home message: if you need that an utility is available in every part of your application, pay attention that is declared at the root scope of your application. Otherwise you can use `fastify-plugin` utility as described [here](#distribution).*
@@ -214,7 +214,7 @@ Now for every request you will run your utility, it is obvious that you can regi
 It can happen that you want a hook that must be executed just for a subset of routes, how can you do that?  Yep, encapsulation!
 
 ```js
-fastify.register((instance, opts, next) => {
+fastify.register((instance, opts, done) => {
   instance.decorate('util', (request, key, value) => { request[key] = value })
 
   instance.addHook('preHandler', (request, reply, done) => {
@@ -226,7 +226,7 @@ fastify.register((instance, opts, next) => {
     reply.send(request)
   })
 
-  next()
+  done()
 })
 
 fastify.get('/plugin2', (request, reply) => {
@@ -260,10 +260,10 @@ Yes, I said that. But what I didn't tell you, is that you can tell to Fastify to
 const fp = require('fastify-plugin')
 const dbClient = require('db-client')
 
-function dbPlugin (fastify, opts, next) {
+function dbPlugin (fastify, opts, done) {
   dbClient.connect(opts.url, (err, conn) => {
     fastify.decorate('db', conn)
-    next()
+    done()
   })
 }
 
@@ -279,10 +279,10 @@ const fastify = require('fastify')()
 const fp = require('fastify-plugin')
 const dbClient = require('db-client')
 
-function dbPlugin (fastify, opts, next) {
+function dbPlugin (fastify, opts, done) {
   dbClient.connect(opts.url, (err, conn) => {
     fastify.decorate('db', conn)
-    next()
+    done()
   })
 }
 

package/docs/Plugins.md

@@ -45,10 +45,10 @@ The `options` parameter can also be a `Function` which will be evaluated at the
 ```js
 const fp = require('fastify-plugin')
 
-fastify.register(fp((fastify, opts, next) => {
+fastify.register(fp((fastify, opts, done) => {
   fastify.decorate('foo_bar', { hello: 'world' })
 
-  next()
+  done()
 }))
 
 // The opts argument of fastify-foo will be { hello: 'world' }
@@ -97,27 +97,27 @@ await fastify.listen(3000)
 ```
 <a name="create-plugin"></a>
 ### Create a plugin
-Creating a plugin is very easy, you just need to create a function that takes three parameters, the `fastify` instance, an options object and the next callback.<br>
+Creating a plugin is very easy, you just need to create a function that takes three parameters, the `fastify` instance, an `options` object and the `done` callback.<br>
 Example:
 ```js
-module.exports = function (fastify, opts, next) {
+module.exports = function (fastify, opts, done) {
   fastify.decorate('utility', () => {})
 
   fastify.get('/', handler)
 
-  next()
+  done()
 }
 ```
 You can also use `register` inside another `register`:
 ```js
-module.exports = function (fastify, opts, next) {
+module.exports = function (fastify, opts, done) {
   fastify.decorate('utility', () => {})
 
   fastify.get('/', handler)
 
   fastify.register(require('./other-plugin'))
 
-  next()
+  done()
 }
 ```
 Sometimes, you will need to know when the server is about to close, for example because you must close a connection to a database. To know when this is going to happen, you can use the [`'onClose'`](https://github.com/fastify/fastify/blob/master/docs/Hooks.md#on-close) hook.
@@ -136,18 +136,18 @@ We recommend to using the `fastify-plugin` module, because it solves this proble
 ```js
 const fp = require('fastify-plugin')
 
-module.exports = fp(function (fastify, opts, next) {
+module.exports = fp(function (fastify, opts, done) {
   fastify.decorate('utility', () => {})
-  next()
+  done()
 }, '0.x')
 ```
 Check the [`fastify-plugin`](https://github.com/fastify/fastify-plugin) documentation to know more about how use this module.
 
 If you don't use the `fastify-plugin` module, you can use the `'skip-override'` hidden property, but we do not recommend it. If in the future the Fastify API changes it will be a your responsibility update the module, while if you use `fastify-plugin`, you can be sure about backwards compatibility.
 ```js
-function yourPlugin (fastify, opts, next) {
+function yourPlugin (fastify, opts, done) {
   fastify.decorate('utility', () => {})
-  next()
+  done()
 }
 yourPlugin[Symbol.for('skip-override')] = true
 module.exports = yourPlugin

package/docs/Reply.md

@@ -10,6 +10,7 @@
   - [.hasHeader(key)](#hasheaderkey)
   - [.redirect(dest)](#redirectdest)
   - [.callNotFound()](#callnotfound)
+  - [.getResponseTime()](#getresponsetime)
   - [.type(contentType)](#typecontenttype)
   - [.serializer(func)](#serializerfunc)
   - [.sent](#sent)
@@ -109,6 +110,14 @@ Invokes the custom not found handler.
 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.
+
+```js
+const milliseconds = reply.getResponseTime()
+```
+
 <a name="type"></a>
 ### .type(contentType)
 Sets the content type for the response.
@@ -274,17 +283,15 @@ The type of the sent payload (after serialization and going through any [`onSend
 Fastify natively handles promises and supports async-await.<br>
 *Note that in the following examples we are not using reply.send.*
 ```js
+const delay = promisify(setTimeout)
+
 fastify.get('/promises', options, function (request, reply) {
-  return new Promise(function (resolve) {
-    setTimeout(resolve, 200, { hello: 'world' })
-  })
+ return delay(200).then(() => { return { hello: 'world' }})
 })
 
 fastify.get('/async-await', options, async function (request, reply) {
-  var res = await new Promise(function (resolve) {
-    setTimeout(resolve, 200, { hello: 'world' })
-  })
-  return res
+  await delay(200)
+  return { hello: 'world' }
 })
 ```