fastify 4.0.0-rc.2 → 4.0.0-rc.3

package/README.md

@@ -8,7 +8,6 @@
 [![CI](https://github.com/fastify/fastify/workflows/ci/badge.svg)](https://github.com/fastify/fastify/actions/workflows/ci.yml)
 [![Package Manager CI](https://github.com/fastify/fastify/workflows/package-manager-ci/badge.svg)](https://github.com/fastify/fastify/actions/workflows/package-manager-ci.yml)
 [![Web SIte](https://github.com/fastify/fastify/workflows/website/badge.svg)](https://github.com/fastify/fastify/actions/workflows/website.yml)
-[![Known Vulnerabilities](https://snyk.io/test/github/fastify/fastify/badge.svg)](https://snyk.io/test/github/fastify/fastify)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 
 </div>
@@ -18,7 +17,7 @@
 [![NPM version](https://img.shields.io/npm/v/fastify.svg?style=flat)](https://www.npmjs.com/package/fastify)
 [![NPM downloads](https://img.shields.io/npm/dm/fastify.svg?style=flat)](https://www.npmjs.com/package/fastify)
 [![Security Responsible
-Disclosure](https://img.shields.io/badge/Security-Responsible%20Disclosure-yellow.svg)](https://github.com/nodejs/security-wg/blob/HEAD/processes/responsible_disclosure_template.md)
+Disclosure](https://img.shields.io/badge/Security-Responsible%20Disclosure-yellow.svg)](https://github.com/fastify/fastify/blob/main/SECURITY.md)
 [![Discord](https://img.shields.io/discord/725613461949906985)](https://discord.gg/fastify)
 
 </div>
@@ -282,7 +281,7 @@ Great contributors on a specific area in the Fastify ecosystem will be invited t
 
 ## Hosted by
 
-[<img src="https://github.com/openjs-foundation/cross-project-council/blob/HEAD/logos/openjsf-color.png?raw=true" width="250px;"/>](https://openjsf.org/projects/#growth)
+[<img src="https://github.com/openjs-foundation/artwork/blob/main/openjs_foundation/openjs_foundation-logo-horizontal-color.png?raw=true" width="250px;"/>](https://openjsf.org/projects/#growth)
 
 We are a [Growth Project](https://github.com/openjs-foundation/cross-project-council/blob/HEAD/PROJECT_PROGRESSION.md#growth-stage) in the [OpenJS Foundation](https://openjsf.org/).
 

package/docs/Guides/Ecosystem.md

@@ -22,8 +22,6 @@ section.
 - [`fastify-awilix`](https://github.com/fastify/fastify-awilix) Dependency
   injection support for Fastify, based on
   [awilix](https://github.com/jeffijoe/awilix).
-- [`@fastify/bankai`](https://github.com/fastify/fastify-bankai)
-  [Bankai](https://github.com/yoshuawuyts/bankai) assets compiler for Fastify.
 - [`@fastify/basic-auth`](https://github.com/fastify/fastify-basic-auth) Basic
   auth plugin for Fastify.
 - [`@fastify/bearer-auth`](https://github.com/fastify/fastify-bearer-auth) Bearer
@@ -38,7 +36,7 @@ section.
   cookie headers.
 - [`@fastify/cors`](https://github.com/fastify/fastify-cors) Enables the use of
   CORS in a Fastify application.
-- [`fastify-csrf`](https://github.com/fastify/fastify-csrf) A plugin for adding
+- [`@fastify/csrf-protection`](https://github.com/fastify/csrf-protection) A plugin for adding
   [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery) protection to
   Fastify.
 - [`@fastify/diagnostics-channel`](https://github.com/fastify/fastify-diagnostics-channel)
@@ -59,6 +57,7 @@ section.
   function.
 - [`@fastify/helmet`](https://github.com/fastify/fastify-helmet) Important
   security headers for Fastify.
+- [`@fastify/hotwire`](https://github.com/fastify/fastify-hotwire) Use the Hotwire pattern with Fastify.
 - [`@fastify/http-proxy`](https://github.com/fastify/fastify-http-proxy) Proxy
   your HTTP requests to another server, with hooks.
 - [`@fastify/jwt`](https://github.com/fastify/fastify-jwt) JWT utils for Fastify,
@@ -405,6 +404,7 @@ section.
 - [`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-racing`](https://github.com/metcoder95/fastify-racing) Fastify's plugin that adds support to handle an aborted request asynchronous.
 - [`fastify-raw-body`](https://github.com/Eomm/fastify-raw-body) Add the
   `request.rawBody` field.
 - [`fastify-rbac`](https://gitlab.com/m03geek/fastify-rbac) Fastify role-based

package/docs/Guides/Getting-Started.md

@@ -56,9 +56,6 @@ fastify.listen({ port: 3000 }, function (err, address) {
 
 Do you prefer to use `async/await`? Fastify supports it out-of-the-box.
 
-*(We also suggest using
-[make-promises-safe](https://github.com/mcollina/make-promises-safe) to avoid
-file descriptor and memory leaks.)*
 ```js
 // ESM
 import Fastify from 'fastify'
@@ -74,6 +71,9 @@ fastify.get('/', async (request, reply) => {
   return { hello: 'world' }
 })
 
+/**
+ * Run the server!
+ */
 const start = async () => {
   try {
     await fastify.listen({ port: 3000 })
@@ -133,6 +133,9 @@ declaration](../Reference/Routes.md) docs).
 // ESM
 import Fastify from 'fastify'
 import firstRoute from './our-first-route'
+/**
+ * @type {import('fastify').FastifyInstance} Instance of Fastify
+ */
 const fastify = Fastify({
   logger: true
 })
@@ -150,6 +153,9 @@ fastify.listen({ port: 3000 }, function (err, address) {
 
 ```js
 // CommonJs
+/**
+ * @type {import('fastify').FastifyInstance} Instance of Fastify
+ */
 const fastify = require('fastify')({
   logger: true
 })
@@ -168,6 +174,11 @@ fastify.listen({ port: 3000 }, function (err, address) {
 ```js
 // our-first-route.js
 
+/**
+ * Encapsulates the routes
+ * @param {FastifyInstance} fastify  Encapsulated Fastify Instance
+ * @param {Object} options plugin options, refer to https://www.fastify.io/docs/latest/Reference/Plugins/#plugin-options
+ */
 async function routes (fastify, options) {
   fastify.get('/', async (request, reply) => {
     return { hello: 'world' }
@@ -208,6 +219,9 @@ import Fastify from 'fastify'
 import dbConnector from './our-db-connector'
 import firstRoute from './our-first-route'
 
+/**
+ * @type {import('fastify').FastifyInstance} Instance of Fastify
+ */
 const fastify = Fastify({
   logger: true
 })
@@ -225,6 +239,9 @@ fastify.listen({ port: 3000 }, function (err, address) {
 
 ```js
 // CommonJs
+/**
+ * @type {import('fastify').FastifyInstance} Instance of Fastify
+ */
 const fastify = require('fastify')({
   logger: true
 })
@@ -248,6 +265,10 @@ fastify.listen({ port: 3000 }, function (err, address) {
 import fastifyPlugin from 'fastify-plugin'
 import fastifyMongo from '@fastify/mongodb'
 
+/**
+ * @param {FastifyInstance} fastify
+ * @param {Object} options
+ */
 async function dbConnector (fastify, options) {
   fastify.register(fastifyMongo, {
     url: 'mongodb://localhost:27017/test_database'
@@ -262,8 +283,17 @@ module.exports = fastifyPlugin(dbConnector)
 
 ```js
 // CommonJs
+/**
+ * @type {import('fastify-plugin').FastifyPlugin}
+ */
 const fastifyPlugin = require('fastify-plugin')
 
+
+/**
+ * Connects to a MongoDB database
+ * @param {FastifyInstance} fastify Encapsulated Fastify Instance
+ * @param {Object} options plugin options, refer to https://www.fastify.io/docs/latest/Reference/Plugins/#plugin-options
+ */
 async function dbConnector (fastify, options) {
   fastify.register(require('@fastify/mongodb'), {
     url: 'mongodb://localhost:27017/test_database'
@@ -278,6 +308,11 @@ module.exports = fastifyPlugin(dbConnector)
 
 **our-first-route.js**
 ```js
+/**
+ * A plugin that provide encapsulated routes
+ * @param {FastifyInstance} fastify encapsulated fastify instance
+ * @param {Object} options plugin options, refer to https://www.fastify.io/docs/latest/Reference/Plugins/#plugin-options
+ */
 async function routes (fastify, options) {
   const collection = fastify.mongo.db.collection('test_collection')
 
@@ -403,6 +438,10 @@ Schema](https://json-schema.org/).
 
 Let's look at an example demonstrating validation for routes:
 ```js
+/**
+ * @type {import('fastify').RouteShorthandOptions}
+ * @const
+ */
 const opts = {
   schema: {
     body: {
@@ -435,6 +474,10 @@ JSON bodies and serialize JSON output.
 To speed up JSON serialization (yes, it is slow!) use the `response` key of the
 schema option as shown in the following example:
 ```js
+/**
+ * @type {import('fastify').RouteShorthandOptions}
+ * @const
+ */
 const opts = {
   schema: {
     response: {
@@ -468,6 +511,9 @@ request](../Reference/Request.md) object at `request.body`.
 The following example returns the parsed body of a request back to the client:
 
 ```js
+/**
+ * @type {import('fastify').RouteShorthandOptions}
+ */
 const opts = {}
 fastify.post('/', opts, async (request, reply) => {
   return request.body

package/docs/Guides/Write-Plugin.md

@@ -80,9 +80,9 @@ to show that the plugin works as intended. Both
 Actions](https://github.com/features/actions) are free for open source projects
 and easy to set up.
 
-In addition, you can enable services like [Dependabot](https://dependabot.com/)
-or [Snyk](https://snyk.io/), which will help you keep your dependencies up to
-date and discover if a new release of Fastify has some issues with your plugin.
+In addition, you can enable services like [Dependabot](https://dependabot.com/),
+which 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

package/docs/Migration-Guide-V4.md

@@ -9,4 +9,4 @@ All v3 deprecations have been removed and they will no longer work after upgradi
 
 ### Deprecation of `app.use()`
 
-Starting this version of Fastify, we have deprecated the use of `app.use()`. We have decided not to support the use of middlewares. Both [`middie`](https://github.com/fastify/middie) and [`@fastify/express`](https://github.com/fastify/fastify-express) will still be there and maintained. Use Fastify's [hooks](./Hooks.md) instead.
+Starting this version of Fastify, we have deprecated the use of `app.use()`. We have decided not to support the use of middlewares. Both [`middie`](https://github.com/fastify/middie) and [`@fastify/express`](https://github.com/fastify/fastify-express) will still be there and maintained. Use Fastify's [hooks](./Reference/Hooks.md) instead.

package/docs/Reference/Errors.md

@@ -17,13 +17,6 @@ way to deal with them is to
 [crash](https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly).
 
 #### Catching Errors In Promises
-In Node.js, unhandled promise rejections (that is, without a `.catch()` handler)
-can also cause memory and file descriptor leaks. While `unhandledRejection` is
-deprecated in Node.js, unhandled rejections will not throw, and still
-potentially leak. You should use a module like
-[`make-promises-safe`](https://github.com/mcollina/make-promises-safe) to ensure
-unhandled rejections _always_ throw.
-
 If you are using promises, you should attach a `.catch()` handler synchronously.
 
 ### Errors In Fastify

package/docs/Reference/Plugins.md

@@ -9,7 +9,7 @@ By default, `register` creates a *new scope*, this means that if you make some
 changes to the Fastify instance (via `decorate`), this change will not be
 reflected by the current context ancestors, but only by its descendants. This
 feature allows us to achieve plugin *encapsulation* and *inheritance*, in this
-way we create a *direct acyclic graph* (DAG) and we will not have issues caused
+way we create a *directed acyclic graph* (DAG) and we will not have issues caused
 by cross dependencies.
 
 You may have already seen in the [Getting Started]((../Guides/Getting-Started.md#your-first-plugin)) guide how easy it is to use this API:

package/docs/Reference/Routes.md

@@ -653,3 +653,24 @@ fastify.route({
   }
 })
 ```
+
+### ⚠  HTTP version check
+
+Fastify will check the HTTP version of every request, based on configuration
+options ([http2](./Server.md#http2), [https](./Server.md#https), and
+[serverFactory](./Server.md#serverfactory)), to determine if it matches one or
+all of the > following versions: `2.0`, `1.1`, and `1.0`. If Fastify receives
+a different HTTP version in the request it will return a
+`505 HTTP Version Not Supported` error.
+
+|                          | 2.0 | 1.1 | 1.0 | skip |
+|:------------------------:|:---:|:---:|:---:|:----:|
+| http2                    | ✓   |     |     |      |
+| http2 + https            | ✓   |     |     |      |
+| http2 + https.allowHTTP1 | ✓   | ✓   | ✓   |      |
+| https                    |     | ✓   | ✓   |      |
+| http                     |     | ✓   | ✓   |      |
+| serverFactory            |     |     |     | ✓    |
+
+ Note: The internal HTTP version check will be removed in the future when Node
+ implements [this feature](https://github.com/nodejs/node/issues/43115).

package/docs/Reference/Server.md

@@ -54,7 +54,7 @@ describes the properties available in that options object.
     - [routing](#routing)
     - [route](#route)
     - [close](#close)
-    - [decorate*](#decorate)
+    - [decorate\*](#decorate)
     - [register](#register)
     - [addHook](#addhook)
     - [prefix](#prefix)
@@ -75,6 +75,8 @@ describes the properties available in that options object.
     - [schemaController](#schemacontroller)
     - [setNotFoundHandler](#setnotfoundhandler)
     - [setErrorHandler](#seterrorhandler)
+    - [addConstraintStrategy](#addconstraintstrategy)
+    - [hasConstraintStrategy](#hasconstraintstrategy)
     - [printRoutes](#printroutes)
     - [printPlugins](#printplugins)
     - [addContentTypeParser](#addcontenttypeparser)
@@ -463,7 +465,7 @@ Defines the label used for the request identifier when logging the request.
 <a id="factory-gen-request-id"></a>
 
 Function for generating the request-id. It will receive the incoming request as
-a parameter.
+a parameter. This function is expected to be error-free.
 
 + Default: `value of 'request-id' header if provided or monotonically increasing
   integers`
@@ -588,12 +590,10 @@ constraint strategies in the
 ```js
 const customVersionStrategy = {
   storage: function () {
-    let versions = {}
+    const versions = {}
     return {
       get: (version) => { return versions[version] || null },
-      set: (version, store) => { versions[version] = store },
-      del: (version) => { delete versions[version] },
-      empty: () => { versions = {} }
+      set: (version, store) => { versions[version] = store }
     }
   },
   deriveVersion: (req, ctx) => {
@@ -952,6 +952,8 @@ Note that the array contains the `fastify.server.address()` too.
 #### getDefaultRoute
 <a id="getDefaultRoute"></a>
 
+The `defaultRoute` handler handles requests that do not match any URL specified by your Fastify application.
+This defaults to the 404 handler, but can be overridden with [setDefaultRoute](#setdefaultroute).
 Method to get the `defaultRoute` for the server:
 
 ```js
@@ -961,6 +963,8 @@ const defaultRoute = fastify.getDefaultRoute()
 #### setDefaultRoute
 <a id="setDefaultRoute"></a>
 
+**Note**: The default 404 handler, or one set using `setNotFoundHandler`, will never trigger if the default route is overridden.
+Use [setNotFoundHandler](#setnotfoundhandler) if you want to customize 404 handling instead.
 Method to set the `defaultRoute` for the server:
 
 ```js
@@ -1349,6 +1353,42 @@ if (statusCode >= 500) {
 }
 ```
 
+#### addConstraintStrategy
+<a id="addConstraintStrategy"></a>
+
+Function to add a custom constraint strategy. To register a new type of constraint, you must add a new constraint strategy that knows how to match values to handlers, and that knows how to get the constraint value from a request.
+
+Add a custom constraint strategy using the `fastify.addConstraintStrategy` method:
+
+```js
+const customResponseTypeStrategy = {
+  // strategy name for referencing in the route handler `constraints` options
+  name: 'accept',
+  // storage factory for storing routes in the find-my-way route tree
+  storage: function () {
+    let handlers = {}
+    return {
+      get: (type) => { return handlers[type] || null },
+      set: (type, store) => { handlers[type] = store }
+    }
+  },
+  // function to get the value of the constraint from each incoming request
+  deriveConstraint: (req, ctx) => {
+    return req.headers['accept']
+  },
+  // optional flag marking if handlers without constraints can match requests that have a value for this constraint
+  mustMatchWhenDerived: true
+}
+
+const router = Fastify();
+router.addConstraintStrategy(customResponseTypeStrategy);
+```
+
+#### hasConstraintStrategy
+<a id="hasConstraintStrategy"></a>
+
+The `fastify.hasConstraintStrategy(strategyName)` checks if there already exists a custom constraint strategy with the same name.
+
 #### printRoutes
 <a id="print-routes"></a>
 

package/docs/Reference/TypeScript.md

@@ -183,6 +183,16 @@ Also it has the advantage to use the defined type within your handlers
 
 Here are some options how to achieve this.
 
+#### Fastify Type Providers
+
+Fastify offers two packages wrapping `json-schema-to-ts` and `typebox`:
+
+- `@fastify/type-provider-json-schema-to-ts`
+- `@fastify/type-provider-typebox`
+
+They simplify schema validation setup and you can read more about them in [Type Providers](./Type-Providers.md) page.
+
+Below is how to setup schema validation using vanilla `typebox` and `json-schema-to-ts` packages.
 
 #### typebox
 
@@ -330,7 +340,7 @@ into TypeScript interfaces!
      //  or if using async
      //  preValidation: async (request, reply) => {
      //    const { username, password } = request.query
-     //    return username !== "admin" ? new Error("Must be admin") : undefined;
+     //    if (username !== "admin") throw new Error("Must be admin");
      //  }
    }, async (request, reply) => {
      const customerHeader = request.headers['h-Custom']

package/fastify.js

@@ -1,10 +1,9 @@
 'use strict'
 
-const VERSION = '4.0.0-rc.2'
+const VERSION = '4.0.0-rc.3'
 
 const Avvio = require('avvio')
 const http = require('http')
-const querystring = require('querystring')
 let lightMyRequest
 
 const {
@@ -32,7 +31,7 @@ const {
   kFourOhFourContext
 } = require('./lib/symbols.js')
 
-const createServer = require('./lib/server')
+const { createServer, compileValidateHTTPVersion } = require('./lib/server')
 const Reply = require('./lib/reply')
 const Request = require('./lib/request')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
@@ -99,7 +98,6 @@ function fastify (options) {
   validateBodyLimitOption(options.bodyLimit)
 
   const requestIdHeader = options.requestIdHeader || defaultInitOptions.requestIdHeader
-  const querystringParser = options.querystringParser || querystring.parse
   const genReqId = options.genReqId || reqIdGenFactory()
   const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
   const bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
@@ -131,7 +129,6 @@ function fastify (options) {
   options.logger = logger
   options.genReqId = genReqId
   options.requestIdHeader = requestIdHeader
-  options.querystringParser = querystringParser
   options.requestIdLogLabel = requestIdLogLabel
   options.disableRequestLogging = disableRequestLogging
   options.ajv = ajvOptions
@@ -140,7 +137,7 @@ function fastify (options) {
   const initialConfig = getSecuredInitialConfig(options)
   const keepAliveConnections = options.forceCloseConnections === true ? new Set() : noopSet()
 
-  // exposeHeadRoutes have its defult set from the validatorfrom the validatorfrom the validatorfrom the validator
+  // exposeHeadRoutes have its default set from the validator
   options.exposeHeadRoutes = initialConfig.exposeHeadRoutes
 
   let constraints = options.constraints
@@ -172,7 +169,8 @@ function fastify (options) {
       maxParamLength: options.maxParamLength || defaultInitOptions.maxParamLength,
       caseSensitive: options.caseSensitive,
       allowUnsafeRegex: options.allowUnsafeRegex || defaultInitOptions.allowUnsafeRegex,
-      buildPrettyMeta: defaultBuildPrettyMeta
+      buildPrettyMeta: defaultBuildPrettyMeta,
+      querystringParser: options.querystringParser
     },
     keepAliveConnections
   })
@@ -310,7 +308,10 @@ function fastify (options) {
     setNotFoundHandler,
     setErrorHandler,
     // Set fastify initial configuration options read-only object
-    initialConfig
+    initialConfig,
+    // constraint strategies
+    addConstraintStrategy: router.addConstraintStrategy.bind(router),
+    hasConstraintStrategy: router.hasConstraintStrategy.bind(router)
   }
 
   Object.defineProperties(fastify, {
@@ -408,7 +409,8 @@ function fastify (options) {
     logger,
     hasLogger,
     setupResponseListeners,
-    throwIfAlreadyStarted
+    throwIfAlreadyStarted,
+    validateHTTPVersion: compileValidateHTTPVersion(options)
   })
 
   // Delay configuring clientError handler so that it can access fastify state.
@@ -607,7 +609,7 @@ function fastify (options) {
     if (req.headers['accept-version'] !== undefined) {
       // we remove the accept-version header for performance result
       // because we do not want to go through the constraint checking
-      // the usage of symbol here to prevent any colision on custom header name
+      // the usage of symbol here to prevent any collision on custom header name
       req.headers[kRequestAcceptVersion] = req.headers['accept-version']
       req.headers['accept-version'] = undefined
     }

package/lib/hooks.js

@@ -231,6 +231,10 @@ function onSendHookRunner (functions, request, reply, payload, cb) {
   }
 
   function handleReject (err) {
+    if (!err) {
+      err = new FST_ERR_SEND_UNDEFINED_ERR()
+    }
+
     cb(err, request, reply, payload)
   }
 

package/lib/pluginUtils.js

@@ -103,8 +103,8 @@ function checkVersion (fn) {
 
   const requiredVersion = meta.fastify
 
-  const sanitizedVersion = this.version.replace(/-rc.\d+$/, '')
-  if (requiredVersion && !semver.satisfies(sanitizedVersion, requiredVersion)) {
+  const fastifyRc = /-rc.+$/.test(this.version)
+  if (requiredVersion && semver.satisfies(this.version, requiredVersion, { includePrerelease: fastifyRc }) === false) {
     throw new FST_ERR_PLUGIN_VERSION_MISMATCH(meta.name, requiredVersion, this.version)
   }
 }

package/lib/route.js

@@ -20,7 +20,8 @@ const {
   FST_ERR_SCH_SERIALIZATION_BUILD,
   FST_ERR_DEFAULT_ROUTE_INVALID_TYPE,
   FST_ERR_DUPLICATED_ROUTE,
-  FST_ERR_INVALID_URL
+  FST_ERR_INVALID_URL,
+  FST_ERR_SEND_UNDEFINED_ERR
 } = require('./errors')
 
 const {
@@ -47,7 +48,6 @@ function buildRouting (options) {
   let avvio
   let fourOhFour
   let requestIdHeader
-  let querystringParser
   let requestIdLogLabel
   let logger
   let hasLogger
@@ -58,6 +58,7 @@ function buildRouting (options) {
   let ignoreTrailingSlash
   let return503OnClosing
   let globalExposeHeadRoutes
+  let validateHTTPVersion
 
   let closing = false
 
@@ -69,10 +70,10 @@ function buildRouting (options) {
       hasLogger = fastifyArgs.hasLogger
       setupResponseListeners = fastifyArgs.setupResponseListeners
       throwIfAlreadyStarted = fastifyArgs.throwIfAlreadyStarted
+      validateHTTPVersion = fastifyArgs.validateHTTPVersion
 
       globalExposeHeadRoutes = options.exposeHeadRoutes
       requestIdHeader = options.requestIdHeader
-      querystringParser = options.querystringParser
       requestIdLogLabel = options.requestIdLogLabel
       genReqId = options.genReqId
       disableRequestLogging = options.disableRequestLogging
@@ -94,7 +95,18 @@ function buildRouting (options) {
     },
     routeHandler,
     closeRoutes: () => { closing = true },
-    printRoutes: router.prettyPrint.bind(router)
+    printRoutes: router.prettyPrint.bind(router),
+    addConstraintStrategy,
+    hasConstraintStrategy
+  }
+
+  function addConstraintStrategy (strategy) {
+    throwIfAlreadyStarted('Cannot add constraint strategy when fastify instance is already started!')
+    return router.addConstraintStrategy(strategy)
+  }
+
+  function hasConstraintStrategy (strategyName) {
+    return router.hasConstraintStrategy(strategyName)
   }
 
   // Convert shorthand to extended route declaration
@@ -322,7 +334,19 @@ function buildRouting (options) {
   }
 
   // HTTP request entry point, the routing has already been executed
-  function routeHandler (req, res, params, context) {
+  function routeHandler (req, res, params, context, query) {
+    // TODO: The check here should be removed once https://github.com/nodejs/node/issues/43115 resolve in core.
+    if (!validateHTTPVersion(req.httpVersion)) {
+      const message = '{"error":"HTTP Version Not Supported","message":"HTTP Version Not Supported","statusCode":505}'
+      const headers = {
+        'Content-Type': 'application/json',
+        'Content-Length': message.length
+      }
+      res.writeHead(505, headers)
+      res.end(message)
+      return
+    }
+
     if (closing === true) {
       /* istanbul ignore next mac, windows */
       if (req.httpVersionMajor !== 2) {
@@ -374,8 +398,6 @@ function buildRouting (options) {
     const childLogger = logger.child(loggerBinding, loggerOpts)
     childLogger[kDisableRequestLogging] = disableRequestLogging
 
-    const queryPrefix = req.url.indexOf('?')
-    const query = querystringParser(queryPrefix > -1 ? req.url.slice(queryPrefix + 1) : '')
     const request = new context.Request(id, params, req, query, childLogger, context)
     const reply = new context.Reply(res, request, childLogger)
 
@@ -489,6 +511,10 @@ function preParsingHookRunner (functions, request, reply, cb) {
   }
 
   function handleReject (err) {
+    if (!err) {
+      err = new FST_ERR_SEND_UNDEFINED_ERR()
+    }
+
     next(err)
   }
 

package/lib/server.js

@@ -8,7 +8,8 @@ const warnings = require('./warnings')
 const { kState, kOptions, kServerBindings } = require('./symbols')
 const { FST_ERR_HTTP2_INVALID_VERSION, FST_ERR_REOPENED_CLOSE_SERVER, FST_ERR_REOPENED_SERVER } = require('./errors')
 
-module.exports = createServer
+module.exports.createServer = createServer
+module.exports.compileValidateHTTPVersion = compileValidateHTTPVersion
 
 function createServer (options, httpHandler) {
   const server = getServerInstance(options, httpHandler)
@@ -208,6 +209,56 @@ function listenPromise (server, listenOptions) {
   })
 }
 
+/**
+ * Creates a function that, based upon initial configuration, will
+ * verify that every incoming request conforms to allowed
+ * HTTP versions for the Fastify instance, e.g. a Fastify HTTP/1.1
+ * server will not serve HTTP/2 requests upon the result of the
+ * verification function.
+ *
+ * @param {object} options fastify option
+ * @param {function} [options.serverFactory] If present, the
+ * validator function will skip all checks.
+ * @param {boolean} [options.http2 = false] If true, the validator
+ * function will allow HTTP/2 requests.
+ * @param {object} [options.https = null] https server options
+ * @param {boolean} [options.https.allowHTTP1] If true and use
+ * with options.http2 the validator function will allow HTTP/1
+ * request to http2 server.
+ *
+ * @returns {function} HTTP version validator function.
+ */
+function compileValidateHTTPVersion (options) {
+  let bypass = false
+  // key-value map to store valid http version
+  const map = new Map()
+  if (options.serverFactory) {
+    // When serverFactory is passed, we cannot identify how to check http version reliably
+    // So, we should skip the http version check
+    bypass = true
+  }
+  if (options.http2) {
+    // HTTP2 must serve HTTP/2.0
+    map.set('2.0', true)
+    if (options.https && options.https.allowHTTP1 === true) {
+      // HTTP2 with HTTPS.allowHTTP1 allow fallback to HTTP/1.1 and HTTP/1.0
+      map.set('1.1', true)
+      map.set('1.0', true)
+    }
+  } else {
+    // HTTP must server HTTP/1.1 and HTTP/1.0
+    map.set('1.1', true)
+    map.set('1.0', true)
+  }
+  // The compiled function here placed in one of the hottest path inside fastify
+  // the implementation here must be as performant as possible
+  return function validateHTTPVersion (httpVersion) {
+    // `bypass` skip the check when custom server factory provided
+    // `httpVersion in obj` check for the valid http version we should support
+    return bypass || map.has(httpVersion)
+  }
+}
+
 function getServerInstance (options, httpHandler) {
   let server = null
   if (options.serverFactory) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.0.0-rc.2",
+  "version": "4.0.0-rc.3",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -180,7 +180,7 @@
     "@fastify/fast-json-stringify-compiler": "^1.0.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.1.0",
-    "find-my-way": "^5.3.0",
+    "find-my-way": "^6.0.0",
     "light-my-request": "^4.7.0",
     "pino": "^7.5.1",
     "process-warning": "^1.0.0",

package/test/constrained-routes.test.js

@@ -113,12 +113,10 @@ test('Should allow registering custom constrained routes', t => {
   const constraint = {
     name: 'secret',
     storage: function () {
-      let secrets = {}
+      const secrets = {}
       return {
         get: (secret) => { return secrets[secret] || null },
-        set: (secret, store) => { secrets[secret] = store },
-        del: (secret) => { delete secrets[secret] },
-        empty: () => { secrets = {} }
+        set: (secret, store) => { secrets[secret] = store }
       }
     },
     deriveConstraint: (req, ctx) => {
@@ -183,6 +181,266 @@ test('Should allow registering custom constrained routes', t => {
   })
 })
 
+test('Should allow registering custom constrained routes outside constructor', t => {
+  t.plan(8)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify()
+  fastify.addConstraintStrategy(constraint)
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'beta' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from beta' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'X-Secret': 'alpha'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'from alpha' })
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'X-Secret': 'beta'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'from beta' })
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'X-Secret': 'gamma'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 404)
+  })
+})
+
+test('Add a constraint strategy after fastify instance was started', t => {
+  t.plan(4)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => { reply.send('ok') }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'ok')
+    t.equal(res.statusCode, 200)
+
+    t.throws(
+      () => fastify.addConstraintStrategy(constraint),
+      'Cannot add constraint strategy when fastify instance is already started!'
+    )
+  })
+})
+
+test('Add a constraint strategy should throw an error if there already exist custom strategy with the same name', t => {
+  t.plan(1)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify()
+
+  fastify.addConstraintStrategy(constraint)
+  t.throws(
+    () => fastify.addConstraintStrategy(constraint),
+    'There already exists a custom constraint with the name secret.'
+  )
+})
+
+test('Add a constraint strategy shouldn\'t throw an error if default constraint with the same name isn\'t used', t => {
+  t.plan(1)
+
+  const constraint = {
+    name: 'version',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify()
+  fastify.addConstraintStrategy(constraint)
+
+  t.pass()
+})
+
+test('Add a constraint strategy should throw an error if default constraint with the same name is used', t => {
+  t.plan(1)
+
+  const constraint = {
+    name: 'version',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { version: '1.0.0' },
+    handler: (req, reply) => {
+      reply.send('ok')
+    }
+  })
+
+  t.throws(
+    () => fastify.addConstraintStrategy(constraint),
+    'There already exists a route with version constraint.'
+  )
+})
+
+test('The hasConstraintStrategy should return false for default constraints until they are used', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  t.equal(fastify.hasConstraintStrategy('version'), false)
+  t.equal(fastify.hasConstraintStrategy('host'), false)
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  t.equal(fastify.hasConstraintStrategy('version'), false)
+  t.equal(fastify.hasConstraintStrategy('host'), true)
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { version: '1.0.0' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  t.equal(fastify.hasConstraintStrategy('version'), true)
+  t.equal(fastify.hasConstraintStrategy('host'), true)
+})
+
+test('The hasConstraintStrategy should return true if there already exist a custom constraint with the same name', t => {
+  t.plan(2)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify()
+
+  t.equal(fastify.hasConstraintStrategy('secret'), false)
+  fastify.addConstraintStrategy(constraint)
+  t.equal(fastify.hasConstraintStrategy('secret'), true)
+})
+
 test('Should allow registering an unconstrained route after a constrained route', t => {
   t.plan(6)
   const fastify = Fastify()

package/test/hooks.test.js

@@ -3146,6 +3146,64 @@ test('reply.send should throw if undefined error is thrown', t => {
   })
 })
 
+test('reply.send should throw if undefined error is thrown at preParsing hook', t => {
+  /* eslint prefer-promise-reject-errors: ["error", {"allowEmptyReject": true}] */
+
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', function (req, reply, done) {
+    return Promise.reject()
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.send('hello')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 500)
+    t.same(JSON.parse(res.payload), {
+      error: 'Internal Server Error',
+      code: 'FST_ERR_SEND_UNDEFINED_ERR',
+      message: 'Undefined error has occurred',
+      statusCode: 500
+    })
+  })
+})
+
+test('reply.send should throw if undefined error is thrown at onSend hook', t => {
+  /* eslint prefer-promise-reject-errors: ["error", {"allowEmptyReject": true}] */
+
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('onSend', function (req, reply, done) {
+    return Promise.reject()
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.send('hello')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 500)
+    t.same(JSON.parse(res.payload), {
+      error: 'Internal Server Error',
+      code: 'FST_ERR_SEND_UNDEFINED_ERR',
+      message: 'Undefined error has occurred',
+      statusCode: 500
+    })
+  })
+})
+
 test('onTimeout should be triggered', t => {
   t.plan(6)
   const fastify = Fastify({ connectionTimeout: 500 })

package/test/internals/initialConfig.test.js

@@ -68,12 +68,10 @@ test('Fastify.initialConfig should expose all options', t => {
   const versionStrategy = {
     name: 'version',
     storage: function () {
-      let versions = {}
+      const versions = {}
       return {
         get: (version) => { return versions[version] || null },
-        set: (version, store) => { versions[version] = store },
-        del: (version) => { delete versions[version] },
-        empty: () => { versions = {} }
+        set: (version, store) => { versions[version] = store }
       }
     },
     deriveConstraint: (req, ctx) => {
@@ -362,12 +360,10 @@ test('Fastify.initialConfig should accept the deprecated versioning option', t =
 
   const versioning = {
     storage: function () {
-      let versions = {}
+      const versions = {}
       return {
         get: (version) => { return versions[version] || null },
-        set: (version, store) => { versions[version] = store },
-        del: (version) => { delete versions[version] },
-        empty: () => { versions = {} }
+        set: (version, store) => { versions[version] = store }
       }
     },
     deriveVersion: (req, ctx) => {

package/test/internals/server.test.js

@@ -4,7 +4,7 @@ const { test } = require('tap')
 const proxyquire = require('proxyquire')
 
 const Fastify = require('../../fastify')
-const createServer = require('../../lib/server')
+const { createServer } = require('../../lib/server')
 
 const handler = (req, res) => {
   res.writeHead(200, { 'Content-Type': 'application/json' })
@@ -19,7 +19,7 @@ test('start listening', async t => {
 })
 
 test('DNS errors does not stop the main server on localhost - promise interface', async t => {
-  const createServer = proxyquire('../../lib/server', {
+  const { createServer } = proxyquire('../../lib/server', {
     dns: {
       lookup: (hostname, options, cb) => {
         cb(new Error('DNS error'))
@@ -34,7 +34,7 @@ test('DNS errors does not stop the main server on localhost - promise interface'
 
 test('DNS errors does not stop the main server on localhost - callback interface', t => {
   t.plan(2)
-  const createServer = proxyquire('../../lib/server', {
+  const { createServer } = proxyquire('../../lib/server', {
     dns: {
       lookup: (hostname, options, cb) => {
         cb(new Error('DNS error'))
@@ -51,7 +51,7 @@ test('DNS errors does not stop the main server on localhost - callback interface
 
 test('DNS returns empty binding', t => {
   t.plan(2)
-  const createServer = proxyquire('../../lib/server', {
+  const { createServer } = proxyquire('../../lib/server', {
     dns: {
       lookup: (hostname, options, cb) => {
         cb(null, [])
@@ -68,7 +68,7 @@ test('DNS returns empty binding', t => {
 
 test('DNS returns more than two binding', t => {
   t.plan(2)
-  const createServer = proxyquire('../../lib/server', {
+  const { createServer } = proxyquire('../../lib/server', {
     dns: {
       lookup: (hostname, options, cb) => {
         cb(null, [

package/test/listen.test.js

@@ -7,7 +7,6 @@ const { test, before } = require('tap')
 const dns = require('dns').promises
 const dnsCb = require('dns')
 const sget = require('simple-get').concat
-const semver = require('semver')
 const Fastify = require('..')
 
 let localhost
@@ -372,12 +371,19 @@ test('addresses getter', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
   for (const address of localAddresses) {
     address.port = port
-    if (semver.lt(process.versions.node, '18.0.0')) {
+    if (typeof address.family === 'number') {
+      address.family = 'IPv' + address.family
+    }
+  }
+  const appAddresses = app.addresses()
+  for (const address of appAddresses) {
+    if (typeof address.family === 'number') {
       address.family = 'IPv' + address.family
     }
   }
   localAddresses.sort((a, b) => a.address.localeCompare(b.address))
-  t.same(app.addresses().sort((a, b) => a.address.localeCompare(b.address)), localAddresses, 'after listen')
+  appAddresses.sort((a, b) => a.address.localeCompare(b.address))
+  t.same(appAddresses, localAddresses, 'after listen')
 
   await app.close()
   t.same(app.addresses(), [], 'after close')

package/test/types/instance.test-d.ts

@@ -10,6 +10,7 @@ import fastify, {
 import { HookHandlerDoneFunction } from '../../types/hooks'
 import { FastifyReply } from '../../types/reply'
 import { FastifyRequest } from '../../types/request'
+import { DefaultRoute } from '../../types/route'
 import { FastifySchemaControllerOptions } from '../../types/schema'
 
 const server = fastify()
@@ -307,3 +308,19 @@ expectError(server.decorate<string>('test', true))
 expectError(server.decorate<(myNumber: number) => number>('test', function (myNumber: number): string {
   return ''
 }))
+
+const versionConstraintStrategy = {
+  name: 'version',
+  storage: () => ({
+    get: () => () => {},
+    set: () => { },
+    del: () => { },
+    empty: () => { }
+  }),
+  validate () {},
+  deriveConstraint: () => 'foo'
+}
+expectType<void>(server.addConstraintStrategy(versionConstraintStrategy))
+expectType<boolean>(server.hasConstraintStrategy(versionConstraintStrategy.name))
+
+expectAssignable<DefaultRoute<RawRequestDefaultExpression, RawReplyDefaultExpression>>(server.getDefaultRoute())

package/test/unsupported-httpversion.test.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const net = require('net')
+const t = require('tap')
+const Fastify = require('../fastify')
+
+t.test('Will return 505 HTTP error if HTTP version (default) is not supported', t => {
+  const fastify = Fastify()
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const port = fastify.server.address().port
+    const client = net.createConnection({ port }, () => {
+      client.write('GET / HTTP/5.1\r\n\r\n')
+
+      client.once('data', data => {
+        t.match(data.toString(), /505 HTTP Version Not Supported/i)
+        client.end(() => {
+          t.end()
+        })
+      })
+    })
+  })
+})
+
+t.test('Will return 505 HTTP error if HTTP version (2.0 when server is 1.1) is not supported', t => {
+  const fastify = Fastify()
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const port = fastify.server.address().port
+    const client = net.createConnection({ port }, () => {
+      client.write('GET / HTTP/2.0\r\n\r\n')
+
+      client.once('data', data => {
+        t.match(data.toString(), /505 HTTP Version Not Supported/i)
+        client.end(() => {
+          t.end()
+        })
+      })
+    })
+  })
+})

package/test/versioned-routes.test.js

@@ -480,12 +480,10 @@ test('Should register a versioned route with custom versioning strategy', t => {
   const customVersioning = {
     name: 'version',
     storage: function () {
-      let versions = {}
+      const versions = {}
       return {
         get: (version) => { return versions[version] || null },
-        set: (version, store) => { versions[version] = store },
-        del: (version) => { delete versions[version] },
-        empty: () => { versions = {} }
+        set: (version, store) => { versions[version] = store }
       }
     },
     deriveConstraint: (req, ctx) => {
@@ -561,12 +559,10 @@ test('Should get error using an invalid a versioned route, using default validat
   const fastify = Fastify({
     versioning: {
       storage: function () {
-        let versions = {}
+        const versions = {}
         return {
           get: (version) => { return versions[version] || null },
-          set: (version, store) => { versions[version] = store },
-          del: (version) => { delete versions[version] },
-          empty: () => { versions = {} }
+          set: (version, store) => { versions[version] = store }
         }
       },
       deriveVersion: (req, ctx) => {

package/types/instance.d.ts

@@ -1,4 +1,6 @@
+import * as http from 'http'
 import { FastifyError } from '@fastify/error'
+import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
 import { CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse } from 'light-my-request'
 import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction, removeAllContentTypeParsers, removeContentTypeParser } from './content-type-parser'
 import { onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler } from './hooks'
@@ -29,6 +31,7 @@ export interface PrintRoutesOptions {
 }
 
 type NotInInterface<Key, _Interface> = Key extends keyof _Interface ? never : Key
+type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
 
 /**
  * Fastify server instance. Returned by the core `fastify()` method.
@@ -83,6 +86,9 @@ export interface FastifyInstance<
   hasRequestDecorator(decorator: string | symbol): boolean;
   hasReplyDecorator(decorator: string | symbol): boolean;
 
+  addConstraintStrategy(strategy: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>): void;
+  hasConstraintStrategy(strategyName: string): boolean;
+
   inject(opts: InjectOptions | string, cb: LightMyRequestCallback): void;
   inject(opts: InjectOptions | string): Promise<LightMyRequestResponse>;
   inject(): LightMyRequestChain;
@@ -206,7 +212,7 @@ export interface FastifyInstance<
   register: FastifyRegister<FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> & PromiseLike<undefined>>;
 
   routing(req: RawRequest, res: RawReply): void;
-  getDefaultRoute: DefaultRoute<RawRequest, RawReply>;
+  getDefaultRoute(): DefaultRoute<RawRequest, RawReply>;
   setDefaultRoute(defaultRoute: DefaultRoute<RawRequest, RawReply>): void;
 
   route<