fastify 2.14.1 → 2.15.3

package/docs/Hooks.md

@@ -18,6 +18,7 @@ By using hooks you can interact directly with the lifecycle of Fastify. There ar
   - [Manage Errors from a hook](#manage-errors-from-a-hook)
   - [Respond to a request from a hook](#respond-to-a-request-from-a-hook)
 - [Application Hooks](#application-hooks)
+  - [onReady](#onready)
   - [onClose](#onclose)
   - [onRoute](#onroute)
   - [onRegister](#onregister)
@@ -107,7 +108,7 @@ If you are using the `preSerialization` hook, you can change (or replace) the pa
 
 ```js
 fastify.addHook('preSerialization', (request, reply, payload, done) => {
-  const err = null;
+  const err = null
   const newPayload = { wrapped: payload }
   done(err, newPayload)
 })
@@ -282,12 +283,34 @@ fastify.addHook('preHandler', async (request, reply) => {
 
 You can hook into the application-lifecycle as well. It's important to note that these hooks aren't fully encapsulated. The `this` inside the hooks are encapsulated but the handlers can respond to an event outside the encapsulation boundaries.
 
+- [onReady](#onready)
 - [onClose](#onclose)
 - [onRoute](#onroute)
 - [onRegister](#onregister)
 
-<a name="on-close"></a>
+### onReady
+Triggered before the server starts listening for requests. It cannot change the routes or add new hooks.
+Registered hook functions are executed serially.
+Only after all `onReady` hook functions have completed will the server start listening for requests.
+Hook functions accept one argument: a callback, `done`, to be invoked after the hook function is complete.
+Hook functions are invoked with `this` bound to the associated Fastify instance.
+
+```js
+// callback style
+fastify.addHook('onReady', function (done) {
+  // Some code
+  const err = null;
+  done(err)
+})
+
+// or async/await style
+fastify.addHook('onReady', async function () {
+  // Some async code
+  await loadCacheFromDatabase()
+})
+```
 
+<a name="on-close"></a>
 ### onClose
 Triggered when `fastify.close()` is invoked to stop the server. It is useful when [plugins](https://github.com/fastify/fastify/blob/master/docs/Plugins.md) need a "shutdown" event, for example to close an open connection to a database.<br>
 The first argument is the Fastify instance, the second one the `done` callback.
@@ -297,6 +320,7 @@ fastify.addHook('onClose', (instance, done) => {
   done()
 })
 ```
+
 <a name="on-route"></a>
 ### onRoute
 Triggered when a new route is registered. Listeners are passed a `routeOptions` object as the sole parameter. The interface is synchronous, and, as such, the listeners do not get passed a callback.

package/docs/Server.md

@@ -748,13 +748,15 @@ fastify.register(function (instance, options, done) {
 <a name="set-error-handler"></a>
 #### setErrorHandler
 
-`fastify.setErrorHandler(handler(error, request, reply))`: Set a function that will be called whenever an error happens. The handler is fully encapsulated, so different plugins can set different error handlers. *async-await* is supported as well.<br>
+`fastify.setErrorHandler(handler(error, request, reply))`: Set a function that will be called whenever an error happens. The handler is bound to the Fastify instance, and is fully encapsulated, so different plugins can set different error handlers. *async-await* is supported as well.<br>
 *Note: If the error `statusCode` is less than 400, Fastify will automatically set it at 500 before calling the error handler.*
 
 ```js
 fastify.setErrorHandler(function (error, request, reply) {
   // Log error
+  this.log.error(error)
   // Send error response
+  reply.status(409).send({ ok: false })
 })
 ```
 

package/docs/Validation-and-Serialization.md

@@ -14,7 +14,7 @@ Fastify uses a schema-based approach, and even if it is not mandatory we recomme
 <a name="validation"></a>
 ### Validation
 The route validation internally relies upon [Ajv](https://www.npmjs.com/package/ajv), which is a high-performance JSON schema validator. Validating the input is very easy: just add the fields that you need inside the route schema, and you are done! The supported validations are:
-- `body`: validates the body of the request if it is a POST or a PUT.
+- `body`: validates the body of the request if it is a POST, a PATCH or a PUT.
 - `querystring` or `query`: validates the query string. This can be a complete JSON Schema object (with a `type` property of `'object'` and a `'properties'` object containing parameters) or a simpler variation in which the `type` and `properties` attributes are forgone and the query parameters are listed at the top level (see the example below).
 - `params`: validates the route params.
 - `headers`: validates the request headers.
@@ -338,7 +338,6 @@ Fastify's [baseline ajv configuration](https://github.com/epoberezkin/ajv#option
   removeAdditional: true, // remove additional properties
   useDefaults: true, // replace missing properties and items with the values from corresponding default keyword
   coerceTypes: true, // change data type of data to match type keyword
-  allErrors: true,   // check for all errors
   nullable: true     // support keyword "nullable" from Open API 3 specification.
 }
 ```
@@ -355,7 +354,6 @@ const ajv = new Ajv({
   removeAdditional: true,
   useDefaults: true,
   coerceTypes: true,
-  allErrors: true,
   nullable: true,
   // any other options
   // ...
@@ -666,7 +664,7 @@ Inline comments in the schema below describe how to configure it to show a diffe
 ```js
 const fastify = Fastify({
   ajv: {
-    customOptions: { allErrors: true, jsonPointers: true },
+    customOptions: { jsonPointers: true },
     plugins: [
       require('ajv-errors')
     ]
@@ -713,11 +711,7 @@ If you want to return localized error messages, take a look at [ajv-i18n](https:
 ```js
 const localize = require('ajv-i18n')
 
-const fastify = Fastify({
-  ajv: {
-    customOptions: { allErrors: true }
-  }
-})
+const fastify = Fastify()
 
 const schema = {
   body: {

package/fastify.d.ts

@@ -667,7 +667,7 @@ declare namespace fastify {
     /**
      * Set a function that will be called whenever an error happens
      */
-    setErrorHandler<E = FastifyError>(handler: (error: E, request: FastifyRequest<HttpRequest>, reply: FastifyReply<HttpResponse>) => void): void
+    setErrorHandler<E = FastifyError>(handler: (this: FastifyInstance<HttpServer, HttpRequest, HttpResponse>, error: E, request: FastifyRequest<HttpRequest>, reply: FastifyReply<HttpResponse>) => void): void
 
     /**
      * Set a function that will be called whenever an error happens

package/fastify.js

@@ -6,6 +6,7 @@ const querystring = require('querystring')
 let lightMyRequest
 
 const {
+  kAvvioBoot,
   kChildren,
   kBodyLimit,
   kRoutePrefix,
@@ -33,7 +34,7 @@ const Request = require('./lib/request')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
 const decorator = require('./lib/decorate')
 const ContentTypeParser = require('./lib/contentTypeParser')
-const { Hooks, buildHooks } = require('./lib/hooks')
+const { Hooks, buildHooks, hookRunnerApplication } = require('./lib/hooks')
 const { Schemas, buildSchemas } = require('./lib/schemas')
 const { createLogger } = require('./lib/logger')
 const pluginUtils = require('./lib/pluginUtils')
@@ -166,6 +167,7 @@ function build (options) {
     },
     [pluginUtils.registeredPlugins]: [],
     [kPluginNameChain]: [],
+    [kAvvioBoot]: null,
     // routes shorthand methods
     delete: function _delete (url, opts, handler) {
       return router.prepareRoute.call(this, 'DELETE', url, opts, handler)
@@ -285,6 +287,8 @@ function build (options) {
   // Override to allow the plugin incapsulation
   avvio.override = override
   avvio.on('start', () => (fastify[kState].started = true))
+  fastify[kAvvioBoot] = fastify.ready // the avvio ready function
+  fastify.ready = ready // overwrite the avvio ready function
   // cache the closing value, since we are checking it in an hot path
   avvio.once('preReady', () => {
     fastify.onClose((instance, done) => {
@@ -348,8 +352,15 @@ function build (options) {
         else lightMyRequest(httpHandler, opts, cb)
       })
     } else {
-      return this.ready()
-        .then(() => lightMyRequest(httpHandler, opts))
+      return lightMyRequest((req, res) => {
+        this.ready(function (err) {
+          if (err) {
+            res.emit('error', err)
+            return
+          }
+          httpHandler(req, res)
+        })
+      }, opts)
     }
   }
 
@@ -371,6 +382,48 @@ function build (options) {
     }
   }
 
+  function ready (cb) {
+    let resolveReady
+    let rejectReady
+
+    // run the hooks after returning the promise
+    process.nextTick(runHooks)
+
+    if (!cb) {
+      return new Promise(function (resolve, reject) {
+        resolveReady = resolve
+        rejectReady = reject
+      })
+    }
+
+    function runHooks () {
+      // start loading
+      fastify[kAvvioBoot]((err, done) => {
+        if (err || fastify[kState].started) {
+          manageErr(err)
+        } else {
+          hookRunnerApplication('onReady', fastify[kAvvioBoot], fastify, manageErr)
+        }
+        done()
+      })
+    }
+
+    function manageErr (err) {
+      if (cb) {
+        if (err) {
+          cb(err)
+        } else {
+          cb(undefined, fastify)
+        }
+      } else {
+        if (err) {
+          return rejectReady(err)
+        }
+        resolveReady(fastify)
+      }
+    }
+  }
+
   // wrapper that we expose to the user for hooks handling
   function addHook (name, fn) {
     throwIfAlreadyStarted('Cannot call "addHook" when fastify instance is already started!')
@@ -380,6 +433,10 @@ function build (options) {
       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)
       }
+    } else if (name === 'onReady') {
+      if (fn.constructor.name === 'AsyncFunction' && fn.length !== 0) {
+        throw new Error('Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+      }
     } 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)
@@ -395,6 +452,9 @@ function build (options) {
     } else if (name === 'onRegister') {
       this[kHooks].validate(name, fn)
       this[kGlobalHooks].onRegister.push(fn)
+    } else if (name === 'onReady') {
+      this[kHooks].validate(name, fn)
+      this[kHooks].add(name, fn)
     } else {
       this.after((err, done) => {
         _addHook.call(this, name, fn)
@@ -495,7 +555,7 @@ function build (options) {
   function setErrorHandler (func) {
     throwIfAlreadyStarted('Cannot call "setErrorHandler" when fastify instance is already started!')
 
-    this._errorHandler = func
+    this._errorHandler = func.bind(this)
     return this
   }
 }
@@ -513,6 +573,7 @@ function override (old, fn, opts) {
 
   const instance = Object.create(old)
   old[kChildren].push(instance)
+  instance.ready = old[kAvvioBoot].bind(instance)
   instance[kChildren] = []
   instance[kReply] = Reply.buildReply(instance[kReply])
   instance[kRequest] = Request.buildRequest(instance[kRequest])

package/lib/hooks.js

@@ -12,6 +12,7 @@ const supportedHooks = [
   // executed at start/close time
   'onRoute',
   'onRegister',
+  'onReady',
   'onClose'
 ]
 const {
@@ -22,6 +23,11 @@ const {
   }
 } = require('./errors')
 
+const {
+  kChildren,
+  kHooks
+} = require('./symbols')
+
 function Hooks () {
   this.onRequest = []
   this.preParsing = []
@@ -31,6 +37,7 @@ function Hooks () {
   this.onResponse = []
   this.onSend = []
   this.onError = []
+  this.onReady = []
 }
 
 Hooks.prototype.validate = function (hook, fn) {
@@ -56,9 +63,80 @@ function buildHooks (h) {
   hooks.onSend = h.onSend.slice()
   hooks.onResponse = h.onResponse.slice()
   hooks.onError = h.onError.slice()
+  hooks.onReady = []
   return hooks
 }
 
+function hookRunnerApplication (hookName, boot, server, cb) {
+  const hooks = server[kHooks][hookName]
+  var i = 0
+  var c = 0
+
+  next()
+
+  function exit (err) {
+    if (err) {
+      cb(err)
+      return
+    }
+    cb()
+  }
+
+  function next (err) {
+    if (err) {
+      exit(err)
+      return
+    }
+
+    if (i === hooks.length && c === server[kChildren].length) {
+      if (i === 0 && c === 0) { // speed up start
+        exit()
+      } else {
+        boot(function manageTimeout (err, done) {
+          exit(err) // reply to the client's cb
+          done(err) // goahead with the avvio line
+        })
+      }
+      return
+    }
+
+    if (i === hooks.length && c < server[kChildren].length) {
+      const child = server[kChildren][c++]
+      hookRunnerApplication(hookName, boot, child, next)
+      return
+    }
+
+    boot(wrap(hooks[i++], server))
+    next()
+  }
+
+  function wrap (fn, server) {
+    return function (err, done) {
+      if (err) {
+        done(err)
+        return
+      }
+
+      if (fn.length === 1) {
+        try {
+          fn.call(server, done)
+        } catch (error) {
+          done(error)
+        }
+        return
+      }
+
+      const ret = fn.call(server)
+      if (ret && typeof ret.then === 'function') {
+        ret.then(done, done)
+        return
+      }
+
+      done(err) // auto done
+    }
+  }
+}
+
 function hookRunner (functions, runner, request, reply, cb) {
   var i = 0
 
@@ -131,5 +209,6 @@ module.exports = {
   buildHooks,
   hookRunner,
   onSendHookRunner,
-  hookIterator
+  hookIterator,
+  hookRunnerApplication
 }

package/lib/reply.js

@@ -138,9 +138,30 @@ Reply.prototype.send = function (payload) {
 
   if (this[kReplySerializer] !== null) {
     payload = this[kReplySerializer](payload)
-  } else if (hasContentType === false || contentType.indexOf('application/json') > -1) {
-    if (hasContentType === false || contentType.indexOf('charset') === -1) {
+
+  // The indexOf below also matches custom json mimetypes such as 'application/hal+json' or 'application/ld+json'
+  } else if (hasContentType === false || contentType.indexOf('json') > -1) {
+    if (hasContentType === false) {
       this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
+    } else {
+      // If hasContentType === true, we have a JSON mimetype
+      if (contentType.indexOf('charset') === -1) {
+        // If we have simply application/json instead of a custom json mimetype
+        if (contentType.indexOf('/json') > -1) {
+          this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
+        } else {
+          const currContentType = this[kReplyHeaders]['content-type']
+          // We extract the custom mimetype part (e.g. 'hal+' from 'application/hal+json')
+          const customJsonType = currContentType.substring(
+            currContentType.indexOf('/'),
+            currContentType.indexOf('json') + 4
+          )
+
+          // We ensure we set the header to the proper JSON content-type if necessary
+          // (e.g. 'application/hal+json' instead of 'application/json')
+          this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON.replace('/json', customJsonType)
+        }
+      }
     }
     if (typeof payload !== 'string') {
       preserializeHook(this, payload)

package/lib/symbols.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const keys = {
+  kAvvioBoot: Symbol('fastify.avvioBoot'),
   kChildren: Symbol('fastify.children'),
   kBodyLimit: Symbol('fastify.bodyLimit'),
   kRoutePrefix: Symbol('fastify.routePrefix'),

package/lib/validation.js

@@ -171,7 +171,9 @@ function buildSchemaCompiler (externalSchemas, options, cache) {
     coerceTypes: true,
     useDefaults: true,
     removeAdditional: true,
-    allErrors: true,
+    // Explicitly set allErrors to `false`.
+    // When set to `true`, a DoS attack is possible.
+    allErrors: false,
     nullable: true
   }, options.customOptions, { cache }))
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "2.14.1",
+  "version": "2.15.3",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -143,7 +143,7 @@
   "dependencies": {
     "abstract-logging": "^2.0.0",
     "ajv": "^6.12.0",
-    "avvio": "^6.3.1",
+    "avvio": "^6.5.0",
     "fast-json-stringify": "^1.18.0",
     "find-my-way": "^2.2.2",
     "flatstr": "^1.0.12",

package/test/hooks.on-ready.async.js

@@ -0,0 +1,173 @@
+'use strict'
+
+const Fastify = require('../fastify')
+const immediate = require('util').promisify(setImmediate)
+
+module.exports = function asyncTest (t) {
+  t.test('async onReady should be called in order', t => {
+    t.plan(7)
+    const fastify = Fastify()
+
+    let order = 0
+
+    fastify.addHook('onReady', async function () {
+      await immediate()
+      t.equals(order++, 0, 'called in root')
+      t.equals(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    })
+
+    fastify.register(async (childOne, o) => {
+      childOne.addHook('onReady', async function () {
+        await immediate()
+        t.equals(order++, 1, 'called in childOne')
+        t.equals(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      })
+
+      childOne.register(async (childTwo, o) => {
+        childTwo.addHook('onReady', async function () {
+          await immediate()
+          t.equals(order++, 2, 'called in childTwo')
+          t.equals(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+        })
+      })
+    })
+
+    return fastify.ready().then(() => { t.pass('ready') })
+  })
+
+  t.test('mix ready and onReady', t => {
+    t.plan(2)
+    const fastify = Fastify()
+    let order = 0
+
+    fastify.addHook('onReady', async function () {
+      await immediate()
+      order++
+    })
+
+    return fastify.ready()
+      .then(() => {
+        t.equals(order, 1)
+        return fastify.ready()
+      })
+      .then(() => {
+        t.equals(order, 1, 'ready hooks execute once')
+      })
+  })
+
+  t.test('listen and onReady order', async t => {
+    t.plan(9)
+
+    const fastify = Fastify()
+    let order = 0
+
+    fastify.register((instance, opts, next) => {
+      instance.ready(checkOrder.bind(null, 0))
+      instance.addHook('onReady', checkOrder.bind(null, 4))
+
+      instance.register((subinstance, opts, next) => {
+        subinstance.ready(checkOrder.bind(null, 1))
+        subinstance.addHook('onReady', checkOrder.bind(null, 5))
+
+        subinstance.register((realSubInstance, opts, next) => {
+          realSubInstance.ready(checkOrder.bind(null, 2))
+          realSubInstance.addHook('onReady', checkOrder.bind(null, 6))
+          next()
+        })
+        next()
+      })
+      next()
+    })
+
+    fastify.addHook('onReady', checkOrder.bind(null, 3))
+
+    await fastify.ready()
+    t.pass('trigger the onReady')
+    await fastify.listen(0)
+    t.pass('do not trigger the onReady')
+
+    await fastify.close()
+
+    function checkOrder (shouldbe) {
+      t.equals(order, shouldbe)
+      order++
+    }
+  })
+
+  t.test('multiple ready calls', async t => {
+    t.plan(11)
+
+    const fastify = Fastify()
+    let order = 0
+
+    fastify.register(async (instance, opts) => {
+      instance.ready(checkOrder.bind(null, 1))
+      instance.addHook('onReady', checkOrder.bind(null, 6))
+
+      await instance.register(async (subinstance, opts) => {
+        subinstance.ready(checkOrder.bind(null, 2))
+        subinstance.addHook('onReady', checkOrder.bind(null, 7))
+      })
+
+      t.equals(order, 0, 'ready and hooks not triggered yet')
+      order++
+    })
+
+    fastify.addHook('onReady', checkOrder.bind(null, 3))
+    fastify.addHook('onReady', checkOrder.bind(null, 4))
+    fastify.addHook('onReady', checkOrder.bind(null, 5))
+
+    await fastify.ready()
+    t.pass('trigger the onReady')
+
+    await fastify.ready()
+    t.pass('do not trigger the onReady')
+
+    await fastify.ready()
+    t.pass('do not trigger the onReady')
+
+    function checkOrder (shouldbe) {
+      t.equals(order, shouldbe)
+      order++
+    }
+  })
+
+  t.test('onReady should manage error in async', t => {
+    t.plan(4)
+    const fastify = Fastify()
+
+    fastify.addHook('onReady', function (done) {
+      t.pass('called in root')
+      done()
+    })
+
+    fastify.register(async (childOne, o) => {
+      childOne.addHook('onReady', async function () {
+        t.pass('called in childOne')
+        throw new Error('FAIL ON READY')
+      })
+
+      childOne.register(async (childTwo, o) => {
+        childTwo.addHook('onReady', async function () {
+          t.fail('should not be called')
+        })
+      })
+    })
+
+    fastify.ready(err => {
+      t.ok(err)
+      t.equals(err.message, 'FAIL ON READY')
+    })
+  })
+
+  t.test('onReady throw loading error', t => {
+    t.plan(1)
+    const fastify = Fastify()
+
+    try {
+      fastify.addHook('onReady', async function (done) {})
+    } catch (e) {
+      t.true(e.message === 'Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+    }
+  })
+}

package/test/hooks.on-ready.test.js

@@ -0,0 +1,236 @@
+'use strict'
+
+const semver = require('semver')
+const t = require('tap')
+const Fastify = require('../fastify')
+
+if (semver.gt(process.versions.node, '8.0.0')) {
+  require('./hooks.on-ready.async')(t)
+} else {
+  t.test('async tests', t => {
+    t.plan(1)
+    t.pass('Skip because Node version < 8')
+  })
+}
+
+t.test('onReady should be called in order', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  let order = 0
+
+  fastify.addHook('onReady', function (done) {
+    t.equals(order++, 0, 'called in root')
+    t.equals(this.pluginName, fastify.pluginName, 'the this binding is the right instance')
+    done()
+  })
+
+  fastify.register((childOne, o, next) => {
+    childOne.addHook('onReady', function (done) {
+      t.equals(order++, 1, 'called in childOne')
+      t.equals(this.pluginName, childOne.pluginName, 'the this binding is the right instance')
+      done()
+    })
+
+    childOne.register((childTwo, o, next) => {
+      childTwo.addHook('onReady', function () {
+        return new Promise((resolve) => {
+          setTimeout(resolve, 0)
+        })
+          .then(() => {
+            t.equals(order++, 2, 'called in childTwo')
+            t.equals(this.pluginName, childTwo.pluginName, 'the this binding is the right instance')
+          })
+      })
+      next()
+    })
+    next()
+  })
+
+  fastify.ready(err => t.error(err))
+})
+
+t.test('onReady should manage error in sync', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('onReady', function (done) {
+    t.pass('called in root')
+    done()
+  })
+
+  fastify.register((childOne, o, next) => {
+    childOne.addHook('onReady', function (done) {
+      t.pass('called in childOne')
+      done(new Error('FAIL ON READY'))
+    })
+
+    childOne.register((childTwo, o, next) => {
+      childTwo.addHook('onReady', function () {
+        return Promise().resolve()
+          .then(() => {
+            t.fail('should not be called')
+          })
+      })
+      next()
+    })
+
+    next()
+  })
+
+  fastify.ready(err => {
+    t.ok(err)
+    t.equals(err.message, 'FAIL ON READY')
+  })
+})
+
+t.test('onReady should manage sync error', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('onReady', function (done) {
+    t.pass('called in root')
+    done()
+  })
+
+  fastify.register((childOne, o, next) => {
+    childOne.addHook('onReady', function (done) {
+      t.pass('called in childOne')
+      throw new Error('FAIL UNWANTED SYNC EXCEPTION')
+    })
+
+    childOne.register((childTwo, o, next) => {
+      childTwo.addHook('onReady', function () {
+        t.fail('should not be called')
+      })
+      next()
+    })
+
+    next()
+  })
+
+  fastify.ready(err => {
+    t.ok(err)
+    t.equals(err.message, 'FAIL UNWANTED SYNC EXCEPTION')
+  })
+})
+
+t.test('onReady can not add decorators or application hooks', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('onReady', function (done) {
+    t.pass('called in root')
+    fastify.decorate('test', () => {})
+
+    fastify.addHook('onReady', function () {
+      t.fail('it will be not called')
+    })
+    done()
+  })
+
+  fastify.addHook('onReady', function (done) {
+    t.ok(this.hasDecorator('test'))
+    done()
+  })
+
+  fastify.ready(err => { t.error(err) })
+})
+
+t.test('onReady cannot add lifecycle hooks', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.addHook('onReady', function (done) {
+    t.pass('called in root')
+    try {
+      fastify.addHook('onRequest', (request, reply, done) => {})
+    } catch (error) {
+      t.ok(error)
+      t.equals(error.message, 'root plugin has already booted')
+      done(error)
+    }
+  })
+
+  fastify.addHook('onRequest', (request, reply, done) => {})
+  fastify.get('/', (r, reply) => reply.send('hello'))
+
+  fastify.ready((err) => { t.ok(err) })
+})
+
+t.test('onReady does not call done', t => {
+  t.plan(3)
+  const fastify = Fastify({ pluginTimeout: 500 })
+
+  fastify.addHook('onReady', function (done) {
+    t.pass('called in root')
+    // done() // don't call done to test timeout
+  })
+
+  fastify.ready(err => {
+    t.ok(err)
+    t.equal(err.code, 'ERR_AVVIO_READY_TIMEOUT')
+  })
+})
+
+t.test('ready chain order when no await', t => {
+  t.plan(3)
+  const fastify = Fastify({ })
+
+  let i = 0
+  fastify.ready(() => {
+    i++
+    t.equals(i, 1)
+  })
+  fastify.ready(() => {
+    i++
+    t.equals(i, 2)
+  })
+  fastify.ready(() => {
+    i++
+    t.equals(i, 3)
+  })
+})
+
+t.test('ready return the server with callback', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.ready((err, instance) => {
+    t.error(err)
+    t.deepEquals(instance, fastify)
+  })
+})
+
+t.test('ready return the server with Promise', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.ready()
+    .then(instance => { t.deepEquals(instance, fastify) })
+    .catch(err => { t.fail(err) })
+})
+
+t.test('ready return registered', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.register((one, opts, next) => {
+    one.ready().then(itself => { t.deepEquals(itself, one) })
+    next()
+  })
+
+  fastify.register((two, opts, next) => {
+    two.ready().then(itself => { t.deepEquals(itself, two) })
+
+    two.register((twoDotOne, opts, next) => {
+      twoDotOne.ready().then(itself => { t.deepEquals(itself, twoDotOne) })
+      next()
+    })
+    next()
+  })
+
+  fastify.ready()
+    .then(instance => { t.deepEquals(instance, fastify) })
+    .catch(err => { t.fail(err) })
+})

package/test/inject.test.js

@@ -409,3 +409,18 @@ test('should throw error if callback specified and if ready errors', t => {
     t.strictEqual(err, error)
   })
 })
+
+test('should support builder-style injection with non-ready app', (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+  fastify.inject().get('/').end().then((res) => {
+    t.deepEqual(payload, JSON.parse(res.payload))
+    t.strictEqual(res.statusCode, 200)
+    t.strictEqual(res.headers['content-length'], '17')
+  })
+})

package/test/internals/reply.test.js

@@ -544,6 +544,57 @@ test('plain string with content type application/json should NOT be serialized a
   })
 })
 
+test('plain string with custom json content type should NOT be serialized as json', t => {
+  t.plan(16)
+
+  const fastify = require('../..')()
+
+  const customSamples = {
+    collectionjson: {
+      mimeType: 'application/vnd.collection+json',
+      sample: '{"collection":{"version":"1.0","href":"http://api.example.com/people/"}}'
+    },
+    hal: {
+      mimeType: 'application/hal+json',
+      sample: '{"_links":{"self":{"href":"https://api.example.com/people/1"}},"name":"John Doe"}'
+    },
+    jsonapi: {
+      mimeType: 'application/vnd.api+json',
+      sample: '{"data":{"type":"people","id":"1"}}'
+    },
+    jsonld: {
+      mimeType: 'application/ld+json',
+      sample: '{"@context":"https://json-ld.org/contexts/person.jsonld","name":"John Doe"}'
+    },
+    siren: {
+      mimeType: 'application/vnd.siren+json',
+      sample: '{"class":"person","properties":{"name":"John Doe"}}'
+    }
+  }
+
+  Object.keys(customSamples).forEach((path) => {
+    fastify.get(`/${path}`, function (req, reply) {
+      reply.type(customSamples[path].mimeType).send(customSamples[path].sample)
+    })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    Object.keys(customSamples).forEach((path) => {
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/' + path
+      }, (err, response, body) => {
+        t.error(err)
+        t.strictEqual(response.headers['content-type'], customSamples[path].mimeType + '; charset=utf-8')
+        t.deepEqual(body.toString(), customSamples[path].sample)
+      })
+    })
+  })
+})
+
 test('non-string with content type application/json SHOULD be serialized as json', t => {
   t.plan(4)
 
@@ -568,6 +619,57 @@ test('non-string with content type application/json SHOULD be serialized as json
   })
 })
 
+test('non-string with custom json content type SHOULD be serialized as json', t => {
+  t.plan(16)
+
+  const fastify = require('../..')()
+
+  const customSamples = {
+    collectionjson: {
+      mimeType: 'application/vnd.collection+json',
+      sample: JSON.parse('{"collection":{"version":"1.0","href":"http://api.example.com/people/"}}')
+    },
+    hal: {
+      mimeType: 'application/hal+json',
+      sample: JSON.parse('{"_links":{"self":{"href":"https://api.example.com/people/1"}},"name":"John Doe"}')
+    },
+    jsonapi: {
+      mimeType: 'application/vnd.api+json',
+      sample: JSON.parse('{"data":{"type":"people","id":"1"}}')
+    },
+    jsonld: {
+      mimeType: 'application/ld+json',
+      sample: JSON.parse('{"@context":"https://json-ld.org/contexts/person.jsonld","name":"John Doe"}')
+    },
+    siren: {
+      mimeType: 'application/vnd.siren+json',
+      sample: JSON.parse('{"class":"person","properties":{"name":"John Doe"}}')
+    }
+  }
+
+  Object.keys(customSamples).forEach((path) => {
+    fastify.get(`/${path}`, function (req, reply) {
+      reply.type(customSamples[path].mimeType).send(customSamples[path].sample)
+    })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    Object.keys(customSamples).forEach((path) => {
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/' + path
+      }, (err, response, body) => {
+        t.error(err)
+        t.strictEqual(response.headers['content-type'], customSamples[path].mimeType + '; charset=utf-8')
+        t.deepEqual(body.toString(), JSON.stringify(customSamples[path].sample))
+      })
+    })
+  })
+})
+
 test('error object with a content type that is not application/json should work', t => {
   t.plan(6)
 

package/test/request-error.test.js

@@ -73,3 +73,84 @@ test('default 400 on request error with custom error handler', t => {
     })
   })
 })
+
+test('error handler binding', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.setErrorHandler(function (err, request, reply) {
+    t.strictEqual(this, fastify)
+    reply
+      .code(err.statusCode)
+      .type('application/json; charset=utf-8')
+      .send(err)
+  })
+
+  fastify.post('/', function (req, reply) {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    simulate: {
+      error: true
+    },
+    body: {
+      text: '12345678901234567890123456789012345678901234567890'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.statusCode, 400)
+    t.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+    t.deepEqual(JSON.parse(res.payload), {
+      error: 'Bad Request',
+      message: 'Simulated',
+      statusCode: 400
+    })
+  })
+})
+
+test('encapsulated error handler binding', t => {
+  t.plan(7)
+
+  const fastify = Fastify()
+
+  fastify.register(function (app, opts, next) {
+    app.decorate('hello', 'world')
+    t.strictEqual(app.hello, 'world')
+    app.post('/', function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+    app.setErrorHandler(function (err, request, reply) {
+      t.strictEqual(this.hello, 'world')
+      reply
+        .code(err.statusCode)
+        .type('application/json; charset=utf-8')
+        .send(err)
+    })
+    next()
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    simulate: {
+      error: true
+    },
+    body: {
+      text: '12345678901234567890123456789012345678901234567890'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.strictEqual(res.statusCode, 400)
+    t.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+    t.deepEqual(res.json(), {
+      error: 'Bad Request',
+      message: 'Simulated',
+      statusCode: 400
+    })
+    t.strictEqual(fastify.hello, undefined)
+  })
+})

package/test/validation-error-handling.test.js

@@ -57,10 +57,10 @@ test('should fail immediately with invalid payload', t => {
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.deepEqual(JSON.parse(res.payload), {
+    t.deepEqual(res.json(), {
       statusCode: 400,
       error: 'Bad Request',
-      message: "body should have required property 'name', body should have required property 'work'"
+      message: "body should have required property 'name'"
     })
     t.strictEqual(res.statusCode, 400)
   })
@@ -216,19 +216,12 @@ test('should be able to attach validation to request', t => {
   }, (err, res) => {
     t.error(err)
 
-    t.deepEqual(JSON.parse(res.payload), [{
+    t.deepEqual(res.json(), [{
       keyword: 'required',
       dataPath: '',
       schemaPath: '#/required',
       params: { missingProperty: 'name' },
       message: 'should have required property \'name\''
-    },
-    {
-      keyword: 'required',
-      dataPath: '',
-      schemaPath: '#/required',
-      params: { missingProperty: 'work' },
-      message: 'should have required property \'work\''
     }])
     t.strictEqual(res.statusCode, 400)
   })
@@ -255,7 +248,7 @@ test('should respect when attachValidation is explicitly set to false', t => {
     t.deepEqual(JSON.parse(res.payload), {
       statusCode: 400,
       error: 'Bad Request',
-      message: "body should have required property 'name', body should have required property 'work'"
+      message: "body should have required property 'name'"
     })
     t.strictEqual(res.statusCode, 400)
   })
@@ -285,7 +278,7 @@ test('Attached validation error should take precendence over setErrorHandler', t
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.deepEqual(res.payload, "Attached: Error: body should have required property 'name', body should have required property 'work'")
+    t.deepEqual(res.payload, "Attached: Error: body should have required property 'name'")
     t.strictEqual(res.statusCode, 400)
   })
 })
@@ -320,7 +313,7 @@ test('should handle response validation error', t => {
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.strictEqual(res.payload, '{"statusCode":500,"error":"Internal Server Error","message":"name is required!"}')
+    t.strictEqual(res.payload, '{"statusCode":500,"error":"Internal Server Error","message":"\\"name\\" is required!"}')
   })
 })
 
@@ -350,7 +343,7 @@ test('should handle response validation error with promises', t => {
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.strictEqual(res.payload, '{"statusCode":500,"error":"Internal Server Error","message":"name is required!"}')
+    t.strictEqual(res.payload, '{"statusCode":500,"error":"Internal Server Error","message":"\\"name\\" is required!"}')
   })
 })
 
@@ -378,7 +371,7 @@ test('should return a defined output message parsing AJV errors', t => {
     url: '/'
   }, (err, res) => {
     t.error(err)
-    t.strictEqual(res.payload, '{"statusCode":400,"error":"Bad Request","message":"body should have required property \'name\', body should have required property \'work\'"}')
+    t.strictEqual(res.payload, '{"statusCode":400,"error":"Bad Request","message":"body should have required property \'name\'"}')
   })
 })