fastify 6.0.0-alpha.5 → 6.0.0-alpha.6

package/docs/Reference/Request.md

@@ -1,42 +1,112 @@
 <h1 align="center">Fastify</h1>
 
 ## Request
+- [Introduction](#introduction)
+- [Request](#request-object)
+  - [Properties](#properties)
+    - [.body](#body)
+    - [.query](#query)
+    - [.params](#params)
+    - [.headers](#headers)
+    - [.id](#id)
+    - [.log](#log)
+    - [.method](#method)
+    - [.url](#url)
+    - [.routeOptions](#routeoptions)
+    - [.server](#server)
+    - [.raw](#raw)
+    - [.ip](#ip)
+    - [.ips](#ips)
+    - [.host](#host)
+    - [.hostname](#hostname)
+    - [.port](#port)
+    - [.protocol](#protocol)
+    - [.originalUrl](#originalurl)
+    - [.mediaType](#mediatype)
+    - [.signal](#signal)
+    - [.socket](#socket)
+    - [.is404](#is404)
+    - [.validationError](#validationerror)
+  - [Methods](#methods)
+    - [.getDecorator(name)](#getdecorator)
+    - [.setDecorator(name, value)](#setdecorator)
+    - [.getValidationFunction(schema | httpPart)](#getvalidationfunction)
+    - [.compileValidationSchema(schema, [httpPart])](#compilevalidationschema)
+    - [.validateInput(data, [schema | httpPart], [httpPart])](#validate)
+
+### Introduction
+<a id="introduction"></a>
+
 The first parameter of the handler function is `Request`.
 
 Request is a core Fastify object containing the following fields:
-- `query` - The parsed querystring, its format is specified by
-  [`querystringParser`](./Server.md#querystringparser).
-- `body` - The request payload, see [Content-Type Parser](./ContentTypeParser.md)
-  for details on what request payloads Fastify natively parses and how to support
-  other content types.
-- `params` - The params matching the URL. Values are percent-decoded
-  (for example `%20` becomes a space, and `%2f` becomes `/`). Decoded
-  values may contain `.`, `..`, `/`, or other characters; treat them as
-  untrusted input. See the security note below and
-  [Routes - Url building](./Routes.md#url-building).
+- `query` - The parsed querystring.
+- `body` - The request payload.
+- `params` - The params matching the URL.
 - [`headers`](#headers) - The headers getter and setter.
 - `raw` - The incoming HTTP request from Node core.
-- `server` - The Fastify server instance, scoped to the current
-  [encapsulation context](./Encapsulation.md).
+- `server` - The Fastify server instance.
 - `id` - The request ID.
 - `log` - The logger instance of the incoming request.
-- `ip` - The IP address of the incoming request. This value is taken from
-  `socket.remoteAddress` (or from `X-Forwarded-For` when
-  [`trustProxy`](./Server.md#factory-trust-proxy) is enabled).
-- `ips` - An array of IP addresses, ordered from closest to furthest, from
-  `X-Forwarded-For` (only when
-  [`trustProxy`](./Server.md#factory-trust-proxy) is enabled).
-- `host` - The host of the incoming request (derived from `X-Forwarded-Host`
-  when [`trustProxy`](./Server.md#factory-trust-proxy) is enabled). For HTTP/2
-  compatibility, it returns `:authority` if no host header exists. The host
-  header may return an empty string if `requireHostHeader` is `false`, not
-  provided with HTTP/1.0, or removed by schema validation.
+- `ip` - The IP address of the incoming request.
+- `ips` - An array of IP addresses from `X-Forwarded-For`.
+- `host` - The host of the incoming request.
 - `hostname` - The hostname parsed from `request.host`.
-- `port` - The port parsed from `request.host`, which may refer to the port the
-  server is listening on.
-- `protocol` - The protocol of the incoming request (`https` or `http`). This
-  value comes from `socket.encrypted` (or `X-Forwarded-Proto` when
-  [`trustProxy`](./Server.md#factory-trust-proxy) is enabled).
+- `port` - The port parsed from `request.host`.
+- `protocol` - The protocol of the incoming request (`https` or `http`).
+- `method` - The method of the incoming request.
+- `url` - The URL of the incoming request.
+- `originalUrl` - The original URL of the incoming request.
+- `mediaType` - The media type extracted from `Content-Type` header.
+- `is404` - `true` if request is being handled by 404 handler, `false` otherwise.
+- `socket` - The underlying connection of the incoming request.
+- `signal` - An `AbortSignal` that aborts on handler timeout or client
+  disconnect.
+- `routeOptions` - The route [`option`](./Routes.md#routes-options) object.
+- `validationError` - The validation error, when `attachValidation` is set.
+- `getDecorator(name)` - Returns the value of a request decorator.
+- `setDecorator(name, value)` - Sets the value of a request decorator.
+- [.getValidationFunction(schema | httpPart)](#getvalidationfunction) -
+  Returns a validation function for the specified schema or HTTP part, if
+  set or cached.
+- [.compileValidationSchema(schema, [httpPart])](#compilevalidationschema) -
+  Compiles the specified schema and returns a validation function using the
+  default (or customized) `ValidationCompiler`. The optional `httpPart` is
+  forwarded to the `ValidationCompiler` if provided, defaults to `null`.
+- [.validateInput(data, schema | httpPart, [httpPart])](#validate) -
+  Validates the input using the specified schema or HTTP part and returns
+  `true` if the input is valid, `false` otherwise. If `httpPart` is provided,
+  the function uses the validator for that HTTP part. Defaults to `null`.
+
+```js
+fastify.post('/:params', options, function (request, reply) {
+  console.log(request.body)
+  console.log(request.query)
+  console.log(request.params)
+  console.log(request.headers)
+  console.log(request.raw)
+  console.log(request.server)
+  console.log(request.id)
+  console.log(request.ip)
+  console.log(request.ips)
+  console.log(request.host)
+  console.log(request.hostname)
+  console.log(request.port)
+  console.log(request.protocol)
+  console.log(request.url)
+  console.log(request.routeOptions.method)
+  console.log(request.routeOptions.bodyLimit)
+  console.log(request.routeOptions.handlerTimeout)
+  console.log(request.routeOptions.url)
+  console.log(request.routeOptions.attachValidation)
+  console.log(request.routeOptions.logLevel)
+  console.log(request.routeOptions.version)
+  console.log(request.routeOptions.exposeHeadRoute)
+  console.log(request.routeOptions.prefixTrailingSlash)
+  console.log(request.routeOptions.config)
+  request.log.info('some info')
+})
+```
 
 > ⚠️ Security:
 > `request.params`, `request.query`, `request.headers`, and `request.body`
@@ -55,51 +125,32 @@ Request is a core Fastify object containing the following fields:
 > they must be validated explicitly (for example: trusted proxy
 > configuration, allow-lists, strict parsing, and normalization).
 
-- `method` - The method of the incoming request.
-- `url` - The URL of the incoming request.
-- `originalUrl` - Similar to `url`, allows access to the original `url` in
-  case of internal re-routing.
-- `mediaType` - The media type extracted from `Content-Type` header. When `Content-Type`
-  header is missing, it will return `undefined`.
-- `is404` - `true` if request is being handled by 404 handler, `false` otherwise.
-- `socket` - The underlying connection of the incoming request.
-- `signal` - An `AbortSignal` that aborts when the handler timeout
-  fires or the client disconnects. Created lazily on first access, so
-  there is zero overhead when not used. When
-  [`handlerTimeout`](./Server.md#factory-handler-timeout) is configured,
-  the signal is pre-created and also aborts on timeout. Pass it to
-  `fetch()`, database queries, or any API accepting a `signal` option
-  for cooperative cancellation. On timeout, `signal.reason` is the
-  `FST_ERR_HANDLER_TIMEOUT` error; on client disconnect it is a generic
-  `AbortError`. Check `signal.reason.code` to distinguish the two cases.
-- `routeOptions` - The route [`option`](./Routes.md#routes-options) object.
-  - `bodyLimit` - Either server limit or route limit.
-  - `handlerTimeout` - The handler timeout configured for this route.
-  - `config` - The [`config`](./Routes.md#routes-config) object for this route.
-  - `method` - The HTTP method for the route.
-  - `url` - The path of the URL to match this route.
-  - `handler` - The handler for this route.
-  - `attachValidation` - Attach `validationError` to request (if there is
-    a schema defined).
-  - `logLevel` - Log level defined for this route.
-  - `schema` - The JSON schemas definition for this route.
-  - `version` - A semver compatible string that defines the version of the endpoint.
-  - `exposeHeadRoute` - Creates a sibling HEAD route for any GET routes.
-  - `prefixTrailingSlash` - String used to determine how to handle passing `/`
-    as a route with a prefix.
-- [.getValidationFunction(schema | httpPart)](#getvalidationfunction) -
-  Returns a validation function for the specified schema or HTTP part, if
-  set or cached.
-- [.compileValidationSchema(schema, [httpPart])](#compilevalidationschema) -
-  Compiles the specified schema and returns a validation function using the
-  default (or customized) `ValidationCompiler`. The optional `httpPart` is
-  forwarded to the `ValidationCompiler` if provided, defaults to `null`.
-- [.validateInput(data, schema | httpPart, [httpPart])](#validate) -
-  Validates the input using the specified schema or HTTP part and returns
-  `true` if the input is valid, `false` otherwise. If `httpPart` is provided,
-  the function uses the validator for that HTTP part. Defaults to `null`.
+### Request
+<a id="request-object"></a>
+
+#### Properties
+<a id="properties"></a>
+
+##### .body
+
+The request payload. See [Content-Type Parser](./ContentTypeParser.md) for
+details on what request payloads Fastify natively parses and how to support
+other content types.
+
+##### .query
 
-### Headers
+The parsed querystring. Its format is specified by
+[`querystringParser`](./Server.md#querystringparser).
+
+##### .params
+
+The params matching the URL. Values are percent-decoded (for example `%20`
+becomes a space, and `%2f` becomes `/`). Decoded values may contain `.`, `..`,
+`/`, or other characters; treat them as untrusted input. See the
+[security note](#introduction) and
+[Routes - Url building](./Routes.md#url-building).
+
+##### .headers
 
 The `request.headers` is a getter that returns an object with the headers of the
 incoming request. Set custom headers as follows:
@@ -112,7 +163,7 @@ request.headers = {
 ```
 
 This operation adds new values to the request headers, accessible via
-`request.headers.bar`. Standard request headers remain accessible via
+`request.headers.foo`. Standard request headers remain accessible via
 `request.raw.headers`.
 
 For performance reasons, `Symbol('fastify.RequestAcceptVersion')` may be added
@@ -130,41 +181,186 @@ to headers on `not found` routes.
 > your application needs an allow-listed header subset, build and consume it
 > explicitly from the validated data or from `request.raw.headers`.
 
+##### .id
+
+The request ID. It is generated by [`genReqId`](./Server.md#genreqid), or read
+from the header configured with [`requestIdHeader`](./Server.md#requestidheader)
+when the incoming request includes it.
+
+##### .log
+
+The logger instance of the incoming request. By default, it is a child logger of
+the server logger that adds the request ID (`reqId`) to every log line. See
+[`childLoggerFactory`](./Server.md#childLoggerFactory) to customize it.
+
+##### .method
+
+The method of the incoming request.
+
+##### .url
+
+The URL of the incoming request.
+
+##### .routeOptions
+
+The route [`option`](./Routes.md#routes-options) object.
+- `bodyLimit` - Either server limit or route limit.
+- `handlerTimeout` - The handler timeout configured for this route.
+- `config` - The [`config`](./Routes.md#routes-config) object for this route.
+- `method` - The HTTP method for the route.
+- `url` - The path of the URL to match this route.
+- `handler` - The handler for this route.
+- `attachValidation` - Attach `validationError` to request (if there is
+  a schema defined).
+- `logLevel` - Log level defined for this route.
+- `schema` - The JSON schemas definition for this route.
+- `version` - A semver compatible string that defines the version of the
+  endpoint.
+- `exposeHeadRoute` - Creates a sibling HEAD route for any GET routes.
+- `prefixTrailingSlash` - String used to determine how to handle passing `/`
+  as a route with a prefix.
+
+##### .server
+
+The Fastify server instance, scoped to the current
+[encapsulation context](./Encapsulation.md).
+
+##### .raw
+
+The incoming HTTP request from Node core.
+
+##### .ip
+
+The IP address of the incoming request. This value is taken from
+`socket.remoteAddress` (or from `X-Forwarded-For` when
+[`trustProxy`](./Server.md#factory-trust-proxy) is enabled). It is `undefined`
+when the underlying socket is not available.
+
+##### .ips
+
+An array of IP addresses, ordered from closest to furthest, from
+`X-Forwarded-For` (only when [`trustProxy`](./Server.md#factory-trust-proxy) is
+enabled). It is `undefined` when `trustProxy` is not enabled.
+
+##### .host
+
+The host of the incoming request (derived from `X-Forwarded-Host` when
+[`trustProxy`](./Server.md#factory-trust-proxy) is enabled). For HTTP/2
+compatibility, it returns `:authority` if no host header exists. The host header
+may return an empty string if `requireHostHeader` is `false`, not provided with
+HTTP/1.0, or removed by schema validation.
+
+##### .hostname
+
+The hostname parsed from `request.host`. For IPv6 hosts, the brackets are kept
+(for example, `[::1]`).
+
+##### .port
+
+The port parsed from `request.host`, which may refer to the port the server is
+listening on. It is `null` when the host does not include a port.
+
+##### .protocol
+
+The protocol of the incoming request (`https` or `http`). This value comes from
+`socket.encrypted` (or `X-Forwarded-Proto` when
+[`trustProxy`](./Server.md#factory-trust-proxy) is enabled). It is `undefined`
+when the underlying socket is not available.
+
+##### .originalUrl
+
+Similar to `url`, allows access to the original `url` in case of internal
+re-routing.
+
+##### .mediaType
+
+The media type extracted from `Content-Type` header. When `Content-Type` header
+is missing, it will return `undefined`.
+
+##### .signal
+
+An `AbortSignal` that aborts when the handler timeout fires or the client
+disconnects. Created lazily on first access, so there is zero overhead when not
+used. When [`handlerTimeout`](./Server.md#factory-handler-timeout) is
+configured, the signal is pre-created and also aborts on timeout. Pass it to
+`fetch()`, database queries, or any API accepting a `signal` option for
+cooperative cancellation. On timeout, `signal.reason` is the
+`FST_ERR_HANDLER_TIMEOUT` error; on client disconnect it is a generic
+`AbortError`. Check `signal.reason.code` to distinguish the two cases.
+
+##### .socket
+
+The underlying connection of the incoming request.
+
+##### .is404
+
+`true` if request is being handled by 404 handler, `false` otherwise.
+
+##### .validationError
+
+The validation error of the request. It is set only when the route has the
+[`attachValidation`](./Routes.md#routes-options) option enabled and the
+validation fails; otherwise it is `undefined`. In that case, Fastify calls the
+handler instead of replying with a `400` error. See
+[Validation and Serialization](./Validation-and-Serialization.md#error-handling)
+for the properties of the error object.
+
 ```js
-fastify.post('/:params', options, function (request, reply) {
-  console.log(request.body)
-  console.log(request.query)
-  console.log(request.params)
-  console.log(request.headers)
-  console.log(request.raw)
-  console.log(request.server)
-  console.log(request.id)
-  console.log(request.ip)
-  console.log(request.ips)
-  console.log(request.host)
-  console.log(request.hostname)
-  console.log(request.port)
-  console.log(request.protocol)
-  console.log(request.url)
-  console.log(request.routeOptions.method)
-  console.log(request.routeOptions.bodyLimit)
-  console.log(request.routeOptions.handlerTimeout)
-  console.log(request.routeOptions.url)
-  console.log(request.routeOptions.attachValidation)
-  console.log(request.routeOptions.logLevel)
-  console.log(request.routeOptions.version)
-  console.log(request.routeOptions.exposeHeadRoute)
-  console.log(request.routeOptions.prefixTrailingSlash)
-  console.log(request.routeOptions.config)
-  request.log.info('some info')
+fastify.post('/', { schema, attachValidation: true }, function (request, reply) {
+  if (request.validationError) {
+    // `request.validationError.validationContext` is the failed part,
+    // for example `body`
+    reply.code(422).send(request.validationError)
+    return
+  }
+  reply.send({ hello: 'world' })
+})
+```
+
+#### Methods
+<a id="methods"></a>
+
+##### .getDecorator(name)
+<a id="getdecorator"></a>
+
+Returns the value of a request decorator declared with
+[`decorateRequest`](./Decorators.md#decoraterequestname-value-dependencies).
+If the decorator is a function, it is returned bound to the request. It throws
+an `FST_ERR_DEC_UNDECLARED` error if the decorator has not been declared. See
+[`getDecorator`](./Decorators.md#getdecoratorname) for more details.
+
+```js
+fastify.decorateRequest('user', null)
+
+fastify.get('/', function (request, reply) {
+  const user = request.getDecorator('user')
+  reply.send({ user })
 })
 ```
-### .getValidationFunction(schema | httpPart)
+
+##### .setDecorator(name, value)
+<a id="setdecorator"></a>
+
+Sets the value of a request decorator declared with
+[`decorateRequest`](./Decorators.md#decoraterequestname-value-dependencies).
+It throws an `FST_ERR_DEC_UNDECLARED` error if the decorator has not been
+declared. See [`setDecorator`](./Decorators.md#setdecoratorname-value) for more
+details.
+
+```js
+fastify.decorateRequest('user', null)
+
+fastify.addHook('preHandler', async (request) => {
+  request.setDecorator('user', 'Bob Dylan')
+})
+```
+
+##### .getValidationFunction(schema | httpPart)
 <a id="getvalidationfunction"></a>
 
 By calling this function with a provided `schema` or `httpPart`, it returns a
 `validation` function to validate diverse inputs. It returns `undefined` if no
-serialization function is found using the provided inputs.
+validation function is found using the provided inputs.
 
 This function has an `errors` property. Errors encountered during the last
 validation are assigned to `errors`.
@@ -190,10 +386,10 @@ console.log(validate({ foo: 0.5 })) // false
 console.log(validate.errors) // validation errors
 ```
 
-See [.compileValidationSchema(schema, [httpStatus])](#compileValidationSchema)
+See [.compileValidationSchema(schema, [httpPart])](#compilevalidationschema)
 for more information on compiling validation schemas.
 
-### .compileValidationSchema(schema, [httpPart])
+##### .compileValidationSchema(schema, [httpPart])
 <a id="compilevalidationschema"></a>
 
 This function compiles a validation schema and returns a function to validate data.
@@ -231,8 +427,8 @@ const validate = request
                         type: 'string'
                       }
                     }
-                  }, 200)
-console.log(validate({ hello: 'world' })) // false
+                  }, 'body')
+console.log(validate({ foo: {} })) // false
 console.log(validate.errors) // validation errors
 ```
 
@@ -280,7 +476,7 @@ const newValidate = request.compileValidationSchema(newSchema)
 console.log(newValidate === validate) // false
 ```
 
-### .validateInput(data, [schema | httpPart], [httpPart])
+##### .validateInput(data, [schema | httpPart], [httpPart])
 <a id="validate"></a>
 
 This function validates the input based on the provided schema or HTTP part. If
@@ -318,5 +514,5 @@ request
   .validateInput({ hello: 'world'}, 'query') // false
 ```
 
-See [.compileValidationSchema(schema, [httpStatus])](#compileValidationSchema)
+See [.compileValidationSchema(schema, [httpPart])](#compilevalidationschema)
 for more information on compiling validation schemas.

package/docs/Reference/Server.md

@@ -41,6 +41,7 @@ describes the properties available in that options object.
     - [`allowUnsafeRegex`](#allowunsaferegex)
     - [`buildPrettyMeta`](#buildprettymeta)
     - [`caseSensitive`](#casesensitive)
+    - [`compile`](#compile)
     - [`constraints`](#constraints)
     - [`defaultRoute`](#defaultroute)
     - [`ignoreDuplicateSlashes`](#ignoreduplicateslashes)
@@ -920,6 +921,36 @@ fastify.get('/user/:username', (request, reply) => {
 })
 ```
 
+### `compile`
+<a id="compile"></a>
+
++ Default: `false`
+
+When `true`, Fastify calls the
+[`compile()`](https://github.com/delvedor/find-my-way#compiler-mode) method of
+`find-my-way` once all the routes are registered, right before the
+[`onReady`](./Hooks.md#onready) hooks run. This applies to both the main
+router and the router used for [not found handlers](#set-not-found-handler).
+Each HTTP method's routing tree is
+turned into generated JavaScript instead of being walked for every request,
+which makes route lookups faster. Matching semantics are the same as with the
+default tree walk.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    compile: true
+  }
+})
+```
+
+Keep in mind that:
+
++ the compiled matcher works on the raw request URL; URLs containing
+  percent-encoded characters fall back to the decoded path and are not faster;
++ every route generates its own code, so applications with thousands of routes
+  produce a large amount of JavaScript, which needs to warm up per route.
+
 ### `constraints`
 <a id="constraints"></a>
 
@@ -1044,9 +1075,14 @@ multi) routes by using `maxParamLength` option; the default value is 100
 characters. If the maximum length limit is reached, the not found route will
 be invoked.
 
-This can be useful especially if you have a regex-based route, protecting you
-against [ReDoS
+For regex routes, the limit applies to the values captured by the regular
+expression, and it is checked only after the expression has run against the
+whole path segment. `maxParamLength` therefore does not limit the input a route
+regex processes and does not protect against [ReDoS
 attacks](https://community.owasp.org/attacks/Regular_expression_Denial_of_Service_-_ReDoS).
+To guard against ReDoS, keep [`allowUnsafeRegex`](#allow-unsafe-regex)
+disabled so that potentially catastrophic regular expressions are rejected when
+the route is registered.
 
 
 ### `onBadUrl`
@@ -2382,6 +2418,7 @@ The properties that can currently be exposed are:
   - allowUnsafeRegex
   - buildPrettyMeta
   - caseSensitive
+  - compile
   - constraints
   - defaultRoute
   - ignoreDuplicateSlashes

package/docs/Reference/Validation-and-Serialization.md

@@ -799,7 +799,7 @@ For example:
 const schema = {
   response: {
     200: {
-      description: 'Response schema that support different content types'
+      description: 'Response schema that support different content types',
       content: {
         'application/json': {
           schema: {
@@ -851,6 +851,15 @@ const schema = {
 fastify.post('/url', { schema }, handler)
 ```
 
+> When the route declares a per-content-type response schema through `content`,
+> Fastify matches the response `Content-Type` against the declared keys and falls
+> back to `*/*` (if present). If the response `Content-Type` is not declared and
+> there is no `*/*` key, serialization **fails closed**: Fastify throws
+> `FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN` and replies with a `500` error,
+> instead of silently serializing the payload with `JSON.stringify` (which would
+> bypass the response schema). Every `Content-Type` a route may respond with must
+> be declared, or the route must define a `*/*` catch-all.
+
 #### Serializer Compiler
 <a id="schema-serializer"></a>
 
@@ -931,6 +940,11 @@ message has to be rebuilt from the raw validation result:
 - `validationContext` is the part of the request that failed validation
   (`body`, `params`, `querystring` or `headers`).
 - `code` is `FST_ERR_VALIDATION` and `statusCode` is `400`.
+- When the validator reports a list of errors (as Ajv does) and the default
+  [`schemaErrorFormatter`](#schemaerrorformatter) is used, the error is an
+  instance of [`FST_ERR_VALIDATION`](./Errors.md#fst_err_validation) without a
+  [stack trace](./Errors.md#errors-in-input-data). Errors returned by the
+  validator itself, or by a custom formatter, are used as they are.
 
 ```js
 const fastify = Fastify()

package/fastify.d.ts

@@ -96,6 +96,7 @@ declare namespace fastify {
   type TrustProxyFunction = (address: string, hop: number) => boolean
 
   export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'onMaxParamLength' | 'querystringParser' | 'constraints'> & {
+    compile?: boolean,
     constraints?: {
       [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
     },

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '6.0.0-alpha.4'
+const VERSION = '6.0.0-alpha.6'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -83,6 +83,23 @@ const { buildErrorHandler } = require('./lib/error-handler.js')
 
 const initChannel = diagnostics.channel('fastify.initialization')
 
+function asyncDisposableHook (disposable) {
+  return function (instance, done) {
+    disposable[Symbol.asyncDispose]().then(() => done(), done)
+  }
+}
+
+function disposableHook (disposable) {
+  return function (instance, done) {
+    try {
+      disposable[Symbol.dispose]()
+      done()
+    } catch (err) {
+      done(err)
+    }
+  }
+}
+
 /**
  * @param {import('./fastify.js').FastifyServerOptions} serverOptions
  */
@@ -381,6 +398,13 @@ function fastify (serverOptions) {
 
   // cache the closing value, since we are checking it in an hot path
   avvio.once('preReady', () => {
+    // All the routes are registered at this point. Routes added or removed
+    // afterwards make find-my-way compile the changed trees again lazily.
+    if (options.routerOptions.compile === true) {
+      router.compileRoutes()
+      fourOhFour.router.compile()
+    }
+
     fastify.onClose((instance, done) => {
       fastify[kState].closing = true
       router.closeRoutes()
@@ -598,6 +622,16 @@ function fastify (serverOptions) {
       }
     }
 
+    if (name === 'onClose' && typeof fn !== 'function') {
+      if (typeof fn[Symbol.asyncDispose] === 'function') {
+        fn = asyncDisposableHook(fn)
+      } else if (typeof fn[Symbol.dispose] === 'function') {
+        fn = disposableHook(fn)
+      } else {
+        throw new errorCodes.FST_ERR_HOOK_INVALID_HANDLER(name, Object.prototype.toString.call(fn))
+      }
+    }
+
     if (name === 'onClose') {
       this.onClose(fn.bind(this))
     } else if (name === 'onReady' || name === 'onListen' || name === 'onRoute' || name === 'preClose') {