fastify 4.8.1 → 4.9.1

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/Decorators.md

@@ -114,10 +114,39 @@ fastify.get('/', async function (request, reply) {
 The `dependencies` parameter is an optional list of decorators that the
 decorator being defined relies upon. This list is simply a list of string names
 of other decorators. In the following example, the "utility" decorator depends
-upon "greet" and "log" decorators:
+upon "greet" and "hi" decorators:
 
 ```js
-fastify.decorate('utility', fn, ['greet', 'log'])
+async function greetDecorator (fastify, opts) {
+  fastify.decorate('greet', () => {
+    return 'greet message'
+  })
+}
+
+async function hiDecorator (fastify, opts) {
+  fastify.decorate('hi', () => {
+    return 'hi message'
+  })
+}
+
+async function utilityDecorator (fastify, opts) {
+  fastify.decorate('utility', () => {
+    return `${fastify.greet()} | ${fastify.hi()}`
+  })
+}
+
+fastify.register(fastifyPlugin(greetDecorator, { name: 'greet' }))
+fastify.register(fastifyPlugin(hiDecorator, { name: 'hi' }))
+fastify.register(fastifyPlugin(utilityDecorator, { dependencies: ['greet', 'hi'] }))
+
+fastify.get('/', function (req, reply) {
+  // Response: {"hello":"greet message | hi message"}
+  reply.send({ hello: fastify.utility() })
+})
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) throw err
+})
 ```
 
 Note: using an arrow function will break the binding of `this` to the

package/docs/Reference/Errors.md

@@ -332,7 +332,7 @@ The router received an invalid url.
 ### FST_ERR_ASYNC_CONSTRAINT
 <a id="FST_ERR_ASYNC_CONSTRAINT"></a>
 
-The router received error when using asynchronous constraints.
+The router received an error when using asynchronous constraints.
 
 #### FST_ERR_DEFAULT_ROUTE_INVALID_TYPE
 <a id="FST_ERR_DEFAULT_ROUTE_INVALID_TYPE"></a>

package/docs/Reference/Hooks.md

@@ -449,9 +449,9 @@ fastify.addHook('onRoute', (routeOptions) => {
 })
 ```
 
-If you want to add more routes within an onRoute hook, you have to tag these
-routes properly. If you don't, the hook will run into an infinite loop. The
-recommended approach is shown below.
+To add more routes within an onRoute hook, the routes must
+be tagged correctly. The hook will run into an infinite loop if
+not tagged. The recommended approach is shown below.
 
 ```js
 const kRouteAlreadyProcessed = Symbol('route-already-processed')

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)
@@ -627,13 +656,13 @@ fastify.get('/json', options, function (request, reply) {
 #### Streams
 <a id="send-streams"></a>
 
-*send* can also handle streams out of the box. If you are sending a stream and
-you have not set a `'Content-Type'` header, *send* will set it at
+*send* can also handle streams by setting the `'Content-Type'` header to
 `'application/octet-stream'`.
 ```js
 fastify.get('/streams', function (request, reply) {
   const fs = require('fs')
   const stream = fs.createReadStream('some-file', 'utf8')
+  reply.header('Content-Type', 'application/octet-stream')
   reply.send(stream)
 })
 ```

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
@@ -734,9 +734,9 @@ fastify.route({
 
 #### Asynchronous Custom Constraints
 
-You can provide your custom constraints and the `constraint` criteria can be
-fetched from other source, for example `database`. Usage of asynchronous custom
-constraint should place at the last resort since it impacts the router
+Custom constraints can be provided and the `constraint` criteria can be
+fetched from another source such as `database`. The use of asynchronous
+custom constraints should be a last resort as it impacts router
 performance.
 
 ```js

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.1'
+const VERSION = '4.9.1'
 
 const Avvio = require('avvio')
 const http = require('http')

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 (opts[hook] !== undefined && 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 = {