fastify 2.7.1 → 2.11.0

package/docs/Validation-and-Serialization.md

@@ -240,6 +240,77 @@ This example will returns:
 | /sub  | one, two        |
 | /deep | one, two, three |
 
+<a name="ajv-plugins"></a>
+#### Ajv Plugins
+
+You can provide a list of plugins you want to use with Ajv:
+
+> Refer to [`ajv options`](https://github.com/fastify/fastify/blob/master/docs/Server.md#factory-ajv) to check plugins format
+
+```js
+const fastify = require('fastify')({
+  ajv: {
+    plugins: [
+      require('ajv-merge-patch')
+    ]
+  }
+})
+
+fastify.route({
+  method: 'POST',
+  url: '/',
+  schema: {
+    body: {
+      $patch: {
+        source: {
+          type: 'object',
+          properties: {
+            q: {
+              type: 'string'
+            }
+          }
+        },
+        with: [
+          {
+            op: 'add',
+            path: '/properties/q',
+            value: { type: 'number' }
+          }
+        ]
+      }
+    }
+  },
+  handler (req, reply) {
+    reply.send({ ok: 1 })
+  }
+})
+
+fastify.route({
+  method: 'POST',
+  url: '/',
+  schema: {
+    body: {
+      $merge: {
+        source: {
+          type: 'object',
+          properties: {
+            q: {
+              type: 'string'
+            }
+          }
+        },
+        with: {
+          required: ['q']
+        }
+      }
+    }
+  },
+  handler (req, reply) {
+    reply.send({ ok: 1 })
+  }
+})
+```
+
 <a name="schema-compiler"></a>
 #### Schema Compiler
 
@@ -257,7 +328,9 @@ Fastify's [baseline ajv configuration](https://github.com/epoberezkin/ajv#option
 }
 ```
 
-This baseline configuration cannot be modified. If you want to change or set additional config options, you will need to create your own instance and override the existing one like:
+This baseline configuration can be modified by providing [`ajv.customOptions`](https://github.com/fastify/fastify/blob/master/docs/Server.md#factory-ajv) to your Fastify factory.
+
+If you want to change or set additional config options, you will need to create your own instance and override the existing one like:
 
 ```js
 const fastify = require('fastify')()
@@ -280,6 +353,7 @@ fastify.setSchemaCompiler(function (schema) {
 // Alternatively, you can set the schema compiler using the setter property:
 fastify.schemaCompiler = function (schema) { return ajv.compile(schema) })
 ```
+_**Note:** If you use a custom instance of any validator (even Ajv), you have to add schemas to the validator instead of fastify, since fastify's default validator is no longer used, and fastify's `addSchema` method has no idea what validator you are using._
 
 But maybe you want to change the validation library. Perhaps you like `Joi`. In this case, you can use it to validate the url parameters, body, and query string!
 
@@ -300,6 +374,68 @@ In that case the function returned by `schemaCompiler` returns an object like:
 * `error`: filled with an instance of `Error` or a string that describes the validation error
 * `value`: the coerced value that passed the validation
 
+<a name="schema-resolver"></a>
+#### Schema Resolver
+
+The `schemaResolver` is a function that works together with the `schemaCompiler`: you can't use it
+with the default schema compiler. This feature is useful when you use complex schemas with `$ref` keyword
+in your routes and a custom validator.
+
+This is needed because all the schemas you add to your custom compiler are unknown to Fastify but it
+need to resolve the `$ref` paths.
+
+```js
+const fastify = require('fastify')()
+const Ajv = require('ajv')
+const ajv = new Ajv()
+
+ajv.addSchema({
+  $id: 'urn:schema:foo',
+  definitions: {
+    foo: { type: 'string' }
+  },
+  type: 'object',
+  properties: {
+    foo: { $ref: '#/definitions/foo' }
+  }
+})
+ajv.addSchema({
+  $id: 'urn:schema:response',
+  type: 'object',
+  required: ['foo'],
+  properties: {
+    foo: { $ref: 'urn:schema:foo#/definitions/foo' }
+  }
+})
+ajv.addSchema({
+  $id: 'urn:schema:request',
+  type: 'object',
+  required: ['foo'],
+  properties: {
+    foo: { $ref: 'urn:schema:foo#/definitions/foo' }
+  }
+})
+
+fastify.setSchemaCompiler(schema => ajv.compile(schema))
+fastify.setSchemaResolver((ref) => {
+  return ajv.getSchema(ref).schema
+})
+
+fastify.route({
+  method: 'POST',
+  url: '/',
+  schema: {
+    body: ajv.getSchema('urn:schema:request').schema,
+    response: {
+      '2xx': ajv.getSchema('urn:schema:response').schema
+    }
+  },
+  handler (req, reply) {
+    reply.send({ foo: 'bar' })
+  }
+})
+```
+
 <a name="serialization"></a>
 ### Serialization
 Usually you will send your data to the clients via JSON, and Fastify has a powerful tool to help you, [fast-json-stringify](https://www.npmjs.com/package/fast-json-stringify), which is used if you have provided an output schema in the route options. We encourage you to use an output schema, as it will increase your throughput by 100-400% depending on your payload and will prevent accidental disclosure of sensitive information.

package/examples/typescript-server.ts

@@ -3,7 +3,7 @@
  * Most type annotations in this file are not strictly necessary but are
  * included for this example.
  *
- * To run this example exectute the following commands to install typescript,
+ * To run this example execute the following commands to install typescript,
  * transpile the code, and start the server:
  *
  * npm i -g typescript

package/fastify.d.ts

@@ -4,6 +4,7 @@
 
 /// <reference types="node" />
 
+import * as ajv from 'ajv'
 import * as http from 'http'
 import * as http2 from 'http2'
 import * as https from 'https'
@@ -21,7 +22,10 @@ declare function fastify(opts?: fastify.ServerOptionsAsSecureHttp2): fastify.Fas
 // eslint-disable-next-line no-redeclare
 declare namespace fastify {
 
-  type Plugin < HttpServer, HttpRequest, HttpResponse, T > = (instance: FastifyInstance< HttpServer, HttpRequest, HttpResponse >, opts: T, callback: (err?: FastifyError) => void) => void
+  type Plugin<HttpServer, HttpRequest, HttpResponse, Options, PluginInstance extends Function = Function> =
+    PluginInstance extends () => Promise<void> ?
+      ((instance: FastifyInstance< HttpServer, HttpRequest, HttpResponse >, options: Options) => Promise<void>) :
+      (instance: FastifyInstance<HttpServer, HttpRequest, HttpResponse>, options: Options, callback: (err?: FastifyError) => void) => void;
 
   type Middleware < HttpServer, HttpRequest, HttpResponse > = (this: FastifyInstance<HttpServer, HttpRequest, HttpResponse>, req: HttpRequest, res: HttpResponse, callback: (err?: FastifyError) => void) => void
 
@@ -81,7 +85,7 @@ declare namespace fastify {
     req: FastifyRequest<HttpRequest, Query, Params, Headers, Body>,
     reply: FastifyReply<HttpResponse>,
     done: (err?: Error) => void,
-  ) => void
+  ) => void | Promise<any>
 
   type FastifyMiddlewareWithPayload<
   HttpServer = http.Server,
@@ -97,7 +101,7 @@ declare namespace fastify {
     reply: FastifyReply<HttpResponse>,
     payload: any,
     done: (err?: Error, value?: any) => void,
-  ) => void
+  ) => void | Promise<any>
 
   type RequestHandler<
   HttpRequest = http.IncomingMessage,
@@ -113,6 +117,7 @@ declare namespace fastify {
   ) => void | Promise<any>
 
   type SchemaCompiler = (schema: Object) => Function
+  type SchemaResolver = (ref: string) => Object
 
   type BodyParser<HttpRequest, RawBody extends string | Buffer> =
     | ((req: HttpRequest, rawBody: RawBody, done: (err: Error | null, body?: any) => void) => void)
@@ -165,6 +170,7 @@ declare namespace fastify {
     headers(headers: { [key: string]: any }): FastifyReply<HttpResponse>
     getHeader(name: string): string | undefined
     hasHeader(name: string): boolean
+    removeHeader(name: string): FastifyReply<HttpResponse>
     callNotFound(): void
     getResponseTime(): number
     type(contentType: string): FastifyReply<HttpResponse>
@@ -176,8 +182,12 @@ declare namespace fastify {
     sent: boolean
     res: HttpResponse
     context: FastifyContext
+    request: FastifyRequest
   }
   type TrustProxyFunction = (addr: string, index: number) => boolean
+  type ServerFactoryHandlerFunction = (request: http.IncomingMessage | http2.Http2ServerRequest, response: http.ServerResponse | http2.Http2ServerResponse) => void
+  type ServerFactoryFunction = (handler: ServerFactoryHandlerFunction, options: ServerOptions) => http.Server | http2.Http2Server
+
   interface ServerOptions {
     caseSensitive?: boolean,
     ignoreTrailingSlash?: boolean,
@@ -185,6 +195,7 @@ declare namespace fastify {
     pluginTimeout?: number,
     disableRequestLogging?: boolean,
     onProtoPoisoning?: 'error' | 'remove' | 'ignore',
+    onConstructorPoisoning?: 'error' | 'remove' | 'ignore',
     logger?: any,
     trustProxy?: string | number | boolean | Array<string> | TrustProxyFunction,
     maxParamLength?: number,
@@ -199,7 +210,15 @@ declare namespace fastify {
       deriveVersion<Context>(req: Object, ctx?: Context) : String,
     },
     modifyCoreObjects?: boolean,
-    return503OnClosing?: boolean
+    return503OnClosing?: boolean,
+    genReqId?: () => number | string,
+    requestIdHeader?: string,
+    requestIdLogLabel?: string,
+    serverFactory?: ServerFactoryFunction,
+    ajv?: {
+      customOptions?: ajv.Options,
+      plugins?: Array<Array<any>|String>
+    }
   }
   interface ServerOptionsAsSecure extends ServerOptions {
     https: http2.SecureServerOptions
@@ -241,9 +260,15 @@ declare namespace fastify {
   > {
     schema?: RouteSchema
     attachValidation?: boolean
+    onSend?:
+      | FastifyMiddlewareWithPayload<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>
+      | Array<FastifyMiddlewareWithPayload<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>>
     onRequest?:
       | FastifyMiddleware<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>
       | Array<FastifyMiddleware<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>>
+    onResponse?:
+      | FastifyMiddleware<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>
+      | Array<FastifyMiddleware<HttpServer, HttpRequest, HttpResponse>>
     preParsing?:
       | FastifyMiddleware<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>
       | Array<FastifyMiddleware<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>>
@@ -256,10 +281,13 @@ declare namespace fastify {
     preSerialization?:
       FastifyMiddlewareWithPayload<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>
       | Array<FastifyMiddlewareWithPayload<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>>
+    handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>
     schemaCompiler?: SchemaCompiler
     bodyLimit?: number
     logLevel?: string
+    logSerializers?: Object
     config?: any
+    version?: string
     prefixTrailingSlash?: 'slash' | 'no-slash' | 'both'
   }
 
@@ -286,6 +314,7 @@ declare namespace fastify {
   interface RegisterOptions<HttpServer, HttpRequest, HttpResponse> {
     [key: string]: any,
     prefix?: string,
+    logSerializers?: Object
   }
 
   /**
@@ -362,7 +391,7 @@ declare namespace fastify {
     get<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -379,7 +408,7 @@ declare namespace fastify {
     put<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -396,7 +425,7 @@ declare namespace fastify {
     patch<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -413,7 +442,7 @@ declare namespace fastify {
     post<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -430,7 +459,7 @@ declare namespace fastify {
     head<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -447,7 +476,7 @@ declare namespace fastify {
     delete<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -464,7 +493,7 @@ declare namespace fastify {
     options<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -481,7 +510,7 @@ declare namespace fastify {
     all<Query = DefaultQuery, Params = DefaultParams, Headers = DefaultHeaders, Body = DefaultBody>(
       url: string,
       opts: RouteShorthandOptions<HttpServer, HttpRequest, HttpResponse, Query, Params, Headers, Body>,
-      handler: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
+      handler?: RequestHandler<HttpRequest, HttpResponse, Query, Params, Headers, Body>,
     ): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
@@ -532,10 +561,15 @@ declare namespace fastify {
      */
     use(path: string, middleware: Middleware<HttpServer, HttpRequest, HttpResponse>): void
 
+    /**
+     * Apply the given middleware to routes matching the given multiple path
+     */
+    use(path: string[], middleware: Middleware<HttpServer, HttpRequest, HttpResponse>): void
+
     /**
      * Registers a plugin
      */
-    register<T extends RegisterOptions<HttpServer, HttpRequest, HttpResponse>>(plugin: Plugin<HttpServer, HttpRequest, HttpResponse, T>, opts?: T): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
+    register<Options extends RegisterOptions<HttpServer, HttpRequest, HttpResponse>, PluginInstance extends Function>(plugin: Plugin<HttpServer, HttpRequest, HttpResponse, Options, PluginInstance>, options?: Options): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
     /**
      * `Register a callback that will be executed just after a register.
@@ -671,6 +705,11 @@ declare namespace fastify {
      */
     setSchemaCompiler(schemaCompiler: SchemaCompiler): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
 
+    /**
+     * Set the schema resolver to find the `$ref` schema object
+     */
+    setSchemaResolver(schemaResolver: SchemaResolver): FastifyInstance<HttpServer, HttpRequest, HttpResponse>
+
     /**
      * Create a shared schema
      */

package/fastify.js

@@ -10,9 +10,11 @@ const {
   kBodyLimit,
   kRoutePrefix,
   kLogLevel,
+  kLogSerializers,
   kHooks,
   kSchemas,
   kSchemaCompiler,
+  kSchemaResolver,
   kReplySerializerDefault,
   kContentTypeParser,
   kReply,
@@ -21,7 +23,8 @@ const {
   kFourOhFour,
   kState,
   kOptions,
-  kGlobalHooks
+  kGlobalHooks,
+  kPluginNameChain
 } = require('./lib/symbols.js')
 
 const { createServer } = require('./lib/server')
@@ -55,7 +58,7 @@ function build (options) {
   validateBodyLimitOption(options.bodyLimit)
 
   if (options.logger && options.logger.genReqId) {
-    process.emitWarning(`Using 'genReqId' in logger options is deprecated. Use fastify options instead. See: https://www.fastify.io/docs/latest/Server/#gen-request-id`)
+    process.emitWarning("Using 'genReqId' in logger options is deprecated. Use fastify options instead. See: https://www.fastify.io/docs/latest/Server/#gen-request-id")
     options.genReqId = options.logger.genReqId
   }
 
@@ -66,6 +69,21 @@ function build (options) {
   const requestIdLogLabel = options.requestIdLogLabel || 'reqId'
   const bodyLimit = options.bodyLimit || defaultInitOptions.bodyLimit
   const disableRequestLogging = options.disableRequestLogging || false
+  const ajvOptions = Object.assign({
+    customOptions: {},
+    plugins: []
+  }, options.ajv)
+
+  // Ajv options
+  if (!ajvOptions.customOptions || Object.prototype.toString.call(ajvOptions.customOptions) !== '[object Object]') {
+    throw new Error(`ajv.customOptions option should be an object, instead got '${typeof ajvOptions.customOptions}'`)
+  }
+  if (!ajvOptions.plugins || !Array.isArray(ajvOptions.plugins)) {
+    throw new Error(`ajv.plugins option should be an array, instead got '${typeof ajvOptions.customOptions}'`)
+  }
+  ajvOptions.plugins = ajvOptions.plugins.map(plugin => {
+    return Array.isArray(plugin) ? plugin : [plugin]
+  })
 
   // Instance Fastify components
   const { logger, hasLogger } = createLogger(options)
@@ -79,11 +97,13 @@ function build (options) {
   options.requestIdLogLabel = requestIdLogLabel
   options.modifyCoreObjects = modifyCoreObjects
   options.disableRequestLogging = disableRequestLogging
+  options.ajv = ajvOptions
 
   // Default router
   const router = buildRouting({
     config: {
       defaultRoute: defaultRoute,
+      onBadUrl: onBadUrl,
       ignoreTrailingSlash: options.ignoreTrailingSlash || defaultInitOptions.ignoreTrailingSlash,
       maxParamLength: options.maxParamLength || defaultInitOptions.maxParamLength,
       caseSensitive: options.caseSensitive,
@@ -116,11 +136,17 @@ function build (options) {
     [kBodyLimit]: bodyLimit,
     [kRoutePrefix]: '',
     [kLogLevel]: '',
+    [kLogSerializers]: null,
     [kHooks]: new Hooks(),
     [kSchemas]: schemas,
     [kSchemaCompiler]: null,
+    [kSchemaResolver]: null,
     [kReplySerializerDefault]: null,
-    [kContentTypeParser]: new ContentTypeParser(bodyLimit, (options.onProtoPoisoning || defaultInitOptions.onProtoPoisoning)),
+    [kContentTypeParser]: new ContentTypeParser(
+      bodyLimit,
+      (options.onProtoPoisoning || defaultInitOptions.onProtoPoisoning),
+      (options.onConstructorPoisoning || defaultInitOptions.onConstructorPoisoning)
+    ),
     [kReply]: Reply.buildReply(Reply),
     [kRequest]: Request.buildRequest(Request),
     [kMiddlewares]: [],
@@ -130,6 +156,7 @@ function build (options) {
       onRegister: []
     },
     [pluginUtils.registeredPlugins]: [],
+    [kPluginNameChain]: [],
     // routes shorthand methods
     delete: function _delete (url, opts, handler) {
       return router.prepareRoute.call(this, 'DELETE', url, opts, handler)
@@ -169,6 +196,7 @@ function build (options) {
     addSchema: addSchema,
     getSchemas: schemas.getSchemas.bind(schemas),
     setSchemaCompiler: setSchemaCompiler,
+    setSchemaResolver: setSchemaResolver,
     setReplySerializer: setReplySerializer,
     // custom parsers
     addContentTypeParser: ContentTypeParser.helpers.addContentTypeParser,
@@ -224,6 +252,15 @@ function build (options) {
     }
   })
 
+  Object.defineProperty(fastify, 'pluginName', {
+    get: function () {
+      if (this[kPluginNameChain].length > 1) {
+        return this[kPluginNameChain].join(' -> ')
+      }
+      return this[kPluginNameChain][0]
+    }
+  })
+
   // Install and configure Avvio
   // Avvio will update the following Fastify methods:
   // - register
@@ -330,13 +367,13 @@ function build (options) {
     throwIfAlreadyStarted('Cannot call "addHook" when fastify instance is already started!')
 
     // TODO: v3 instead of log a warning, throw an error
-    if (name === 'onSend' || name === 'preSerialization') {
+    if (name === 'onSend' || name === 'preSerialization' || name === 'onError') {
       if (fn.constructor.name === 'AsyncFunction' && fn.length === 4) {
-        fastify.log.warn(`Async function has too many arguments. Async hooks should not use the 'next' argument.`, new Error().stack)
+        fastify.log.warn("Async function has too many arguments. Async hooks should not use the 'next' argument.", new Error().stack)
       }
     } else {
       if (fn.constructor.name === 'AsyncFunction' && fn.length === 3) {
-        fastify.log.warn(`Async function has too many arguments. Async hooks should not use the 'next' argument.`, new Error().stack)
+        fastify.log.warn("Async function has too many arguments. Async hooks should not use the 'next' argument.", new Error().stack)
       }
     }
 
@@ -390,6 +427,15 @@ function build (options) {
     fourOhFour.router.lookup(req, res)
   }
 
+  function onBadUrl (path, req, res) {
+    const body = `{"error":"Bad Request","message":"'${path}' is not a valid url component","statusCode":400}`
+    res.writeHead(400, {
+      'Content-Type': 'application/json',
+      'Content-Length': body.length
+    })
+    res.end(body)
+  }
+
   function setNotFoundHandler (opts, handler) {
     throwIfAlreadyStarted('Cannot call "setNotFoundHandler" when fastify instance is already started!')
 
@@ -404,6 +450,13 @@ function build (options) {
     return this
   }
 
+  function setSchemaResolver (schemaRefResolver) {
+    throwIfAlreadyStarted('Cannot call "setSchemaResolver" when fastify instance is already started!')
+
+    this[kSchemaResolver] = schemaRefResolver
+    return this
+  }
+
   function setReplySerializer (replySerializer) {
     throwIfAlreadyStarted('Cannot call "setReplySerializer" when fastify instance is already started!')
 
@@ -424,7 +477,10 @@ function build (options) {
 // Everything that need to be encapsulated must be handled in this function.
 function override (old, fn, opts) {
   const shouldSkipOverride = pluginUtils.registerPlugin.call(old, fn)
+
   if (shouldSkipOverride) {
+    // after every plugin registration we will enter a new name
+    old[kPluginNameChain].push(pluginUtils.getDisplayName(fn))
     return old
   }
 
@@ -441,12 +497,17 @@ function override (old, fn, opts) {
   instance[kSchemas] = buildSchemas(old[kSchemas])
   instance.getSchemas = instance[kSchemas].getSchemas.bind(instance[kSchemas])
   instance[pluginUtils.registeredPlugins] = Object.create(instance[pluginUtils.registeredPlugins])
+  instance[kPluginNameChain] = [pluginUtils.getPluginName(fn) || pluginUtils.getFuncPreview(fn)]
+
+  if (instance[kLogSerializers] || opts.logSerializers) {
+    instance[kLogSerializers] = Object.assign(Object.create(instance[kLogSerializers]), opts.logSerializers)
+  }
 
   if (opts.prefix) {
     instance[kFourOhFour].arrange404(instance)
   }
 
-  for (const hook of instance[kGlobalHooks].onRegister) hook.call(this, instance)
+  for (const hook of instance[kGlobalHooks].onRegister) hook.call(this, instance, opts)
 
   return instance
 }