fastify 2.10.0 → 2.11.0

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'
@@ -184,6 +185,9 @@ declare namespace fastify {
     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,
@@ -191,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,
@@ -205,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
@@ -247,6 +260,9 @@ 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>>
@@ -269,7 +285,9 @@ declare namespace fastify {
     schemaCompiler?: SchemaCompiler
     bodyLimit?: number
     logLevel?: string
+    logSerializers?: Object
     config?: any
+    version?: string
     prefixTrailingSlash?: 'slash' | 'no-slash' | 'both'
   }
 
@@ -296,6 +314,7 @@ declare namespace fastify {
   interface RegisterOptions<HttpServer, HttpRequest, HttpResponse> {
     [key: string]: any,
     prefix?: string,
+    logSerializers?: Object
   }
 
   /**
@@ -542,6 +561,11 @@ 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
      */

package/fastify.js

@@ -10,6 +10,7 @@ const {
   kBodyLimit,
   kRoutePrefix,
   kLogLevel,
+  kLogSerializers,
   kHooks,
   kSchemas,
   kSchemaCompiler,
@@ -68,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)
@@ -81,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,
@@ -118,12 +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]: [],
@@ -404,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!')
 
@@ -467,11 +499,15 @@ function override (old, fn, opts) {
   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
 }

package/lib/configValidator.js

@@ -14,10 +14,11 @@ var validate = (function() {
     if ((data && typeof data === "object" && !Array.isArray(data))) {
       if (data.bodyLimit === undefined) data.bodyLimit = 1048576;
       if (data.caseSensitive === undefined) data.caseSensitive = true;
-      if (data.disableRequestLogging === undefined) data.disableRequestLogging = false;
       if (data.ignoreTrailingSlash === undefined) data.ignoreTrailingSlash = false;
+      if (data.disableRequestLogging === undefined) data.disableRequestLogging = false;
       if (data.maxParamLength === undefined) data.maxParamLength = 100;
       if (data.onProtoPoisoning === undefined) data.onProtoPoisoning = "error";
+      if (data.onConstructorPoisoning === undefined) data.onConstructorPoisoning = "ignore";
       if (data.pluginTimeout === undefined) data.pluginTimeout = 10000;
       if (data.requestIdHeader === undefined) data.requestIdHeader = "request-id";
       if (data.requestIdLogLabel === undefined) data.requestIdLogLabel = "reqId";
@@ -321,80 +322,81 @@ var validate = (function() {
                 }
                 var valid1 = errors === errs_1;
                 if (valid1) {
-                  var data1 = data.maxParamLength;
+                  var data1 = data.disableRequestLogging;
                   var errs_1 = errors;
-                  if ((typeof data1 !== "number" || (data1 % 1) || data1 !== data1)) {
+                  if (typeof data1 !== "boolean") {
                     var dataType1 = typeof data1;
                     var coerced1 = undefined;
-                    if (dataType1 == 'boolean' || data1 === null || (dataType1 == 'string' && data1 && data1 == +data1 && !(data1 % 1))) coerced1 = +data1;
+                    if (data1 === 'false' || data1 === 0 || data1 === null) coerced1 = false;
+                    else if (data1 === 'true' || data1 === 1) coerced1 = true;
                     if (coerced1 === undefined) {
                       validate.errors = [{
                         keyword: 'type',
-                        dataPath: (dataPath || '') + '.maxParamLength',
-                        schemaPath: '#/properties/maxParamLength/type',
+                        dataPath: (dataPath || '') + '.disableRequestLogging',
+                        schemaPath: '#/properties/disableRequestLogging/type',
                         params: {
-                          type: 'integer'
+                          type: 'boolean'
                         },
-                        message: 'should be integer'
+                        message: 'should be boolean'
                       }];
                       return false;
                     } else {
                       data1 = coerced1;
-                      data['maxParamLength'] = coerced1;
+                      data['disableRequestLogging'] = coerced1;
                     }
                   }
                   var valid1 = errors === errs_1;
                   if (valid1) {
-                    var data1 = data.onProtoPoisoning;
+                    var data1 = data.maxParamLength;
                     var errs_1 = errors;
-                    if (typeof data1 !== "string") {
+                    if ((typeof data1 !== "number" || (data1 % 1) || data1 !== data1)) {
                       var dataType1 = typeof data1;
                       var coerced1 = undefined;
-                      if (dataType1 == 'number' || dataType1 == 'boolean') coerced1 = '' + data1;
-                      else if (data1 === null) coerced1 = '';
+                      if (dataType1 == 'boolean' || data1 === null || (dataType1 == 'string' && data1 && data1 == +data1 && !(data1 % 1))) coerced1 = +data1;
                       if (coerced1 === undefined) {
                         validate.errors = [{
                           keyword: 'type',
-                          dataPath: (dataPath || '') + '.onProtoPoisoning',
-                          schemaPath: '#/properties/onProtoPoisoning/type',
+                          dataPath: (dataPath || '') + '.maxParamLength',
+                          schemaPath: '#/properties/maxParamLength/type',
                           params: {
-                            type: 'string'
+                            type: 'integer'
                           },
-                          message: 'should be string'
+                          message: 'should be integer'
                         }];
                         return false;
                       } else {
                         data1 = coerced1;
-                        data['onProtoPoisoning'] = coerced1;
+                        data['maxParamLength'] = coerced1;
                       }
                     }
                     var valid1 = errors === errs_1;
                     if (valid1) {
-                      var data1 = data.pluginTimeout;
+                      var data1 = data.onProtoPoisoning;
                       var errs_1 = errors;
-                      if ((typeof data1 !== "number" || (data1 % 1) || data1 !== data1)) {
+                      if (typeof data1 !== "string") {
                         var dataType1 = typeof data1;
                         var coerced1 = undefined;
-                        if (dataType1 == 'boolean' || data1 === null || (dataType1 == 'string' && data1 && data1 == +data1 && !(data1 % 1))) coerced1 = +data1;
+                        if (dataType1 == 'number' || dataType1 == 'boolean') coerced1 = '' + data1;
+                        else if (data1 === null) coerced1 = '';
                         if (coerced1 === undefined) {
                           validate.errors = [{
                             keyword: 'type',
-                            dataPath: (dataPath || '') + '.pluginTimeout',
-                            schemaPath: '#/properties/pluginTimeout/type',
+                            dataPath: (dataPath || '') + '.onProtoPoisoning',
+                            schemaPath: '#/properties/onProtoPoisoning/type',
                             params: {
-                              type: 'integer'
+                              type: 'string'
                             },
-                            message: 'should be integer'
+                            message: 'should be string'
                           }];
                           return false;
                         } else {
                           data1 = coerced1;
-                          data['pluginTimeout'] = coerced1;
+                          data['onProtoPoisoning'] = coerced1;
                         }
                       }
                       var valid1 = errors === errs_1;
                       if (valid1) {
-                        var data1 = data.requestIdHeader;
+                        var data1 = data.onConstructorPoisoning;
                         var errs_1 = errors;
                         if (typeof data1 !== "string") {
                           var dataType1 = typeof data1;
@@ -404,8 +406,8 @@ var validate = (function() {
                           if (coerced1 === undefined) {
                             validate.errors = [{
                               keyword: 'type',
-                              dataPath: (dataPath || '') + '.requestIdHeader',
-                              schemaPath: '#/properties/requestIdHeader/type',
+                              dataPath: (dataPath || '') + '.onConstructorPoisoning',
+                              schemaPath: '#/properties/onConstructorPoisoning/type',
                               params: {
                                 type: 'string'
                               },
@@ -414,35 +416,86 @@ var validate = (function() {
                             return false;
                           } else {
                             data1 = coerced1;
-                            data['requestIdHeader'] = coerced1;
+                            data['onConstructorPoisoning'] = coerced1;
                           }
                         }
                         var valid1 = errors === errs_1;
                         if (valid1) {
-                          var data1 = data.requestIdLogLabel;
+                          var data1 = data.pluginTimeout;
                           var errs_1 = errors;
-                          if (typeof data1 !== "string") {
+                          if ((typeof data1 !== "number" || (data1 % 1) || data1 !== data1)) {
                             var dataType1 = typeof data1;
                             var coerced1 = undefined;
-                            if (dataType1 == 'number' || dataType1 == 'boolean') coerced1 = '' + data1;
-                            else if (data1 === null) coerced1 = '';
+                            if (dataType1 == 'boolean' || data1 === null || (dataType1 == 'string' && data1 && data1 == +data1 && !(data1 % 1))) coerced1 = +data1;
                             if (coerced1 === undefined) {
                               validate.errors = [{
                                 keyword: 'type',
-                                dataPath: (dataPath || '') + '.requestIdLogLabel',
-                                schemaPath: '#/properties/requestIdLogLabel/type',
+                                dataPath: (dataPath || '') + '.pluginTimeout',
+                                schemaPath: '#/properties/pluginTimeout/type',
                                 params: {
-                                  type: 'string'
+                                  type: 'integer'
                                 },
-                                message: 'should be string'
+                                message: 'should be integer'
                               }];
                               return false;
                             } else {
                               data1 = coerced1;
-                              data['requestIdLogLabel'] = coerced1;
+                              data['pluginTimeout'] = coerced1;
                             }
                           }
                           var valid1 = errors === errs_1;
+                          if (valid1) {
+                            var data1 = data.requestIdHeader;
+                            var errs_1 = errors;
+                            if (typeof data1 !== "string") {
+                              var dataType1 = typeof data1;
+                              var coerced1 = undefined;
+                              if (dataType1 == 'number' || dataType1 == 'boolean') coerced1 = '' + data1;
+                              else if (data1 === null) coerced1 = '';
+                              if (coerced1 === undefined) {
+                                validate.errors = [{
+                                  keyword: 'type',
+                                  dataPath: (dataPath || '') + '.requestIdHeader',
+                                  schemaPath: '#/properties/requestIdHeader/type',
+                                  params: {
+                                    type: 'string'
+                                  },
+                                  message: 'should be string'
+                                }];
+                                return false;
+                              } else {
+                                data1 = coerced1;
+                                data['requestIdHeader'] = coerced1;
+                              }
+                            }
+                            var valid1 = errors === errs_1;
+                            if (valid1) {
+                              var data1 = data.requestIdLogLabel;
+                              var errs_1 = errors;
+                              if (typeof data1 !== "string") {
+                                var dataType1 = typeof data1;
+                                var coerced1 = undefined;
+                                if (dataType1 == 'number' || dataType1 == 'boolean') coerced1 = '' + data1;
+                                else if (data1 === null) coerced1 = '';
+                                if (coerced1 === undefined) {
+                                  validate.errors = [{
+                                    keyword: 'type',
+                                    dataPath: (dataPath || '') + '.requestIdLogLabel',
+                                    schemaPath: '#/properties/requestIdLogLabel/type',
+                                    params: {
+                                      type: 'string'
+                                    },
+                                    message: 'should be string'
+                                  }];
+                                  return false;
+                                } else {
+                                  data1 = coerced1;
+                                  data['requestIdLogLabel'] = coerced1;
+                                }
+                              }
+                              var valid1 = errors === errs_1;
+                            }
+                          }
                         }
                       }
                     }
@@ -507,11 +560,11 @@ validate.schema = {
         "setDefaultValue": true
       }
     },
-    "disableRequestLogging": {
+    "ignoreTrailingSlash": {
       "type": "boolean",
       "default": false
     },
-    "ignoreTrailingSlash": {
+    "disableRequestLogging": {
       "type": "boolean",
       "default": false
     },
@@ -523,6 +576,10 @@ validate.schema = {
       "type": "string",
       "default": "error"
     },
+    "onConstructorPoisoning": {
+      "type": "string",
+      "default": "ignore"
+    },
     "pluginTimeout": {
       "type": "integer",
       "default": 10000
@@ -545,14 +602,4 @@ function customRule0 (schemaParamValue, validatedParamValue, validationSchemaObj
   return true
 }
 
-module.exports.defaultInitOptions = {
-  "bodyLimit":1048576,
-  "caseSensitive":true,
-  "disableRequestLogging": false,
-  "ignoreTrailingSlash":false,
-  "maxParamLength":100,
-  "onProtoPoisoning":"error",
-  "pluginTimeout":10000,
-  "requestIdHeader":"request-id",
-  "requestIdLogLabel":"reqId"
-}
+module.exports.defaultInitOptions = {"bodyLimit":1048576,"caseSensitive":true,"disableRequestLogging":false,"ignoreTrailingSlash":false,"maxParamLength":100,"onProtoPoisoning":"error","onConstructorPoisoning":"ignore","pluginTimeout":10000,"requestIdHeader":"request-id","requestIdLogLabel":"reqId"}

package/lib/contentTypeParser.js

@@ -22,8 +22,8 @@ const {
   }
 } = require('./errors')
 
-function ContentTypeParser (bodyLimit, onProtoPoisoning) {
-  this[kDefaultJsonParse] = getDefaultJsonParser(onProtoPoisoning)
+function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning) {
+  this[kDefaultJsonParse] = getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)
   this.customParsers = {}
   this.customParsers['application/json'] = new Parser(true, false, bodyLimit, this[kDefaultJsonParse])
   this.customParsers['text/plain'] = new Parser(true, false, bodyLimit, defaultPlainTextParser)
@@ -189,7 +189,7 @@ function rawBody (request, reply, options, parser, done) {
   }
 }
 
-function getDefaultJsonParser (onProtoPoisoning) {
+function getDefaultJsonParser (onProtoPoisoning, onConstructorPoisoning) {
   return defaultJsonParser
 
   function defaultJsonParser (req, body, done) {
@@ -198,7 +198,7 @@ function getDefaultJsonParser (onProtoPoisoning) {
     }
 
     try {
-      var json = secureJson.parse(body, { protoAction: onProtoPoisoning })
+      var json = secureJson.parse(body, { protoAction: onProtoPoisoning, constructorAction: onConstructorPoisoning })
     } catch (err) {
       err.statusCode = 400
       return done(err, undefined)

package/lib/context.js

@@ -4,7 +4,7 @@ const { kFourOhFourContext, kReplySerializerDefault } = require('./symbols.js')
 
 // Objects that holds the context of every request
 // Every route holds an instance of this object.
-function Context (schema, handler, Reply, Request, contentTypeParser, config, errorHandler, bodyLimit, logLevel, attachValidation, replySerializer) {
+function Context (schema, handler, Reply, Request, contentTypeParser, config, errorHandler, bodyLimit, logLevel, logSerializers, attachValidation, replySerializer) {
   this.schema = schema
   this.handler = handler
   this.Reply = Reply
@@ -20,6 +20,7 @@ function Context (schema, handler, Reply, Request, contentTypeParser, config, er
   this._middie = null
   this._parserOptions = { limit: bodyLimit || null }
   this.logLevel = logLevel
+  this.logSerializers = logSerializers
   this[kFourOhFourContext] = null
   this.attachValidation = attachValidation
   this[kReplySerializerDefault] = replySerializer

package/lib/logger.js

@@ -6,7 +6,7 @@
  * License: MIT (https://raw.githubusercontent.com/pinojs/pino-http/master/LICENSE)
  */
 
-const abstractLogging = require('abstract-logging')
+const nullLogger = require('abstract-logging')
 const pino = require('pino')
 const { serializersSym } = pino.symbols
 const { isValidLogger } = require('./validation')
@@ -82,7 +82,7 @@ function createLogger (options) {
     })
     return { logger, hasLogger: true }
   } else if (!options.logger) {
-    const logger = Object.create(abstractLogging)
+    const logger = nullLogger
     logger.child = () => logger
     return { logger, hasLogger: false }
   } else {

package/lib/route.js

@@ -6,7 +6,7 @@ const Context = require('./context')
 const { buildMiddie, onRunMiddlewares } = require('./middleware')
 const { hookRunner, hookIterator } = require('./hooks')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
-const supportedHooks = ['preParsing', 'preValidation', 'onRequest', 'preHandler', 'preSerialization', 'onResponse']
+const supportedHooks = ['preParsing', 'preValidation', 'onRequest', 'preHandler', 'preSerialization', 'onResponse', 'onSend']
 const validation = require('./validation')
 const buildSchema = validation.build
 const { buildSchemaCompiler } = validation
@@ -22,8 +22,10 @@ const {
 const {
   kRoutePrefix,
   kLogLevel,
+  kLogSerializers,
   kHooks,
   kSchemas,
+  kOptions,
   kSchemaCompiler,
   kSchemaResolver,
   kContentTypeParser,
@@ -180,6 +182,10 @@ function buildRouting (options) {
       opts.prefix = prefix
       opts.logLevel = opts.logLevel || this[kLogLevel]
 
+      if (this[kLogSerializers] || opts.logSerializers) {
+        opts.logSerializers = Object.assign(Object.create(this[kLogSerializers]), opts.logSerializers)
+      }
+
       if (opts.attachValidation == null) {
         opts.attachValidation = false
       }
@@ -207,6 +213,7 @@ function buildRouting (options) {
         this._errorHandler,
         opts.bodyLimit,
         opts.logLevel,
+        opts.logSerializers,
         opts.attachValidation,
         this[kReplySerializerDefault]
       )
@@ -223,7 +230,7 @@ function buildRouting (options) {
         try {
           if (opts.schemaCompiler == null && this[kSchemaCompiler] == null) {
             const externalSchemas = this[kSchemas].getJsonSchemas({ onlyAbsoluteUri: true })
-            this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, schemaCache))
+            this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, this[kOptions].ajv, schemaCache))
           }
 
           buildSchema(context, opts.schemaCompiler || this[kSchemaCompiler], this[kSchemas], this[kSchemaResolver])
@@ -312,7 +319,15 @@ function buildRouting (options) {
       }
     }
 
-    var childLogger = logger.child({ [requestIdLogLabel]: req.id, level: context.logLevel })
+    var loggerOpts = {
+      [requestIdLogLabel]: req.id,
+      level: context.logLevel
+    }
+
+    if (context.logSerializers) {
+      loggerOpts.serializers = context.logSerializers
+    }
+    var childLogger = logger.child(loggerOpts)
     childLogger[kDisableRequestLogging] = disableRequestLogging
 
     // added hostname, ip, and ips back to the Node req object to maintain backward compatibility

package/lib/schemas.js

@@ -135,7 +135,7 @@ Schemas.prototype.cleanId = function (schema) {
 }
 
 Schemas.prototype.getSchemaAnyway = function (schema) {
-  if (schema.oneOf || schema.allOf || schema.anyOf) return schema
+  if (schema.oneOf || schema.allOf || schema.anyOf || schema.$merge || schema.$patch) return schema
   if (!schema.type || !schema.properties) {
     return {
       type: 'object',

package/lib/symbols.js

@@ -5,6 +5,7 @@ const keys = {
   kBodyLimit: Symbol('fastify.bodyLimit'),
   kRoutePrefix: Symbol('fastify.routePrefix'),
   kLogLevel: Symbol('fastify.logLevel'),
+  kLogSerializers: Symbol('fastify.logSerializers'),
   kHooks: Symbol('fastify.hooks'),
   kSchemas: Symbol('fastify.schemas'),
   kSchemaCompiler: Symbol('fastify.schemaCompiler'),

package/lib/validation.js

@@ -163,17 +163,22 @@ function schemaErrorsText (errors, dataVar) {
   return text.slice(0, -separator.length)
 }
 
-function buildSchemaCompiler (externalSchemas, cache) {
+function buildSchemaCompiler (externalSchemas, options, cache) {
   // This instance of Ajv is private
   // it should not be customized or used
-  const ajv = new Ajv({
+  const ajv = new Ajv(Object.assign({
     coerceTypes: true,
     useDefaults: true,
     removeAdditional: true,
     allErrors: true,
-    nullable: true,
-    cache
-  })
+    nullable: true
+  }, options.customOptions, { cache }))
+
+  if (options.plugins && options.plugins.length > 0) {
+    for (const plugin of options.plugins) {
+      plugin[0](ajv, plugin[1])
+    }
+  }
 
   if (Array.isArray(externalSchemas)) {
     externalSchemas.forEach(s => ajv.addSchema(s))