fastify 4.8.1 → 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.1'
+const VERSION = '4.9.0'
 
 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 (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 = {

package/lib/schemas.js

@@ -7,7 +7,8 @@ const kFluentSchema = Symbol.for('fluent-schema-object')
 const {
   FST_ERR_SCH_MISSING_ID,
   FST_ERR_SCH_ALREADY_PRESENT,
-  FST_ERR_SCH_DUPLICATE
+  FST_ERR_SCH_DUPLICATE,
+  FST_ERR_SCH_CONTENT_MISSING_SCHEMA
 } = require('./errors')
 
 const SCHEMAS_SOURCE = ['params', 'body', 'querystring', 'query', 'headers']
@@ -86,7 +87,27 @@ function normalizeSchema (routeSchemas, serverOptions) {
   if (routeSchemas.response) {
     const httpCodes = Object.keys(routeSchemas.response)
     for (const code of httpCodes) {
-      routeSchemas.response[code] = getSchemaAnyway(routeSchemas.response[code], serverOptions.jsonShorthand)
+      const contentProperty = routeSchemas.response[code].content
+
+      let hasContentMultipleContentTypes = false
+      if (contentProperty) {
+        const keys = Object.keys(contentProperty)
+        for (let i = 0; i < keys.length; i++) {
+          const mediaName = keys[i]
+          if (!contentProperty[mediaName].schema) {
+            if (keys.length === 1) { break }
+            throw new FST_ERR_SCH_CONTENT_MISSING_SCHEMA(mediaName)
+          }
+          routeSchemas.response[code].content[mediaName].schema = getSchemaAnyway(contentProperty[mediaName].schema, serverOptions.jsonShorthand)
+          if (i === keys.length - 1) {
+            hasContentMultipleContentTypes = true
+          }
+        }
+      }
+
+      if (!hasContentMultipleContentTypes) {
+        routeSchemas.response[code] = getSchemaAnyway(routeSchemas.response[code], serverOptions.jsonShorthand)
+      }
     }
   }
 
@@ -129,22 +150,49 @@ function getSchemaAnyway (schema, jsonShorthand) {
  *
  * @param {object} context the request context
  * @param {number} statusCode the http status code
+ * @param {string} contentType the reply content type
  * @returns {function|boolean} the right JSON Schema function to serialize
  * the reply or false if it is not set
  */
-function getSchemaSerializer (context, statusCode) {
+function getSchemaSerializer (context, statusCode, contentType) {
   const responseSchemaDef = context[kSchemaResponse]
   if (!responseSchemaDef) {
     return false
   }
   if (responseSchemaDef[statusCode]) {
+    if (responseSchemaDef[statusCode].constructor === Object) {
+      const mediaName = contentType.split(';')[0]
+      if (responseSchemaDef[statusCode][mediaName]) {
+        return responseSchemaDef[statusCode][mediaName]
+      }
+
+      return false
+    }
     return responseSchemaDef[statusCode]
   }
   const fallbackStatusCode = (statusCode + '')[0] + 'xx'
   if (responseSchemaDef[fallbackStatusCode]) {
+    if (responseSchemaDef[fallbackStatusCode].constructor === Object) {
+      const mediaName = contentType.split(';')[0]
+      if (responseSchemaDef[fallbackStatusCode][mediaName]) {
+        return responseSchemaDef[fallbackStatusCode][mediaName]
+      }
+
+      return false
+    }
+
     return responseSchemaDef[fallbackStatusCode]
   }
   if (responseSchemaDef.default) {
+    if (responseSchemaDef.default.constructor === Object) {
+      const mediaName = contentType.split(';')[0]
+      if (responseSchemaDef.default[mediaName]) {
+        return responseSchemaDef.default[mediaName]
+      }
+
+      return false
+    }
+
     return responseSchemaDef.default
   }
   return false

package/lib/validation.js

@@ -22,12 +22,28 @@ function compileSchemasForSerialization (context, compile) {
         throw new Error('response schemas should be nested under a valid status code, e.g { 2xx: { type: "object" } }')
       }
 
-      acc[statusCode] = compile({
-        schema,
-        url,
-        method,
-        httpStatus: statusCode
-      })
+      if (schema.content) {
+        const contentTypesSchemas = {}
+        for (const mediaName of Object.keys(schema.content)) {
+          const contentSchema = schema.content[mediaName].schema
+          contentTypesSchemas[mediaName] = compile({
+            schema: contentSchema,
+            url,
+            method,
+            httpStatus: statusCode,
+            contentType: mediaName
+          })
+        }
+        acc[statusCode] = contentTypesSchemas
+      } else {
+        acc[statusCode] = compile({
+          schema,
+          url,
+          method,
+          httpStatus: statusCode
+        })
+      }
+
       return acc
     }, {})
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.8.1",
+  "version": "4.9.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -146,7 +146,7 @@
     "fast-json-body": "^1.1.0",
     "fast-json-stringify": "^5.3.0",
     "fastify-plugin": "^4.2.1",
-    "fluent-json-schema": "^3.1.0",
+    "fluent-json-schema": "^4.0.0",
     "form-data": "^4.0.0",
     "h2url": "^0.2.0",
     "http-errors": "^2.0.0",

package/test/content-type.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+
+test('should remove content-type for setErrorHandler', async t => {
+  t.plan(8)
+  let count = 0
+
+  const fastify = Fastify()
+  fastify.setErrorHandler(function (error, request, reply) {
+    t.same(error.message, 'kaboom')
+    t.same(reply.hasHeader('content-type'), false)
+    reply.code(400).send({ foo: 'bar' })
+  })
+  fastify.addHook('onSend', async function (request, reply, payload) {
+    count++
+    t.same(typeof payload, 'string')
+    switch (count) {
+      case 1: {
+        // should guess the correct content-type based on payload
+        t.same(reply.getHeader('content-type'), 'text/plain; charset=utf-8')
+        throw Error('kaboom')
+      }
+      case 2: {
+        // should guess the correct content-type based on payload
+        t.same(reply.getHeader('content-type'), 'application/json; charset=utf-8')
+        return payload
+      }
+      default: {
+        t.fail('should not reach')
+      }
+    }
+  })
+  fastify.get('/', function (request, reply) {
+    reply.send('plain-text')
+  })
+
+  const { statusCode, body } = await fastify.inject({ method: 'GET', path: '/' })
+  t.same(statusCode, 400)
+  t.same(body, JSON.stringify({ foo: 'bar' }))
+})

package/test/hooks.test.js

@@ -3301,3 +3301,41 @@ test('onTimeout should be triggered and socket _meta is set', t => {
     })
   })
 })
+
+test('registering invalid hooks should throw an error', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  t.throws(() => {
+    fastify.route({
+      method: 'GET',
+      path: '/invalidHook',
+      onRequest: [undefined],
+      async handler () {
+        return 'hello world'
+      }
+    })
+  }, new Error('onRequest hook should be a function, instead got undefined'))
+
+  t.throws(() => {
+    fastify.route({
+      method: 'GET',
+      path: '/invalidHook',
+      onRequest: undefined,
+      async handler () {
+        return 'hello world'
+      }
+    })
+  }, new Error('onRequest hook should be a function, instead got undefined'))
+
+  t.throws(() => {
+    fastify.addHook('onRoute', (routeOptions) => {
+      routeOptions.onSend = [undefined]
+    })
+
+    fastify.get('/', function (request, reply) {
+      reply.send('hello world')
+    })
+  }, new Error('onSend hook should be a function, instead got undefined'))
+})

package/test/internals/hooks.test.js

@@ -66,7 +66,7 @@ test('should throw on wrong parameters', t => {
   const hooks = new Hooks()
   t.plan(4)
   try {
-    hooks.add(null, noop)
+    hooks.add(null, () => {})
     t.fail()
   } catch (e) {
     t.equal(e.code, 'FST_ERR_HOOK_INVALID_TYPE')
@@ -74,10 +74,10 @@ test('should throw on wrong parameters', t => {
   }
 
   try {
-    hooks.add('', null)
+    hooks.add('onSend', null)
     t.fail()
   } catch (e) {
     t.equal(e.code, 'FST_ERR_HOOK_INVALID_HANDLER')
-    t.equal(e.message, 'The hook callback must be a function')
+    t.equal(e.message, 'onSend hook should be a function, instead got object')
   }
 })

package/test/internals/reply-serialize.test.js

@@ -45,6 +45,16 @@ function getResponseSchema () {
           type: 'string'
         }
       }
+    },
+    '3xx': {
+      content: {
+        'application/json': {
+          schema: {
+            fullName: { type: 'string' },
+            phone: { type: 'number' }
+          }
+        }
+      }
     }
   }
 }
@@ -141,7 +151,20 @@ test('Reply#compileSerializationSchema', t => {
         }
       }
 
-      t.plan(10)
+      const custom2 = ({ schema, httpStatus, url, method, contentType }) => {
+        t.equal(schema, schemaObj)
+        t.equal(url, '/user')
+        t.equal(method, 'GET')
+        t.equal(httpStatus, '3xx')
+        t.equal(contentType, 'application/json')
+
+        return input => {
+          t.same(input, { fullName: 'Jone', phone: 1090243795 })
+          return JSON.stringify(input)
+        }
+      }
+
+      t.plan(17)
       const schemaObj = getDefaultSchema()
 
       fastify.get('/', { serializerCompiler: custom }, (req, reply) => {
@@ -157,10 +180,22 @@ test('Reply#compileSerializationSchema', t => {
         reply.send({ hello: 'world' })
       })
 
+      fastify.get('/user', { serializerCompiler: custom2 }, (req, reply) => {
+        const input = { fullName: 'Jone', phone: 1090243795 }
+        const first = reply.compileSerializationSchema(schemaObj, '3xx', 'application/json')
+        t.ok(first(input), JSON.stringify(input))
+        reply.send(input)
+      })
+
       await fastify.inject({
         path: '/',
         method: 'GET'
       })
+
+      await fastify.inject({
+        path: '/user',
+        method: 'GET'
+      })
     }
   )
 
@@ -209,10 +244,19 @@ test('Reply#getSerializationFunction', t => {
         status: 'error',
         code: 'something'
       }
+      const okInput3xx = {
+        fullName: 'Jone',
+        phone: 0
+      }
+      const noOkInput3xx = {
+        fullName: 'Jone',
+        phone: 'phone'
+      }
       let cached4xx
       let cached201
+      let cachedJson3xx
 
-      t.plan(9)
+      t.plan(13)
 
       const responseSchema = getResponseSchema()
 
@@ -234,15 +278,19 @@ test('Reply#getSerializationFunction', t => {
           if (Number(id) === 1) {
             const serialize4xx = reply.getSerializationFunction('4xx')
             const serialize201 = reply.getSerializationFunction(201)
+            const serializeJson3xx = reply.getSerializationFunction('3xx', 'application/json')
             const serializeUndefined = reply.getSerializationFunction(undefined)
 
             cached4xx = serialize4xx
             cached201 = serialize201
+            cachedJson3xx = serializeJson3xx
 
             t.type(serialize4xx, Function)
             t.type(serialize201, Function)
+            t.type(serializeJson3xx, Function)
             t.equal(serialize4xx(okInput4xx), JSON.stringify(okInput4xx))
             t.equal(serialize201(okInput201), JSON.stringify(okInput201))
+            t.equal(serializeJson3xx(okInput3xx), JSON.stringify(okInput3xx))
             t.notOk(serializeUndefined)
 
             try {
@@ -260,13 +308,21 @@ test('Reply#getSerializationFunction', t => {
               t.equal(err.message, '"status" is required!')
             }
 
+            try {
+              serializeJson3xx(noOkInput3xx)
+            } catch (err) {
+              t.equal(err.message, 'The value "phone" cannot be converted to a number.')
+            }
+
             reply.status(201).send(okInput201)
           } else {
             const serialize201 = reply.getSerializationFunction(201)
             const serialize4xx = reply.getSerializationFunction('4xx')
+            const serializeJson3xx = reply.getSerializationFunction('3xx', 'application/json')
 
             t.equal(serialize4xx, cached4xx)
             t.equal(serialize201, cached201)
+            t.equal(serializeJson3xx, cachedJson3xx)
             reply.status(401).send(okInput4xx)
           }
         }
@@ -367,7 +423,7 @@ test('Reply#getSerializationFunction', t => {
 })
 
 test('Reply#serializeInput', t => {
-  t.plan(5)
+  t.plan(6)
 
   t.test(
     'Should throw if missed serialization function from HTTP status',
@@ -395,6 +451,47 @@ test('Reply#serializeInput', t => {
     }
   )
 
+  t.test(
+    'Should throw if missed serialization function from HTTP status with specific content type',
+    async t => {
+      const fastify = Fastify()
+
+      t.plan(2)
+
+      fastify.get('/', {
+        schema: {
+          response: {
+            '3xx': {
+              content: {
+                'application/json': {
+                  schema: {
+                    fullName: { type: 'string' },
+                    phone: { type: 'number' }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }, (req, reply) => {
+        reply.serializeInput({}, '3xx', 'application/vnd.v1+json')
+      })
+
+      const result = await fastify.inject({
+        path: '/',
+        method: 'GET'
+      })
+
+      t.equal(result.statusCode, 500)
+      t.same(result.json(), {
+        statusCode: 500,
+        code: 'FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN',
+        error: 'Internal Server Error',
+        message: 'Missing serialization function. Key "3xx:application/vnd.v1+json"'
+      })
+    }
+  )
+
   t.test('Should use a serializer fn from HTTP status', async t => {
     const fastify = Fastify()
     const okInput201 = {
@@ -413,8 +510,16 @@ test('Reply#serializeInput', t => {
       status: 'error',
       code: 'something'
     }
+    const okInput3xx = {
+      fullName: 'Jone',
+      phone: 0
+    }
+    const noOkInput3xx = {
+      fullName: 'Jone',
+      phone: 'phone'
+    }
 
-    t.plan(4)
+    t.plan(6)
 
     fastify.get(
       '/',
@@ -438,6 +543,17 @@ test('Reply#serializeInput', t => {
           JSON.stringify(okInput201)
         )
 
+        t.equal(
+          reply.serializeInput(okInput3xx, {}, '3xx', 'application/json'),
+          JSON.stringify(okInput3xx)
+        )
+
+        try {
+          reply.serializeInput(noOkInput3xx, '3xx', 'application/json')
+        } catch (err) {
+          t.equal(err.message, 'The value "phone" cannot be converted to a number.')
+        }
+
         try {
           reply.serializeInput(notOkInput4xx, '4xx')
         } catch (err) {

package/test/schema-serialization.test.js

@@ -60,6 +60,236 @@ test('custom serializer options', t => {
   })
 })
 
+test('Different content types', t => {
+  t.plan(32)
+
+  const fastify = Fastify()
+  fastify.addSchema({
+    $id: 'test',
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      age: { type: 'number' },
+      verified: { type: 'boolean' }
+    }
+  })
+
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                name: { type: 'string' },
+                image: { type: 'string' },
+                address: { type: 'string' }
+              }
+            },
+            'application/vnd.v1+json': {
+              schema: {
+                type: 'array',
+                items: { $ref: 'test' }
+              }
+            }
+          }
+        },
+        201: {
+          content: { type: 'string' }
+        },
+        202: {
+          content: { const: 'Processing exclusive content' }
+        },
+        '3xx': {
+          content: {
+            'application/vnd.v2+json': {
+              schema: {
+                fullName: { type: 'string' },
+                phone: { type: 'string' }
+              }
+            }
+          }
+        },
+        default: {
+          content: {
+            'application/json': {
+              schema: {
+                details: { type: 'string' }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    switch (req.headers.accept) {
+      case 'application/json':
+        reply.header('Content-Type', 'application/json')
+        reply.send({ id: 1, name: 'Foo', image: 'profile picture', address: 'New Node' })
+        break
+      case 'application/vnd.v1+json':
+        reply.header('Content-Type', 'application/vnd.v1+json')
+        reply.send([{ id: 2, name: 'Boo', age: 18, verified: false }, { id: 3, name: 'Woo', age: 30, verified: true }])
+        break
+      case 'application/vnd.v2+json':
+        reply.header('Content-Type', 'application/vnd.v2+json')
+        reply.code(300)
+        reply.send({ fullName: 'Jhon Smith', phone: '01090000000', authMethod: 'google' })
+        break
+      case 'application/vnd.v3+json':
+        reply.header('Content-Type', 'application/vnd.v3+json')
+        reply.code(300)
+        reply.send({ firstName: 'New', lastName: 'Hoo', country: 'eg', city: 'node' })
+        break
+      case 'application/vnd.v4+json':
+        reply.header('Content-Type', 'application/vnd.v4+json')
+        reply.code(201)
+        reply.send({ boxId: 1, content: 'Games' })
+        break
+      case 'application/vnd.v5+json':
+        reply.header('Content-Type', 'application/vnd.v5+json')
+        reply.code(202)
+        reply.send({ content: 'interesting content' })
+        break
+      case 'application/vnd.v6+json':
+        reply.header('Content-Type', 'application/vnd.v6+json')
+        reply.code(400)
+        reply.send({ desc: 'age is missing', details: 'validation error' })
+        break
+      case 'application/vnd.v7+json':
+        reply.code(400)
+        reply.send({ details: 'validation error' })
+        break
+      default:
+        // to test if schema not found
+        reply.header('Content-Type', 'application/vnd.v3+json')
+        reply.code(200)
+        reply.send([{ type: 'student', grade: 6 }, { type: 'student', grade: 9 }])
+    }
+  })
+
+  fastify.get('/test', {
+    serializerCompiler: ({ contentType }) => {
+      t.equal(contentType, 'application/json')
+      return data => JSON.stringify(data)
+    },
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                name: { type: 'string' },
+                image: { type: 'string' },
+                address: { type: 'string' }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/json')
+    reply.send({ age: 18, city: 'AU' })
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ name: 'Foo', image: 'profile picture', address: 'New Node' }))
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v1+json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify([{ name: 'Boo', age: 18, verified: false }, { name: 'Woo', age: 30, verified: true }]))
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify([{ type: 'student', grade: 6 }, { type: 'student', grade: 9 }]))
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v2+json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ fullName: 'Jhon Smith', phone: '01090000000' }))
+    t.equal(res.statusCode, 300)
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v3+json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ firstName: 'New', lastName: 'Hoo', country: 'eg', city: 'node' }))
+    t.equal(res.statusCode, 300)
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v4+json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ content: 'Games' }))
+    t.equal(res.statusCode, 201)
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v5+json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ content: 'Processing exclusive content' }))
+    t.equal(res.statusCode, 202)
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v6+json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ desc: 'age is missing', details: 'validation error' }))
+    t.equal(res.statusCode, 400)
+  })
+
+  fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v7+json' } }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ details: 'validation error' }))
+    t.equal(res.statusCode, 400)
+  })
+
+  fastify.inject({ method: 'GET', url: '/test' }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, JSON.stringify({ age: 18, city: 'AU' }))
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Invalid multiple content schema, throw FST_ERR_SCH_CONTENT_MISSING_SCHEMA error', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.get('/testInvalid', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                fullName: { type: 'string' },
+                phone: { type: 'string' }
+              },
+              example: {
+                fullName: 'John Doe',
+                phone: '201090243795'
+              }
+            },
+            type: 'string'
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/json')
+    reply.send({ fullName: 'Any name', phone: '0109001010' })
+  })
+
+  fastify.ready((err) => {
+    t.equal(err.message, "Schema is missing for the content type 'type'")
+    t.equal(err.statusCode, 500)
+    t.equal(err.code, 'FST_ERR_SCH_CONTENT_MISSING_SCHEMA')
+  })
+})
+
 test('Use the same schema id in different places', t => {
   t.plan(2)
   const fastify = Fastify()

package/test/schema-special-usage.test.js

@@ -702,3 +702,45 @@ test('Custom schema object should not trigger FST_ERR_SCH_DUPLICATE', async t =>
   await fastify.ready()
   t.pass('fastify is ready')
 })
+
+test('The default schema compilers should not be called when overwritte by the user', async t => {
+  const Fastify = t.mock('../', {
+    '@fastify/ajv-compiler': () => {
+      t.fail('The default validator compiler should not be called')
+    },
+    '@fastify/fast-json-stringify-compiler': () => {
+      t.fail('The default serializer compiler should not be called')
+    }
+  })
+
+  const fastify = Fastify({
+    schemaController: {
+      compilersFactory: {
+        buildValidator: function factory () {
+          t.pass('The custom validator compiler should be called')
+          return function validatorCompiler () {
+            return () => { return true }
+          }
+        },
+        buildSerializer: function factory () {
+          t.pass('The custom serializer compiler should be called')
+          return function serializerCompiler () {
+            return () => { return true }
+          }
+        }
+      }
+    }
+  })
+
+  fastify.get('/',
+    {
+      schema: {
+        query: { foo: { type: 'string' } },
+        response: {
+          200: { type: 'object' }
+        }
+      }
+    }, () => {})
+
+  await fastify.ready()
+})

package/types/reply.d.ts

@@ -55,10 +55,10 @@ export interface FastifyReply<
   serializer(fn: (payload: any) => string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   serialize(payload: any): string | ArrayBuffer | Buffer;
   // Serialization Methods
-  getSerializationFunction(httpStatus: string): (payload: {[key: string]: unknown}) => string;
+  getSerializationFunction(httpStatus: string, contentType?: string): (payload: {[key: string]: unknown}) => string;
   getSerializationFunction(schema: {[key: string]: unknown}): (payload: {[key: string]: unknown}) => string;
-  compileSerializationSchema(schema: {[key: string]: unknown}, httpStatus?: string): (payload: {[key: string]: unknown}) => string;
-  serializeInput(input: {[key: string]: unknown}, schema: {[key: string]: unknown}, httpStatus?: string): string;
-  serializeInput(input: {[key: string]: unknown}, httpStatus: string): unknown;
+  compileSerializationSchema(schema: {[key: string]: unknown}, httpStatus?: string, contentType?: string): (payload: {[key: string]: unknown}) => string;
+  serializeInput(input: {[key: string]: unknown}, schema: {[key: string]: unknown}, httpStatus?: string, contentType?: string): string;
+  serializeInput(input: {[key: string]: unknown}, httpStatus: string, contentType?: string): unknown;
   then(fulfilled: () => void, rejected: (err: Error) => void): void;
 }

package/types/schema.d.ts

@@ -20,6 +20,7 @@ export interface FastifyRouteSchemaDef<T> {
   url: string;
   httpPart?: string;
   httpStatus?: string;
+  contentType?: string;
 }
 
 export interface FastifySchemaValidationError {