fastify 2.7.1 → 2.11.0

package/README.md

@@ -4,8 +4,11 @@
 
 <div align="center">
 
-[![Build Status](https://travis-ci.org/fastify/fastify.svg?branch=master)](https://travis-ci.org/fastify/fastify)
-[![Build Status](https://dev.azure.com/fastify/fastify/_apis/build/status/fastify.fastify)](https://dev.azure.com/fastify/fastify/_build/latest?definitionId=1) [![Known Vulnerabilities](https://snyk.io/test/github/fastify/fastify/badge.svg)](https://snyk.io/test/github/fastify/fastify)
+![](https://github.com/fastify/fastify/workflows/ci/badge.svg)
+![](https://github.com/fastify/fastify/workflows/package-manager-ci/badge.svg)
+![](https://github.com/fastify/fastify/workflows/website/badge.svg)
+[![Build Status](https://dev.azure.com/fastify/fastify/_apis/build/status/fastify.fastify)](https://dev.azure.com/fastify/fastify/_build/latest?definitionId=1)
+[![Known Vulnerabilities](https://snyk.io/test/github/fastify/fastify/badge.svg)](https://snyk.io/test/github/fastify/fastify)
 [![Coverage Status](https://coveralls.io/repos/github/fastify/fastify/badge.svg?branch=master)](https://coveralls.io/github/fastify/fastify?branch=master)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)
 
@@ -145,10 +148,11 @@ matters to you.
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Server.md"><code><b>Server</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Routes.md"><code><b>Routes</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Logging.md"><code><b>Logging</b></code></a>
-* <a href="https://github.com/fastify/fastify/blob/master/docs/Middlewares.md"><code><b>Middlewares</b></code></a>
+* <a href="https://github.com/fastify/fastify/blob/master/docs/Middleware.md"><code><b>Middleware</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Hooks.md"><code><b>Hooks</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Decorators.md"><code><b>Decorators</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md"><code><b>Validation and Serialization</b></code></a>
+* <a href="https://github.com/fastify/fastify/blob/master/docs/Fluent-Schema.md"><code><b>Fluent Schema</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Lifecycle.md"><code><b>Lifecycle</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Reply.md"><code><b>Reply</b></code></a>
 * <a href="https://github.com/fastify/fastify/blob/master/docs/Request.md"><code><b>Request</b></code></a>
@@ -190,11 +194,11 @@ Team members are listed in alphabetical order.
 * [__Matteo Collina__](https://github.com/mcollina), <https://twitter.com/matteocollina>, <https://www.npmjs.com/~matteo.collina>
 * [__Tomas Della Vedova__](https://github.com/delvedor), <https://twitter.com/delvedor>, <https://www.npmjs.com/~delvedor>
 * [__Dustin Deus__](https://github.com/StarpTech), <https://twitter.com/dustindeus>, <https://www.npmjs.com/~starptech>
+* [__Denis Fäcke__](https://github.com/SerayaEryn), <https://twitter.com/serayaeryn>, <https://www.npmjs.com/~serayaeryn>
 * [__Luciano Mammino__](https://github.com/lmammino), <https://twitter.com/loige>, <https://www.npmjs.com/~lmammino>
 * [__Cemre Mengu__](https://github.com/cemremengu), <https://twitter.com/cemremengu>, <https://www.npmjs.com/~cemremengu>
 * [__Manuel Spigolon__](https://github.com/eomm), <https://twitter.com/manueomm>, <https://www.npmjs.com/~eomm>
 * [__James Sumners__](https://github.com/jsumners), <https://twitter.com/jsumners79>, <https://www.npmjs.com/~jsumners>
-* [__Nathan Woltman__](https://github.com/nwoltman), <https://twitter.com/NathanWoltman>, <https://www.npmjs.com/~nwoltman>
 
 ### Fastify Plugins team
 * [__Matteo Collina__](https://github.com/mcollina), <https://twitter.com/matteocollina>, <https://www.npmjs.com/~matteo.collina>
@@ -210,6 +214,13 @@ Great contributors on a specific area in the Fastify ecosystem will be invited t
 **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>
+* [__Nathan Woltman__](https://github.com/nwoltman), <https://twitter.com/NathanWoltman>, <https://www.npmjs.com/~nwoltman>
+
+## Hosted by
+
+[<img src="https://github.com/openjs-foundation/cross-project-council/blob/master/logos/openjsf-color.png?raw=true" width="250px;"/>](https://openjsf.org/projects/#incubating)
+
+We are currently an [incubated project](https://openjsf.org/blog/2019/11/20/web-framework-fastify-joins-openjs-foundation-as-an-incubating-project/) at the OpenJS Foundation.
 
 ## Acknowledgements
 

package/build/build-validation.js

@@ -15,9 +15,12 @@ const ajv = new Ajv({
 const defaultInitOptions = {
   bodyLimit: 1024 * 1024, // 1 MiB
   caseSensitive: true,
+  disableRequestLogging: false,
   ignoreTrailingSlash: false,
   maxParamLength: 100,
   onProtoPoisoning: 'error',
+  // TODO v3: default should be 'error'
+  onConstructorPoisoning: 'ignore',
   pluginTimeout: 10000,
   requestIdHeader: 'request-id',
   requestIdLogLabel: 'reqId'
@@ -62,8 +65,13 @@ const schema = {
       then: { setDefaultValue: true }
     },
     ignoreTrailingSlash: { type: 'boolean', default: defaultInitOptions.ignoreTrailingSlash },
+    disableRequestLogging: {
+      type: 'boolean',
+      default: false
+    },
     maxParamLength: { type: 'integer', default: defaultInitOptions.maxParamLength },
     onProtoPoisoning: { type: 'string', default: defaultInitOptions.onProtoPoisoning },
+    onConstructorPoisoning: { type: 'string', default: defaultInitOptions.onConstructorPoisoning },
     pluginTimeout: { type: 'integer', default: defaultInitOptions.pluginTimeout },
     requestIdHeader: { type: 'string', default: defaultInitOptions.requestIdHeader },
     requestIdLogLabel: { type: 'string', default: defaultInitOptions.requestIdLogLabel }

package/docs/Benchmarking.md

@@ -1,13 +1,13 @@
 <h1 align="center">Fastify</h1>
 
 ## Benchmarking
-Benchmarking is important if you want to measure how a change can impact your application performance. We provide a simple way to benchmark your application from the point of view of a user and contributor. The setup allows you to automate benchmarks in different branches on different Node.js versions.
+Benchmarking is important if you want to measure how a change can impact the performance of your application. We provide a simple way to benchmark your application from the point of view of a user and contributor. The setup allows you to automate benchmarks in different branches and on different Node.js versions.
 
 The modules we'll use:
 - [Autocannon](https://github.com/mcollina/autocannon): A HTTP/1.1 benchmarking tool written in node.
 - [Branch-comparer](https://github.com/StarpTech/branch-comparer): Checkout multiple git branches, execute scripts and log the results.
 - [Concurrently](https://github.com/kimmobrunfeldt/concurrently): Run commands concurrently.
-- [Npx](https://github.com/zkat/npx) NPM package runner - We using it to run scripts against different Node.js Versions and execute local binaries. Shipped with npm@5.2.0.
+- [Npx](https://github.com/zkat/npx) NPM package runner - We are using it to run scripts against different Node.js Versions and to execute local binaries. Shipped with npm@5.2.0.
 
 ## Simple
 

package/docs/ContentTypeParser.md

@@ -1,11 +1,11 @@
 <h1 align="center">Fastify</h1>
 
-## Content Type Parser
+## `Content-Type` Parser
 Natively, Fastify only supports `'application/json'` and `'text/plain'` content types. The default charset is `utf-8`. If you need to support different content types, you can use the `addContentTypeParser` API. *The default JSON and/or plain text parser can be changed.*
 
-As with the other APIs, `addContentTypeParser` is encapsulated in the scope in which it is declared. This means that if you declare it in the root scope it will be available everywhere, while if you declare it inside a register it will be available only in that scope and its children.
+As with the other APIs, `addContentTypeParser` is encapsulated in the scope in which it is declared. This means that if you declare it in the root scope it will be available everywhere, while if you declare it inside a plugin it will be available only in that scope and its children.
 
-Fastify adds automatically the parsed request payload to the [Fastify request](https://github.com/fastify/fastify/blob/master/docs/Request.md) object, you can reach it with `request.body`.
+Fastify automatically adds the parsed request payload to the [Fastify request](https://github.com/fastify/fastify/blob/master/docs/Request.md) object which you can access with `request.body`.
 
 ### Usage
 ```js
@@ -14,13 +14,15 @@ fastify.addContentTypeParser('application/jsoff', function (req, done) {
     done(err, body)
   })
 })
-// handle multiple content types as the same
+
+// Handle multiple content types with the same function
 fastify.addContentTypeParser(['text/xml', 'application/xml'], function (req, done) {
   xmlParser(req, function (err, body) {
     done(err, body)
   })
 })
-// async also supported in Node versions >= 8.0.0
+
+// Async is also supported in Node versions >= 8.0.0
 fastify.addContentTypeParser('application/jsoff', async function (req) {
   var res = await new Promise((resolve, reject) => resolve(req))
   return res
@@ -32,13 +34,13 @@ You can also use the `hasContentTypeParser` API to find if a specific content ty
 ```js
 if (!fastify.hasContentTypeParser('application/jsoff')){
   fastify.addContentTypeParser('application/jsoff', function (req, done) {
-    //code to parse request body /payload for given content type
+    // Code to parse request body/payload for the given content type
   })
 }
 ```
 
 #### Body Parser
-You can parse the body of the request in two ways. The first one is shown above: you add a custom content type parser and handle the request stream. In the second one you should pass a `parseAs` option to the `addContentTypeParser` API, where you declare how you want to get the body, it could be `'string'` or `'buffer'`. If you use the `parseAs` option Fastify will internally handle the stream and perform some checks, such as the [maximum size](https://github.com/fastify/fastify/blob/master/docs/Server.md#factory-body-limit) of the body and the content length. If the limit is exceeded the custom parser will not be invoked.
+You can parse the body of a request in two ways. The first one is shown above: you add a custom content type parser and handle the request stream. In the second one, you should pass a `parseAs` option to the `addContentTypeParser` API, where you declare how you want to get the body. It could be of type `'string'` or `'buffer'`. If you use the `parseAs` option, Fastify will internally handle the stream and perform some checks, such as the [maximum size](https://github.com/fastify/fastify/blob/master/docs/Server.md#factory-body-limit) of the body and the content length. If the limit is exceeded the custom parser will not be invoked.
 ```js
 fastify.addContentTypeParser('application/json', { parseAs: 'string' }, function (req, body, done) {
   try {
@@ -58,8 +60,8 @@ See [`example/parser.js`](https://github.com/fastify/fastify/blob/master/example
 + `parseAs` (string): Either `'string'` or `'buffer'` to designate how the incoming data should be collected. Default: `'buffer'`.
 + `bodyLimit` (number): The maximum payload size, in bytes, that the custom parser will accept. Defaults to the global body limit passed to the [`Fastify factory function`](https://github.com/fastify/fastify/blob/master/docs/Server.md#bodylimit).
 
-#### Catch All
-There are some cases where you need to catch all requests regardless of their content type. With Fastify, you just need to add the `'*'` content type.
+#### Catch-All
+There are some cases where you need to catch all requests regardless of their content type. With Fastify, you can just use the `'*'` content type.
 ```js
 fastify.addContentTypeParser('*', function (req, done) {
   var data = ''
@@ -70,7 +72,7 @@ fastify.addContentTypeParser('*', function (req, done) {
 })
 ```
 
-In this way, all of the requests that do not have a corresponding content type parser will be handled by the specified function.
+Using this, all requests that do not have a corresponding content type parser will be handled by the specified function.
 
 This is also useful for piping the request stream. You can define a content parser like:
 

package/docs/Decorators.md

@@ -2,9 +2,9 @@
 
 ## Decorators
 
-If you need to add functionality to the Fastify instance, the `decorate` API is what you need.
+If you need to add functionality to the Fastify instance, the `decorate` API is what you want.
 
-The API allows you to add new properties to the Fastify instance. A value is not restricted to a function and could also be an object or a string, for example.
+The API allows you to add new properties to the Fastify instance. Possible values are not restricted by type and could be functions, objects or strings, for example.
 
 <a name="usage"></a>
 ### Usage
@@ -13,11 +13,11 @@ The API allows you to add new properties to the Fastify instance. A value is not
 Just call the `decorate` API and pass the name of the new property and its value.
 ```js
 fastify.decorate('utility', () => {
-  // something very useful
+  // Something very useful
 })
 ```
 
-As said above, you can also decorate the instance with non-function values:
+As mentioned above, you can also decorate the instance with non-function values:
 ```js
 fastify.decorate('conf', {
   db: 'some.db',
@@ -25,7 +25,7 @@ fastify.decorate('conf', {
 })
 ```
 
-Once you decorate the instance, you can access the value by using the name you passed as a parameter:
+Once the instance was decorated, you can access the new value by using the name you passed as a parameter:
 ```js
 fastify.utility()
 
@@ -34,14 +34,14 @@ console.log(fastify.conf.db)
 
 <a name="decorate-reply"></a>
 **decorateReply**
-As the name suggests, this API is needed if you want to add new methods to the `Reply` core object. Just call the `decorateReply` API and pass the name of the new property and its value:
+As the name suggests, this API can be used to add new methods to the `Reply` core object. Just call the `decorateReply` API and pass the name of the new property and its value:
 ```js
 fastify.decorateReply('utility', function () {
-  // something very useful
+  // Something very useful
 })
 ```
 
-Note: using an arrow function will break the binding of `this` to the Fastify `reply` instance.
+Note: using an arrow function will break the binding of `this` to the Fastify `Reply` instance.
 
 <a name="decorate-request"></a>
 **decorateRequest**
@@ -52,12 +52,12 @@ fastify.decorateRequest('utility', function () {
 })
 ```
 
-Note: using an arrow function will break the binding of `this` to the Fastify `request` instance.
+Note: using an arrow function will break the binding of `this` to the Fastify `Request` instance.
 
 <a name="decorators-encapsulation"></a>
-#### Decorators and encapsulation
+#### Decorators and Encapsulation
 
-If you define a decorator (using decorate, decorateRequest or decorateReply) with the same name more than once in the same **encapsulated** plugin, fastify will throw an exception.
+If you define a decorator (using `decorate`, `decorateRequest` or `decorateReply`) with the same name more than once in the same **encapsulated** plugin, Fastify will throw an exception.
 
 As an example, the following will throw:
 
@@ -65,7 +65,7 @@ As an example, the following will throw:
 const server = require('fastify')()
 
 server.decorateReply('view', function (template, args) {
-  // Amazing view rendering engine.
+  // Amazing view rendering engine
 })
 
 server.get('/', (req, reply) => {
@@ -75,7 +75,7 @@ server.get('/', (req, reply) => {
 // Somewhere else in our codebase, we define another
 // view decorator. This throws.
 server.decorateReply('view', function (template, args) {
-  // another rendering engine
+  // Another rendering engine
 })
 
 server.listen(3000)
@@ -96,7 +96,7 @@ server.register(async function (server, opts) {
   // plugin. This will not throw as outside of this encapsulated
   // plugin view is the old one, while inside it is the new one.
   server.decorateReply('view', function (template, args) {
-    // another rendering engine
+    // Another rendering engine
   })
 
   server.get('/', (req, reply) => {

package/docs/Ecosystem.md

@@ -51,6 +51,8 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`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-auth0-verify`](https://github.com/nearform/fastify-auth0-verify): Auth0 verification plugin for Fastify, internally uses [fastify-jwt](https://npm.im/fastify-jwt) and [jsonwebtoken](https://npm.im/jsonwebtoken).
+- [`fastify-autocrud`](https://github.com/paranoiasystem/fastify-autocrud) Plugin for autogenerate CRUD routes as fast as possible.
 - [`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.
 - [`fastify-bookshelf`](https://github.com/butlerx/fastify-bookshelfjs) Fastify plugin to add [bookshelf.js](http://bookshelfjs.org/) orm support.
@@ -63,6 +65,7 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-decorators`](https://github.com/L2jLiga/fastify-decorators) Fastify plugin that provides the set of TypeScript decorators.
 - [`fastify-dynamodb`](https://github.com/matrus2/fastify-dynamodb) AWS DynamoDB plugin for Fastify. It exposes [AWS.DynamoDB.DocumentClient()](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html) object.
 - [`fastify-error-page`](https://github.com/hemerajs/fastify-error-page) Fastify plugin to print errors in structured HTML to the browser.
+- [`fastify-errors-properties`](https://github.com/ShogunPanda/fastify-errors-properties) A error handling plugin for Fastify that enables additional properties in errors.
 - [`fastify-favicon`](https://github.com/smartiniOnGitHub/fastify-favicon) Fastify plugin to serve default favicon.
 - [`fastify-feature-flags`](https://gitlab.com/m03geek/fastify-feature-flags) Fastify feature flags plugin with multiple providers support (e.g. env, [config](http://lorenwest.github.io/node-config/), [unleash](https://unleash.github.io/)).
 - [`fastify-file-upload`](https://github.com/huangang/fastify-file-upload) Fastify plugin for uploading files.
@@ -74,6 +77,7 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-healthcheck`](https://github.com/smartiniOnGitHub/fastify-healthcheck) Fastify plugin to serve an health check route and a probe script.
 - [`fastify-hemera`](https://github.com/hemerajs/fastify-hemera) Fastify Hemera plugin, for writing reliable & fault-tolerant microservices with [nats.io](https://nats.io/).
 - [`fastify-http2https`](https://github.com/lolo32/fastify-http2https) Redirect HTTP requests to HTTPS, both using the same port number, or different response on HTTP and HTTPS.
+- [`fastify-https-redirect`](https://github.com/tomsvogel/fastify-https-redirect) Fastify plugin for auto redirect from http to https
 - [`fastify-http-client`](https://github.com/kenuyx/fastify-http-client) Plugin to send HTTP(s) requests. Built upon [urllib](https://github.com/node-modules/urllib).
 - [`fastify-influxdb`](https://github.com/alex-ppg/fastify-influxdb) Fastify InfluxDB plugin connecting to an InfluxDB instance via the Influx default package.
 - [`fastify-jwt-authz`](https://github.com/Ethan-Arrowood/fastify-jwt-authz) JWT user scope verifier.
@@ -87,8 +91,9 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-markdown`](https://github.com/freezestudio/fastify-markdown) Plugin to markdown support.
 - [`fastify-metrics`](https://gitlab.com/m03geek/fastify-metrics) Plugin for exporting [Prometheus](https://prometheus.io) metrics.
 - [`fastify-mongo-memory`](https://github.com/chapuletta/fastify-mongo-memory) Fastify MongoDB in Memory Plugin for testing support.
+- [`fastify-mongoose-api`](https://github.com/jeka-kiselyov/fastify-mongoose-api) Fastify plugin to create REST API methods based on Mongoose MongoDB models.
 - [`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-multer`](https://github.com/fox1t/fastify-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.
@@ -98,6 +103,7 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`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-qs`](https://github.com/webdevium/fastify-qs) A plugin for Fastify that adds support for parsing URL query parameters with [qs](https://github.com/ljharb/qs).
 - [`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.

package/docs/Errors.md

@@ -6,12 +6,12 @@
 <a name="error-handling"></a>
 ### Error Handling
 
-Uncaught errors are likely to cause memory leaks, file descriptor leaks and other major production issues. [Domains](https://nodejs.org/en/docs/guides/domain-postmortem/) were introduced to try fixing this issue, but they did not. Given the fact that it is not possible to process all uncaught errors in a sensible way, the best way to deal with them at the moment is to [crash](https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly). In case of promises, make sure to [handle](https://nodejs.org/dist/latest-v8.x/docs/api/deprecations.html#deprecations_dep0018_unhandled_promise_rejections) errors [correctly](https://github.com/mcollina/make-promises-safe).
+Uncaught errors are likely to cause memory leaks, file descriptor leaks and other major production issues. [Domains](https://nodejs.org/en/docs/guides/domain-postmortem/) were introduced to try fixing this issue, but they did not. Given the fact that it is not possible to process all uncaught errors sensibly, the best way to deal with them at the moment is to [crash](https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly). In case of promises, make sure to [handle](https://nodejs.org/dist/latest-v8.x/docs/api/deprecations.html#deprecations_dep0018_unhandled_promise_rejections) errors [correctly](https://github.com/mcollina/make-promises-safe).
 
 Fastify follows an all-or-nothing approach and aims to be lean and optimal as much as possible. Thus, the developer is responsible for making sure that the errors are handled properly. Most of the errors are usually a result of unexpected input data, so we recommend specifying a [JSON.schema validation](https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md) for your input data.
 
-Note that Fastify doesn't catch uncaught errors within callback based routes for you, so any uncaught errors will result in a crash.
-If routes are declared as `async` though - the error will safely be caught by the promise and routed to the default error handler of Fastify for a generic `Internal Server Error` response. For customizing this behavior, you should use [setErrorHandler](https://github.com/fastify/fastify/blob/master/docs/Server.md#seterrorhandler).
+Note that Fastify doesn't catch uncaught errors within callback-based routes for you, so any uncaught errors will result in a crash.
+If routes are declared as `async` though - the error will safely be caught by the promise and routed to the default error handler of Fastify for a generic `Internal Server Error` response. For customizing this behaviour, you should use [setErrorHandler](https://github.com/fastify/fastify/blob/master/docs/Server.md#seterrorhandler).
 
 <a name="fastify-error-codes"></a>
 ### Fastify Error Codes
@@ -24,7 +24,7 @@ The parser for this content type was already registered.
 <a name="FST_ERR_CTP_INVALID_TYPE"></a>
 #### FST_ERR_CTP_INVALID_TYPE
 
-The content type should be a string.
+The `Content-Type` should be a string.
 
 <a name="FST_ERR_CTP_EMPTY_TYPE"></a>
 #### FST_ERR_CTP_EMPTY_TYPE
@@ -44,12 +44,12 @@ The provided parse type is not supported. Accepted values are `string` or `buffe
 <a name="FST_ERR_CTP_BODY_TOO_LARGE"></a>
 #### FST_ERR_CTP_BODY_TOO_LARGE
 
-Request body is larger than the provided limit.
+The request body is larger than the provided limit.
 
 <a name="FST_ERR_CTP_INVALID_MEDIA_TYPE"></a>
 #### FST_ERR_CTP_INVALID_MEDIA_TYPE
 
-Received media type is not supported (i.e. there is no suitable content-type parser for it).
+The received media type is not supported (i.e. there is no suitable `Content-Type` parser for it).
 
 <a name="FST_ERR_CTP_INVALID_CONTENT_LENGTH"></a>
 #### FST_ERR_CTP_INVALID_CONTENT_LENGTH
@@ -79,7 +79,7 @@ The hook callback must be a function.
 <a name="FST_ERR_LOG_INVALID_DESTINATION"></a>
 #### FST_ERR_LOG_INVALID_DESTINATION
 
-Logger acceptes either a `'stream'` or a `'file'` as the destination.
+The logger accepts either a `'stream'` or a `'file'` as the destination.
 
 <a id="FST_ERR_REP_ALREADY_SENT"></a>
 ### FST_ERR_REP_ALREADY_SENT
@@ -111,7 +111,12 @@ A schema with the same `$id` already exists.
 
 No schema with the provided `$id` exists.
 
+<a name="FST_ERR_SCH_BUILD"></a>
+#### FST_ERR_SCH_BUILD
+
+The JSON schema provided to one route is not valid.
+
 <a name="FST_ERR_PROMISE_NOT_FULLFILLED"></a>
 #### FST_ERR_PROMISE_NOT_FULLFILLED
 
-Promise may not be fulfilled with 'undefined' when statusCode is not 204.
+A promise may not be fulfilled with 'undefined' when statusCode is not 204.

package/docs/Fluent-Schema.md

@@ -2,19 +2,16 @@
 
 ## Fluent Schema
 
-The [Validation and Serialization](https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md)
-has explained all the parameter accepted by Fastify to set a JSON Schema Validation, to validates
-the input, and a JSON Schema Serialization to optimize the output.
+The [Validation and Serialization](https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md) documentation outlines all parameters accepted by Fastify to set up JSON Schema Validation in order to validate the input, and JSON Schema Serialization in order to optimize the output.
 
-To set up the JSON schemas of our Fastify application, we can use [`fluent-schema`][fluent-schema-repo]
-to simplify this task and reuse constants values.
+[`fluent-schema`](fluent-schema-repo) can be used to simplify this task while allowing the reuse of constants.
 
 ### Basic settings
 
 ```js
 const S = require('fluent-schema')
 
-// You can have an object like this, or query a db to get the values
+// You can have an object like this, or query a DB to get the values
 const MY_KEY = {
   KEY1: 'ONE',
   KEY2: 'TWO'
@@ -41,7 +38,7 @@ const paramsJsonSchema = S.object()
 const headersJsonSchema = S.object()
   .prop('x-foo', S.string().required())
 
-// note that there is no need to call `.valueOf()`!
+// Note that there is no need to call `.valueOf()`!
 const schema = {
   body: bodyJsonSchema,
   querystring: queryStringJsonSchema, // (or) query: queryStringJsonSchema
@@ -56,11 +53,11 @@ fastify.post('/the/url', { schema }, handler)
 
 With `fluent-schema` you can manipulate your schemas in an easier and programmatic way and then reuse them
 thanks to the `addSchema()` method. You can refer to the schema in two different manners that are detailed
-in [Validation-and-Serialization.md](./Validation-and-Serialization.md#adding-a-shared-schema) document.
+in the [Validation-and-Serialization.md](./Validation-and-Serialization.md#adding-a-shared-schema) documentation.
 
-Here some example usage:
+Here are some usage examples:
 
-**`$ref-way`**: refer to external schema.
+**`$ref-way`**: refer to an external schema.
 
 ```js
 const addressSchema = S.object()
@@ -74,7 +71,7 @@ const addressSchema = S.object()
 const commonSchemas = S.object()
   .id('https://fastify/demo')
   .definition('addressSchema', addressSchema)
-  .definition('otherSchema', otherSchema) // you can add any schemas you need
+  .definition('otherSchema', otherSchema) // You can add any schemas you need
 
 fastify.addSchema(commonSchemas)
 
@@ -117,6 +114,6 @@ const schema = { body: bodyJsonSchema }
 fastify.post('/the/url', { schema }, handler)
 ```
 
-NB: you can mix up the usage `$ref-way` and the `replace-way` with `fastify.addSchema`.
+NB: you can mix up the `$ref-way` and the `replace-way` when using `fastify.addSchema`.
 
 [fluent-schema-repo]: https://github.com/fastify/fluent-schema

package/docs/Getting-Started.md

@@ -2,7 +2,7 @@
 
 ## Getting Started
 Hello! Thank you for checking out Fastify!<br>
-This document aims to be a gentle introduction to the framework and its features. It is an elementary introduction with examples and links to other parts of the documentation.<br>
+This document aims to be a gentle introduction to the framework and its features. It is an elementary preface with examples and links to other parts of the documentation.<br>
 Let's start!
 
 <a name="install"></a>
@@ -41,7 +41,7 @@ fastify.listen(3000, function (err, address) {
 ```
 
 Do you prefer to use `async/await`? Fastify supports it out-of-the-box.<br>
-*(we also suggest using [make-promises-safe](https://github.com/mcollina/make-promises-safe) to avoid file descriptor and memory leaks)*
+*(We also suggest using [make-promises-safe](https://github.com/mcollina/make-promises-safe) to avoid file descriptor and memory leaks.)*
 ```js
 const fastify = require('fastify')()
 
@@ -61,8 +61,8 @@ start()
 ```
 
 Awesome, that was easy.<br>
-Unfortunately, writing a complex application requires significantly more code than this example. A classic problem when you are building a new application is how handle multiple files, asynchronous bootstrapping and the architecture of your code.<br>
-Fastify offers an easy platform that helps solve all of problems, and more.
+Unfortunately, writing a complex application requires significantly more code than this example. A classic problem when you are building a new application is how to handle multiple files, asynchronous bootstrapping and the architecture of your code.<br>
+Fastify offers an easy platform that helps to solve all of the problems outlined above, and more!
 
 > ## Note
 > The above examples, and subsequent examples in this document, default to listening *only* on the localhost `127.0.0.1` interface. To listen on all available IPv4 interfaces the example should be modified to listen on `0.0.0.0` like so:
@@ -83,9 +83,9 @@ Fastify offers an easy platform that helps solve all of problems, and more.
 
 <a name="first-plugin"></a>
 ### Your first plugin
-As with JavaScript everything is an object, with Fastify everything is a plugin.<br>
+As with JavaScript, where everything is an object, with Fastify everything is a plugin.<br>
 Before digging into it, let's see how it works!<br>
-Let's declare our basic server, but instead of declaring the route inside the entry point, we'll declare it in an external file (checkout the [route declaration](https://github.com/fastify/fastify/blob/master/docs/Routes.md) docs).
+Let's declare our basic server, but instead of declaring the route inside the entry point, we'll declare it in an external file (check out the [route declaration](https://github.com/fastify/fastify/blob/master/docs/Routes.md) docs).
 ```js
 const fastify = require('fastify')({
   logger: true
@@ -113,16 +113,22 @@ async function routes (fastify, options) {
 
 module.exports = routes
 ```
-In this example we used the `register` API. This API is the core of the Fastify framework, and is the only way to register routes, plugins and so on.
+In this example, we used the `register` API, which is the core of the Fastify framework. It is the only way to add routes, plugins, et cetera.
 
-At the beginning of this guide we noted that Fastify provides a foundation that assists with the asynchronous bootstrapping of your application. Why this is important?
-Consider the scenario where a database connection is needed to handle data storage. Obviously the database connection needs to be available prior to the server accepting connections. How do we address this problem?<br>
-A typical solution is to use a complex callback, or promises, system that will mix the framework API with other libraries and the application code.<br>
+At the beginning of this guide, we noted that Fastify provides a foundation that assists with asynchronous bootstrapping of your application. Why is this important?
+Consider the scenario where a database connection is needed to handle data storage. Obviously, the database connection needs to be available before the server is accepting connections. How do we address this problem?<br>
+A typical solution is to use a complex callback, or promises - a system that will mix the framework API with other libraries and the application code.<br>
 Fastify handles this internally, with minimum effort!
 
 Let's rewrite the above example with a database connection.<br>
 *(we will use a simple example, for a robust solution consider using [`fastify-mongo`](https://github.com/fastify/fastify-mongodb) or another in the Fastify [ecosystem](https://github.com/fastify/fastify/blob/master/docs/Ecosystem.md))*
 
+First, install `fastify-plugin`:
+
+```
+npm install --save fastify-plugin
+```
+
 **server.js**
 ```js
 const fastify = require('fastify')({
@@ -185,18 +191,17 @@ module.exports = routes
 
 Wow, that was fast!<br>
 Let's recap what we have done here since we've introduced some new concepts.<br>
-As you can see, we used `register` both for the database connector and the routes registration.
-This is one of the best features of Fastify, it will load your plugins in the same order you declare them, and it will load the next plugin only once the current one has been loaded. In this way we can register the database connector in the first plugin and use it in the second *(read [here](https://github.com/fastify/fastify/blob/master/docs/Plugins.md#handle-the-scope) to understand how to handle the scope of a plugin)*.
+As you can see, we used `register` both for the database connector and the registration of the routes.
+This is one of the best features of Fastify, it will load your plugins in the same order you declare them, and it will load the next plugin only once the current one has been loaded. In this way, we can register the database connector in the first plugin and use it in the second *(read [here](https://github.com/fastify/fastify/blob/master/docs/Plugins.md#handle-the-scope) to understand how to handle the scope of a plugin)*.
 Plugin loading starts when you call `fastify.listen()`, `fastify.inject()` or `fastify.ready()`
 
-We have used the `decorate` API. Let's take a moment to understand what it is and how it works. A scenario is to use the same code/library in different parts of an application. A solution is to require the code/library that it is needed. This works, but is annoying because of duplicated code repeated and, if needed, long refactors.<br>
-To solve this Fastify offers the `decorate` API, which adds custom objects to the Fastify namespace, so that they can be used everywhere.
+We have also used the `decorate` API to add custom objects to the Fastify namespace, making them available for use everywhere. Use of this API is encouraged to faciliate easy code reuse and to decrease code or logic duplication.
 
 To dig deeper into how Fastify plugins work, how to develop new plugins, and for details on how to use the whole Fastify API to deal with the complexity of asynchronously bootstrapping an application, read [the hitchhiker's guide to plugins](https://github.com/fastify/fastify/blob/master/docs/Plugins-Guide.md).
 
 <a name="plugin-loading-order"></a>
 ### Loading order of your plugins
-To guarantee a consistent and predictable behavior of your application, we highly recommend to always load your code as shown below:
+To guarantee a consistent and predictable behaviour of your application, we highly recommend to always load your code as shown below:
 ```
 └── plugins (from the Fastify ecosystem)
 └── your plugins (your custom plugins)
@@ -204,8 +209,8 @@ To guarantee a consistent and predictable behavior of your application, we highl
 └── hooks and middlewares
 └── your services
 ```
-In this way you will always have access to all of the properties declared in the current scope.<br/>
-As discussed previously, Fastify offers a solid encapsulation model, to help you build your application as single and independent services. If you want to register a plugin only for a subset of routes, you have just to replicate the above structure.
+In this way, you will always have access to all of the properties declared in the current scope.<br/>
+As discussed previously, Fastify offers a solid encapsulation model, to help you build your application as single and independent services. If you want to register a plugin only for a subset of routes, you just have to replicate the above structure.
 ```
 └── plugins (from the Fastify ecosystem)
 └── your plugins (your custom plugins)
@@ -230,7 +235,7 @@ As discussed previously, Fastify offers a solid encapsulation model, to help you
 
 <a name="validate-data"></a>
 ### Validate your data
-Data validation is extremely important and is a core concept of the framework.<br>
+Data validation is extremely important and a core concept of the framework.<br>
 To validate incoming requests, Fastify uses [JSON Schema](http://json-schema.org/).
 Let's look at an example demonstrating validation for routes:
 ```js
@@ -255,8 +260,8 @@ Read [Validation and Serialization](https://github.com/fastify/fastify/blob/mast
 
 <a name="serialize-data"></a>
 ### Serialize your data
-Fastify has first class support for JSON. It is extremely optimized to parse a JSON body and to serialize JSON output.<br>
-To speed up JSON serialization (yes, it is slow!) use the `response` key of the schema option like so:
+Fastify has first class support for JSON. It is extremely optimized to parse JSON bodies and to serialize JSON output.<br>
+To speed up JSON serialization (yes, it is slow!) use the `response` key of the schema option as shown in the following example:
 ```js
 const opts = {
   schema: {
@@ -275,23 +280,22 @@ fastify.get('/', opts, async (request, reply) => {
   return { hello: 'world' }
 })
 ```
-Simply by specifying a schema as shown, a speed up your of serialization by 2x or even 3x can be achieved. This also helps protect against leaking of sensitive data, since Fastify will serialize only the data present in the response schema.
+Simply by specifying a schema as shown, you can speed up serialization by a factor of 2-3. This also helps to protect against leakage of potentially sensitive data, since Fastify will serialize only the data present in the response schema.
 Read [Validation and Serialization](https://github.com/fastify/fastify/blob/master/docs/Validation-and-Serialization.md) to learn more.
 
 <a name="extend-server"></a>
 ### Extend your server
-Fastify is built to be extremely extensible and very minimal, We believe that a bare minimum framework is all that is necessary to make great applications possible.<br>
+Fastify is built to be extremely extensible and minimal, we believe that a bare bones framework is all that is necessary to make great applications possible.<br>
 In other words, Fastify is not a "batteries included" framework, and relies on an amazing [ecosystem](https://github.com/fastify/fastify/blob/master/docs/Ecosystem.md)!
 
 <a name="test-server"></a>
 ### Test your server
-Fastify does not offer a testing framework, but we do recommend a way to write your tests that uses the features and the architecture of Fastify.<br>
+Fastify does not offer a testing framework, but we do recommend a way to write your tests that uses the features and architecture of Fastify.<br>
 Read the [testing](https://github.com/fastify/fastify/blob/master/docs/Testing.md) documentation to learn more!
 
 <a name="cli"></a>
 ### Run your server from CLI
-Fastify also has CLI integration thanks to
-[fastify-cli](https://github.com/fastify/fastify-cli).
+Fastify also has CLI integration thanks to [fastify-cli](https://github.com/fastify/fastify-cli).
 
 First, install `fastify-cli`:
 

package/docs/HTTP2.md

@@ -35,7 +35,7 @@ fastify.get('/', function (request, reply) {
 fastify.listen(3000)
 ```
 
-ALPN negotiation allows to support both HTTPS and HTTP/2 over the same socket.
+ALPN negotiation allows support for both HTTPS and HTTP/2 over the same socket.
 Node core `req` and `res` objects can be either [HTTP/1](https://nodejs.org/api/http.html)
 or [HTTP/2](https://nodejs.org/api/http2.html).
 _Fastify_ supports this out of the box: