fastify 4.13.0 → 4.14.0

package/docs/Guides/Ecosystem.md

@@ -648,5 +648,7 @@ section.
   Reusable workflows for use in the Fastify plugin
 - [`fast-maker`](https://github.com/imjuni/fast-maker) route configuration
   generator by directory structure.
+- [`fastify-flux`](https://github.com/Jnig/fastify-flux) Tool for building
+  Fastify APIs using decorators and convert Typescript interface to JSON Schema.
 - [`simple-tjscli`](https://github.com/imjuni/simple-tjscli) CLI tool to
   generate JSON Schema from TypeScript interfaces.

package/docs/Reference/Hooks.md

@@ -19,6 +19,7 @@ are Request/Reply hooks and application hooks:
   - [onSend](#onsend)
   - [onResponse](#onresponse)
   - [onTimeout](#ontimeout)
+  - [onRequestAbort](#onrequestabort)
   - [Manage Errors from a hook](#manage-errors-from-a-hook)
   - [Respond to a request from a hook](#respond-to-a-request-from-a-hook)
 - [Application Hooks](#application-hooks)
@@ -267,6 +268,26 @@ service (if the `connectionTimeout` property is set on the Fastify instance).
 The `onTimeout` hook is executed when a request is timed out and the HTTP socket
 has been hanged up. Therefore, you will not be able to send data to the client.
 
+### onRequestAbort
+
+```js
+fastify.addHook('onRequestAbort', (request, reply, done) => {
+  // Some code
+  done()
+})
+```
+Or `async/await`:
+```js
+fastify.addHook('onRequestAbort', async (request, reply) => {
+  // Some code
+  await asyncMethod()
+})
+```
+The `onRequestAbort` hook is executed when a client closes the connection before
+the entire request has been received. Therefore, you will not be able to send
+data to the client.
+
+**Notice:** client abort detection is not completely reliable. See: [`Detecting-When-Clients-Abort.md`](../Guides/Detecting-When-Clients-Abort.md)
 
 ### Manage Errors from a hook
 If you get an error during the execution of your hook, just pass it to `done()`

package/docs/Reference/LTS.md

@@ -62,7 +62,7 @@ YAML workflow labels below:
 | OS      | YAML Workflow Label    | Package Manager           | Node.js      |
 |---------|------------------------|---------------------------|--------------|
 | Linux   | `ubuntu-latest`        | npm                       | 14,16,18     |
-| Linux   | `ubuntu-18.04`         | yarn,pnpm                 | 14,16,18     |
+| Linux   | `ubuntu-latest`        | yarn,pnpm                 | 14,16,18     |
 | Windows | `windows-latest`       | npm                       | 14,16,18     |
 | MacOS   | `macos-latest`         | npm                       | 14,16,18     |
 

package/docs/Reference/Server.md

@@ -382,7 +382,9 @@ fastify.addHook('onResponse', (req, reply, done) => {
 ```
 
 Please note that this setting will also disable an error log written by the
-default `onResponse` hook on reply callback errors.
+default `onResponse` hook on reply callback errors. Other log messages 
+emitted by Fastify will stay enabled, like deprecation warnings and messages
+emitted when requests are received while the server is closing.
 
 ### `serverFactory`
 <a id="custom-http-server"></a>

package/fastify.d.ts

@@ -3,16 +3,16 @@ import * as http2 from 'http2'
 import * as https from 'https'
 import { Socket } from 'net'
 
-import { Options as AjvOptions, ValidatorCompiler } from '@fastify/ajv-compiler'
+import { Options as AjvOptions, ValidatorFactory } from '@fastify/ajv-compiler'
 import { FastifyError } from '@fastify/error'
-import { Options as FJSOptions, SerializerCompiler } from '@fastify/fast-json-stringify-compiler'
+import { Options as FJSOptions, SerializerFactory } from '@fastify/fast-json-stringify-compiler'
 import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
 import { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse, CallbackFunc as LightMyRequestCallback } from 'light-my-request'
 
 import { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction } from './types/content-type-parser'
 import { FastifyContext, FastifyContextConfig } from './types/context'
 import { FastifyErrorCodes } from './types/errors'
-import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, 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 './types/hooks'
+import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, onRequestAbortHookHandler, onRequestAbortAsyncHookHandler } from './types/hooks'
 import { FastifyListenOptions, FastifyInstance, PrintRoutesOptions } from './types/instance'
 import { FastifyBaseLogger, FastifyLoggerInstance, FastifyLoggerOptions, PinoLoggerOptions, FastifyLogFn, LogLevel } from './types/logger'
 import { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
@@ -20,7 +20,7 @@ import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './type
 import { FastifyReply } from './types/reply'
 import { FastifyRequest, RequestGenericInterface } from './types/request'
 import { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface } from './types/route'
-import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError } from './types/schema'
+import { FastifySchema, FastifySchemaCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
 import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/serverFactory'
 import { FastifyTypeProvider, FastifyTypeProviderDefault } from './types/type-provider'
 import { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
@@ -28,7 +28,7 @@ import { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaul
 declare module '@fastify/error' {
   interface FastifyError {
     validation?: fastify.ValidationResult[];
-    validationContext?: 'body' | 'headers' | 'parameters' | 'querystring';
+    validationContext?: SchemaErrorDataVar;
   }
 }
 
@@ -134,8 +134,8 @@ declare namespace fastify {
         getSchemas(): Record<string, unknown>;
       };
       compilersFactory?: {
-        buildValidator?: ValidatorCompiler;
-        buildSerializer?: SerializerCompiler;
+        buildValidator?: ValidatorFactory;
+        buildSerializer?: SerializerFactory;
       };
     };
     return503OnClosing?: boolean,
@@ -149,7 +149,7 @@ declare namespace fastify {
       res: FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RequestGeneric, FastifyContextConfig, SchemaCompiler, TypeProvider>
     ) => void,
     rewriteUrl?: (req: RawRequestDefaultExpression<RawServer>) => string,
-    schemaErrorFormatter?: (errors: FastifySchemaValidationError[], dataVar: string) => Error,
+    schemaErrorFormatter?: SchemaErrorFormatter,
     /**
      * listener to error events emitted by client connections
      */
@@ -179,7 +179,7 @@ declare namespace fastify {
     FastifyError, // '@fastify/error'
     FastifySchema, FastifySchemaCompiler, // './types/schema'
     HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault, // './types/utils'
-    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, // './types/hooks'
+    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, onRequestAbortHookHandler, onRequestAbortAsyncHookHandler, // './types/hooks'
     FastifyServerFactory, FastifyServerFactoryHandler, // './types/serverFactory'
     FastifyTypeProvider, FastifyTypeProviderDefault, // './types/type-provider'
     FastifyErrorCodes, // './types/errors'

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.13.0'
+const VERSION = '4.14.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -588,6 +588,10 @@ function fastify (options) {
       if (fn.constructor.name === 'AsyncFunction' && fn.length !== 0) {
         throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
       }
+    } else if (name === 'onRequestAbort') {
+      if (fn.constructor.name === 'AsyncFunction' && fn.length !== 1) {
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
+      }
     } else {
       if (fn.constructor.name === 'AsyncFunction' && fn.length === 3) {
         throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()

package/lib/context.js

@@ -48,6 +48,7 @@ function Context ({
   this.preHandler = null
   this.onResponse = null
   this.preSerialization = null
+  this.onRequestAbort = null
   this.config = config
   this.errorHandler = errorHandler || server[kErrorHandler]
   this._middie = null

package/lib/error-handler.js

@@ -11,7 +11,8 @@ const {
 } = require('./symbols.js')
 
 const {
-  FST_ERR_REP_INVALID_PAYLOAD_TYPE
+  FST_ERR_REP_INVALID_PAYLOAD_TYPE,
+  FST_ERR_FAILED_ERROR_SERIALIZATION
 } = require('./errors')
 
 const { getSchemaSerializer } = require('./schemas')
@@ -113,11 +114,7 @@ function fallbackErrorHandler (error, reply, cb) {
     // error is always FST_ERR_SCH_SERIALIZATION_BUILD because this is called from route/compileSchemasForSerialization
     reply.log.error({ err, statusCode: res.statusCode }, 'The serializer for the given status code failed')
     reply.code(500)
-    payload = serializeError({
-      error: statusCodes['500'],
-      message: err.message,
-      statusCode: 500
-    })
+    payload = serializeError(new FST_ERR_FAILED_ERROR_SERIALIZATION(err.message, error.message))
   }
 
   if (typeof payload !== 'string' && !Buffer.isBuffer(payload)) {

package/lib/error-serializer.js

@@ -2,15 +2,14 @@
 /* istanbul ignore file */
 
   'use strict'
-
   
 
 // eslint-disable-next-line
 const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
 
 class Serializer {
-  constructor (options = {}) {
-    switch (options.rounding) {
+  constructor (options) {
+    switch (options && options.rounding) {
       case 'floor':
         this.parseInteger = Math.floor
         break
@@ -20,6 +19,7 @@ class Serializer {
       case 'round':
         this.parseInteger = Math.round
         break
+      case 'trunc':
       default:
         this.parseInteger = Math.trunc
         break
@@ -27,17 +27,28 @@ class Serializer {
   }
 
   asInteger (i) {
-    if (typeof i === 'bigint') {
+    if (typeof i === 'number') {
+      if (i === Infinity || i === -Infinity) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      }
+      if (Number.isInteger(i)) {
+        return '' + i
+      }
+      if (Number.isNaN(i)) {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
+      }
+      return this.parseInteger(i)
+    } else if (i === null) {
+      return '0'
+    } else if (typeof i === 'bigint') {
       return i.toString()
-    } else if (Number.isInteger(i)) {
-      return '' + i
     } else {
       /* eslint no-undef: "off" */
       const integer = this.parseInteger(i)
-      if (Number.isNaN(integer) || !Number.isFinite(integer)) {
-        throw new Error(`The value "${i}" cannot be converted to an integer.`)
-      } else {
+      if (Number.isFinite(integer)) {
         return '' + integer
+      } else {
+        throw new Error(`The value "${i}" cannot be converted to an integer.`)
       }
     }
   }
@@ -91,23 +102,24 @@ class Serializer {
   }
 
   asString (str) {
-    const quotes = '"'
-    if (str instanceof Date) {
-      return quotes + str.toISOString() + quotes
-    } else if (str === null) {
-      return quotes + quotes
-    } else if (str instanceof RegExp) {
-      str = str.source
-    } else if (typeof str !== 'string') {
-      str = str.toString()
+    if (typeof str !== 'string') {
+      if (str === null) {
+        return '""'
+      }
+      if (str instanceof Date) {
+        return '"' + str.toISOString() + '"'
+      }
+      if (str instanceof RegExp) {
+        str = str.source
+      } else {
+        str = str.toString()
+      }
     }
 
     // Fast escape chars check
     if (!STR_ESCAPE.test(str)) {
-      return quotes + str + quotes
-    }
-
-    if (str.length < 42) {
+      return '"' + str + '"'
+    } else if (str.length < 42) {
       return this.asStringSmall(str)
     } else {
       return JSON.stringify(str)
@@ -151,81 +163,50 @@ class Serializer {
 }
 
   
-
-  const serializer = new Serializer({"mode":"standalone"})
+  const serializer = new Serializer()
   
 
   
-    function main (input) {
-      let json = ''
-      json += anonymous0(input)
-      return json
-    }
     
     function anonymous0 (input) {
       // #
   
-      var obj = (input && typeof input.toJSON === 'function')
+      const obj = (input && typeof input.toJSON === 'function')
     ? input.toJSON()
     : input
   
-      var json = '{'
-      var addComma = false
+      let json = '{'
+      let addComma = false
   
       if (obj["statusCode"] !== undefined) {
-        
-  if (addComma) {
-    json += ','
-  } else {
-    addComma = true
-  }
-
-        json += "\"statusCode\"" + ':'
+        !addComma && (addComma = true) || (json += ',')
+        json += "\"statusCode\":"
       json += serializer.asNumber(obj["statusCode"])
       }
     
       if (obj["code"] !== undefined) {
-        
-  if (addComma) {
-    json += ','
-  } else {
-    addComma = true
-  }
-
-        json += "\"code\"" + ':'
+        !addComma && (addComma = true) || (json += ',')
+        json += "\"code\":"
       json += serializer.asString(obj["code"])
       }
     
       if (obj["error"] !== undefined) {
-        
-  if (addComma) {
-    json += ','
-  } else {
-    addComma = true
-  }
-
-        json += "\"error\"" + ':'
+        !addComma && (addComma = true) || (json += ',')
+        json += "\"error\":"
       json += serializer.asString(obj["error"])
       }
     
       if (obj["message"] !== undefined) {
-        
-  if (addComma) {
-    json += ','
-  } else {
-    addComma = true
-  }
-
-        json += "\"message\"" + ':'
+        !addComma && (addComma = true) || (json += ',')
+        json += "\"message\":"
       json += serializer.asString(obj["message"])
       }
     
-      json += '}'
-      return json
+      return json + '}'
     }
   
+    const main = anonymous0
+    
     
-  
 
   module.exports = main
-      

package/lib/errors.js

@@ -214,6 +214,10 @@ const codes = {
     'FST_ERR_BAD_TRAILER_VALUE',
     "Called reply.trailer('%s', fn) with an invalid type: %s. Expected a function."
   ),
+  FST_ERR_FAILED_ERROR_SERIALIZATION: createError(
+    'FST_ERR_FAILED_ERROR_SERIALIZATION',
+    'Failed to serialize an error. Error: %s. Original error: %s'
+  ),
   FST_ERR_MISSING_SERIALIZATION_FN: createError(
     'FST_ERR_MISSING_SERIALIZATION_FN',
     'Missing serialization function. Key "%s"'

package/lib/hooks.js

@@ -15,7 +15,8 @@ const lifecycleHooks = [
   'preHandler',
   'onSend',
   'onResponse',
-  'onError'
+  'onError',
+  'onRequestAbort'
 ]
 const supportedHooks = lifecycleHooks.concat(applicationHooks)
 const {
@@ -46,6 +47,7 @@ function Hooks () {
   this.onRegister = []
   this.onReady = []
   this.onTimeout = []
+  this.onRequestAbort = []
 }
 
 Hooks.prototype.validate = function (hook, fn) {
@@ -74,6 +76,7 @@ function buildHooks (h) {
   hooks.onRoute = h.onRoute.slice()
   hooks.onRegister = h.onRegister.slice()
   hooks.onTimeout = h.onTimeout.slice()
+  hooks.onRequestAbort = h.onRequestAbort.slice()
   hooks.onReady = []
   return hooks
 }
@@ -246,6 +249,42 @@ function onSendHookRunner (functions, request, reply, payload, cb) {
   next()
 }
 
+function onRequestAbortHookRunner (functions, runner, request, cb) {
+  let i = 0
+
+  function next (err) {
+    if (err || i === functions.length) {
+      cb(err, request)
+      return
+    }
+
+    let result
+    try {
+      result = runner(functions[i++], request, next)
+    } catch (error) {
+      next(error)
+      return
+    }
+    if (result && typeof result.then === 'function') {
+      result.then(handleResolve, handleReject)
+    }
+  }
+
+  function handleResolve () {
+    next()
+  }
+
+  function handleReject (err) {
+    if (!err) {
+      err = new FST_ERR_SEND_UNDEFINED_ERR()
+    }
+
+    cb(err, request)
+  }
+
+  next()
+}
+
 function hookIterator (fn, request, reply, next) {
   if (reply.sent === true) return undefined
   return fn(request, reply, next)
@@ -256,6 +295,7 @@ module.exports = {
   buildHooks,
   hookRunner,
   onSendHookRunner,
+  onRequestAbortHookRunner,
   hookIterator,
   hookRunnerApplication,
   lifecycleHooks,

package/lib/route.js

@@ -3,7 +3,7 @@
 const FindMyWay = require('find-my-way')
 const Context = require('./context')
 const handleRequest = require('./handleRequest')
-const { hookRunner, hookIterator, lifecycleHooks } = require('./hooks')
+const { hookRunner, hookIterator, onRequestAbortHookRunner, lifecycleHooks } = require('./hooks')
 const { supportedMethods } = require('./httpMethods')
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
@@ -303,7 +303,7 @@ function buildRouting (options) {
 
       // remove the head route created by fastify
       if (hasHEADHandler && !context[kRouteByFastify] && headHandler.store[kRouteByFastify]) {
-        router.off(opts.method, opts.url, { constraints })
+        router.off('HEAD', opts.url, { constraints })
       }
 
       try {
@@ -394,8 +394,25 @@ function buildRouting (options) {
 
   // HTTP request entry point, the routing has already been executed
   function routeHandler (req, res, params, context, query) {
+    const id = genReqId(req)
+
+    const loggerBinding = {
+      [requestIdLogLabel]: id
+    }
+
+    const loggerOpts = {
+      level: context.logLevel
+    }
+
+    if (context.logSerializers) {
+      loggerOpts.serializers = context.logSerializers
+    }
+    const childLogger = logger.child(loggerBinding, loggerOpts)
+    childLogger[kDisableRequestLogging] = disableRequestLogging
+
     // TODO: The check here should be removed once https://github.com/nodejs/node/issues/43115 resolve in core.
     if (!validateHTTPVersion(req.httpVersion)) {
+      childLogger.info({ res: { statusCode: 505 } }, 'request aborted - invalid HTTP version')
       const message = '{"error":"HTTP Version Not Supported","message":"HTTP Version Not Supported","statusCode":505}'
       const headers = {
         'Content-Type': 'application/json',
@@ -424,6 +441,7 @@ function buildRouting (options) {
         }
         res.writeHead(503, headers)
         res.end('{"error":"Service Unavailable","message":"Service Unavailable","statusCode":503}')
+        childLogger.info({ res: { statusCode: 503 } }, 'request aborted - refusing to accept new requests as server is closing')
         return
       }
     }
@@ -445,22 +463,6 @@ function buildRouting (options) {
       req.headers[kRequestAcceptVersion] = undefined
     }
 
-    const id = genReqId(req)
-
-    const loggerBinding = {
-      [requestIdLogLabel]: id
-    }
-
-    const loggerOpts = {
-      level: context.logLevel
-    }
-
-    if (context.logSerializers) {
-      loggerOpts.serializers = context.logSerializers
-    }
-    const childLogger = logger.child(loggerBinding, loggerOpts)
-    childLogger[kDisableRequestLogging] = disableRequestLogging
-
     const request = new context.Request(id, params, req, query, childLogger, context)
     const reply = new context.Reply(res, request, childLogger)
 
@@ -484,6 +486,20 @@ function buildRouting (options) {
       runPreParsing(null, request, reply)
     }
 
+    if (context.onRequestAbort !== null) {
+      req.on('close', () => {
+        /* istanbul ignore else */
+        if (req.aborted) {
+          onRequestAbortHookRunner(
+            context.onRequestAbort,
+            hookIterator,
+            request,
+            handleOnRequestAbortHooksErrors.bind(null, reply)
+          )
+        }
+      })
+    }
+
     if (context.onTimeout !== null) {
       if (!request.raw.socket._meta) {
         request.raw.socket.on('timeout', handleTimeout)
@@ -493,6 +509,12 @@ function buildRouting (options) {
   }
 }
 
+function handleOnRequestAbortHooksErrors (reply, err) {
+  if (err) {
+    reply.log.error({ err }, 'onRequestAborted hook failed')
+  }
+}
+
 function handleTimeout () {
   const { context, request, reply } = this._meta
   hookRunner(

package/lib/symbols.js

@@ -30,6 +30,7 @@ const keys = {
   kRequestValidateFns: Symbol('fastify.request.cache.validateFns'),
   kRequestPayloadStream: Symbol('fastify.RequestPayloadStream'),
   kRequestAcceptVersion: Symbol('fastify.RequestAcceptVersion'),
+  kRequestValidateWeakMap: Symbol('fastify.request.cache.validators'),
   // 404
   kFourOhFour: Symbol('fastify.404'),
   kCanSetNotFoundHandler: Symbol('fastify.canSetNotFoundHandler'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.13.0",
+  "version": "4.14.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -168,10 +168,10 @@
     "typescript": "^4.8.3",
     "undici": "^5.10.0",
     "vary": "^1.1.2",
-    "yup": "^0.32.11"
+    "yup": "^1.0.0"
   },
   "dependencies": {
-    "@fastify/ajv-compiler": "^3.3.1",
+    "@fastify/ajv-compiler": "^3.5.0",
     "@fastify/error": "^3.0.0",
     "@fastify/fast-json-stringify-compiler": "^4.1.0",
     "abstract-logging": "^2.0.1",

package/test/close.test.js

@@ -7,6 +7,7 @@ const test = t.test
 const Fastify = require('..')
 const { Client } = require('undici')
 const semver = require('semver')
+const split = require('split2')
 
 test('close callback', t => {
   t.plan(4)
@@ -303,6 +304,40 @@ t.test('Current opened connection should not accept new incoming connections', t
   })
 })
 
+t.test('rejected incoming connections should be logged', t => {
+  t.plan(2)
+  const stream = split(JSON.parse)
+  const fastify = Fastify({
+    forceCloseConnections: false,
+    logger: {
+      stream,
+      level: 'info'
+    }
+  })
+
+  const messages = []
+  stream.on('data', message => {
+    messages.push(message)
+  })
+  fastify.get('/', (req, reply) => {
+    fastify.close()
+    setTimeout(() => {
+      reply.send({ hello: 'world' })
+    }, 250)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    const instance = new Client('http://localhost:' + fastify.server.address().port)
+    // initial request to trigger close
+    instance.request({ path: '/', method: 'GET' })
+    // subsequent request should be rejected
+    instance.request({ path: '/', method: 'GET' }).then(() => {
+      t.ok(messages.find(message => message.msg.includes('request aborted')))
+    })
+  })
+})
+
 test('Cannot be reopened the closed server without listen callback', async t => {
   t.plan(2)
   const fastify = Fastify()

package/test/hooks-async.test.js

@@ -584,6 +584,18 @@ test('preHandler respond with a stream', t => {
 })
 
 test('Should log a warning if is an async function with `done`', t => {
+  t.test('2 arguments', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    try {
+      fastify.addHook('onRequestAbort', async (req, done) => {})
+    } catch (e) {
+      t.ok(e.code, 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER')
+      t.ok(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+    }
+  })
+
   t.test('3 arguments', t => {
     t.plan(2)
     const fastify = Fastify()

package/test/hooks.test.js

@@ -11,6 +11,10 @@ const split = require('split2')
 const symbols = require('../lib/symbols.js')
 const payload = { hello: 'world' }
 const proxyquire = require('proxyquire')
+const { promisify } = require('util')
+const { connect } = require('net')
+
+const sleep = promisify(setTimeout)
 
 process.removeAllListeners('warning')
 
@@ -3404,3 +3408,210 @@ test('registering invalid hooks should throw an error', async t => {
     })
   }, new Error('onSend hook should be a function, instead got [object Undefined]'))
 })
+
+test('onRequestAbort should be triggered', t => {
+  const fastify = Fastify()
+  let order = 0
+
+  t.plan(3)
+  t.teardown(() => fastify.close())
+
+  fastify.addHook('onRequestAbort', function (req, done) {
+    t.equal(++order, 1, 'called in hook')
+    done()
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/',
+    async handler (request, reply) {
+      await sleep(1000)
+      return { hello: 'world' }
+    },
+    async onRequestAbort (req) {
+      t.equal(++order, 2, 'called in route')
+    }
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const socket = connect(fastify.server.address().port)
+
+    socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
+
+    sleep(500).then(() => socket.destroy())
+  })
+})
+
+test('onRequestAbort should support encapsulation', t => {
+  const fastify = Fastify()
+  let order = 0
+  let child
+
+  t.plan(6)
+  t.teardown(() => fastify.close())
+
+  fastify.addHook('onRequestAbort', function (req, done) {
+    t.equal(++order, 1, 'called in root')
+    t.strictSame(this.pluginName, child.pluginName)
+    done()
+  })
+
+  fastify.register(async function (_child, _, done) {
+    child = _child
+
+    fastify.addHook('onRequestAbort', async function (req) {
+      t.equal(++order, 2, 'called in child')
+      t.strictSame(this.pluginName, child.pluginName)
+    })
+
+    child.route({
+      method: 'GET',
+      path: '/',
+      async handler (request, reply) {
+        await sleep(1000)
+        return { hello: 'world' }
+      },
+      async onRequestAbort (_req) {
+        t.equal(++order, 3, 'called in route')
+      }
+    })
+
+    done()
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const socket = connect(fastify.server.address().port)
+
+    socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
+
+    sleep(500).then(() => socket.destroy())
+  })
+})
+
+test('onRequestAbort should handle errors / 1', t => {
+  const fastify = Fastify()
+
+  t.plan(2)
+  t.teardown(() => fastify.close())
+
+  fastify.addHook('onRequestAbort', function (req, done) {
+    process.nextTick(() => t.pass())
+    done(new Error('KABOOM!'))
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/',
+    async handler (request, reply) {
+      await sleep(1000)
+      return { hello: 'world' }
+    }
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const socket = connect(fastify.server.address().port)
+
+    socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
+
+    sleep(500).then(() => socket.destroy())
+  })
+})
+
+test('onRequestAbort should handle errors / 2', t => {
+  const fastify = Fastify()
+
+  t.plan(2)
+  t.teardown(() => fastify.close())
+
+  fastify.addHook('onRequestAbort', function (req, done) {
+    process.nextTick(() => t.pass())
+    throw new Error('KABOOM!')
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/',
+    async handler (request, reply) {
+      await sleep(1000)
+      return { hello: 'world' }
+    }
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const socket = connect(fastify.server.address().port)
+
+    socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
+
+    sleep(500).then(() => socket.destroy())
+  })
+})
+
+test('onRequestAbort should handle async errors / 1', t => {
+  const fastify = Fastify()
+
+  t.plan(2)
+  t.teardown(() => fastify.close())
+
+  fastify.addHook('onRequestAbort', async function (req) {
+    process.nextTick(() => t.pass())
+    throw new Error('KABOOM!')
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/',
+    async handler (request, reply) {
+      await sleep(1000)
+      return { hello: 'world' }
+    }
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const socket = connect(fastify.server.address().port)
+
+    socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
+
+    sleep(500).then(() => socket.destroy())
+  })
+})
+
+test('onRequestAbort should handle async errors / 2', t => {
+  const fastify = Fastify()
+
+  t.plan(2)
+  t.teardown(() => fastify.close())
+
+  fastify.addHook('onRequestAbort', async function (req) {
+    process.nextTick(() => t.pass())
+    return Promise.reject()
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/',
+    async handler (request, reply) {
+      await sleep(1000)
+      return { hello: 'world' }
+    }
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    const socket = connect(fastify.server.address().port)
+
+    socket.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
+
+    sleep(500).then(() => socket.destroy())
+  })
+})

package/test/logger.test.js

@@ -28,15 +28,17 @@ before(async function () {
   [localhost, localhostForURL] = await helper.getLoopbackHost()
 })
 
-teardown(() => {
-  files.forEach((file) => {
-    try {
-      fs.unlinkSync(file)
-    } catch (e) {
-      console.log(e)
-    }
+if (process.env.CI) {
+  teardown(() => {
+    files.forEach((file) => {
+      try {
+        fs.unlinkSync(file)
+      } catch (e) {
+        console.log(e)
+      }
+    })
   })
-})
+}
 
 test('defaults to info level', t => {
   let fastify = null

package/test/route.test.js

@@ -1493,3 +1493,17 @@ test('exposeHeadRoute should not reuse the same route option', async t => {
     }
   })
 })
+
+test('using fastify.all when a catchall is defined does not degrade performance', { timeout: 5000 }, async t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.get('/*', async (_, reply) => reply.json({ ok: true }))
+
+  for (let i = 0; i < 100; i++) {
+    fastify.all(`/${i}`, async (_, reply) => reply.json({ ok: true }))
+  }
+
+  t.pass()
+})

package/test/schema-serialization.test.js

@@ -833,8 +833,9 @@ test('do not crash if status code serializer errors', async t => {
   t.equal(res.statusCode, 500)
   t.same(res.json(), {
     statusCode: 500,
-    error: 'Internal Server Error',
-    message: '"code" is required!'
+    code: 'FST_ERR_FAILED_ERROR_SERIALIZATION',
+    message: 'Failed to serialize an error. Error: "code" is required!. ' +
+      'Original error: querystring must have required property \'foo\''
   })
 })
 

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

@@ -240,7 +240,7 @@ expectAssignable<ValidationResult>(ajvErrorObject)
 expectAssignable<FastifyError['validation']>([ajvErrorObject])
 expectAssignable<FastifyError['validationContext']>('body')
 expectAssignable<FastifyError['validationContext']>('headers')
-expectAssignable<FastifyError['validationContext']>('parameters')
+expectAssignable<FastifyError['validationContext']>('params')
 expectAssignable<FastifyError['validationContext']>('querystring')
 
 const routeGeneric: RouteGenericInterface = {}

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

@@ -114,6 +114,14 @@ server.addHook('onError', function (request, reply, error, done) {
   expectType<void>(done())
 })
 
+server.addHook('onRequestAbort', function (request, done) {
+  expectType<FastifyInstance>(this)
+  expectType<FastifyRequest>(request)
+  expectAssignable<(err?: FastifyError) => void>(done)
+  expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
+  expectType<void>(done(new Error()))
+})
+
 server.addHook('onRoute', function (opts) {
   expectType<FastifyInstance>(this)
   expectType<RouteOptions & { routePath: string; path: string; prefix: string}>(opts)
@@ -201,6 +209,11 @@ server.addHook('onError', async function (request, reply, error) {
   expectType<FastifyError>(error)
 })
 
+server.addHook('onRequestAbort', async function (request) {
+  expectType<FastifyInstance>(this)
+  expectType<FastifyRequest>(request)
+})
+
 server.addHook('onRegister', async (instance, opts) => {
   expectType<FastifyInstance>(instance)
   expectType<RegisterOptions & FastifyPluginOptions>(opts)

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

@@ -1,9 +1,8 @@
-import { expectAssignable, expectError } from 'tsd'
-import fastify, { FastifyInstance, FastifyRequest, FastifySchema } from '../../fastify'
-import { RouteGenericInterface } from '../../types/route'
-import { ContextConfigDefault } from '../../types/utils'
-import { FastifyReply } from '../../types/reply'
+import { expectAssignable } from 'tsd'
+import fastify, { FastifyInstance, FastifySchema } from '../../fastify'
 import Ajv from 'ajv'
+import { StandaloneValidator } from '@fastify/ajv-compiler'
+import { StandaloneSerializer } from '@fastify/fast-json-stringify-compiler'
 
 const server = fastify()
 
@@ -63,3 +62,36 @@ expectAssignable<FastifyInstance>(server.setValidatorCompiler<FastifySchema & {
 expectAssignable<FastifyInstance>(server.setSerializerCompiler<FastifySchema & { validate: string }>(
   () => data => JSON.stringify(data)
 ))
+
+// https://github.com/fastify/ajv-compiler/issues/95
+{
+  const factory = StandaloneValidator({
+    readMode: false,
+    storeFunction (routeOpts, schemaValidationCode) { }
+  })
+
+  const app = fastify({
+    jsonShorthand: false,
+    schemaController: {
+      compilersFactory: {
+        buildValidator: factory
+      }
+    }
+  })
+}
+
+{
+  const factory = StandaloneSerializer({
+    readMode: false,
+    storeFunction (routeOpts, schemaValidationCode) { }
+  })
+
+  const app = fastify({
+    jsonShorthand: false,
+    schemaController: {
+      compilersFactory: {
+        buildSerializer: factory
+      }
+    }
+  })
+}

package/types/errors.d.ts

@@ -28,6 +28,7 @@ export type FastifyErrorCodes = Record<
 'FST_ERR_BAD_STATUS_CODE'|
 'FST_ERR_BAD_TRAILER_NAME' |
 'FST_ERR_BAD_TRAILER_VALUE' |
+'FST_ERR_FAILED_ERROR_SERIALIZATION' |
 'FST_ERR_MISSING_SERIALIZATION_FN' |
 'FST_ERR_REQ_INVALID_VALIDATION_INVOCATION' |
 'FST_ERR_SCH_MISSING_ID' |

package/types/hooks.d.ts

@@ -394,6 +394,44 @@ export interface onErrorAsyncHookHandler<
   ): Promise<unknown>;
 }
 
+/**
+ * `onRequestAbort` is useful if you need to monitor the if the client aborts the request (if the `request.raw.aborted` property is set to `true`).
+ * The `onRequestAbort` hook is executed when a client closes the connection before the entire request has been received. Therefore, you will not be able to send data to the client.
+ * Notice: client abort detection is not completely reliable. See: https://github.com/fastify/fastify/blob/main/docs/Guides/Detecting-When-Clients-Abort.md
+ */
+export interface onRequestAbortHookHandler<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> {
+  (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
+    request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger>,
+    done: HookHandlerDoneFunction
+  ): void;
+}
+
+export interface onRequestAbortAsyncHookHandler<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> {
+  (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
+    request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger>,
+  ): Promise<unknown>;
+}
+
 // Application Hooks
 
 /**

package/types/instance.d.ts

@@ -3,7 +3,7 @@ import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
 import * as http from 'http'
 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'
+import { onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onRequestAbortAsyncHookHandler, onRequestAbortHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler } from './hooks'
 import { FastifyBaseLogger } from './logger'
 import { FastifyRegister } from './register'
 import { FastifyReply } from './reply'
@@ -13,8 +13,8 @@ import {
   FastifySchema,
   FastifySchemaCompiler,
   FastifySchemaControllerOptions,
-  FastifySchemaValidationError,
-  FastifySerializerCompiler
+  FastifySerializerCompiler,
+  SchemaErrorFormatter
 } from './schema'
 import {
   FastifyTypeProvider,
@@ -393,6 +393,31 @@ export interface FastifyInstance<
     hook: onTimeoutAsyncHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
+  /**
+   * `onRequestAbort` is useful if you need to monitor the if the client aborts the request (if the `request.raw.aborted` property is set to `true`).
+   * The `onRequestAbort` hook is executed when a client closes the connection before the entire request has been received. Therefore, you will not be able to send data to the client.
+   * Notice: client abort detection is not completely reliable. See: https://github.com/fastify/fastify/blob/main/docs/Guides/Detecting-When-Clients-Abort.md
+  */
+  addHook<
+    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+    ContextConfig = ContextConfigDefault,
+    SchemaCompiler extends FastifySchema = FastifySchema,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  >(
+    name: 'onRequestAbort',
+    hook: onRequestAbortHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+
+  addHook<
+    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+    ContextConfig = ContextConfigDefault,
+    SchemaCompiler extends FastifySchema = FastifySchema,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  >(
+    name: 'onRequestAbort',
+    hook: onRequestAbortAsyncHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+
   /**
    * This hook is useful if you need to do some custom error logging or add some specific header in case of error.
    * It is not intended for changing the error, and calling reply.send will throw an exception.
@@ -530,7 +555,7 @@ export interface FastifyInstance<
   /*
   * Set the schema error formatter for all routes.
   */
-  setSchemaErrorFormatter(errorFormatter: (errors: FastifySchemaValidationError[], dataVar: string) => Error): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  setSchemaErrorFormatter(errorFormatter: SchemaErrorFormatter): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
   /**
    * Add a content type parser
    */

package/types/route.d.ts

@@ -1,9 +1,9 @@
 import { FastifyInstance } from './instance'
 import { FastifyRequest, RequestGenericInterface } from './request'
 import { FastifyReply, ReplyGenericInterface } from './reply'
-import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError, FastifySerializerCompiler } from './schema'
+import { FastifySchema, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorFormatter } from './schema'
 import { HTTPMethods, RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, ContextConfigDefault } from './utils'
-import { preValidationHookHandler, preHandlerHookHandler, preSerializationHookHandler, onRequestHookHandler, preParsingHookHandler, onResponseHookHandler, onSendHookHandler, onErrorHookHandler, onTimeoutHookHandler } from './hooks'
+import { preValidationHookHandler, preHandlerHookHandler, preSerializationHookHandler, onRequestHookHandler, preParsingHookHandler, onResponseHookHandler, onSendHookHandler, onErrorHookHandler, onTimeoutHookHandler, onRequestAbortHookHandler } from './hooks'
 import { FastifyError } from '@fastify/error'
 import { FastifyContext } from './context'
 import {
@@ -41,8 +41,7 @@ export interface RouteShorthandOptions<
   constraints?: { [name: string]: any },
   prefixTrailingSlash?: 'slash'|'no-slash'|'both';
   errorHandler?: (this: FastifyInstance, error: FastifyError, request: FastifyRequest, reply: FastifyReply) => void;
-  // TODO: Change to actual type.
-  schemaErrorFormatter?: (errors: FastifySchemaValidationError[], dataVar: string) => Error;
+  schemaErrorFormatter?: SchemaErrorFormatter;
 
   // hooks
   onRequest?: onRequestHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> | onRequestHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
@@ -54,6 +53,7 @@ export interface RouteShorthandOptions<
   onResponse?: onResponseHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> | onResponseHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
   onTimeout?: onTimeoutHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> | onTimeoutHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
   onError?: onErrorHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, SchemaCompiler, TypeProvider, Logger> | onErrorHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, SchemaCompiler, TypeProvider, Logger>[];
+  onRequestAbort?: onRequestAbortHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> | onRequestAbortHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>[];
 }
 
 /**

package/types/schema.d.ts

@@ -1,5 +1,6 @@
-import { ValidatorCompiler } from '@fastify/ajv-compiler'
-import { FastifyInstance, FastifyServerOptions } from '../fastify'
+import { ValidatorFactory } from '@fastify/ajv-compiler'
+import { SerializerFactory } from '@fastify/fast-json-stringify-compiler'
+import { FastifyInstance } from '../fastify'
 /**
  * Schemas in Fastify follow the JSON-Schema standard. For this reason
  * we have opted to not ship strict schema based types. Instead we provide
@@ -50,7 +51,11 @@ export interface FastifySchemaControllerOptions{
     getSchemas(): Record<string, unknown>;
   };
   compilersFactory?: {
-    buildValidator?: ValidatorCompiler;
-    buildSerializer?: (externalSchemas: unknown, serializerOptsServerOption: FastifyServerOptions['serializerOpts']) => FastifySerializerCompiler<unknown>;
+    buildValidator?: ValidatorFactory;
+    buildSerializer?: SerializerFactory;
   };
 }
+
+export type SchemaErrorDataVar = 'body' | 'headers' | 'params' | 'querystring'
+
+export type SchemaErrorFormatter = (errors: FastifySchemaValidationError[], dataVar: SchemaErrorDataVar) => Error