fastify 4.13.0 → 4.14.1

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 processed. 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>
@@ -736,7 +738,8 @@ Fastify provides default error handlers for the most common use cases. It is
 possible to override one or more of those handlers with custom code using this
 option.
 
-*Note: Only `FST_ERR_BAD_URL` is implemented at the moment.*
+*Note: Only `FST_ERR_BAD_URL` and `FST_ERR_ASYNC_CONSTRAINT` are implemented at 
+the moment.*
 
 ```js
 const fastify = require('fastify')({

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.1'
 
 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

@@ -11,8 +11,8 @@ const {
   kLogLevel,
   kContentTypeParser,
   kRouteByFastify,
-  kRequestValidateWeakMap,
-  kReplySerializeWeakMap,
+  kRequestCacheValidateFns,
+  kReplyCacheSerializeFns,
   kPublicRouteContext
 } = require('./symbols.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
@@ -67,8 +68,8 @@ function Context ({
     defaultSchemaErrorFormatter
   this[kRouteByFastify] = isFastify
 
-  this[kRequestValidateWeakMap] = null
-  this[kReplySerializeWeakMap] = null
+  this[kRequestCacheValidateFns] = null
+  this[kReplyCacheSerializeFns] = null
   this.validatorCompiler = validatorCompiler || null
   this.serializerCompiler = serializerCompiler || 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/reply.js

@@ -18,7 +18,7 @@ const {
   kReplyNextErrorHandler,
   kDisableRequestLogging,
   kSchemaResponse,
-  kReplySerializeWeakMap,
+  kReplyCacheSerializeFns,
   kSchemaController,
   kOptions,
   kRouteContext
@@ -323,7 +323,7 @@ Reply.prototype.getSerializationFunction = function (schemaOrStatus, contentType
       serialize = this[kRouteContext][kSchemaResponse]?.[schemaOrStatus]
     }
   } else if (typeof schemaOrStatus === 'object') {
-    serialize = this[kRouteContext][kReplySerializeWeakMap]?.get(schemaOrStatus)
+    serialize = this[kRouteContext][kReplyCacheSerializeFns]?.get(schemaOrStatus)
   }
 
   return serialize
@@ -334,8 +334,8 @@ Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null
   const { method, url } = request
 
   // Check if serialize function already compiled
-  if (this[kRouteContext][kReplySerializeWeakMap]?.has(schema)) {
-    return this[kRouteContext][kReplySerializeWeakMap].get(schema)
+  if (this[kRouteContext][kReplyCacheSerializeFns]?.has(schema)) {
+    return this[kRouteContext][kReplyCacheSerializeFns].get(schema)
   }
 
   const serializerCompiler = this[kRouteContext].serializerCompiler ||
@@ -360,11 +360,11 @@ Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null
   // if it is not used
   // TODO: Explore a central cache for all the schemas shared across
   // encapsulated contexts
-  if (this[kRouteContext][kReplySerializeWeakMap] == null) {
-    this[kRouteContext][kReplySerializeWeakMap] = new WeakMap()
+  if (this[kRouteContext][kReplyCacheSerializeFns] == null) {
+    this[kRouteContext][kReplyCacheSerializeFns] = new WeakMap()
   }
 
-  this[kRouteContext][kReplySerializeWeakMap].set(schema, serializeFn)
+  this[kRouteContext][kReplyCacheSerializeFns].set(schema, serializeFn)
 
   return serializeFn
 }
@@ -393,8 +393,8 @@ Reply.prototype.serializeInput = function (input, schema, httpStatus, contentTyp
     }
   } else {
     // Check if serialize function already compiled
-    if (this[kRouteContext][kReplySerializeWeakMap]?.has(schema)) {
-      serialize = this[kRouteContext][kReplySerializeWeakMap].get(schema)
+    if (this[kRouteContext][kReplyCacheSerializeFns]?.has(schema)) {
+      serialize = this[kRouteContext][kReplyCacheSerializeFns].get(schema)
     } else {
       serialize = this.compileSerializationSchema(schema, httpStatus, contentType)
     }

package/lib/request.js

@@ -11,7 +11,7 @@ const {
   kSchemaQuerystring,
   kSchemaController,
   kOptions,
-  kRequestValidateWeakMap,
+  kRequestCacheValidateFns,
   kRouteContext,
   kPublicRouteContext
 } = require('./symbols')
@@ -254,7 +254,7 @@ Object.defineProperties(Request.prototype, {
         const symbol = HTTP_PART_SYMBOL_MAP[httpPartOrSchema]
         return this[kRouteContext][symbol]
       } else if (typeof httpPartOrSchema === 'object') {
-        return this[kRouteContext][kRequestValidateWeakMap]?.get(httpPartOrSchema)
+        return this[kRouteContext][kRequestCacheValidateFns]?.get(httpPartOrSchema)
       }
     }
   },
@@ -262,8 +262,8 @@ Object.defineProperties(Request.prototype, {
     value: function (schema, httpPart = null) {
       const { method, url } = this
 
-      if (this[kRouteContext][kRequestValidateWeakMap]?.has(schema)) {
-        return this[kRouteContext][kRequestValidateWeakMap].get(schema)
+      if (this[kRouteContext][kRequestCacheValidateFns]?.has(schema)) {
+        return this[kRouteContext][kRequestCacheValidateFns].get(schema)
       }
 
       const validatorCompiler = this[kRouteContext].validatorCompiler ||
@@ -287,11 +287,11 @@ Object.defineProperties(Request.prototype, {
       // if it is not used
       // TODO: Explore a central cache for all the schemas shared across
       // encapsulated contexts
-      if (this[kRouteContext][kRequestValidateWeakMap] == null) {
-        this[kRouteContext][kRequestValidateWeakMap] = new WeakMap()
+      if (this[kRouteContext][kRequestCacheValidateFns] == null) {
+        this[kRouteContext][kRequestCacheValidateFns] = new WeakMap()
       }
 
-      this[kRouteContext][kRequestValidateWeakMap].set(schema, validateFn)
+      this[kRouteContext][kRequestCacheValidateFns].set(schema, validateFn)
 
       return validateFn
     }
@@ -317,8 +317,8 @@ Object.defineProperties(Request.prototype, {
       }
 
       if (validate == null) {
-        if (this[kRouteContext][kRequestValidateWeakMap]?.has(schema)) {
-          validate = this[kRouteContext][kRequestValidateWeakMap].get(schema)
+        if (this[kRouteContext][kRequestCacheValidateFns]?.has(schema)) {
+          validate = this[kRouteContext][kRequestCacheValidateFns].get(schema)
         } else {
           // We proceed to compile if there's no validate function yet
           validate = this.compileValidationSchema(schema, httpPart)