fastify 3.9.2 → 3.12.0

package/docs/Server.md

@@ -133,8 +133,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
@@ -328,6 +326,13 @@ const fastify = require('fastify')({
 })
 ```
 
+<a name="exposeHeadRoutes"></a>
+### `exposeHeadRoutes`
+
+Automatically creates a sibling `HEAD` route for each `GET` route defined. If you want a custom `HEAD` handler without disabling this option, make sure to define it before the `GET` route.
+
++ Default: `false`
+
 <a name="versioning"></a>
 ### `versioning`
 
@@ -457,7 +462,7 @@ function defaultClientErrorHandler (err, socket) {
 }
 ```
 
-*Note: `clientErrorHandler` operates with raw socket. The handler is expected to return a properly formed HTTP response that includes a status line, HTTP headers and a message body. Before attempting to write the socket, the handler should check if the socket it's still writable as it may already have been destroyed.*
+*Note: `clientErrorHandler` operates with raw socket. The handler is expected to return a properly formed HTTP response that includes a status line, HTTP headers and a message body. Before attempting to write the socket, the handler should check if the socket is still writable as it may have already been destroyed.*
 
 ```js
 const fastify = require('fastify')({
@@ -668,6 +673,34 @@ fastify.listen({
 }, (err) => {})
 ```
 
+<a name="getDefaultRoute"></a>
+#### getDefaultRoute
+Method to get the `defaultRoute` for the server:
+
+```js
+const defaultRoute = fastify.getDefaultRoute()
+```
+
+<a name="setDefaultRoute"></a>
+#### setDefaultRoute
+Method to set the `defaultRoute` for the server:
+
+```js
+const defaultRoute = function (req, res) {
+  res.end('hello world')
+}
+
+fastify.setDefaultRoute(defaultRoute)
+```
+
+<a name="routing"></a>
+#### routing
+Method to access the `lookup` method of the internal router and match the request to the appropriate handler:
+
+```js
+fastify.routing(req, res)
+```
+
 <a name="route"></a>
 #### route
 Method to add routes to the server, it also has shorthand functions, check [here](Routes.md).
@@ -737,7 +770,7 @@ Name of the current plugin. There are three ways to define a name (in order).
 2. If you `module.exports` a plugin the filename is used.
 3. If you use a regular [function declaration](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions#Defining_functions) the function name is used.
 
-*Fallback*: The first two lines of your plugin will represent the plugin name. Newlines are replaced by ` -- `. This will help to indentify the root cause when you deal with many plugins.
+*Fallback*: The first two lines of your plugin will represent the plugin name. Newlines are replaced by ` -- `. This will help to identify the root cause when you deal with many plugins.
 
 Important: If you have to deal with nested plugins the name differs with the usage of the [fastify-plugin](https://github.com/fastify/fastify-plugin) because no new scope is created and therefore we have no place to attach contextual data. In that case the plugin name will represent the boot order of all involved plugins in the format of `plugin-A -> plugin-B`.
 
@@ -805,6 +838,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
 

package/docs/Serverless.md

@@ -99,7 +99,7 @@ Unlike AWS Lambda or Google Cloud Functions, Google Cloud Run is a serverless **
 
 *Follow the steps below to deploy to Google Cloud Run if you are already familiar with gcloud or just follow their [quickstart](https://cloud.google.com/run/docs/quickstarts/build-and-deploy)*.
 
-### Adjust Fastfiy server
+### Adjust Fastify server
 
 In order for Fastify to properly listen for requests within the container, be sure to set the correct port and address:
 
@@ -279,69 +279,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()
-
-module.exports = async function (req, res) {
-  await app.ready()
-  app.server.emit('request', req, res)
-}
-```
-
-And a `api/index.js` file:
-
-```js
-'use strict'
+// Require the framework
+import Fastify from "fastify";
 
-const fastify = require('fastify')
+// Instantiate Fastify with some config
+const app = Fastify({
+  logger: true,
+});
 
-function build () {
-  const app = fastify({
-    logger: true
-  })
+// Register your application as a normal plugin.
+app.register(import("../src/app"));
 
-  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/TypeScript.md

@@ -10,7 +10,7 @@ The type system was changed in Fastify version 3. The new type system introduces
 
 > Plugins may or may not include typings. See [Plugins](#plugins) for more information. We encourage users to send pull requests to improve typings support.
 
-🚨 Don't foget to install `@types/node`
+🚨 Don't forget to install `@types/node`
 
 ## Learn By Example
 
@@ -37,7 +37,7 @@ This example will get you up and running with Fastify and TypeScript. It results
   ```
 3. Initialize a TypeScript configuration file:
   ```bash
-  npx typescript --init
+  npx tsc --init
   ```
   or use one of the [recommended ones](https://github.com/tsconfig/bases#node-10-tsconfigjson).
 
@@ -82,7 +82,7 @@ The type system heavily relies on generic properties to provide the most accurat
    }
 
    interface IHeaders {
-     'H-Custom': string;
+     'h-Custom': string;
    }
    ```
 3. Using the two interfaces, define a new API route and pass them as generics. The shorthand route methods (i.e. `.get`) accept a generic object `RequestGenericInterface` containing four named properties: `Body`, `Querystring`, `Params`, and `Headers`. The interfaces will be passed down through the route method into the route method handler `request` instance.
@@ -92,7 +92,7 @@ The type system heavily relies on generic properties to provide the most accurat
      Headers: IHeaders
    }>('/auth', async (request, reply) => {
      const { username, password } = request.query
-     const customerHeader = request.headers['H-Custom']
+     const customerHeader = request.headers['h-Custom']
      // do something with request data
 
      return `logged in!`
@@ -115,7 +115,7 @@ The type system heavily relies on generic properties to provide the most accurat
        done(username !== 'admin' ? new Error('Must be admin') : undefined) // only validate `admin` account
      }
    }, async (request, reply) => {
-     const customerHeader = request.headers['H-Custom']
+     const customerHeader = request.headers['h-Custom']
      // do something with request data
      return `logged in!`
    })
@@ -139,10 +139,10 @@ In the last example we used interfaces to define the types for the request query
      "title": "Headers Schema",
      "type": "object",
      "properties": {
-       "H-Custom": { "type": "string" }
+       "h-Custom": { "type": "string" }
      },
      "additionalProperties": false,
-     "required": ["H-Custom"]
+     "required": ["h-Custom"]
    }
    ```
    ```json
@@ -194,7 +194,7 @@ In the last example we used interfaces to define the types for the request query
        done(username !== 'admin' ? new Error('Must be admin') : undefined)
      }
    }, async (request, reply) => {
-     const customerHeader = request.headers['H-Custom']
+     const customerHeader = request.headers['h-Custom']
      // do something with request data
      return `logged in!`
    })
@@ -211,11 +211,11 @@ In the last example we used interfaces to define the types for the request query
      },
      preHandler: (request, reply) => {
        const { username, password } = request.query
-       const customerHeader = request.headers['H-Custom']
+       const customerHeader = request.headers['h-Custom']
      },
      handler: (request, reply) => {
        const { username, password } = request.query
-       const customerHeader = request.headers['H-Custom']
+       const customerHeader = request.headers['h-Custom']
      }
    })
 
@@ -229,7 +229,7 @@ In the last example we used interfaces to define the types for the request query
    ```
    Pay special attention to the imports at the top of this file. It might seem redundant, but you need to import both the schema files and the generated interfaces.
 
-Great work! Now you can make use of both JSON Schemas and TypeScript definitions. If you didn't know already, defining schemas for your Fastify routes can increase their throughput! Check out the [Validation and Serialization](Validation-and-Serialization.md) documenation for more info.
+Great work! Now you can make use of both JSON Schemas and TypeScript definitions. If you didn't know already, defining schemas for your Fastify routes can increase their throughput! Check out the [Validation and Serialization](Validation-and-Serialization.md) documentation for more info.
 
 Some additional notes:
 - Currently, there is no type definition support for inline JSON schemas. If you can come up with a solution please open a PR!
@@ -333,14 +333,14 @@ This plugin guide is for Fastify plugins written in JavaScript. The steps outlin
    // fastify-plugin is highly recommended for any plugin you write
    const fp = require('fastify-plugin')
 
-   function myPlugin (instance, options, next) {
+   function myPlugin (instance, options, done) {
 
      // decorate the fastify instance with a custom function called myPluginFunc
      instance.decorate('myPluginFunc', (input) => {
        return input.toUpperCase()
      })
 
-     next()
+     done()
    }
 
    module.exports = fp(myPlugin, {
@@ -393,6 +393,23 @@ However, there are a couple of suggestions to help improve this experience:
 - Make sure the `no-unused-vars` rule is enabled in [ESLint](https://eslint.org/docs/rules/no-unused-vars) and any imported plugin are actually being loaded.
 - Use a module such as [depcheck](https://www.npmjs.com/package/depcheck) or [npm-check](https://www.npmjs.com/package/npm-check) to verify plugin dependencies are being used somewhere in your project.
 
+## Code Completion In Vanilla JavaScript
+
+Vanilla JavaScript can use the published types to provide code completion (e.g. [Intellisense](https://code.visualstudio.com/docs/editor/intellisense)) by following the [TypeScript JSDoc Reference](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html).
+
+For example:
+
+```js
+/**
+ * setup some routes
+ * @param {import("fastify").FastifyInstance} fastify 
+ * @param {*} opts 
+ */
+module.exports = async function (fastify, opts) {
+    fastify.get('/look', () => 'at me');
+}
+```
+
 ## API Type System Documentation
 
 This section is a detailed account of all the types available to you in Fastify version 3.x
@@ -588,7 +605,7 @@ server.get('/', async (request, reply) => {
 
 ###### Example 5: Specifying logger types
 
-Fastify uses [Pino](http://getpino.io/#/) logging library under the hood. Some of it's properties can be configured via `logger` field when constructing Fastify's instance. If properties you need aren't exposed, it's also possible to pass a preconfigured external instance of Pino (or any other compatible logger) to Fastify via the same field. This allows creating custom serializers as well, see the [Logging](Logging.md) documentation for more info.
+Fastify uses [Pino](https://getpino.io/#/) logging library under the hood. Some of it's properties can be configured via `logger` field when constructing Fastify's instance. If properties you need aren't exposed, it's also possible to pass a preconfigured external instance of Pino (or any other compatible logger) to Fastify via the same field. This allows creating custom serializers as well, see the [Logging](Logging.md) documentation for more info.
 
 To use an external instance of Pino, add `@types/pino` to devDependencies and pass the instance to `logger` field:
 
@@ -839,7 +856,7 @@ const server = fastify()
 const plugin: FastifyPlugin<{
   option1: string;
   option2: boolean;
-}> = function (instance, opts, next) { }
+}> = function (instance, opts, done) { }
 
 fastify().register(plugin, {}) // Error - options object is missing required properties
 fastify().register(plugin, { option1: '', option2: true }) // OK - options object contains required properties
@@ -862,7 +879,7 @@ Check out the [Specifying Logger Types](#example-5-specifying-logger-types) exam
 
 [src](../types/logger.d.ts#L17)
 
-An interface definition for the internal Fastify logger. It is emulative of the [Pino.js](http://getpino.io/#/) logger. When enabled through server options, use it following the general [logger](Logging.md) documentation.
+An interface definition for the internal Fastify logger. It is emulative of the [Pino.js](https://getpino.io/#/) logger. When enabled through server options, use it following the general [logger](Logging.md) documentation.
 
 ##### fastify.FastifyLogFn
 
@@ -985,7 +1002,7 @@ This interface is passed to instance of FastifyError.
 
 #### Hooks
 
-##### fastify.onRequestHookhandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
+##### fastify.onRequestHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
 [src](../types/hooks.d.ts#L17)
 
@@ -993,7 +1010,7 @@ This interface is passed to instance of FastifyError.
 
 Notice: in the `onRequest` hook, request.body will always be null, because the body parsing happens before the `preHandler` hook.
 
-##### fastify.preParsingHookhandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
+##### fastify.preParsingHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
 [src](../types/hooks.d.ts#L35)
 

package/docs/Validation-and-Serialization.md

@@ -1,14 +1,14 @@
 <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](http://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.
 > As both validation and serialization features dynamically evaluate
 > code with `new Function()`, it is not safe to use
-> user-provided schemas. See [Ajv](http://npm.im/ajv) and
-> [fast-json-stringify](http://npm.im/fast-json-stringify) for more
+> user-provided schemas. See [Ajv](https://npm.im/ajv) and
+> [fast-json-stringify](https://npm.im/fast-json-stringify) for more
 > details.
 
 
@@ -731,7 +731,7 @@ const refToSharedSchemaDefinitions = {
 
 <a name="resources"></a>
 ### Resources
-- [JSON Schema](http://json-schema.org/)
+- [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)
 - [Ajv documentation](https://github.com/epoberezkin/ajv/blob/master/README.md)

package/docs/Write-Plugin.md

@@ -9,7 +9,7 @@ The core principles of Fastify are performance, low overhead and providing a goo
 ## Code
 Fastify uses different techniques to optimize its code, many of them are documented in our Guides. We highly recommend you read [the hitchhiker's guide to plugins](Plugins-Guide.md) to discover all the APIs you can use to build your plugin and learn how use them.
 
-Have you got some question or are you seeking for a suggestion? We are more than happy to help you! Just open an issue in our [help repository](https://github.com/fastify/help).
+Do you have a question or need some advice? We are more than happy to help you! Just open an issue in our [help repository](https://github.com/fastify/help).
 
 Once you submit a plugin to our [ecosystem list](Ecosystem.md), we will review your code and help you improve it if necessary.
 
@@ -33,7 +33,7 @@ Always put an example file in your repository. Examples are very helpful for use
 It is extremely important that a plugin is thoroughly tested to verify that is working properly.<br>
 A plugin without tests will not be accepted to the ecosystem list. A lack of tests does not inspire trust nor guarantee that the code will continue to work among different versions of its dependencies.
 
-We do not enforce any testing library. We use [`tap`](http://www.node-tap.org/) since it offers out of the box parallel testing and code coverage, but it is up to you to choose your library of preference.
+We do not enforce any testing library. We use [`tap`](https://www.node-tap.org/) since it offers out of the box parallel testing and code coverage, but it is up to you to choose your library of preference.
 
 ## Code Linter
 It is not mandatory, but we highly recommend you use a code linter in your plugin. It will ensure a consistent code style and help you to avoid many errors.
@@ -41,8 +41,8 @@ It is not mandatory, but we highly recommend you use a code linter in your plugi
 We use [`standard`](https://standardjs.com/) since it works without the need to configure it and is very easy integrate in a test suite.
 
 ## Continuous Integration
-It is not mandatory, but if you release your code as open source it helps to use Continuous Integration to ensure contributions do not break your plugin and to show that the plugin works as intended. [Travis](https://travis-ci.org/) is free for open source projects and easy to setup.<br>
-In addition you can enable services like [Greenkeeper](https://greenkeeper.io/), that will help you keep your dependencies up to date and discover if a new release of Fastify has some issues with your plugin.
+It is not mandatory, but if you release your code as open source it helps to use Continuous Integration to ensure contributions do not break your plugin and to show that the plugin works as intended. Both [CircleCI](https://circleci.com/) and [GitHub Actions](https://github.com/features/actions) are free for open source projects and easy to setup.<br>
+In addition you can enable services like [Dependabot](https://dependabot.com/) or [Snyk](https://snyk.io/), that will help you keep your dependencies up to date and discover if a new release of Fastify has some issues with your plugin.
 
 ## Let's start!
 Awesome, now you know everything you need to know about how to write a good plugin for Fastify!

package/examples/hooks-benchmark.js

@@ -18,27 +18,27 @@ const opts = {
 }
 
 fastify
-  .addHook('onRequest', function (request, reply, next) {
-    next()
+  .addHook('onRequest', function (request, reply, done) {
+    done()
   })
-  .addHook('onRequest', function (request, reply, next) {
-    next()
+  .addHook('onRequest', function (request, reply, done) {
+    done()
   })
 
 fastify
-  .addHook('preHandler', function (request, reply, next) {
-    next()
+  .addHook('preHandler', function (request, reply, done) {
+    done()
   })
-  .addHook('preHandler', function (request, reply, next) {
-    setImmediate(next)
+  .addHook('preHandler', function (request, reply, done) {
+    setImmediate(done)
   })
-  .addHook('preHandler', function (request, reply, next) {
-    next()
+  .addHook('preHandler', function (request, reply, done) {
+    done()
   })
 
 fastify
-  .addHook('onSend', function (request, reply, payload, next) {
-    next()
+  .addHook('onSend', function (request, reply, payload, done) {
+    done()
   })
 
 fastify.get('/', opts, function (request, reply) {

package/examples/hooks.js

@@ -33,37 +33,37 @@ const optsPost = {
 }
 
 fastify
-  .addHook('onRequest', function (request, reply, next) {
+  .addHook('onRequest', function (request, reply, done) {
     console.log('onRequest')
-    next()
+    done()
   })
-  .addHook('preParsing', function (request, reply, next) {
+  .addHook('preParsing', function (request, reply, done) {
     console.log('preParsing')
-    next()
+    done()
   })
-  .addHook('preValidation', function (request, reply, next) {
+  .addHook('preValidation', function (request, reply, done) {
     console.log('preValidation')
-    next()
+    done()
   })
-  .addHook('preHandler', function (request, reply, next) {
+  .addHook('preHandler', function (request, reply, done) {
     console.log('preHandler')
-    next()
+    done()
   })
-  .addHook('preSerialization', function (request, reply, payload, next) {
+  .addHook('preSerialization', function (request, reply, payload, done) {
     console.log('preSerialization', payload)
-    next()
+    done()
   })
-  .addHook('onError', function (request, reply, error, next) {
+  .addHook('onError', function (request, reply, error, done) {
     console.log('onError', error.message)
-    next()
+    done()
   })
-  .addHook('onSend', function (request, reply, payload, next) {
+  .addHook('onSend', function (request, reply, payload, done) {
     console.log('onSend', payload)
-    next()
+    done()
   })
-  .addHook('onResponse', function (request, reply, next) {
+  .addHook('onResponse', function (request, reply, done) {
     console.log('onResponse')
-    next()
+    done()
   })
   .addHook('onRoute', function (routeOptions) {
     console.log('onRoute')

package/examples/plugin.js

@@ -1,6 +1,6 @@
 'use strict'
 
-module.exports = function (fastify, opts, next) {
+module.exports = function (fastify, opts, done) {
   fastify
     .get('/', opts, function (req, reply) {
       reply.send({ hello: 'world' })
@@ -8,5 +8,5 @@ module.exports = function (fastify, opts, next) {
     .post('/', opts, function (req, reply) {
       reply.send({ hello: 'world' })
     })
-  next()
+  done()
 }

package/examples/route-prefix.js

@@ -15,20 +15,20 @@ const opts = {
   }
 }
 
-fastify.register(function (instance, options, next) {
+fastify.register(function (instance, options, done) {
   // the route will be '/english/hello'
   instance.get('/hello', opts, (req, reply) => {
     reply.send({ greet: 'hello' })
   })
-  next()
+  done()
 }, { prefix: '/english' })
 
-fastify.register(function (instance, options, next) {
+fastify.register(function (instance, options, done) {
   // the route will be '/italian/hello'
   instance.get('/hello', opts, (req, reply) => {
     reply.send({ greet: 'ciao' })
   })
-  next()
+  done()
 }, { prefix: '/italian' })
 
 fastify.listen(8000, function (err) {

package/fastify.d.ts

@@ -83,6 +83,7 @@ export type FastifyServerOptions<
   bodyLimit?: number,
   maxParamLength?: number,
   disableRequestLogging?: boolean,
+  exposeHeadRoutes?: boolean,
   onProtoPoisoning?: 'error' | 'remove' | 'ignore',
   onConstructorPoisoning?: 'error' | 'remove' | 'ignore',
   logger?: boolean | FastifyLoggerOptions<RawServer> | Logger,
@@ -118,6 +119,20 @@ export type FastifyServerOptions<
 
 type TrustProxyFunction = (address: string, hop: number) => boolean
 
+declare module 'fastify-error' {
+  interface FastifyError {
+    validation?: ValidationResult[];
+  }
+}
+
+export interface ValidationResult {
+  keyword: string;
+  dataPath: string;
+  schemaPath: string;
+  params: Record<string, string | string[]>;
+  message: string;
+}
+
 /* Export all additional types */
 export { FastifyRequest, RequestGenericInterface } from './types/request'
 export { FastifyReply } from './types/reply'
@@ -128,7 +143,7 @@ export { FastifyContext } from './types/context'
 export { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
 export * from './types/register'
 export { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser } from './types/content-type-parser'
-export { FastifyError, ValidationResult } from 'fastify-error'
+export { FastifyError } from 'fastify-error'
 export { FastifySchema, FastifySchemaCompiler } from './types/schema'
 export { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
 export * from './types/hooks'