fastify 4.1.0 → 4.2.0

package/docs/Guides/Delay-Accepting-Requests.md

@@ -48,7 +48,7 @@ server (fewer resources allocated to a bound-to-fail task) and for the client
 That will be achieved by wrapping into a custom plugin two main features:
 
 1. the mechanism for authenticating with the provider
-[decorating](../Referece/Decorators.md) the `fastify` object with the
+[decorating](../Reference/Decorators.md) the `fastify` object with the
 authentication key (`magicKey` from here onwards)
 1. the mechanism for denying requests that would, otherwise, fail
 

package/docs/Guides/Ecosystem.md

@@ -132,9 +132,15 @@ section.
   sampling process metrics.
 - [`@dnlup/fastify-traps`](https://github.com/dnlup/fastify-traps) A plugin to
   close the server gracefully on `SIGINT` and `SIGTERM` signals.
+- [`@eropple/fastify-openapi3`](https://github.com/eropple/fastify-openapi3) Provides
+  easy, developer-friendly OpenAPI 3.1 specs + doc explorer based on your routes.
 - [`@gquittet/graceful-server`](https://github.com/gquittet/graceful-server)
   Tiny (~5k), Fast, KISS, and dependency-free Node.JS library to make your
   Fastify API graceful.
+- [`@h4ad/serverless-adapter`](https://github.com/H4ad/serverless-adapter)
+  Run REST APIs and other web applications using your existing Node.js 
+  application framework (Express, Koa, Hapi and Fastify), on top of AWS Lambda, 
+  Huawei and many other clouds.
 - [`@immobiliarelabs/fastify-metrics`](https://github.com/immobiliare/fastify-metrics)
   Minimalistic and opinionated plugin that collects usage/process metrics and
   dispatches to [statsd](https://github.com/statsd/statsd).
@@ -327,6 +333,8 @@ section.
   Kubernetes client plugin.
 - [`fastify-language-parser`](https://github.com/lependu/fastify-language-parser)
   Fastify plugin to parse request language.
+- [`fastify-lcache`](https://github.com/denbon05/fastify-lcache)
+  Lightweight cache plugin
 - [`fastify-loader`](https://github.com/TheNoim/fastify-loader) Load routes from
   a directory and inject the Fastify instance in each file.
 - [`fastify-lured`](https://github.com/lependu/fastify-lured) Plugin to load lua
@@ -478,6 +486,8 @@ section.
   Events with `reply.sse( … )` to Fastify.
 - [`fastify-sse-v2`](https://github.com/nodefactoryio/fastify-sse-v2) to provide
   Server-Sent Events using Async Iterators (supports newer versions of Fastify).
+- [`fastify-ssr-vite`](https://github.com/nineohnine/fastify-ssr-vite) A simple
+  plugin for setting up server side rendering with vite.
 - [`fastify-stripe`](https://github.com/coopflow/fastify-stripe) Plugin to
   initialize and encapsulate [Stripe
   Node.js](https://github.com/stripe/stripe-node) instances in Fastify.

package/docs/Guides/Migration-Guide-V4.md

@@ -8,7 +8,39 @@ work after upgrading.
 
 ## Breaking Changes
 
-### Deprecation of `app.use()`
+### Error handling composition ([#3261](https://github.com/fastify/fastify/pull/3261))
+
+When an error is thrown in a async error handler function, 
+the upper-level error handler is executed if set.
+If there is not a upper-level error handler, the default will 
+be executed as it was previously.
+
+```
+import Fastify from 'fastify'
+
+const fastify = Fastify()
+
+fastify.register(async fastify => {
+  fastify.setErrorHandler(async err => {
+    console.log(err.message) // 'kaboom'
+    throw new Error('caught')
+  })
+  
+  fastify.get('/encapsulated', async () => {
+    throw new Error('kaboom')
+  })
+})
+
+fastify.setErrorHandler(async err => {
+  console.log(err.message) // 'caught' 
+  throw new Error('wrapped')
+})
+
+const res = await fastify.inject('/encapsulated')
+console.log(res.json().message) // 'wrapped'
+```
+
+### Deprecation of `app.use()` ([#3506](https://github.com/fastify/fastify/pull/3506))
 
 Starting this version of Fastify, we have deprecated the use of `app.use()`. We
 have decided not to support the use of middlewares. Both
@@ -70,3 +102,10 @@ properties: {
   }
 }
 ```
+
+### Add `reply.trailers` methods ([#3794](https://github.com/fastify/fastify/pull/3794))
+
+Fastify now supports the [HTTP Trailer] response headers.
+
+
+[HTTP Trailer]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Trailer

package/docs/Guides/Serverless.md

@@ -24,23 +24,31 @@ snippet of code.
 
 ### Contents
 
-- [AWS Lambda](#aws-lambda)
+- [AWS](#aws)
 - [Google Cloud Functions](#google-cloud-functions)
 - [Google Cloud Run](#google-cloud-run)
 - [Netlify Lambda](#netlify-lambda)
 - [Vercel](#vercel)
 
-## AWS Lambda
+## AWS
+
+To integrate with AWS, you have two choices of library:
+
+- Using [@fastify/aws-lambda](https://github.com/fastify/aws-lambda-fastify) 
+  which only adds API Gateway support but has heavy optimizations for fastify.
+- Using [@h4ad/serverless-adapter](https://github.com/H4ad/serverless-adapter) 
+  which is a little slower as it creates an HTTP request for each AWS event but 
+  has support for more AWS services such as: AWS SQS, AWS SNS and others.
+
+So you can decide which option is best for you, but you can test both libraries.
+
+### Using @fastify/aws-lambda
 
 The sample provided allows you to easily build serverless web
 applications/services and RESTful APIs using Fastify on top of AWS Lambda and
 Amazon API Gateway.
 
-*Note: Using
-[@fastify/aws-lambda](https://github.com/fastify/aws-lambda-fastify) is just one
-possible way.*
-
-### app.js
+#### app.js
 
 ```js
 const fastify = require('fastify');
@@ -71,7 +79,7 @@ When you execute your Fastify application like always, i.e. `node app.js` *(the
 detection for this could be `require.main === module`)*, you can normally listen
 to your port, so you can still run your Fastify function locally.
 
-### lambda.js
+#### lambda.js
 
 ```js
 const awsLambdaFastify = require('@fastify/aws-lambda')
@@ -99,14 +107,13 @@ signature to be used as a lambda `handler` function. This way all the incoming
 events (API Gateway requests) are passed to the `proxy` function of
 [@fastify/aws-lambda](https://github.com/fastify/aws-lambda-fastify).
 
-### Example
+#### Example
 
 An example deployable with
 [claudia.js](https://claudiajs.com/tutorials/serverless-express.html) can be
 found
 [here](https://github.com/claudiajs/example-projects/tree/master/fastify-app-lambda).
 
-
 ### Considerations
 
 - API Gateway does not support streams yet, so you are not able to handle
@@ -114,6 +121,12 @@ found
 - API Gateway has a timeout of 29 seconds, so it is important to provide a reply
   during this time.
 
+#### Beyond API Gateway
+
+If you need to integrate with more AWS services, take a look at
+[@h4ad/serverless-adapter](https://viniciusl.com.br/serverless-adapter/docs/main/frameworks/fastify)
+on Fastify to find out how to integrate.
+
 ## Google Cloud Functions
 
 ### Creation of Fastify instance

package/docs/Reference/Hooks.md

@@ -28,6 +28,7 @@ are Request/Reply hooks and application hooks:
   - [onRegister](#onregister)
 - [Scope](#scope)
 - [Route level hooks](#route-level-hooks)
+- [Using Hooks to Inject Custom Properties](#using-hooks-to-inject-custom-properties)
 - [Diagnostics Channel Hooks](#diagnostics-channel-hooks)
 
 **Notice:** the `done` callback is not available when using `async`/`await` or
@@ -649,6 +650,57 @@ fastify.route({
 
 **Note**: both options also accept an array of functions.
 
+## Using Hooks to Inject Custom Properties
+<a id="using-hooks-to-inject-custom-properties"></a>
+
+You can use a hook to inject custom properties into incoming requests.
+This is useful for reusing processed data from hooks in controllers.
+
+A very common use case is, for example, checking user authentication based
+on their token and then storing their recovered data into
+the [Request](./Request.md) instance. This way, your controllers can read it
+easily with `request.authenticatedUser` or whatever you want to call it.
+That's how it might look like:
+
+```js
+fastify.addHook('preParsing', async (request) => {
+  request.authenticatedUser = {
+    id: 42,
+    name: 'Jane Doe',
+    role: 'admin'
+  }
+})
+
+fastify.get('/me/is-admin', async function (req, reply) {
+  return { isAdmin: req.authenticatedUser?.role === 'admin' || false }
+})
+```
+
+Note that `.authenticatedUser` could actually be any property name
+choosen by yourself. Using your own custom property prevents you
+from mutating existing properties, which
+would be a dangerous and destructive operation. So be careful and
+make sure your property is entirely new, also using this approach
+only for very specific and small cases like this example.
+
+Regarding TypeScript in this example, you'd need to update the
+`FastifyRequest` core interface to include your new property typing
+(for more about it, see [TypeScript](./TypeScript.md) page), like:
+
+```ts
+interface AuthenticatedUser { /* ... */ }
+
+declare module 'fastify' {
+  export interface FastifyRequest {
+    authenticatedUser?: AuthenticatedUser;
+  }
+}
+```
+
+Although this is a very pragmatic approach, if you're trying to do
+something more complex that changes these core objects, then
+consider creating a custom [Plugin](./Plugins.md) instead.
+
 ## Diagnostics Channel Hooks
 
 > **Note:** The `diagnostics_channel` is currently experimental on Node.js, so

package/docs/Reference/Plugins.md

@@ -13,7 +13,7 @@ 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
+Started](../Guides/Getting-Started.md#your-first-plugin) guide how easy it is
 to use this API:
 ```
 fastify.register(plugin, [options])

package/docs/Reference/TypeScript.md

@@ -199,17 +199,18 @@ Below is how to setup schema validation using vanilla `typebox` and
 #### typebox
 
 A useful library for building types and a schema at once is
-[typebox](https://www.npmjs.com/package/@sinclair/typebox). With typebox you
-define your schema within your code and use them directly as types or schemas as
-you need them.
+[typebox](https://www.npmjs.com/package/@sinclair/typebox) along with 
+[fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox).
+With typebox you define your schema within your code and use them
+directly as types or schemas as you need them.
 
 When you want to use it for validation of some payload in a fastify route you
 can do it as follows:
 
-1. Install `typebox` in your project.
+1. Install `typebox` and `fastify-type-provider-typebox` in your project.
 
     ```bash
-    npm i @sinclair/typebox
+    npm i @sinclair/typebox @fastify/type-provider-typebox
     ```
 
 2. Define the schema you need with `Type` and create the respective type  with
@@ -218,40 +219,52 @@ can do it as follows:
     ```typescript
     import { Static, Type } from '@sinclair/typebox'
 
-    const User = Type.Object({
+    export const User = Type.Object({
       name: Type.String(),
-      mail: Type.Optional(Type.String({ format: "email" })),
-    });
-    type UserType = Static<typeof User>;
+      mail: Type.Optional(Type.String({ format: 'email' })),
+    })
+
+    export type UserType = Static<typeof User>
     ```
 
 3. Use the defined type and schema during the definition of your route
 
     ```typescript
-    const app = fastify();
+    import Fastify from 'fastify'
+    import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+    // ...
+
+    const fastify = Fastify().withTypeProvider<TypeBoxTypeProvider>()
 
-    app.post<{ Body: UserType; Reply: UserType }>(
-      "/",
+    app.post<{ Body: UserType, Reply: UserType }>(
+      '/',
       {
         schema: {
           body: User,
           response: {
-            200: User,
+            200: User
           },
         },
       },
       (request, reply) => {
-        const { body: user } = request;
-        /* user has type
-        * const user: StaticProperties<{
-        *  name: TString;
-        *  mail: TOptional<TString>;
-        * }>
-        */
-        //...
-        reply.status(200).send(user);
+        // The `name` and `mail` types are automatically inferred
+        const { name, mail } = request.body;
+        reply.status(200).send({ name, mail });
+      }
+    )
+    ```
+
+     **Note** For Ajv version 7 and above is required to use the `ajvTypeBoxPlugin`:
+
+    ```typescript
+    import Fastify from 'fastify'
+    import { ajvTypeBoxPlugin, TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+
+    const fastify = Fastify({
+      ajv: {
+        plugins: [ajvTypeBoxPlugin]
       }
-    );
+    }).withTypeProvider<TypeBoxTypeProvider>()
     ```
 
 #### Schemas in JSON Files
@@ -1359,7 +1372,7 @@ A method for checking the existence of a type parser of a certain content type
 
 ##### fastify.FastifyError
 
-[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L17)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L179)
 
 FastifyError is a custom error object that includes status code and validation
 results.
@@ -1369,7 +1382,7 @@ properties: `statusCode: number` and `validation: ValiationResult[]`.
 
 ##### fastify.ValidationResult
 
-[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L4)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L184)
 
 The route validation internally relies upon Ajv, which is a high-performance
 JSON schema validator.

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

@@ -484,6 +484,17 @@ fastify.post('/the/url', {
 }, handler)
 ```
 
+##### .statusCode property
+
+All validation errors will be added a `.statusCode` property set to `400`. This guarantees
+that the default error handler will set the status code of the response to `400`.
+
+```js
+fastify.setErrorHandler(function (error, request, reply) {
+  request.log.error(error, `This error has status code ${error.statusCode}`)
+  reply.status(error.statusCode).send(error)
+})
+```
 
 ##### Validation messages with other validation libraries
 

package/docs/index.md

@@ -16,7 +16,7 @@ Complete newcomers to Fastify should first read our [Getting
 Started](./Guides/Getting-Started.md) guide.
 
 Developers experienced with Fastify should consult the [reference
-documentation](./Reference/index.md) directly to find the topic they are seeking
+documentation](./Reference/Index.md) directly to find the topic they are seeking
 more information about.
 
 ## Additional Documentation

package/fastify.d.ts

@@ -183,10 +183,10 @@ declare module '@fastify/error' {
 
 export interface ValidationResult {
   keyword: string;
-  dataPath: string;
+  instancePath: string;
   schemaPath: string;
   params: Record<string, string | string[]>;
-  message: string;
+  message?: string;
 }
 
 /* Export all additional types */

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.1.0'
+const VERSION = '4.2.0'
 
 const Avvio = require('avvio')
 const http = require('http')

package/integration/server.js

@@ -0,0 +1,27 @@
+const Fastify = require('../fastify')
+
+const fastify = Fastify()
+
+fastify.listen({
+  host: '::',
+  port: 3000
+})
+
+fastify.get('/', async function (request, reply) {
+  reply.code(200).send({ data: 'home page' })
+})
+
+fastify.post('/post/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(201).send({ data: `${id}` })
+})
+
+fastify.put('/put/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(200).send({ data: `${id}` })
+})
+
+fastify.delete('/delete/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(204).send({ data: `${id}` })
+})

package/integration/test.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/bash
+
+set -e
+
+NUMBER=$RANDOM
+curl -i -X GET -H 'Content-Type: application/json' localhost:3000/ > GET
+if [[ ! $(cat GET | head -1| cut -f2 -d" ") == "200" || ! $(cat GET | tail -1| cut -f4 -d"\"") == "home page" ]] ; then
+exit 1
+fi;
+curl -i -X POST -H 'Content-Type: application/json' localhost:3000/post/$NUMBER --data {} > POST
+if [[ ! $(cat POST | head -1| cut -f2 -d" ") == "201" || ! $(cat POST | tail -1| cut -f4 -d"\"") == $(echo $NUMBER) ]]; then
+exit 1
+fi;
+curl -i -X PUT -H 'Content-Type: application/json' localhost:3000/put/$NUMBER --data {} > PUT
+if [[ ! $(cat PUT | head -1| cut -f2 -d" ") == "200" || ! $(cat PUT | tail -1| cut -f4 -d"\"") == $(echo $NUMBER) ]]; then
+exit 1
+fi;
+curl -i -X DELETE -H 'Content-Type: application/json' localhost:3000/delete/$NUMBER --data {} > DELETE
+if [[ ! $(cat DELETE | head -1| cut -f2 -d" ") == "204" ]]; then
+exit 1
+fi;
+
+rm -f GET POST PUT DELETE

package/lib/context.js

@@ -9,7 +9,8 @@ const {
   kRequest,
   kBodyLimit,
   kLogLevel,
-  kContentTypeParser
+  kContentTypeParser,
+  kRouteByFastify
 } = require('./symbols.js')
 
 // Objects that holds the context of every request
@@ -25,7 +26,8 @@ function Context ({
   attachValidation,
   replySerializer,
   schemaErrorFormatter,
-  server
+  server,
+  isFastify
 }) {
   this.schema = schema
   this.handler = handler
@@ -50,6 +52,7 @@ function Context ({
   this.attachValidation = attachValidation
   this[kReplySerializerDefault] = replySerializer
   this.schemaErrorFormatter = schemaErrorFormatter || server[kSchemaErrorFormatter] || defaultSchemaErrorFormatter
+  this[kRouteByFastify] = isFastify
 
   this.server = server
 }

package/lib/error-serializer.js

@@ -39,7 +39,7 @@ class Serializer {
     } else {
       /* eslint no-undef: "off" */
       const integer = this.parseInteger(i)
-      if (Number.isNaN(integer)) {
+      if (Number.isNaN(integer) || !Number.isFinite(integer)) {
         throw new Error(`The value "${i}" cannot be converted to an integer.`)
       } else {
         return '' + integer
@@ -55,6 +55,8 @@ class Serializer {
     const num = Number(i)
     if (Number.isNaN(num)) {
       throw new Error(`The value "${i}" cannot be converted to a number.`)
+    } else if (!Number.isFinite(num)) {
+      return null
     } else {
       return '' + num
     }
@@ -72,44 +74,44 @@ class Serializer {
     return bool === null ? 'null' : this.asBoolean(bool)
   }
 
-  asDatetime (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asDatetime (date) {
+    const quotes = '"'
     if (date instanceof Date) {
       return quotes + date.toISOString() + quotes
     }
-    return this.asString(date, skipQuotes)
+    return this.asString(date)
   }
 
-  asDatetimeNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asDatetime(date, skipQuotes)
+  asDatetimeNullable (date) {
+    return date === null ? 'null' : this.asDatetime(date)
   }
 
-  asDate (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asDate (date) {
+    const quotes = '"'
     if (date instanceof Date) {
       return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + quotes
     }
-    return this.asString(date, skipQuotes)
+    return this.asString(date)
   }
 
-  asDateNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asDate(date, skipQuotes)
+  asDateNullable (date) {
+    return date === null ? 'null' : this.asDate(date)
   }
 
-  asTime (date, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asTime (date) {
+    const quotes = '"'
     if (date instanceof Date) {
       return quotes + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + quotes
     }
-    return this.asString(date, skipQuotes)
+    return this.asString(date)
   }
 
-  asTimeNullable (date, skipQuotes) {
-    return date === null ? 'null' : this.asTime(date, skipQuotes)
+  asTimeNullable (date) {
+    return date === null ? 'null' : this.asTime(date)
   }
 
-  asString (str, skipQuotes) {
-    const quotes = skipQuotes === true ? '' : '"'
+  asString (str) {
+    const quotes = '"'
     if (str instanceof Date) {
       return quotes + str.toISOString() + quotes
     } else if (str === null) {
@@ -119,11 +121,6 @@ class Serializer {
     } else if (typeof str !== 'string') {
       str = str.toString()
     }
-    // If we skipQuotes it means that we are using it as test
-    // no need to test the string length for the render
-    if (skipQuotes) {
-      return str
-    }
 
     if (str.length < 42) {
       return this.asStringSmall(str)
@@ -185,7 +182,7 @@ class Serializer {
     }
     
     function anonymous0 (input) {
-      // main
+      // #
   
       var obj = (input && typeof input.toJSON === 'function')
     ? input.toJSON()

package/lib/handleRequest.js

@@ -90,7 +90,7 @@ function preValidationCallback (err, request, reply) {
   const result = validateSchema(reply.context, request)
   if (result) {
     if (reply.context.attachValidation === false) {
-      reply.code(400).send(result)
+      reply.send(result)
       return
     }
 

package/lib/route.js

@@ -8,7 +8,7 @@ const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTI
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
 const warning = require('./warnings')
-const { kRequestAcceptVersion } = require('./symbols')
+const { kRequestAcceptVersion, kRouteByFastify } = require('./symbols')
 
 const {
   compileSchemasForValidation,
@@ -113,7 +113,7 @@ function buildRouting (options) {
   }
 
   // Convert shorthand to extended route declaration
-  function prepareRoute ({ method, url, options, handler }) {
+  function prepareRoute ({ method, url, options, handler, isFastify }) {
     if (typeof url !== 'string') {
       throw new FST_ERR_INVALID_URL(typeof url)
     }
@@ -140,11 +140,11 @@ function buildRouting (options) {
       handler: handler || (options && options.handler)
     })
 
-    return route.call(this, { options })
+    return route.call(this, { options, isFastify })
   }
 
   // Route management
-  function route ({ options }) {
+  function route ({ options, isFastify }) {
     // Since we are mutating/assigning only top level props, it is fine to have a shallow copy using the spread operator
     const opts = { ...options }
 
@@ -176,30 +176,30 @@ function buildRouting (options) {
     if (path === '/' && prefix.length > 0 && opts.method !== 'HEAD') {
       switch (opts.prefixTrailingSlash) {
         case 'slash':
-          addNewRoute.call(this, { path })
+          addNewRoute.call(this, { path, isFastify })
           break
         case 'no-slash':
-          addNewRoute.call(this, { path: '' })
+          addNewRoute.call(this, { path: '', isFastify })
           break
         case 'both':
         default:
-          addNewRoute.call(this, { path: '' })
+          addNewRoute.call(this, { path: '', isFastify })
           // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
           if (ignoreTrailingSlash !== true && (ignoreDuplicateSlashes !== true || !prefix.endsWith('/'))) {
-            addNewRoute.call(this, { path, prefixing: true })
+            addNewRoute.call(this, { path, prefixing: true, isFastify })
           }
       }
     } else if (path[0] === '/' && prefix.endsWith('/')) {
       // Ensure that '/prefix/' + '/route' gets registered as '/prefix/route'
-      addNewRoute.call(this, { path: path.slice(1) })
+      addNewRoute.call(this, { path: path.slice(1), isFastify })
     } else {
-      addNewRoute.call(this, { path })
+      addNewRoute.call(this, { path, isFastify })
     }
 
     // chainable api
     return this
 
-    function addNewRoute ({ path, prefixing = false }) {
+    function addNewRoute ({ path, prefixing = false, isFastify = false }) {
       const url = prefix + path
 
       opts.url = url
@@ -241,7 +241,8 @@ function buildRouting (options) {
         attachValidation: opts.attachValidation,
         schemaErrorFormatter: opts.schemaErrorFormatter,
         replySerializer: this[kReplySerializerDefault],
-        server: this
+        server: this,
+        isFastify
       })
 
       if (opts.version) {
@@ -249,13 +250,20 @@ function buildRouting (options) {
         constraints.version = opts.version
       }
 
-      const headRouteExists = opts.method === 'HEAD' && router.find(opts.method, opts.url, constraints) != null
+      const headHandler = router.find('HEAD', opts.url, constraints)
+      const hasHEADHandler = headHandler != null
 
-      // Check if the current route is not for a sibling HEAD one
-      if (!headRouteExists) {
-        try {
-          router.on(opts.method, opts.url, { constraints }, routeHandler, context)
-        } catch (error) {
+      // remove the head route created by fastify
+      if (hasHEADHandler && !context[kRouteByFastify] && headHandler.store[kRouteByFastify]) {
+        router.off(opts.method, opts.url, { constraints })
+      }
+
+      try {
+        router.on(opts.method, opts.url, { constraints }, routeHandler, context)
+      } catch (error) {
+        // any route insertion error created by fastify can be safely ignore
+        // because it only duplicate route for head
+        if (!context[kRouteByFastify]) {
           const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route '${opts.url}'`)
           if (isDuplicatedRoute) {
             throw new FST_ERR_DUPLICATED_ROUTE(opts.method, opts.url)
@@ -320,19 +328,21 @@ function buildRouting (options) {
           }
         })
 
-        const { exposeHeadRoute } = opts
-        const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
-        const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
-
-        if (shouldExposeHead && options.method === 'GET' && !headRouteExists) {
-          const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
-          prepareRoute.call(this, { method: 'HEAD', url: path, options: { ...opts, onSend: onSendHandlers } })
-        } else if (headRouteExists && exposeHeadRoute) {
-          warning.emit('FSTDEP007')
-        }
-
         done(notHandledErr)
       })
+
+      // register head route in sync
+      // we must place it after the `this.after`
+      const { exposeHeadRoute } = opts
+      const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
+      const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
+
+      if (shouldExposeHead && options.method === 'GET' && !hasHEADHandler) {
+        const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
+        prepareRoute.call(this, { method: 'HEAD', url: path, options: { ...opts, onSend: onSendHandlers }, isFastify: true })
+      } else if (hasHEADHandler && exposeHeadRoute) {
+        warning.emit('FSTDEP007')
+      }
     }
   }
 

package/lib/symbols.js

@@ -47,7 +47,8 @@ const keys = {
   kTestInternals: Symbol('fastify.testInternals'),
   kErrorHandler: Symbol('fastify.errorHandler'),
   kHasBeenDecorated: Symbol('fastify.hasBeenDecorated'),
-  kKeepAliveConnections: Symbol('fastify.keepAliveConnections')
+  kKeepAliveConnections: Symbol('fastify.keepAliveConnections'),
+  kRouteByFastify: Symbol('fastify.routeByFastify')
 }
 
 module.exports = keys

package/lib/validation.js

@@ -106,11 +106,13 @@ function validate (context, request) {
 
 function wrapValidationError (result, dataVar, schemaErrorFormatter) {
   if (result instanceof Error) {
+    result.statusCode = result.statusCode || 400
     result.validationContext = result.validationContext || dataVar
     return result
   }
 
   const error = schemaErrorFormatter(result, dataVar)
+  error.statusCode = error.statusCode || 400
   error.validation = result
   error.validationContext = dataVar
   return error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.1.0",
+  "version": "4.2.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -146,7 +146,7 @@
     "eslint-plugin-n": "^15.2.0",
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
-    "fast-json-stringify": "^4.2.0",
+    "fast-json-stringify": "^5.0.0",
     "fastify-plugin": "^3.0.1",
     "fluent-json-schema": "^3.1.0",
     "form-data": "^4.0.0",
@@ -179,10 +179,10 @@
   "dependencies": {
     "@fastify/ajv-compiler": "^3.1.0",
     "@fastify/error": "^3.0.0",
-    "@fastify/fast-json-stringify-compiler": "^3.0.1",
+    "@fastify/fast-json-stringify-compiler": "^4.0.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.1.3",
-    "find-my-way": "^6.3.0",
+    "find-my-way": "^7.0.0",
     "light-my-request": "^5.0.0",
     "pino": "^8.0.0",
     "process-warning": "^2.0.0",

package/test/hooks.test.js

@@ -799,6 +799,27 @@ test('onRoute hook with many prefix', t => {
   fastify.ready(err => { t.error(err) })
 })
 
+test('onRoute hook should not be called when it registered after route', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('onRoute', () => {
+    t.pass()
+  })
+
+  fastify.get('/', function (req, reply) {
+    reply.send()
+  })
+
+  fastify.addHook('onRoute', () => {
+    t.fail('should not be called')
+  })
+
+  fastify.ready(err => {
+    t.error(err)
+  })
+})
+
 test('onResponse hook should log request error', t => {
   t.plan(4)
 

package/test/pretty-print.test.js

@@ -144,7 +144,7 @@ test('pretty print - commonPrefix', t => {
 `
     const flatExpected = `└── / (-)
     ├── helicopter (GET, HEAD)
-    └── hello (GET, PUT, HEAD)
+    └── hello (GET, HEAD, PUT)
 `
     t.equal(typeof radixTree, 'string')
     t.equal(typeof flatTree, 'string')
@@ -200,7 +200,7 @@ test('pretty print - includeMeta, includeHooks', t => {
     │   • (onTimeout) ["onTimeout()"]
     │   • (onRequest) ["anonymous()"]
     │   • (errorHandler) "defaultErrorHandler()"
-    └── hello (GET, PUT, HEAD)
+    └── hello (GET, HEAD, PUT)
         • (onTimeout) ["onTimeout()"]
         • (onRequest) ["anonymous()"]
         • (errorHandler) "defaultErrorHandler()"
@@ -210,7 +210,7 @@ test('pretty print - includeMeta, includeHooks', t => {
     ├── helicopter (GET, HEAD)
     │   • (onTimeout) ["onTimeout()"]
     │   • (onRequest) ["anonymous()"]
-    └── hello (GET, PUT, HEAD)
+    └── hello (GET, HEAD, PUT)
         • (onTimeout) ["onTimeout()"]
         • (onRequest) ["anonymous()"]
 `

package/test/reply-error.test.js

@@ -324,7 +324,7 @@ test('invalid schema - ajv', t => {
 
   fastify.setErrorHandler((err, request, reply) => {
     t.ok(Array.isArray(err.validation))
-    reply.send('error')
+    reply.code(400).send('error')
   })
 
   fastify.inject({

package/test/schema-feature.test.js

@@ -206,7 +206,7 @@ test('Should throw of the schema does not exists in output', t => {
 
   fastify.ready(err => {
     t.equal(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
-    t.match(err.message, /^Failed building the serialization schema for GET: \/:id, due to error Cannot read propert.*/) // error from fast-json-strinfigy
+    t.match(err.message, /^Failed building the serialization schema for GET: \/:id, due to error Cannot find reference.*/) // error from fast-json-strinfigy
   })
 })
 
@@ -826,7 +826,7 @@ test('Validation context in validation result', t => {
     t.equal(err instanceof Error, true)
     t.ok(err.validation, 'detailed errors')
     t.equal(err.validationContext, 'body')
-    reply.send()
+    reply.code(400).send()
   })
   fastify.post('/', {
     handler: echoParams,

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

@@ -7,8 +7,10 @@ import fastify, {
   LightMyRequestChain,
   LightMyRequestResponse,
   LightMyRequestCallback,
-  InjectOptions, FastifyBaseLogger
+  InjectOptions, FastifyBaseLogger,
+  ValidationResult
 } from '../../fastify'
+import { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'http'
 import * as https from 'https'
 import * as http2 from 'http2'
@@ -208,3 +210,12 @@ fastify().then(fastifyInstance => expectAssignable<FastifyInstance>(fastifyInsta
 expectAssignable<FastifyPluginAsync>(async () => {})
 expectAssignable<FastifyPluginCallback>(() => {})
 expectAssignable<FastifyPlugin>(() => {})
+
+const ajvErrorObject: AjvErrorObject = {
+  keyword: '',
+  instancePath: '',
+  schemaPath: '',
+  params: {},
+  message: ''
+}
+expectAssignable<ValidationResult>(ajvErrorObject)

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

@@ -49,7 +49,7 @@ interface RequestData extends RequestGenericInterface {
 type Handler = RouteHandler<RequestData>
 
 type CustomRequest = FastifyRequest<{
-  Body: RequestBody;
+  Body: RequestBody | undefined;
   Querystring: RequestQuerystring;
   Params: RequestParams;
   Headers: RequestHeaders;
@@ -85,7 +85,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifyInstance>(request.server)
 }
 
-const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, ResolveFastifyReplyReturnType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>, ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>, CustomLoggerInterface> = function (request, _reply) {
+const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>, CustomLoggerInterface> = function (request, _reply) {
   expectType<CustomLoggerInterface>(request.log)
 }
 
@@ -104,11 +104,15 @@ const postHandler: Handler = function (request) {
 }
 
 function putHandler (request: CustomRequest, reply: FastifyReply) {
-  expectType<RequestBody>(request.body)
+  expectType<RequestBody | undefined>(request.body)
   expectType<RequestParams>(request.params)
   expectType<RequestHeaders & RawRequestDefaultExpression['headers']>(request.headers)
   expectType<RequestQuerystring>(request.query)
-  expectType<string>(request.body.content)
+  if (typeof request.body === 'undefined') {
+    expectType<undefined>(request.body)
+  } else {
+    expectType<string>(request.body.content)
+  }
   expectType<string>(request.query.from)
   expectType<number>(request.params.id)
   expectType<string>(request.headers['x-foobar'])

package/test/types/type-provider.test-d.ts

@@ -298,7 +298,7 @@ expectError(server.withTypeProvider<TypeBoxProvider>().get(
       }
     }
   },
-  async (_, res): Promise<RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, TypeBoxProvider>> => {
+  async (_, res) => {
     return false
   }
 ))
@@ -384,11 +384,20 @@ expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get(
       } as const
     }
   },
-  async (_, res): Promise<RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, TypeBoxProvider>> => {
+  async (_, res) => {
     return false
   }
 ))
 
+// https://github.com/fastify/fastify/issues/4088
+expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get('/', {
+  schema: {
+    response: { type: 'string' }
+  } as const
+}, (_, res) => {
+  return { foo: 555 }
+}))
+
 // -------------------------------------------------------------------
 // Reply Type Override
 // -------------------------------------------------------------------

package/test/validation-error-handling.test.js

@@ -97,6 +97,38 @@ test('should be able to use setErrorHandler specify custom validation error', t
   })
 })
 
+test('validation error has 400 statusCode set', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.setErrorHandler((error, request, reply) => {
+    const errorResponse = {
+      message: error.message,
+      statusCode: error.statusCode || 500
+    }
+
+    reply.code(errorResponse.statusCode).send(errorResponse)
+  })
+
+  fastify.post('/', { schema }, echoBody)
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      hello: 'michelangelo'
+    },
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.json(), {
+      statusCode: 400,
+      message: "body must have required property 'name'"
+    })
+    t.equal(res.statusCode, 400)
+  })
+})
+
 test('error inside custom error handler should have validationContext', t => {
   t.plan(1)
 

package/types/route.d.ts

@@ -69,14 +69,14 @@ export type RouteHandlerMethod<
   ContextConfig = ContextConfigDefault,
   SchemaCompiler extends FastifySchema = FastifySchema,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
-  ReturnType = ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>,
   RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>,
   Logger extends FastifyLoggerInstance = FastifyLoggerInstance
 > = (
   this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
   request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, RequestType, Logger>,
   reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>
-) => ReturnType
+// This return type used to be a generic type argument. Due to TypeScript's inference of return types, this rendered returns unchecked.
+) => ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>
 
 /**
  * Shorthand options including the handler function property
@@ -89,11 +89,10 @@ export interface RouteShorthandOptionsWithHandler<
   ContextConfig = ContextConfigDefault,
   SchemaCompiler = FastifySchema,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
-  ReturnType = ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>,
   RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>,
   Logger extends FastifyLoggerInstance = FastifyLoggerInstance
 > extends RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger> {
-  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReturnType, RequestType, Logger>;
+  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger>;
 }
 
 /**
@@ -105,18 +104,18 @@ export interface RouteShorthandMethod<
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
 > {
-  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema, ReturnType = ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>, RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>, Logger extends FastifyLoggerInstance = FastifyLoggerInstance>(
+  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema, RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>, Logger extends FastifyLoggerInstance = FastifyLoggerInstance>(
     path: string,
     opts: RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger>,
-    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReturnType, RequestType, Logger>
+    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
-  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema, ReturnType = ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>, RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>, Logger extends FastifyLoggerInstance = FastifyLoggerInstance>(
+  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema, RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>, Logger extends FastifyLoggerInstance = FastifyLoggerInstance>(
     path: string,
-    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReturnType, RequestType, Logger>
+    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
-  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema, ReturnType = ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>, RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>, Logger extends FastifyLoggerInstance = FastifyLoggerInstance>(
+  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema, RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>, Logger extends FastifyLoggerInstance = FastifyLoggerInstance>(
     path: string,
-    opts: RouteShorthandOptionsWithHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReturnType, RequestType, Logger>
+    opts: RouteShorthandOptionsWithHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 }
 
@@ -131,13 +130,12 @@ export interface RouteOptions<
   ContextConfig = ContextConfigDefault,
   SchemaCompiler = FastifySchema,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
-  ReturnType = ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>,
   RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>,
   Logger extends FastifyLoggerInstance = FastifyLoggerInstance
 > extends RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger> {
   method: HTTPMethods | HTTPMethods[];
   url: string;
-  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReturnType, RequestType, Logger>;
+  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, RequestType, Logger>;
 }
 
 export type RouteHandler<

package/types/type-provider.d.ts

@@ -21,17 +21,24 @@ export type CallTypeProvider<F extends FastifyTypeProvider, I> = (F & { input: I
 // -----------------------------------------------------------------------------------------------
 
 // Used to map undefined SchemaCompiler properties to unknown
-type UndefinedToUnknown<T> = T extends undefined ? unknown : T
+//   Without brackets, UndefinedToUnknown<undefined | null> => unknown
+type UndefinedToUnknown<T> = [T] extends [undefined] ? unknown : T
+
+// union-aware keyof operator
+//    keyof ({ a: number} | { b: number}) => never
+//    KeysOf<{a: number} | {b: number}>   => "a" | "b"
+// this exists to allow users to override faulty type-provider logic.
+type KeysOf<T> = T extends any ? keyof T : never
 
 // Resolves Request types either from generic argument or Type Provider.
 type ResolveRequestParams<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<keyof RouteGeneric['Params'] extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['params']> : RouteGeneric['Params']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Params']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['params']> : RouteGeneric['Params']>
 type ResolveRequestQuerystring<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<keyof RouteGeneric['Querystring'] extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['querystring']> : RouteGeneric['Querystring']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Querystring']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['querystring']> : RouteGeneric['Querystring']>
 type ResolveRequestHeaders<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<keyof RouteGeneric['Headers'] extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['headers']> : RouteGeneric['Headers']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Headers']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['headers']> : RouteGeneric['Headers']>
 type ResolveRequestBody<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> =
-  UndefinedToUnknown<keyof RouteGeneric['Body'] extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['body']> : RouteGeneric['Body']>
+  UndefinedToUnknown<KeysOf<RouteGeneric['Body']> extends never ? CallTypeProvider<TypeProvider, SchemaCompiler['body']> : RouteGeneric['Body']>
 
 // The target request type. This type is inferenced on fastify 'requests' via generic argument assignment
 export interface FastifyRequestType<Params = unknown, Querystring = unknown, Headers = unknown, Body = unknown> {