fastify 3.11.0 → 3.14.1

package/docs/Server.md

@@ -4,10 +4,9 @@
 ## Factory
 
 The Fastify module exports a factory function that is used to create new
-<a href="./Server.md"><code><b>Fastify server</b></code></a>
-instances. This factory function accepts an options object which is used to
-customize the resulting instance. This document describes the properties
-available in that options object.
+<code><b>Fastify server</b></code> instances. This factory function accepts
+an options object which is used to customize the resulting instance. This
+document describes the properties available in that options object.
 
 <a name="factory-http2"></a>
 ### `http2`
@@ -133,8 +132,6 @@ logger will point to this instance.
 + `object`: a standard Pino [options object](https://github.com/pinojs/pino/blob/c77d8ec5ce/docs/API.md#constructor).
 This will be passed directly to the Pino constructor. If the following properties
 are not present on the object, they will be added accordingly:
-    * `genReqId`: a synchronous function that will be used to generate identifiers
-    for incoming requests. The default function generates sequential identifiers.
     * `level`: the minimum logging level. If not set, it will be set to `'info'`.
     * `serializers`: a hash of serialization functions. By default, serializers
       are added for `req` (incoming request objects), `res` (outgoing response
@@ -194,7 +191,7 @@ fastify.addHook('onResponse', (req, reply, done) => {
 })
 ```
 
-Please note that this setting will also disable an error log written by the the default `onResponse` hook on reply callback errors.
+Please note that this setting will also disable an error log written by the default `onResponse` hook on reply callback errors.
 
 <a name="custom-http-server"></a>
 ### `serverFactory`
@@ -291,7 +288,7 @@ const fastify = Fastify({ trustProxy: true })
     }
     ```
 
-For more examples refer to [proxy-addr](https://www.npmjs.com/package/proxy-addr) package.
+For more examples refer to [`@fastify/proxy-addr`](https://www.npmjs.com/package/@fastify/proxy-addr) package.
 
 You may access the `ip`, `ips`, `hostname` and `protocol` values on the [`request`](Request.md) object.
 
@@ -335,13 +332,13 @@ Automatically creates a sibling `HEAD` route for each `GET` route defined. If yo
 
 + Default: `false`
 
-<a name="versioning"></a>
-### `versioning`
+<a name="constraints"></a>
+### `constraints`
 
-By default you can version your routes with [semver versioning](Routes.md#version), which is provided by `find-my-way`. There is still an option to provide custom versioning strategy. You can find more information in the [find-my-way](https://github.com/delvedor/find-my-way#versioned-routes) documentation.
+Fastify's built in route constraints are provided by `find-my-way`, which allow constraining routes by `version` or `host`. You are able to add new constraint strategies, or override the built in strategies by providing a `constraints` object with strategies for `find-my-way`. You can find more information on constraint strategies in the [find-my-way](https://github.com/delvedor/find-my-way) documentation.
 
 ```js
-const versioning = {
+const customVersionStrategy = {
   storage: function () {
     let versions = {}
     return {
@@ -357,7 +354,9 @@ const versioning = {
 }
 
 const fastify = require('fastify')({
-  versioning
+  constraints: {
+    version: customVersionStrategy
+  }
 })
 ```
 
@@ -840,6 +839,47 @@ The input `schema` can access all the shared schemas added with [`.addSchema`](#
 #### schemaErrorFormatter
 This property can be used set a function to format errors that happen while the `validationCompiler` fails to validate the schema. See [#error-handling](Validation-and-Serialization.md#schemaerrorformatter).
 
+<a name="schema-controller"></a>
+#### schemaController
+This property can be used to fully manage where the schemas of your application will be stored.
+It can be useful when your schemas are stored in another data structure that is unknown to Fastify.
+See [issue #2446](https://github.com/fastify/fastify/issues/2446) for an example of what
+this property helps to resolve.
+
+```js
+const fastify = Fastify({
+  schemaController: {
+    /**
+     * This factory is called whenever `fastify.register()` is called.
+     * It may receive as input the schemas of the parent context if some schemas has been added.
+     * @param {object} parentSchemas these schemas will be returned by the `getSchemas()` method function of the returned `bucket`.
+     */
+    bucket: function factory (parentSchemas) {
+      return {
+        addSchema (inputSchema) {
+          // This function must store the schema added by the user.
+          // This function is invoked when `fastify.addSchema()` is called.
+        },
+        getSchema (schema$id) {
+          // This function must return the raw schema requested by the `schema$id`.
+          // This function is invoked when `fastify.getSchema(id)` is called.
+          return aSchema
+        },
+        getSchemas () {
+          // This function must return all the schemas referenced by the routes schemas' $ref
+          // It must return a JSON where the property is the schema `$id` and the value is the raw JSON Schema.
+          const allTheSchemaStored = {
+            'schema$id1': schema1,
+            'schema$id2': schema2
+          }
+          return allTheSchemaStored
+        }
+      }
+    }
+  }
+});
+```
+
 <a name="set-not-found-handler"></a>
 #### setNotFoundHandler
 
@@ -920,10 +960,32 @@ fastify.ready(() => {
 })
 ```
 
+<a name="print-plugins"></a>
+#### printPlugins
+
+`fastify.printPlugins()`: Prints the representation of the internal plugin tree used by the avvio, useful for debugging require order issues.<br/>
+*Remember to call it inside or after a `ready` call.*
+
+```js
+fastify.register(async function foo (instance) {
+  instance.register(async function bar () {})
+})
+fastify.register(async function baz () {})
+
+fastify.ready(() => {
+  console.error(fastify.printPlugins())
+  // will output the following to stderr:
+  // └── root
+  //   ├── foo
+  //   │   └── bar
+  //   └── baz
+})
+```
+
 <a name="addContentTypeParser"></a>
 #### addContentTypeParser
 
-`fastify.addContentTypeParser(content-type, options, parser)` is used to pass custom parser for a given content type. Useful for adding parsers for custom content types, e.g. `text/json, application/vnd.oasis.opendocument.text`. `content-type` can be a string or string array.
+`fastify.addContentTypeParser(content-type, options, parser)` is used to pass custom parser for a given content type. Useful for adding parsers for custom content types, e.g. `text/json, application/vnd.oasis.opendocument.text`. `content-type` can be a string, string array or RegExp.
 
 ```js
 // The two arguments passed to getDefaultJsonParser are for ProtoType poisoning and Constructor Poisoning configuration respectively. The possible values are 'ignore', 'remove', 'error'. ignore  skips all validations and it is similar to calling JSON.parse() directly. See the <a href="https://github.com/fastify/secure-json-parse#api">`secure-json-parse` documentation</a> for more information.
@@ -978,10 +1040,14 @@ Currently the properties that can be exposed are:
 - http2
 - https (it will return `false`/`true` or `{ allowHTTP1: true/false }` if explicitly passed)
 - ignoreTrailingSlash
+- disableRequestLogging
 - maxParamLength
 - onProtoPoisoning
+- onConstructorPoisoning
 - pluginTimeout
 - requestIdHeader
+- requestIdLogLabel
+- http2SessionTimeout
 
 ```js
 const { readFileSync } = require('fs')

package/docs/Serverless.md

@@ -1,6 +1,23 @@
 <h1 align="center">Serverless</h1>
 
 Run serverless applications and REST APIs using your existing Fastify application.
+By default, Fastify won't work on your serverless platform of choice, you'll need
+to make some small changes to fix this. This document contains a small guide for
+the most famous serverless providers and how to use Fastify with them.
+
+#### Should you use Fastify in a serverless platform?
+
+That's up to you! Keep in mind that functions as a service should always use
+small and focused functions, but you can also run an entire web application with them.
+It's important to remember that the bigger the application, the slower the initial boot will be.
+The best way to use for running Fastify applications in serverless environments
+is to use platforms like Google Cloud Run, AWS Fargate, and Azure Container Instances,
+where the server can handle multiple requests at the same time and make full use of Fastify features.
+
+One of the best features of using Fastify in serverless applications is the ease of development.
+In your local environment, you will always run directly the Fastify application without the need
+for any additional tool, while the same code will be executed in your serverless platform of
+choice with an additional snippet of code.
 
 ### Contents
 
@@ -9,16 +26,6 @@ Run serverless applications and REST APIs using your existing Fastify applicatio
 - [Netlify Lambda](#netlify-lambda)
 - [Vercel](#vercel)
 
-### Attention Readers:
-> Fastify is not designed to run on serverless environments.
-The Fastify framework is designed to make implementing a traditional HTTP/S server easy.
-Serverless environments requests differently than a standard HTTP/S server;
-thus, we cannot guarantee it will work as expected with Fastify.
-Regardless, based on the examples given in this document,
-it is possible to use Fastify in a serverless environment.
-Again, keep in mind that this is not Fastify's intended use case and
-we do not test for such integration scenarios.
-
 ## AWS Lambda
 
 The sample provided allows you to easily build serverless web applications/services
@@ -49,7 +56,7 @@ if (require.main === module) {
 }
 ```
 
-When executed in your lambda function we don't need to listen to a specific port,
+When executed in your lambda function we do not need to listen to a specific port,
 so we just export the wrapper function `init` in this case.
 The [`lambda.js`](https://www.fastify.io/docs/latest/Serverless/#lambda-js) file will use this export.
 
@@ -90,8 +97,8 @@ An example deployable with [claudia.js](https://claudiajs.com/tutorials/serverle
 
 ### Considerations
 
-- API Gateway doesn't support streams yet, so you're not able to handle [streams](https://www.fastify.io/docs/latest/Reply/#streams).
-- API Gateway has a timeout of 29 seconds, so it's important to provide a reply during this time.
+- API Gateway does not support streams yet, so you are not able to handle [streams](https://www.fastify.io/docs/latest/Reply/#streams).
+- API Gateway has a timeout of 29 seconds, so it is important to provide a reply during this time.
 
 ## Google Cloud Run
 
@@ -262,7 +269,7 @@ module.exports = {
 
 ### Scripts
 
-Add this command to your `package.json` *scripts* 
+Add this command to your `package.json` *scripts*
 
 ```json
 "scripts": {
@@ -279,69 +286,41 @@ Then it should work fine
 
 [Vercel](https://vercel.com) provides zero configuration deployment for
 Node.js applications. In order to use now, it is as simple as
-configuring your `now.json` file like the following:
+configuring your `vercel.json` file like the following:
 
 ```json
 {
-  "version": 2,
-  "builds": [
-    {
-      "src": "api/serverless.js",
-      "use": "@now/node",
-      "config": {
-        "helpers": false
-      }
-    }
-  ],
-  "routes": [
-    { "src": "/.*", "dest": "/api/serverless.js"}
-  ]
+    "rewrites": [
+        {
+            "source": "/(.*)",
+            "destination": "/api/serverless.js"
+        }
+    ]
 }
 ```
 
 Then, write a `api/serverless.js` like so:
 
 ```js
-'use strict'
+"use strict";
 
-const build = require('./index')
+// Read the .env file.
+import * as dotenv from "dotenv";
+dotenv.config();
 
-const app = build()
+// Require the framework
+import Fastify from "fastify";
 
-module.exports = async function (req, res) {
-  await app.ready()
-  app.server.emit('request', req, res)
-}
-```
+// Instantiate Fastify with some config
+const app = Fastify({
+  logger: true,
+});
 
-And a `api/index.js` file:
-
-```js
-'use strict'
+// Register your application as a normal plugin.
+app.register(import("../src/app"));
 
-const fastify = require('fastify')
-
-function build () {
-  const app = fastify({
-    logger: true
-  })
-
-  app.get('/', async (req, res) => {
-    const { name = 'World' } = req.query
-    req.log.info({ name }, 'hello world!')
-    return `Hello ${name}!`
-  })
-
-  return app
+export default async (req, res) => {
+    await app.ready();
+    app.server.emit('request', req, res);
 }
-
-module.exports = build
-```
-
-Note that you'll need to use Node 10 by setting it in `package.json`:
-
-```js
-  "engines": {
-    "node": "10.x"
-  },
 ```

package/docs/Style-Guide.md

@@ -6,9 +6,9 @@ Welcome to *Fastify Style Guide*. This guide is here to provide you with a conve
 
 ## Who is this guide for?
 
-This guide is for anyone who loves to build with Fastify or wants to contribute to our documentation. You don't need to be an expert in writing technical documentation. This guide is here to help you.
+This guide is for anyone who loves to build with Fastify or wants to contribute to our documentation. You do not need to be an expert in writing technical documentation. This guide is here to help you.
 
-Visit the [contribute](https://www.fastify.io/contribute) page on our website or read the [CONTRIBUTE.md](/CONTRIBUTING.md) file on Github to join our Open Source folks.
+Visit the [contribute](https://www.fastify.io/contribute) page on our website or read the [CONTRIBUTING.md](/CONTRIBUTING.md) file on GitHub to join our Open Source folks.
 
 ## Before you write
 
@@ -17,14 +17,14 @@ You need to know the following:
 * JavaScript
 * Node.js
 * Git
-* Github
+* GitHub
 * Markdown
 * HTTP
 * NPM 
 
 ### Consider your Audience
 
-Before you start writing, think about your audience. In this case, your audience should already know HTTP, JavaScript, NPM and NodeJs. It's necessary to keep your readers in mind because they are the one consuming your content. You want to give as much useful information as possible. Consider the vital things they need to know and how they can understand them. Make references and use words readers can relate with easily. Ask for feedback from the community: it can help you write better documentation that focuses on the user and what you want to achieve.
+Before you start writing, think about your audience. In this case, your audience should already know HTTP, JavaScript, NPM, and Node.js. It is necessary to keep your readers in mind because they are the ones consuming your content. You want to give as much useful information as possible. Consider the vital things they need to know and how they can understand them. Use words and references that readers can relate with easily. Ask for feedback from the community, it can help you write better documentation that focuses on the user and what you want to achieve.
 
 ### Get straight to the point
 
@@ -39,27 +39,27 @@ More Like this: To register a parametric path, put a colon before the parameter
 ### Avoid adding video or image content 
 
 
-Do not add videos or screenshots in the documentation. It is easier to keep under version control. Videos and images will eventually end up becoming outdated as new updates keep developing. Instead, make a referral link or a youtube video. You can add links by using `[Title](www.websitename.com)` in the markdown.
+Do not add videos or screenshots in the documentation. It is easier to keep under version control. Videos and images will eventually end up becoming outdated as new updates keep developing. Instead, make a referral link or a YouTube video. You can add links by using `[Title](www.websitename.com)` in the markdown.
 
 **Example**
 
 ```
-To learn more about hooks, See [Fastify hooks](https://www.fastify.io/docs/latest/Hooks).
+To learn more about hooks, see [Fastify hooks](https://www.fastify.io/docs/latest/Hooks).
 ```
 
 Result:
->To learn more about hooks, See [Fastify hooks](https://www.fastify.io/docs/latest/Hooks/).
+>To learn more about hooks, see [Fastify hooks](https://www.fastify.io/docs/latest/Hooks/).
 
 
 
 ### Avoid plagiarism
 
-Make sure you avoid copying other people's work. Keep it as original as possible. You can learn from what they've done and also reference where it's from if you used a particular quote from their work.
+Make sure you avoid copying other people's work. Keep it as original as possible. You can learn from what they have done and reference where it is from if you used a particular quote from their work.
 
 
 ## Word Choice
 
-There are a few things you need to use and avoid when writing your documentation to improve readability for readers and also make documentation neat, direct, and clean.
+There are a few things you need to use and avoid when writing your documentation to improve readability for readers and make documentation neat, direct, and clean.
 
 
 ### When to use the second person "you" as the pronoun
@@ -68,7 +68,7 @@ When writing articles or guides, your content should communicate directly to rea
 
 **Example**
 
-Less Like this: we can use the following plugins.
+Less like this: we can use the following plugins.
 
 More like this: You can use the following plugins.
 
@@ -80,13 +80,18 @@ One of the main rules of formal writing such as reference documentation, or API
 
 **Example**
 
-Less Like this: You can use the following recommendation as an example.
+Less like this: You can use the following recommendation as an example.
 
 More like this: As an example, the following recommendations should be referenced.
 
 To view a live example, refer to the [Decorators.md](/docs/Decorators.md) reference document. 
 
 
+### Avoid using contractions
+
+Contractions are the shortened version of written and spoken forms of a word, i.e. using "don't" instead of "do not".
+Avoid contractions to provide a more formal tone.
+
 ### Avoid using condescending terms
 
 Condescending terms are words that include:
@@ -97,22 +102,22 @@ Condescending terms are words that include:
 * Basically
 * Obviously
 
-The reader may not find it easy to use the Fastify's framework and plugins, avoid words that make it sound simple, easy, offensive, or insensitive. Not everyone who reads the documentation has the same level of understanding.
+The reader may not find it easy to use Fastify's framework and plugins; avoid words that make it sound simple, easy, offensive, or insensitive. Not everyone who reads the documentation has the same level of understanding.
 
 
 ### Starting with a verb
 
-Mostly start your description with a verb, which makes it simple and precise for the reader to follow. Prefer usage present tense because it's easier to read and understand than the past or future tense.
+Mostly start your description with a verb, which makes it simple and precise for the reader to follow. Prefer using present tense because it is easier to read and understand than the past or future tense.
 
 **Example**
 
- Less like this: There is a need for Nodejs to be installed before you can be able to use Fastify.
+ Less like this: There is a need for Node.js to be installed before you can be able to use Fastify.
 
- More like this: Install Nodejs to make use of Fastify.
+ More like this: Install Node.js to make use of Fastify.
 
 ### Grammatical moods 
 
-Grammatical moods is a great way to express your writing. Avoid sounding too bossy while making a direct statement. Know when to switch between indicative, imperative, and subjunctive moods.
+Grammatical moods are a great way to express your writing. Avoid sounding too bossy while making a direct statement. Know when to switch between indicative, imperative, and subjunctive moods.
 
 
 **Indicative** - Use when making a factual statement or question. 
@@ -158,7 +163,7 @@ Here is how your hyperlink should look:
 ```MD
 <!-- More like this -->
 
-// Add clear & breif description
+// Add clear & brief description
 [Fastify Plugins] (https://www.fastify.io/docs/latest/Plugins/)
 
 <!--Less like this -->
@@ -172,9 +177,9 @@ Here is how your hyperlink should look:
 // Empty title
 [](https://www.fastify.io/docs/latest/Plugins/)
 
-// Adding links localhost URL's instead of using code strings (``)
+// Adding links localhost URLs instead of using code strings (``)
 [http://localhost:3000/](http://localhost:3000/)
 
 ```
 
-You can include in your documentation as many essential references as possible, but avoid having numerous links when writing for beginners to avoid distractions.
+Include in your documentation as many essential references as possible, but avoid having numerous links when writing for beginners to avoid distractions.

package/docs/Testing.md

@@ -6,11 +6,11 @@ Testing is one of the most important parts of developing an application. Fastify
 
 Let's `cd` into a fresh directory called 'testing-example' and type `npm init -y` in our terminal.
 
-run `npm install fastify && npm install tap pino-pretty --save-dev`
+Run `npm install fastify && npm install tap pino-pretty --save-dev`
 
 ### Separating concerns makes testing easy
 
- First we're going to separate our application code from our server code:
+ First we are going to separate our application code from our server code:
 
 **app.js**:
 
@@ -55,7 +55,7 @@ server.listen(3000, (err, address) => {
 
 Fastify comes with built-in support for fake http injection thanks to [`light-my-request`](https://github.com/fastify/light-my-request).
 
-Before introducing any tests, we'll use the `.inject` method to make a fake request to our route:
+Before introducing any tests, we will use the `.inject` method to make a fake request to our route:
 
 **app.test.js**:
 
@@ -80,7 +80,7 @@ test()
 
 First, our code will run inside an asynchronous function, giving us access to async/await. 
 
-`.inject` insures all registered plugins have booted up and our application is ready to test. Lastly we pass the request method we want to use and a route. Using await we can store the response without a callback.
+`.inject` insures all registered plugins have booted up and our application is ready to test. Finally, we pass the request method we want to use and a route. Using await we can store the response without a callback.
 
 
 
@@ -120,7 +120,7 @@ test('requests the "/" route', async t => {
 })
 ```
 
-Finally run `npm test` in the terminal and see your test results!
+Finally, run `npm test` in the terminal and see your test results!
 
 The `inject` method can do much more than a simple GET request to a URL:
 ```js