fastify 3.24.0 → 3.25.2

package/docs/{Validation-and-Serialization.md → Reference/Validation-and-Serialization.md}

@@ -1,41 +1,59 @@
 <h1 align="center">Fastify</h1>
 
 ## Validation and Serialization
-Fastify uses a schema-based approach, and even if it is not mandatory we recommend using [JSON Schema](https://json-schema.org/) to validate your routes and serialize your outputs. Internally, Fastify compiles the schema into a highly performant function.
+Fastify uses a schema-based approach, and even if it is not mandatory we
+recommend using [JSON Schema](https://json-schema.org/) to validate your routes
+and serialize your outputs. Internally, Fastify compiles the schema into a
+highly performant function.
 
 > ## ⚠  Security Notice
-> Treat the schema definition as application code.
-> Validation and serialization features dynamically evaluate
-> code with `new Function()`, which is not safe to use with 
-> user-provided schemas. See [Ajv](https://npm.im/ajv) and
-> [fast-json-stringify](https://npm.im/fast-json-stringify) for more
-> details.
-> 
-> Moreover, the [`$async` Ajv feature](https://ajv.js.org/guide/async-validation.html) should not be used as part of the first validation strategy.
-> This option is used to access Databases and reading them during the validation process may lead to Denial of Service Attacks to your
-> application. If you need to run `async` tasks, use [Fastify's hooks](./Hooks.md) instead after validation completes, such as `preHandler`.
+> Treat the schema definition as application code. Validation and serialization
+> features dynamically evaluate code with `new Function()`, which is not safe to
+> use with user-provided schemas. See [Ajv](https://npm.im/ajv) and
+> [fast-json-stringify](https://npm.im/fast-json-stringify) for more details.
+>
+> Moreover, the [`$async` Ajv
+> feature](https://ajv.js.org/guide/async-validation.html) should not be used as
+> part of the first validation strategy. This option is used to access Databases
+> and reading them during the validation process may lead to Denial of Service
+> Attacks to your application. If you need to run `async` tasks, use [Fastify's
+> hooks](./Hooks.md) instead after validation completes, such as `preHandler`.
 
 
 ### Core concepts
-The validation and the serialization tasks are processed by two different, and customizable, actors:
-- [Ajv v6](https://www.npmjs.com/package/ajv/v/6.12.6) for the validation of a request
-- [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify) for the serialization of a response's body
+The validation and the serialization tasks are processed by two different, and
+customizable, actors:
+- [Ajv v6](https://www.npmjs.com/package/ajv/v/6.12.6) for the validation of a
+  request
+- [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify) for
+  the serialization of a response's body
 
-These two separate entities share only the JSON schemas added to Fastify's instance through `.addSchema(schema)`.
+These two separate entities share only the JSON schemas added to Fastify's
+instance through `.addSchema(schema)`.
 
-<a name="shared-schema"></a>
 #### Adding a shared schema
-Thanks to the `addSchema` API, you can add multiple schemas to the Fastify instance and then reuse them in multiple parts of your application.
-As usual, this API is encapsulated.
-
-The shared schemas can be reused through the JSON Schema [**`$ref`**](https://tools.ietf.org/html/draft-handrews-json-schema-01#section-8) keyword.
-Here an overview of _how_ references work:
-
-+ `myField: { $ref: '#foo'}` will search for field with `$id: '#foo'` inside the current schema
-+ `myField: { $ref: '#/definitions/foo'}` will search for field `definitions.foo` inside the current schema
-+ `myField: { $ref: 'http://url.com/sh.json#'}` will search for a shared schema added with `$id: 'http://url.com/sh.json'`
-+ `myField: { $ref: 'http://url.com/sh.json#/definitions/foo'}` will search for a shared schema added with `$id: 'http://url.com/sh.json'` and will use the field `definitions.foo`
-+ `myField: { $ref: 'http://url.com/sh.json#foo'}` will search for a shared schema added with `$id: 'http://url.com/sh.json'` and it will look inside of it for object with `$id: '#foo'`
+<a id="shared-schema"></a>
+
+Thanks to the `addSchema` API, you can add multiple schemas to the Fastify
+instance and then reuse them in multiple parts of your application. As usual,
+this API is encapsulated.
+
+The shared schemas can be reused through the JSON Schema
+[**`$ref`**](https://tools.ietf.org/html/draft-handrews-json-schema-01#section-8)
+keyword. Here an overview of _how_ references work:
+
++ `myField: { $ref: '#foo'}` will search for field with `$id: '#foo'` inside the
+  current schema
++ `myField: { $ref: '#/definitions/foo'}` will search for field
+  `definitions.foo` inside the current schema
++ `myField: { $ref: 'http://url.com/sh.json#'}` will search for a shared schema
+  added with `$id: 'http://url.com/sh.json'`
++ `myField: { $ref: 'http://url.com/sh.json#/definitions/foo'}` will search for
+  a shared schema added with `$id: 'http://url.com/sh.json'` and will use the
+  field `definitions.foo`
++ `myField: { $ref: 'http://url.com/sh.json#foo'}` will search for a shared
+  schema added with `$id: 'http://url.com/sh.json'` and it will look inside of
+  it for object with `$id: '#foo'`
 
 
 **Simple usage:**
@@ -80,12 +98,12 @@ fastify.post('/', {
 })
 ```
 
-<a name="get-shared-schema"></a>
 #### Retrieving the shared schemas
+<a id="get-shared-schema"></a>
 
-If the validator and the serializer are customized, the `.addSchema` method will not be useful since the actors are no longer
-controlled by Fastify.
-To access the schemas added to the Fastify instance, you can simply use `.getSchemas()`:
+If the validator and the serializer are customized, the `.addSchema` method will
+not be useful since the actors are no longer controlled by Fastify. To access
+the schemas added to the Fastify instance, you can simply use `.getSchemas()`:
 
 ```js
 fastify.addSchema({
@@ -100,7 +118,8 @@ const mySchemas = fastify.getSchemas()
 const mySchema = fastify.getSchema('schemaId')
 ```
 
-As usual, the function `getSchemas` is encapsulated and returns the shared schemas available in the selected scope:
+As usual, the function `getSchemas` is encapsulated and returns the shared
+schemas available in the selected scope:
 
 ```js
 fastify.addSchema({ $id: 'one', my: 'hello' })
@@ -124,18 +143,26 @@ fastify.register((instance, opts, done) => {
 
 
 ### Validation
-The route validation internally relies upon [Ajv v6](https://www.npmjs.com/package/ajv/v/6.12.6) which is a high-performance JSON Schema validator.
-Validating the input is very easy: just add the fields that you need inside the route schema, and you are done!
+The route validation internally relies upon [Ajv
+v6](https://www.npmjs.com/package/ajv/v/6.12.6) which is a high-performance JSON
+Schema validator. Validating the input is very easy: just add the fields that
+you need inside the route schema, and you are done!
 
 The supported validations are:
-- `body`: validates the body of the request if it is a POST, PUT, or PATCH method.
+- `body`: validates the body of the request if it is a POST, PUT, or PATCH
+  method.
 - `querystring` or `query`: validates the query string.
 - `params`: validates the route params.
 - `headers`: validates the request headers.
 
-All the validations can be a complete JSON Schema object (with a `type` property of `'object'` and a `'properties'` object containing parameters) or a simpler variation in which the `type` and `properties` attributes are forgone and the parameters are listed at the top level (see the example below).
+All the validations can be a complete JSON Schema object (with a `type` property
+of `'object'` and a `'properties'` object containing parameters) or a simpler
+variation in which the `type` and `properties` attributes are forgone and the
+parameters are listed at the top level (see the example below).
 
-> ℹ If you need to use the lastest version of Ajv (v8) you should read how to do it in the [`schemaController`](Server.md#schema-controller) section. It is explained the easier way to avoid to implement a custom validator.
+> ℹ If you need to use the lastest version of Ajv (v8) you should read how to do
+> it in the [`schemaController`](./Server.md#schema-controller) section. It is
+> explained the easier way to avoid to implement a custom validator.
 
 Example:
 ```js
@@ -202,9 +229,15 @@ const schema = {
 fastify.post('/the/url', { schema }, handler)
 ```
 
-*Note that Ajv will try to [coerce](https://github.com/epoberezkin/ajv#coercing-data-types) the values to the types specified in your schema `type` keywords, both to pass the validation and to use the correctly typed data afterwards.*
+*Note that Ajv will try to
+[coerce](https://github.com/epoberezkin/ajv#coercing-data-types) the values to
+the types specified in your schema `type` keywords, both to pass the validation
+and to use the correctly typed data afterwards.*
 
-The Ajv default configuration in Fastify doesn't support coercing array parameters in querystring. However, Fastify allows [`customOptions`](Server.md#ajv) in Ajv instance. The `coerceTypes: 'array'` will coerce one parameter to a single element in array. Example:
+The Ajv default configuration in Fastify doesn't support coercing array
+parameters in querystring. However, Fastify allows
+[`customOptions`](./Server.md#ajv) in Ajv instance. The `coerceTypes: 'array'`
+will coerce one parameter to a single element in array. Example:
 
 ```js
 const opts = {
@@ -259,9 +292,11 @@ curl -X GET "http://localhost:3000/?ids=1
 {"params":{"hello":["1"]}}
 ```
 
-You can also specify a custom schema validator for each parameter type (body, querystring, params, headers).
+You can also specify a custom schema validator for each parameter type (body,
+querystring, params, headers).
 
-For example, the following code disable type coercion only for the `body` parameters, changing the ajv default options:
+For example, the following code disable type coercion only for the `body`
+parameters, changing the ajv default options:
 
 ```js
 const schemaCompilers = {
@@ -301,13 +336,13 @@ server.setValidatorCompiler(req => {
 
 For further information see [here](https://ajv.js.org/coercion.html)
 
-<a name="ajv-plugins"></a>
 #### Ajv Plugins
+<a id="ajv-plugins"></a>
 
-You can provide a list of plugins you want to use with the default `ajv` instance.  
-Note that the plugin must be **compatible with Ajv v6**.
+You can provide a list of plugins you want to use with the default `ajv`
+instance. Note that the plugin must be **compatible with Ajv v6**.
 
-> Refer to [`ajv options`](Server.md#ajv) to check plugins format
+> Refer to [`ajv options`](./Server.md#ajv) to check plugins format
 
 ```js
 const fastify = require('fastify')({
@@ -365,14 +400,18 @@ fastify.post('/foo', {
 })
 ```
 
-<a name="schema-validator"></a>
 #### Validator Compiler
+<a id="schema-validator"></a>
 
-The `validatorCompiler` is a function that returns a function that validates the body, URL  parameters, headers, and query string.
-The default `validatorCompiler` returns a function that implements the [ajv](https://ajv.js.org/) validation interface.
-Fastify uses it internally to speed the validation up.
+The `validatorCompiler` is a function that returns a function that validates the
+body, URL  parameters, headers, and query string. The default
+`validatorCompiler` returns a function that implements the
+[ajv](https://ajv.js.org/) validation interface. Fastify uses it internally to
+speed the validation up.
 
-Fastify's [baseline ajv configuration](https://github.com/epoberezkin/ajv#options-to-modify-validated-data) is:
+Fastify's [baseline ajv
+configuration](https://github.com/epoberezkin/ajv#options-to-modify-validated-data)
+is:
 
 ```js
 {
@@ -383,9 +422,11 @@ Fastify's [baseline ajv configuration](https://github.com/epoberezkin/ajv#option
 }
 ```
 
-This baseline configuration can be modified by providing [`ajv.customOptions`](Server.md#factory-ajv) to your Fastify factory.
+This baseline configuration can be modified by providing
+[`ajv.customOptions`](./Server.md#factory-ajv) to your Fastify factory.
 
-If you want to change or set additional config options, you will need to create your own instance and override the existing one like:
+If you want to change or set additional config options, you will need to create
+your own instance and override the existing one like:
 
 ```js
 const fastify = require('fastify')()
@@ -403,12 +444,17 @@ fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
   return ajv.compile(schema)
 })
 ```
-_**Note:** If you use a custom instance of any validator (even Ajv), you have to add schemas to the validator instead of Fastify, since Fastify's default validator is no longer used, and Fastify's `addSchema` method has no idea what validator you are using._
+_**Note:** If you use a custom instance of any validator (even Ajv), you have to
+add schemas to the validator instead of Fastify, since Fastify's default
+validator is no longer used, and Fastify's `addSchema` method has no idea what
+validator you are using._
 
-<a name="using-other-validation-libraries"></a>
 ##### Using other validation libraries
+<a id="using-other-validation-libraries"></a>
 
-The `setValidatorCompiler` function makes it easy to substitute `ajv` with almost any Javascript validation library ([joi](https://github.com/hapijs/joi/), [yup](https://github.com/jquense/yup/), ...) or a custom one:
+The `setValidatorCompiler` function makes it easy to substitute `ajv` with
+almost any Javascript validation library ([joi](https://github.com/hapijs/joi/),
+[yup](https://github.com/jquense/yup/), ...) or a custom one:
 
 ```js
 const Joi = require('@hapi/joi')
@@ -461,19 +507,32 @@ fastify.post('/the/url', {
 
 ##### Validation messages with other validation libraries
 
-Fastify's validation error messages are tightly coupled to the default validation engine: errors returned from `ajv` are eventually run through the `schemaErrorsText` function which is responsible for building human-friendly error messages. However, the `schemaErrorsText` function is written with `ajv` in mind : as a result, you may run into odd or incomplete error messages when using other validation libraries.
+Fastify's validation error messages are tightly coupled to the default
+validation engine: errors returned from `ajv` are eventually run through the
+`schemaErrorsText` function which is responsible for building human-friendly
+error messages. However, the `schemaErrorsText` function is written with `ajv`
+in mind : as a result, you may run into odd or incomplete error messages when
+using other validation libraries.
 
 To circumvent this issue, you have 2 main options :
 
-1. make sure your validation function (returned by your custom `schemaCompiler`) returns errors in the exact same structure and format as `ajv` (although this could prove to be difficult and tricky due to differences between validation engines)
-2. or use a custom `errorHandler` to intercept and format your 'custom' validation errors
+1. make sure your validation function (returned by your custom `schemaCompiler`)
+   returns errors in the exact same structure and format as `ajv` (although this
+   could prove to be difficult and tricky due to differences between validation
+   engines)
+2. or use a custom `errorHandler` to intercept and format your 'custom'
+   validation errors
 
-To help you in writing a custom `errorHandler`, Fastify adds 2 properties to all validation errors:
+To help you in writing a custom `errorHandler`, Fastify adds 2 properties to all
+validation errors:
 
-* validation: the content of the `error` property of the object returned by the validation function (returned by your custom `schemaCompiler`)
-* validationContext: the 'context' (body, params, query, headers) where the validation error occurred
+* validation: the content of the `error` property of the object returned by the
+  validation function (returned by your custom `schemaCompiler`)
+* validationContext: the 'context' (body, params, query, headers) where the
+  validation error occurred
 
-A very contrived example of such a custom `errorHandler` handling validation errors is shown below:
+A very contrived example of such a custom `errorHandler` handling validation
+errors is shown below:
 
 ```js
 const errorHandler = (error, request, reply) => {
@@ -503,10 +562,15 @@ const errorHandler = (error, request, reply) => {
 }
 ```
 
-<a name="serialization"></a>
 ### Serialization
-Usually, you will send your data to the clients as JSON, and Fastify has a powerful tool to help you, [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify), which is used if you have provided an output schema in the route options.
-We encourage you to use an output schema, as it can drastically increase throughput and help prevent accidental disclosure of sensitive information.
+<a id="serialization"></a>
+
+Usually, you will send your data to the clients as JSON, and Fastify has a
+powerful tool to help you,
+[fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify), which
+is used if you have provided an output schema in the route options. We encourage
+you to use an output schema, as it can drastically increase throughput and help
+prevent accidental disclosure of sensitive information.
 
 Example:
 ```js
@@ -525,7 +589,8 @@ const schema = {
 fastify.post('/the/url', { schema }, handler)
 ```
 
-As you can see, the response schema is based on the status code. If you want to use the same schema for multiple status codes, you can use `'2xx'`, for example:
+As you can see, the response schema is based on the status code. If you want to
+use the same schema for multiple status codes, you can use `'2xx'`, for example:
 ```js
 const schema = {
   response: {
@@ -546,10 +611,13 @@ const schema = {
 fastify.post('/the/url', { schema }, handler)
 ```
 
-<a name="schema-serializer"></a>
 #### Serializer Compiler
+<a id="schema-serializer"></a>
 
-The `serializerCompiler` is a function that returns a function that must return a string from an input object. You must provide a function to serialize every route where you have defined a `response` JSON Schema.
+The `serializerCompiler` is a function that returns a function that must return
+a string from an input object. When you define a response JSON Schema, you can
+change the default serialization method by providing a function to serialize
+every route where you do.
 
 ```js
 fastify.setSerializerCompiler(({ schema, method, url, httpStatus }) => {
@@ -571,10 +639,13 @@ fastify.get('/user', {
 })
 ```
 
-*If you need a custom serializer in a very specific part of your code, you can set one with [`reply.serializer(...)`](Reply.md#serializerfunc).*
+*If you need a custom serializer in a very specific part of your code, you can
+set one with [`reply.serializer(...)`](./Reply.md#serializerfunc).*
 
 ### Error Handling
-When schema validation fails for a request, Fastify will automatically return a  status 400 response including the result from the validator in the payload. As an example, if you have the following schema for your route
+When schema validation fails for a request, Fastify will automatically return a
+status 400 response including the result from the validator in the payload. As
+an example, if you have the following schema for your route
 
 ```js
 const schema = {
@@ -588,7 +659,8 @@ const schema = {
 }
 ```
 
-and fail to satisfy it, the route will immediately return a response with the following payload
+and fail to satisfy it, the route will immediately return a response with the
+following payload
 
 ```js
 {
@@ -598,7 +670,10 @@ and fail to satisfy it, the route will immediately return a response with the fo
 }
 ```
 
-If you want to handle errors inside the route, you can specify the `attachValidation` option for your route. If there is a _validation error_, the `validationError` property of the request will contain the `Error` object with the raw `validation` result as shown below
+If you want to handle errors inside the route, you can specify the
+`attachValidation` option for your route. If there is a _validation error_, the
+`validationError` property of the request will contain the `Error` object with
+the raw `validation` result as shown below
 
 ```js
 const fastify = Fastify()
@@ -613,11 +688,13 @@ fastify.post('/', { schema, attachValidation: true }, function (req, reply) {
 
 #### `schemaErrorFormatter`
 
-If you want to format errors yourself, you can provide a sync function that must return an error as the `schemaErrorFormatter` option to Fastify when instantiating.
-The context function will be the Fastify server instance.
+If you want to format errors yourself, you can provide a sync function that must
+return an error as the `schemaErrorFormatter` option to Fastify when
+instantiating. The context function will be the Fastify server instance.
 
 `errors` is an array of Fastify schema errors `FastifySchemaValidationError`.
-`dataVar` is the currently validated part of the schema. (params | body | querystring | headers).
+`dataVar` is the currently validated part of the schema. (params | body |
+querystring | headers).
 
 ```js
 const fastify = Fastify({
@@ -635,7 +712,9 @@ fastify.setSchemaErrorFormatter(function (errors, dataVar) {
 })
 ```
 
-You can also use [setErrorHandler](https://www.fastify.io/docs/latest/Server/#seterrorhandler) to define a custom response for validation errors such as
+You can also use
+[setErrorHandler](./Server.md#seterrorhandler) to
+define a custom response for validation errors such as
 
 ```js
 fastify.setErrorHandler(function (error, request, reply) {
@@ -645,11 +724,18 @@ fastify.setErrorHandler(function (error, request, reply) {
 })
 ```
 
-If you want custom error response in schema without headaches and quickly, you can take a look at [`ajv-errors`](https://github.com/epoberezkin/ajv-errors). Check out the [example](https://github.com/fastify/example/blob/HEAD/validation-messages/custom-errors-messages.js) usage.
-> Make sure to install version 1.0.1 of `ajv-errors`, because later versions of it are not compatible with AJV v6 (the version shipped by Fastify v3).
+If you want custom error response in schema without headaches and quickly, you
+can take a look at [`ajv-errors`](https://github.com/epoberezkin/ajv-errors).
+Check out the
+[example](https://github.com/fastify/example/blob/HEAD/validation-messages/custom-errors-messages.js)
+usage.
+> Make sure to install version 1.0.1 of `ajv-errors`, because later versions of
+> it are not compatible with AJV v6 (the version shipped by Fastify v3).
 
-Below is an example showing how to add **custom error messages for each property** of a schema by supplying custom AJV options.
-Inline comments in the schema below describe how to configure it to show a different error message for each case:
+Below is an example showing how to add **custom error messages for each
+property** of a schema by supplying custom AJV options. Inline comments in the
+schema below describe how to configure it to show a different error message for
+each case:
 
 ```js
 const fastify = Fastify({
@@ -699,7 +785,8 @@ fastify.post('/', { schema, }, (request, reply) => {
 })
 ```
 
-If you want to return localized error messages, take a look at [ajv-i18n](https://github.com/epoberezkin/ajv-i18n)
+If you want to return localized error messages, take a look at
+[ajv-i18n](https://github.com/epoberezkin/ajv-i18n)
 
 ```js
 const localize = require('ajv-i18n')
@@ -734,7 +821,8 @@ fastify.setErrorHandler(function (error, request, reply) {
 ### JSON Schema support
 
 JSON Schema has some type of utilities in order to optimize your schemas that,
-in conjunction with Fastify's shared schema, let you reuse all your schemas easily.
+in conjunction with Fastify's shared schema, let you reuse all your schemas
+easily.
 
 | Use Case                          | Validator | Serializer |
 |-----------------------------------|-----------|------------|
@@ -836,12 +924,16 @@ const refToSharedSchemaDefinitions = {
 }
 ```
 
-<a name="resources"></a>
 ### Resources
+<a id="resources"></a>
+
 - [JSON Schema](https://json-schema.org/)
-- [Understanding JSON Schema](https://spacetelescope.github.io/understanding-json-schema/)
-- [fast-json-stringify documentation](https://github.com/fastify/fast-json-stringify)
+- [Understanding JSON
+  Schema](https://spacetelescope.github.io/understanding-json-schema/)
+- [fast-json-stringify
+  documentation](https://github.com/fastify/fast-json-stringify)
 - [Ajv documentation](https://github.com/epoberezkin/ajv/blob/master/README.md)
 - [Ajv i18n](https://github.com/epoberezkin/ajv-i18n)
 - [Ajv custom errors](https://github.com/epoberezkin/ajv-errors)
-- Custom error handling with core methods with error file dumping [example](https://github.com/fastify/example/tree/master/validation-messages)
+- Custom error handling with core methods with error file dumping
+  [example](https://github.com/fastify/example/tree/master/validation-messages)

package/docs/index.md

@@ -0,0 +1,24 @@
+<h1 align="center">Fastify</h1>
+
+The documentation for Fastify is split into two categories:
+
+- [Reference documentation](./Reference/Index.md)
+- [Guides](./Guides/Index.md)
+
+The reference documentation utilizes a very formal style in an effort to document
+Fastify's API and implementation details thoroughly for the developer who needs
+such. The guides category utilizes an informal, educational, style as a means to
+introduce newcomers to core, and advanced, Fastify concepts.
+
+## Where To Start
+
+Complete newcomers to Fastify should first read our [Getting
+Started](./Guides/Getting-Started.md) guide.
+
+Developers experienced with Fastify should consult the [reference
+documentation](./Reference/index.md) directly to find the topic they are seeking
+more information about.
+
+## Additional Documentation
+
+- Fastify's [Long Term Support (LTS)](./Reference/LTS.md) policy

package/examples/typescript-server.ts

@@ -73,6 +73,6 @@ server.get<{
 server.listen(8080, (err, address) => {
   if (err) {
     console.error(err);
-    process.exit(0);
+    process.exit(1);
   }
 });

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '3.24.0'
+const VERSION = '3.25.2'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -631,8 +631,7 @@ function fastify (options) {
   function setSchemaController (schemaControllerOpts) {
     throwIfAlreadyStarted('Cannot call "setSchemaController" when fastify instance is already started!')
     const old = this[kSchemaController]
-    const parent = old.parent || old
-    const schemaController = SchemaController.buildSchemaController(parent, Object.assign({}, old.opts, schemaControllerOpts))
+    const schemaController = SchemaController.buildSchemaController(old, Object.assign({}, old.opts, schemaControllerOpts))
     this[kSchemaController] = schemaController
     this.getSchema = schemaController.getSchema.bind(schemaController)
     this.getSchemas = schemaController.getSchemas.bind(schemaController)

package/lib/contentTypeParser.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { AsyncResource } = require('async_hooks')
 let lru = require('tiny-lru')
 // Needed to handle Webpack and faux modules
 // See https://github.com/fastify/fastify/issues/2356
@@ -137,6 +138,7 @@ ContentTypeParser.prototype.remove = function (contentType) {
 
 ContentTypeParser.prototype.run = function (contentType, handler, request, reply) {
   const parser = this.cache.get(contentType) || this.getParser(contentType)
+  const resource = new AsyncResource('content-type-parser:run', request)
 
   if (parser === undefined) {
     reply.send(new FST_ERR_CTP_INVALID_MEDIA_TYPE(contentType))
@@ -163,12 +165,15 @@ ContentTypeParser.prototype.run = function (contentType, handler, request, reply
   }
 
   function done (error, body) {
-    if (error) {
-      reply.send(error)
-    } else {
-      request.body = body
-      handler(request, reply)
-    }
+    // We cannot use resource.bind() because it is broken in node v12.
+    resource.runInAsyncScope(() => {
+      if (error) {
+        reply.send(error)
+      } else {
+        request.body = body
+        handler(request, reply)
+      }
+    })
   }
 }
 

package/lib/decorate.js

@@ -40,7 +40,7 @@ function decorateConstructor (konstructor, name, fn, dependencies) {
     throw new FST_ERR_DEC_ALREADY_PRESENT(name)
   }
 
-  checkDependencies(instance, name, dependencies)
+  checkDependencies(konstructor, name, dependencies)
 
   if (fn && (typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
     Object.defineProperty(instance, name, {
@@ -68,14 +68,17 @@ function decorateFastify (name, fn, dependencies) {
 
 function checkExistence (instance, name) {
   if (name) {
-    return name in instance
+    return name in instance || (instance.prototype && name in instance.prototype) || hasKey(instance, name)
   }
 
   return instance in this
 }
 
 function hasKey (fn, name) {
-  return fn.props.find(({ key }) => key === name)
+  if (fn.props) {
+    return fn.props.find(({ key }) => key === name)
+  }
+  return false
 }
 
 function checkRequestExistence (name) {

package/lib/logger.js

@@ -50,7 +50,7 @@ const serializers = {
     return {
       method: req.method,
       url: req.url,
-      version: req.headers['accept-version'],
+      version: req.headers && req.headers['accept-version'],
       hostname: req.hostname,
       remoteAddress: req.ip,
       remotePort: req.socket ? req.socket.remotePort : undefined

package/lib/route.js

@@ -248,7 +248,7 @@ function buildRouting (options) {
         opts.schemaErrorFormatter || this[kSchemaErrorFormatter]
       )
 
-      const headRouteExists = router.find('HEAD', url) != null
+      const headRouteExists = router.find('HEAD', url, constraints) != null
 
       try {
         router.on(opts.method, opts.url, { constraints }, routeHandler, context)

package/lib/server.js

@@ -14,19 +14,20 @@ function createServer (options, httpHandler) {
   let server = null
   if (options.serverFactory) {
     server = options.serverFactory(httpHandler, options)
-  } else if (options.https) {
-    if (options.http2) {
+  } else if (options.http2) {
+    if (options.https) {
       server = http2().createSecureServer(options.https, httpHandler)
-      server.on('session', sessionTimeout(options.http2SessionTimeout))
     } else {
-      server = https.createServer(options.https, httpHandler)
-      server.keepAliveTimeout = options.keepAliveTimeout
+      server = http2().createServer(httpHandler)
     }
-  } else if (options.http2) {
-    server = http2().createServer(httpHandler)
     server.on('session', sessionTimeout(options.http2SessionTimeout))
   } else {
-    server = http.createServer(httpHandler)
+    // this is http1
+    if (options.https) {
+      server = https.createServer(options.https, httpHandler)
+    } else {
+      server = http.createServer(httpHandler)
+    }
     server.keepAliveTimeout = options.keepAliveTimeout
     server.requestTimeout = options.requestTimeout
     // we treat zero as null