fastify 4.8.0 → 4.9.0

package/docs/Guides/Ecosystem.md

@@ -155,6 +155,10 @@ section.
 - [`@ethicdevs/fastify-git-server`](https://github.com/EthicDevs/fastify-git-server)
   A plugin to easily create git server and make one/many Git repositories available
   for clone/fetch/push through the standard `git` (over http) commands.
+- [`@fastify-userland/request-id`](https://github.com/fastify-userland/request-id)
+  Fastify Request ID Plugin
+- [`@fastify-userland/typeorm-query-runner`](https://github.com/fastify-userland/typeorm-query-runner)
+  Fastify typeorm QueryRunner plugin
 - [`@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.
@@ -235,7 +239,7 @@ section.
   send HTTP requests via [axios](https://github.com/axios/axios).
 - [`fastify-babel`](https://github.com/cfware/fastify-babel) Fastify plugin for
   development servers that require Babel transformations of JavaScript sources.
-- [`fastify-bcrypt`](https://github.com/heply/fastify-bcrypt) A Bcrypt hash
+- [`fastify-bcrypt`](https://github.com/beliven-it/fastify-bcrypt) A Bcrypt hash
   generator & checker.
 - [`fastify-blipp`](https://github.com/PavelPolyakov/fastify-blipp) Prints your
   routes to the console, so you definitely know which endpoints are available.
@@ -263,8 +267,8 @@ section.
   Sequelize ORM.
 - [`fastify-couchdb`](https://github.com/nigelhanlon/fastify-couchdb) Fastify
   plugin to add CouchDB support via [nano](https://github.com/apache/nano).
-- [`fastify-crud-generator`](https://github.com/heply/fastify-crud-generator) A
-  plugin to rapidly generate CRUD routes for any entity.
+- [`fastify-crud-generator`](https://github.com/beliven-it/fastify-crud-generator)
+  A plugin to rapidly generate CRUD routes for any entity.
 - [`fastify-custom-healthcheck`](https://github.com/gkampitakis/fastify-custom-healthcheck)
   Fastify plugin to add health route in your server that asserts custom
   functions.
@@ -453,7 +457,7 @@ section.
   Fastify plugin for memoize responses by expressive settings.
 - [`fastify-piscina`](https://github.com/piscinajs/fastify-piscina) A worker
   thread pool plugin using [Piscina](https://github.com/piscinajs/piscina).
-- [`fastify-polyglot`](https://github.com/heply/fastify-polyglot) A plugin to
+- [`fastify-polyglot`](https://github.com/beliven-it/fastify-polyglot) A plugin to
   handle i18n using
   [node-polyglot](https://www.npmjs.com/package/node-polyglot).
 - [`fastify-postgraphile`](https://github.com/alemagio/fastify-postgraphile)
@@ -547,7 +551,7 @@ section.
   [Tokenize](https://github.com/Bowser65/Tokenize) plugin for Fastify that
   removes the pain of managing authentication tokens, with built-in integration
   for `fastify-auth`.
-- [`fastify-totp`](https://github.com/heply/fastify-totp) A plugin to handle
+- [`fastify-totp`](https://github.com/beliven-it/fastify-totp) A plugin to handle
   TOTP (e.g. for 2FA).
 - [`fastify-twitch-ebs-tools`](https://github.com/lukemnet/fastify-twitch-ebs-tools)
   Useful functions for Twitch Extension Backend Services (EBS).
@@ -606,6 +610,8 @@ section.
   and updated Typeorm plugin for use with Fastify.
 
 #### [Community Tools](#community-tools)
+- [`@fastify-userland/workflows`](https://github.com/fastify-userland/workflows)
+  Reusable workflows for use in the Fastify plugin
 - [`fast-maker`](https://github.com/imjuni/fast-maker) route configuration
   generator by directory structure.
 - [`simple-tjscli`](https://github.com/imjuni/simple-tjscli) CLI tool to

package/docs/Reference/Reply.md

@@ -20,9 +20,9 @@
   - [.callNotFound()](#callnotfound)
   - [.getResponseTime()](#getresponsetime)
   - [.type(contentType)](#typecontenttype)
-  - [.getSerializationFunction(schema | httpStatus)](#getserializationfunctionschema--httpstatus)
-  - [.compileSerializationSchema(schema, httpStatus)](#compileserializationschemaschema-httpstatus)
-  - [.serializeInput(data, [schema | httpStatus], [httpStatus])](#serializeinputdata-schema--httpstatus-httpstatus)
+  - [.getSerializationFunction(schema | httpStatus, [contentType])](#getserializationfunctionschema--httpstatus)
+  - [.compileSerializationSchema(schema, [httpStatus], [contentType])](#compileserializationschemaschema-httpstatus)
+  - [.serializeInput(data, [schema | httpStatus], [httpStatus], [contentType])](#serializeinputdata-schema--httpstatus-httpstatus)
   - [.serializer(func)](#serializerfunc)
   - [.raw](#raw)
   - [.sent](#sent)
@@ -63,16 +63,17 @@ object that exposes the following functions and properties:
 - `.serialize(payload)` - Serializes the specified payload using the default
   JSON serializer or using the custom serializer (if one is set) and returns the
   serialized payload.
-- `.getSerializationFunction(schema | httpStatus)` - Returns the serialization
+- `.getSerializationFunction(schema | httpStatus, [contentType])` - Returns the serialization
   function for the specified schema or http status, if any of either are set.
-- `.compileSerializationSchema(schema, httpStatus)` - Compiles the specified
-  schema and returns a serialization function using the default (or customized)
-  `SerializerCompiler`. The optional `httpStatus` is forwarded to the
-  `SerializerCompiler` if provided, default to `undefined`.
-- `.serializeInput(data, schema, [,httpStatus])` - Serializes the specified data
-  using the specified schema and returns the serialized payload.
-  If the optional `httpStatus` is provided, the function will use the serializer
-  function given for that HTTP Status Code. Default to `undefined`.
+- `.compileSerializationSchema(schema, [httpStatus], [contentType])` - Compiles 
+  the specified schema and returns a serialization function using the default 
+  (or customized) `SerializerCompiler`. The optional `httpStatus` is forwarded 
+  to the `SerializerCompiler` if provided, default to `undefined`.
+- `.serializeInput(data, schema, [,httpStatus], [contentType])` - Serializes 
+  the specified data using the specified schema and returns the serialized payload.
+  If the optional `httpStatus`, and `contentType` are provided, the function 
+  will use the serializer function given for that specific content type and 
+  HTTP Status Code. Default to `undefined`.
 - `.serializer(function)` - Sets a custom serializer for the payload.
 - `.send(payload)` - Sends the payload to the user, could be a plain text, a
   buffer, JSON, stream, or an Error object.
@@ -339,12 +340,12 @@ reply.type('text/html')
 If the `Content-Type` has a JSON subtype, and the charset parameter is not set,
 `utf-8` will be used as the charset by default.
 
-### .getSerializationFunction(schema | httpStatus)
+### .getSerializationFunction(schema | httpStatus, [contentType])
 <a id="getserializationfunction"></a>
 
 By calling this function using a provided `schema` or `httpStatus`, 
-it will return a `serialzation` function that can be used to
-serialize diverse inputs. It returns `undefined` if no
+and the optional `contentType`, it will return a `serialzation` function 
+that can be used to serialize diverse inputs. It returns `undefined` if no
 serialization function was found using either of the provided inputs.
 
 This heavily depends of the `schema#responses` attached to the route, or
@@ -367,12 +368,18 @@ serialize({ foo: 'bar' }) // '{"foo":"bar"}'
 const serialize = reply
                   .getSerializationFunction(200)
 serialize({ foo: 'bar' }) // '{"foo":"bar"}'
+
+// or
+
+const serialize = reply
+                  .getSerializationFunction(200, 'application/json')
+serialize({ foo: 'bar' }) // '{"foo":"bar"}'
 ```
 
-See [.compileSerializationSchema(schema, [httpStatus])](#compileserializationschema)
+See [.compileSerializationSchema(schema, [httpStatus], [contentType])](#compileserializationschema)
 for more information on how to compile serialization schemas.
 
-### .compileSerializationSchema(schema, httpStatus)
+### .compileSerializationSchema(schema, [httpStatus], [contentType])
 <a id="compileserializationschema"></a>
 
 This function will compile a serialization schema and
@@ -381,9 +388,9 @@ The function returned (a.k.a. _serialization function_) returned is compiled
 by using the provided `SerializerCompiler`. Also this is cached by using
 a `WeakMap` for reducing compilation calls.
 
-The optional paramater `httpStatus`, if provided, is forwarded directly
-the `SerializerCompiler`, so it can be used to compile the serialization
-function if a custom `SerializerCompiler` is used.
+The optional paramaters `httpStatus` and `contentType`, if provided, 
+are forwarded directly to the `SerializerCompiler`, so it can be used 
+to compile the serialization function if a custom `SerializerCompiler` is used.
 
 This heavily depends of the `schema#responses` attached to the route, or
 the serialization functions compiled by using `compileSerializationSchema`.
@@ -412,6 +419,23 @@ const serialize = reply
                     } 
                   }, 200)
 serialize({ foo: 'bar' }) // '{"foo":"bar"}'
+
+// or
+
+const serialize = reply
+                  .compileSerializationSchema({
+                        '3xx': {
+                          content: {
+                            'application/json': {
+                              schema: {
+                                name: { type: 'string' },
+                                phone: { type: 'number' }
+                              }
+                            }
+                          }
+                        }
+                  }, '3xx', 'application/json')
+serialize({ name: 'Jone', phone: 201090909090 }) // '{"name":"Jone", "phone":201090909090}'
 ```
 
 Note that you should be careful when using this function, as it will cache
@@ -461,14 +485,14 @@ const newSerialize = reply.compileSerializationSchema(newSchema)
 console.log(newSerialize === serialize) // false
 ```
 
-### .serializeInput(data, [schema | httpStatus], [httpStatus])
+### .serializeInput(data, [schema | httpStatus], [httpStatus], [contentType])
 <a id="serializeinput"></a>
 
 This function will serialize the input data based on the provided schema,
 or http status code. If both provided, the `httpStatus` will take presedence.
 
 If there is not a serialization function for a given `schema`, a new serialization
-function will be compiled forwarding the `httpStatus` if provided.
+function will be compiled forwarding the `httpStatus`, and the `contentType` if provided.
 
 ```js
 reply
@@ -497,9 +521,14 @@ reply
 
 reply
   .serializeInput({ foo: 'bar'}, 200) // '{"foo":"bar"}'
+
+// or
+
+reply
+  .serializeInput({ name: 'Jone', age: 18 }, '200', 'application/vnd.v1+json') // '{"name": "Jone", "age": 18}'
 ```
 
-See [.compileSerializationSchema(schema, [httpStatus])](#compileserializationschema)
+See [.compileSerializationSchema(schema, [httpStatus], [contentType])](#compileserializationschema)
 for more information on how to compile serialization schemas.
 
 ### .serializer(func)

package/docs/Reference/Routes.md

@@ -94,8 +94,8 @@ fastify.route(options)
   schemas for request validations. See the [Validation and
   Serialization](./Validation-and-Serialization.md#schema-validator)
   documentation.
-* `serializerCompiler({ { schema, method, url, httpStatus } })`: function that
-  builds schemas for response serialization. See the [Validation and
+* `serializerCompiler({ { schema, method, url, httpStatus, contentType } })`: 
+  function that builds schemas for response serialization. See the [Validation and
   Serialization](./Validation-and-Serialization.md#schema-serializer)
   documentation.
 * `schemaErrorFormatter(errors, dataVar)`: function that formats the errors from

package/docs/Reference/Server.md

@@ -1370,7 +1370,7 @@ const fastify = Fastify({
       buildSerializer: function factory (externalSchemas, serializerOptsServerOption) {
         // This factory function must return a schema serializer compiler.
         // See [#schema-serializer](./Validation-and-Serialization.md#schema-serializer) for details.
-        return function serializerCompiler ({ schema, method, url, httpStatus }) {
+        return function serializerCompiler ({ schema, method, url, httpStatus, contentType }) {
           return data => JSON.stringify(data)
         }
       }

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

@@ -611,6 +611,44 @@ const schema = {
 
 fastify.post('/the/url', { schema }, handler)
 ```
+You can even have a specific response schema for different content types.
+For example:
+```js
+const schema = {
+      response: {
+        200: {
+          description: 'Response schema that support different content types'
+          content: {
+            'application/json': {
+              schema: {
+                name: { type: 'string' },
+                image: { type: 'string' },
+                address: { type: 'string' }
+              }
+            },
+            'application/vnd.v1+json': {
+              schema: {
+                type: 'array',
+                items: { $ref: 'test' }
+              }
+            }
+          }
+        },
+        '3xx': {
+          content: {
+            'application/vnd.v2+json': {
+              schema: {
+                fullName: { type: 'string' },
+                phone: { type: 'string' }
+              }
+            }
+          }
+        }
+      }
+    }
+
+fastify.post('/url', { schema }, handler)
+```
 
 #### Serializer Compiler
 <a id="schema-serializer"></a>
@@ -621,7 +659,7 @@ change the default serialization method by providing a function to serialize
 every route where you do.
 
 ```js
-fastify.setSerializerCompiler(({ schema, method, url, httpStatus }) => {
+fastify.setSerializerCompiler(({ schema, method, url, httpStatus, contentType }) => {
   return data => JSON.stringify(data)
 })
 

package/fastify.js

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

package/lib/contentTypeParser.js

@@ -29,9 +29,10 @@ const {
 
 function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning) {
   this[kDefaultJsonParse] = getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)
-  this.customParsers = {}
-  this.customParsers['application/json'] = new Parser(true, false, bodyLimit, this[kDefaultJsonParse])
-  this.customParsers['text/plain'] = new Parser(true, false, bodyLimit, defaultPlainTextParser)
+  // using a map instead of a plain object to avoid prototype hijack attacks
+  this.customParsers = new Map()
+  this.customParsers.set('application/json', new Parser(true, false, bodyLimit, this[kDefaultJsonParse]))
+  this.customParsers.set('text/plain', new Parser(true, false, bodyLimit, defaultPlainTextParser))
   this.parserList = ['application/json', 'text/plain']
   this.parserRegExpList = []
   this.cache = lru(100)
@@ -62,35 +63,35 @@ ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
   )
 
   if (contentTypeIsString && contentType === '*') {
-    this.customParsers[''] = parser
+    this.customParsers.set('', parser)
   } else {
     if (contentTypeIsString) {
       this.parserList.unshift(contentType)
     } else {
       this.parserRegExpList.unshift(contentType)
     }
-    this.customParsers[contentType] = parser
+    this.customParsers.set(contentType.toString(), parser)
   }
 }
 
 ContentTypeParser.prototype.hasParser = function (contentType) {
-  return contentType in this.customParsers
+  return this.customParsers.has(typeof contentType === 'string' ? contentType : contentType.toString())
 }
 
 ContentTypeParser.prototype.existingParser = function (contentType) {
-  if (contentType === 'application/json') {
-    return this.customParsers['application/json'] && this.customParsers['application/json'].fn !== this[kDefaultJsonParse]
+  if (contentType === 'application/json' && this.customParsers.has(contentType)) {
+    return this.customParsers.get(contentType).fn !== this[kDefaultJsonParse]
   }
-  if (contentType === 'text/plain') {
-    return this.customParsers['text/plain'] && this.customParsers['text/plain'].fn !== defaultPlainTextParser
+  if (contentType === 'text/plain' && this.customParsers.has(contentType)) {
+    return this.customParsers.get(contentType).fn !== defaultPlainTextParser
   }
 
-  return contentType in this.customParsers
+  return this.hasParser(contentType)
 }
 
 ContentTypeParser.prototype.getParser = function (contentType) {
-  if (contentType in this.customParsers) {
-    return this.customParsers[contentType]
+  if (this.hasParser(contentType)) {
+    return this.customParsers.get(contentType)
   }
 
   if (this.cache.has(contentType)) {
@@ -101,7 +102,7 @@ ContentTypeParser.prototype.getParser = function (contentType) {
   for (var i = 0; i !== this.parserList.length; ++i) {
     const parserName = this.parserList[i]
     if (contentType.indexOf(parserName) !== -1) {
-      const parser = this.customParsers[parserName]
+      const parser = this.customParsers.get(parserName)
       this.cache.set(contentType, parser)
       return parser
     }
@@ -111,17 +112,17 @@ ContentTypeParser.prototype.getParser = function (contentType) {
   for (var j = 0; j !== this.parserRegExpList.length; ++j) {
     const parserRegExp = this.parserRegExpList[j]
     if (parserRegExp.test(contentType)) {
-      const parser = this.customParsers[parserRegExp]
+      const parser = this.customParsers.get(parserRegExp.toString())
       this.cache.set(contentType, parser)
       return parser
     }
   }
 
-  return this.customParsers['']
+  return this.customParsers.get('')
 }
 
 ContentTypeParser.prototype.removeAll = function () {
-  this.customParsers = {}
+  this.customParsers = new Map()
   this.parserRegExpList = []
   this.parserList = []
   this.cache = lru(100)
@@ -130,7 +131,7 @@ ContentTypeParser.prototype.removeAll = function () {
 ContentTypeParser.prototype.remove = function (contentType) {
   if (!(typeof contentType === 'string' || contentType instanceof RegExp)) throw new FST_ERR_CTP_INVALID_TYPE()
 
-  delete this.customParsers[contentType]
+  this.customParsers.delete(contentType.toString())
 
   const parsers = typeof contentType === 'string' ? this.parserList : this.parserRegExpList
 
@@ -289,7 +290,7 @@ function Parser (asString, asBuffer, bodyLimit, fn) {
 function buildContentTypeParser (c) {
   const contentTypeParser = new ContentTypeParser()
   contentTypeParser[kDefaultJsonParse] = c[kDefaultJsonParse]
-  Object.assign(contentTypeParser.customParsers, c.customParsers)
+  contentTypeParser.customParsers = new Map(c.customParsers.entries())
   contentTypeParser.parserList = c.parserList.slice()
   return contentTypeParser
 }

package/lib/error-handler.js

@@ -49,6 +49,8 @@ function handleError (reply, error, cb) {
   // In case the error handler throws, we set the next errorHandler so we can error again
   reply[kReplyNextErrorHandler] = Object.getPrototypeOf(errorHandler)
 
+  // we need to remove content-type to allow content-type guessing for serialization
+  delete reply[kReplyHeaders]['content-type']
   delete reply[kReplyHeaders]['content-length']
 
   const func = errorHandler.func

package/lib/error-serializer.js

@@ -217,7 +217,7 @@ class Serializer {
     }
   
     
-    
+  
 
   module.exports = main
       

package/lib/errors.js

@@ -97,7 +97,7 @@ const codes = {
   ),
   FST_ERR_HOOK_INVALID_HANDLER: createError(
     'FST_ERR_HOOK_INVALID_HANDLER',
-    'The hook callback must be a function',
+    '%s hook should be a function, instead got %s',
     500,
     TypeError
   ),
@@ -165,6 +165,10 @@ const codes = {
     'FST_ERR_MISSING_SERIALIZATION_FN',
     'Missing serialization function. Key "%s"'
   ),
+  FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN: createError(
+    'FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN',
+    'Missing serialization function. Key "%s:%s"'
+  ),
   FST_ERR_REQ_INVALID_VALIDATION_INVOCATION: createError(
     'FST_ERR_REQ_INVALID_VALIDATION_INVOCATION',
     'Invalid validation invocation. Missing validation function for HTTP part "%s" nor schema provided.'
@@ -181,6 +185,10 @@ const codes = {
     'FST_ERR_SCH_ALREADY_PRESENT',
     "Schema with id '%s' already declared!"
   ),
+  FST_ERR_SCH_CONTENT_MISSING_SCHEMA: createError(
+    'FST_ERR_SCH_CONTENT_MISSING_SCHEMA',
+    "Schema is missing for the content type '%s'"
+  ),
   FST_ERR_SCH_DUPLICATE: createError(
     'FST_ERR_SCH_DUPLICATE',
     "Schema with '%s' already present!"

package/lib/hooks.js

@@ -49,10 +49,10 @@ function Hooks () {
 
 Hooks.prototype.validate = function (hook, fn) {
   if (typeof hook !== 'string') throw new FST_ERR_HOOK_INVALID_TYPE()
-  if (typeof fn !== 'function') throw new FST_ERR_HOOK_INVALID_HANDLER()
   if (supportedHooks.indexOf(hook) === -1) {
     throw new Error(`${hook} hook not supported!`)
   }
+  if (typeof fn !== 'function') throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof fn)
 }
 
 Hooks.prototype.add = function (hook, fn) {

package/lib/reply.js

@@ -44,7 +44,8 @@ const {
   FST_ERR_BAD_STATUS_CODE,
   FST_ERR_BAD_TRAILER_NAME,
   FST_ERR_BAD_TRAILER_VALUE,
-  FST_ERR_MISSING_SERIALIZATION_FN
+  FST_ERR_MISSING_SERIALIZATION_FN,
+  FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN
 } = require('./errors')
 const warning = require('./warnings')
 
@@ -312,11 +313,15 @@ Reply.prototype.code = function (code) {
 
 Reply.prototype.status = Reply.prototype.code
 
-Reply.prototype.getSerializationFunction = function (schemaOrStatus) {
+Reply.prototype.getSerializationFunction = function (schemaOrStatus, contentType) {
   let serialize
 
   if (typeof schemaOrStatus === 'string' || typeof schemaOrStatus === 'number') {
-    serialize = this[kRouteContext][kSchemaResponse]?.[schemaOrStatus]
+    if (typeof contentType === 'string') {
+      serialize = this[kRouteContext][kSchemaResponse]?.[schemaOrStatus]?.[contentType]
+    } else {
+      serialize = this[kRouteContext][kSchemaResponse]?.[schemaOrStatus]
+    }
   } else if (typeof schemaOrStatus === 'object') {
     serialize = this[kRouteContext][kReplySerializeWeakMap]?.get(schemaOrStatus)
   }
@@ -324,7 +329,7 @@ Reply.prototype.getSerializationFunction = function (schemaOrStatus) {
   return serialize
 }
 
-Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null) {
+Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null, contentType = null) {
   const { request } = this
   const { method, url } = request
 
@@ -346,7 +351,8 @@ Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null
     schema,
     method,
     url,
-    httpStatus
+    httpStatus,
+    contentType
   })
 
   // We create a WeakMap to compile the schema only once
@@ -363,22 +369,34 @@ Reply.prototype.compileSerializationSchema = function (schema, httpStatus = null
   return serializeFn
 }
 
-Reply.prototype.serializeInput = function (input, schema, httpStatus) {
+Reply.prototype.serializeInput = function (input, schema, httpStatus, contentType) {
+  const possibleContentType = httpStatus
   let serialize
   httpStatus = typeof schema === 'string' || typeof schema === 'number'
     ? schema
     : httpStatus
 
+  contentType = httpStatus && possibleContentType !== httpStatus
+    ? possibleContentType
+    : contentType
+
   if (httpStatus != null) {
-    serialize = this[kRouteContext][kSchemaResponse]?.[httpStatus]
+    if (contentType != null) {
+      serialize = this[kRouteContext][kSchemaResponse]?.[httpStatus]?.[contentType]
+    } else {
+      serialize = this[kRouteContext][kSchemaResponse]?.[httpStatus]
+    }
 
-    if (serialize == null) throw new FST_ERR_MISSING_SERIALIZATION_FN(httpStatus)
+    if (serialize == null) {
+      if (contentType) throw new FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN(httpStatus, contentType)
+      throw new FST_ERR_MISSING_SERIALIZATION_FN(httpStatus)
+    }
   } else {
     // Check if serialize function already compiled
     if (this[kRouteContext][kReplySerializeWeakMap]?.has(schema)) {
       serialize = this[kRouteContext][kReplySerializeWeakMap].get(schema)
     } else {
-      serialize = this.compileSerializationSchema(schema, httpStatus)
+      serialize = this.compileSerializationSchema(schema, httpStatus, contentType)
     }
   }
 
@@ -483,7 +501,7 @@ function preserializeHookEnd (err, request, reply, payload) {
     } else if (reply[kRouteContext] && reply[kRouteContext][kReplySerializerDefault]) {
       payload = reply[kRouteContext][kReplySerializerDefault](payload, reply.raw.statusCode)
     } else {
-      payload = serialize(reply[kRouteContext], payload, reply.raw.statusCode)
+      payload = serialize(reply[kRouteContext], payload, reply.raw.statusCode, reply[kReplyHeaders]['content-type'])
     }
   } catch (e) {
     wrapSeralizationError(e, reply)
@@ -797,10 +815,11 @@ function notFound (reply) {
  * @param {object} context the request context
  * @param {object} data the JSON payload to serialize
  * @param {number} statusCode the http status code
+ * @param {string} contentType the reply content type
  * @returns {string} the serialized payload
  */
-function serialize (context, data, statusCode) {
-  const fnSerialize = getSchemaSerializer(context, statusCode)
+function serialize (context, data, statusCode, contentType) {
+  const fnSerialize = getSchemaSerializer(context, statusCode, contentType)
   if (fnSerialize) {
     return fnSerialize(data)
   }

package/lib/route.js

@@ -20,7 +20,8 @@ const {
   FST_ERR_DEFAULT_ROUTE_INVALID_TYPE,
   FST_ERR_DUPLICATED_ROUTE,
   FST_ERR_INVALID_URL,
-  FST_ERR_SEND_UNDEFINED_ERR
+  FST_ERR_SEND_UNDEFINED_ERR,
+  FST_ERR_HOOK_INVALID_HANDLER
 } = require('./errors')
 
 const {
@@ -243,6 +244,20 @@ function buildRouting (options) {
         }
       }
 
+      for (const hook of lifecycleHooks) {
+        if (opts && hook in opts) {
+          if (Array.isArray(opts[hook])) {
+            for (const func of opts[hook]) {
+              if (typeof func !== 'function') {
+                throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof func)
+              }
+            }
+          } else if (typeof opts[hook] !== 'function') {
+            throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof opts[hook])
+          }
+        }
+      }
+
       const constraints = opts.constraints || {}
       const config = {
         ...opts.config,

package/lib/schema-controller.js

@@ -15,12 +15,16 @@ function buildSchemaController (parentSchemaCtrl, opts) {
     return new SchemaController(parentSchemaCtrl, opts)
   }
 
-  let compilersFactory = {
-    buildValidator: ValidatorSelector(),
-    buildSerializer: SerializerSelector()
+  const compilersFactory = Object.assign({
+    buildValidator: null,
+    buildSerializer: null
+  }, opts?.compilersFactory)
+
+  if (!compilersFactory.buildValidator) {
+    compilersFactory.buildValidator = ValidatorSelector()
   }
-  if (opts && opts.compilersFactory) {
-    compilersFactory = Object.assign(compilersFactory, opts.compilersFactory)
+  if (!compilersFactory.buildSerializer) {
+    compilersFactory.buildSerializer = SerializerSelector()
   }
 
   const option = {