fastify 2.7.1 → 2.11.0

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/errors.js

@@ -7,42 +7,42 @@ const codes = {}
  * Basic
  */
 
-createError('FST_ERR_NOT_FOUND', `Not Found`, 404)
+createError('FST_ERR_NOT_FOUND', 'Not Found', 404)
 
 /**
  * ContentTypeParser
 */
-createError('FST_ERR_CTP_ALREADY_PRESENT', `Content type parser '%s' already present.`)
+createError('FST_ERR_CTP_ALREADY_PRESENT', "Content type parser '%s' already present.")
 createError('FST_ERR_CTP_INVALID_TYPE', 'The content type should be a string', 500, TypeError)
 createError('FST_ERR_CTP_EMPTY_TYPE', 'The content type cannot be an empty string', 500, TypeError)
 createError('FST_ERR_CTP_INVALID_HANDLER', 'The content type handler should be a function', 500, TypeError)
-createError('FST_ERR_CTP_INVALID_PARSE_TYPE', `The body parser can only parse your data as 'string' or 'buffer', you asked '%s' which is not supported.`, 500, TypeError)
+createError('FST_ERR_CTP_INVALID_PARSE_TYPE', "The body parser can only parse your data as 'string' or 'buffer', you asked '%s' which is not supported.", 500, TypeError)
 createError('FST_ERR_CTP_BODY_TOO_LARGE', 'Request body is too large', 413, RangeError)
-createError('FST_ERR_CTP_INVALID_MEDIA_TYPE', `Unsupported Media Type: %s`, 415)
+createError('FST_ERR_CTP_INVALID_MEDIA_TYPE', 'Unsupported Media Type: %s', 415)
 createError('FST_ERR_CTP_INVALID_CONTENT_LENGTH', 'Request body size did not match Content-Length', 400, RangeError)
-createError('FST_ERR_CTP_EMPTY_JSON_BODY', `Body cannot be empty when content-type is set to 'application/json'`, 400)
+createError('FST_ERR_CTP_EMPTY_JSON_BODY', "Body cannot be empty when content-type is set to 'application/json'", 400)
 
 /**
  * decorate
 */
-createError('FST_ERR_DEC_ALREADY_PRESENT', `The decorator '%s' has already been added!`)
-createError('FST_ERR_DEC_MISSING_DEPENDENCY', `The decorator is missing dependency '%s'.`)
+createError('FST_ERR_DEC_ALREADY_PRESENT', "The decorator '%s' has already been added!")
+createError('FST_ERR_DEC_MISSING_DEPENDENCY', "The decorator is missing dependency '%s'.")
 
 /**
  * hooks
 */
-createError('FST_ERR_HOOK_INVALID_TYPE', `The hook name must be a string`, 500, TypeError)
-createError('FST_ERR_HOOK_INVALID_HANDLER', `The hook callback must be a function`, 500, TypeError)
+createError('FST_ERR_HOOK_INVALID_TYPE', 'The hook name must be a string', 500, TypeError)
+createError('FST_ERR_HOOK_INVALID_HANDLER', 'The hook callback must be a function', 500, TypeError)
 
 /**
  * logger
 */
-createError('FST_ERR_LOG_INVALID_DESTINATION', `Cannot specify both logger.stream and logger.file options`)
+createError('FST_ERR_LOG_INVALID_DESTINATION', 'Cannot specify both logger.stream and logger.file options')
 
 /**
  * reply
 */
-createError('FST_ERR_REP_INVALID_PAYLOAD_TYPE', `Attempted to send payload of invalid type '%s'. Expected a string or Buffer.`, 500, TypeError)
+createError('FST_ERR_REP_INVALID_PAYLOAD_TYPE', "Attempted to send payload of invalid type '%s'. Expected a string or Buffer.", 500, TypeError)
 createError('FST_ERR_REP_ALREADY_SENT', 'Reply was already sent.')
 createError('FST_ERR_REP_SENT_VALUE', 'The only possible value for reply.sent is true.')
 createError('FST_ERR_SEND_INSIDE_ONERR', 'You cannot use `send` inside the `onError` hook')
@@ -50,25 +50,27 @@ createError('FST_ERR_SEND_INSIDE_ONERR', 'You cannot use `send` inside the `onEr
 /**
  * schemas
 */
-createError('FST_ERR_SCH_MISSING_ID', `Missing schema $id property`)
-createError('FST_ERR_SCH_ALREADY_PRESENT', `Schema with id '%s' already declared!`)
-createError('FST_ERR_SCH_NOT_PRESENT', `Schema with id '%s' does not exist!`)
-createError('FST_ERR_SCH_DUPLICATE', `Schema with '%s' already present!`)
+createError('FST_ERR_SCH_MISSING_ID', 'Missing schema $id property')
+createError('FST_ERR_SCH_ALREADY_PRESENT', "Schema with id '%s' already declared!")
+createError('FST_ERR_SCH_NOT_PRESENT', "Schema with id '%s' does not exist!")
+createError('FST_ERR_SCH_DUPLICATE', "Schema with '%s' already present!")
+createError('FST_ERR_SCH_BUILD', 'Failed building the schema for %s: %s, due error %s')
+createError('FST_ERR_SCH_MISSING_COMPILER', 'You must provide a schemaCompiler to route %s %s to use the schemaResolver')
 
 /**
  * wrapThenable
  */
-createError('FST_ERR_PROMISE_NOT_FULLFILLED', `Promise may not be fulfilled with 'undefined' when statusCode is not 204`)
+createError('FST_ERR_PROMISE_NOT_FULLFILLED', "Promise may not be fulfilled with 'undefined' when statusCode is not 204")
 
 /**
  * http2
  */
-createError('FST_ERR_HTTP2_INVALID_VERSION', `HTTP2 is available only from node >= 8.8.1`)
+createError('FST_ERR_HTTP2_INVALID_VERSION', 'HTTP2 is available only from node >= 8.8.1')
 
 /**
  * initialConfig
  */
-createError('FST_ERR_INIT_OPTS_INVALID', `Invalid initialization options: '%s'`)
+createError('FST_ERR_INIT_OPTS_INVALID', "Invalid initialization options: '%s'")
 
 function createError (code, message, statusCode = 500, Base = Error) {
   if (!code) throw new Error('Fastify error code must not be empty')
@@ -95,6 +97,7 @@ function createError (code, message, statusCode = 500, Base = Error) {
     this.message = `${this.code}: ${this.message}`
     this.statusCode = statusCode || undefined
   }
+  FastifyError.prototype[Symbol.toStringTag] = 'Error'
 
   inherits(FastifyError, Base)
 

package/lib/fourOhFour.js

@@ -34,14 +34,7 @@ function fourOhFour (options) {
   // 404 router, used for handling encapsulated 404 handlers
   const router = FindMyWay({ defaultRoute: fourOhFourFallBack })
 
-  const fof = {
-    router,
-    setNotFoundHandler: setNotFoundHandler,
-    setContext: setContext,
-    arrange404: arrange404
-  }
-
-  return fof
+  return { router, setNotFoundHandler, setContext, arrange404 }
 
   function arrange404 (instance) {
     // Change the pointer of the fastify instance to itself, so register + prefix can add new 404 handler
@@ -49,8 +42,15 @@ function fourOhFour (options) {
     instance[kCanSetNotFoundHandler] = true
   }
 
-  function basic404 (req, reply) {
-    reply.code(404).send(new Error('Not Found'))
+  function basic404 (request, reply) {
+    const { url, method } = request.raw
+    const message = `Route ${method}:${url} not found`
+    request.log.info(message)
+    reply.code(404).send({
+      message,
+      error: 'Not Found',
+      statusCode: 404
+    })
   }
 
   function setContext (instance, context) {

package/lib/handleRequest.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const validation = require('./validation')
-const validateSchema = validation.validate
+const { validate: validateSchema } = require('./validation')
 const { hookRunner, hookIterator } = require('./hooks')
 const wrapThenable = require('./wrapThenable')
 

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/pluginUtils.js

@@ -11,6 +11,35 @@ function getMeta (fn) {
   return fn[Symbol.for('plugin-meta')]
 }
 
+function getPluginName (func) {
+  // let's see if this is a file, and in that case use that
+  // this is common for plugins
+  const cache = require.cache
+  const keys = Object.keys(cache)
+
+  for (var i = 0; i < keys.length; i++) {
+    if (cache[keys[i]].exports === func) {
+      return keys[i]
+    }
+  }
+
+  // if not maybe it's a named function, so use that
+  if (func.name) {
+    return func.name
+  }
+
+  return null
+}
+
+function getFuncPreview (func) {
+  // takes the first two lines of the function if nothing else works
+  return func.toString().split('\n').slice(0, 2).map(s => s.trim()).join(' -- ')
+}
+
+function getDisplayName (fn) {
+  return fn[Symbol.for('fastify.display-name')]
+}
+
 function shouldSkipOverride (fn) {
   return !!fn[Symbol.for('skip-override')]
 }
@@ -71,7 +100,10 @@ function registerPlugin (fn) {
 }
 
 module.exports = {
+  getPluginName,
+  getFuncPreview,
   registeredPlugins,
+  getDisplayName,
   registerPlugin
 }
 

package/lib/reply.js

@@ -86,6 +86,15 @@ Object.defineProperty(Reply.prototype, 'sent', {
   }
 })
 
+Object.defineProperty(Reply.prototype, 'statusCode', {
+  get () {
+    return this.res.statusCode
+  },
+  set (value) {
+    this.code(value)
+  }
+})
+
 Reply.prototype.send = function (payload) {
   if (this[kReplyIsRunningOnErrorHook] === true) {
     throw new FST_ERR_SEND_INSIDE_ONERR()
@@ -93,17 +102,17 @@ Reply.prototype.send = function (payload) {
 
   if (this[kReplySent]) {
     this.log.warn({ err: new FST_ERR_REP_ALREADY_SENT() }, 'Reply already sent')
-    return
+    return this
   }
 
   if (payload instanceof Error || this[kReplyIsError] === true) {
     onErrorHook(this, payload, onSendHook)
-    return
+    return this
   }
 
   if (payload === undefined) {
     onSendHook(this, payload)
-    return
+    return this
   }
 
   var contentType = getHeader(this, 'content-type')
@@ -115,13 +124,13 @@ Reply.prototype.send = function (payload) {
         this[kReplyHeaders]['content-type'] = CONTENT_TYPE.OCTET
       }
       onSendHook(this, payload)
-      return
+      return this
     }
 
     if (hasContentType === false && typeof payload === 'string') {
       this[kReplyHeaders]['content-type'] = CONTENT_TYPE.PLAIN
       onSendHook(this, payload)
-      return
+      return this
     }
   }
 
@@ -133,10 +142,12 @@ Reply.prototype.send = function (payload) {
     }
 
     preserializeHook(this, payload)
-    return
+    return this
   }
 
   onSendHook(this, payload)
+
+  return this
 }
 
 Reply.prototype.getHeader = function (key) {
@@ -237,6 +248,30 @@ Reply.prototype.getResponseTime = function () {
   return responseTime
 }
 
+// Make reply a thenable, so it could be used with async/await.
+// See
+// - https://github.com/fastify/fastify/issues/1864 for the discussions
+// - https://promisesaplus.com/ for the definition of thenable
+// - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then for the signature
+Reply.prototype.then = function (fullfilled, rejected) {
+  if (this.sent) {
+    fullfilled()
+    return
+  }
+
+  eos(this.res, function (err) {
+    // We must not treat ERR_STREAM_PREMATURE_CLOSE as
+    // an error because it is created by eos, not by the stream.
+    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
+      if (rejected) {
+        rejected(err)
+      }
+    } else {
+      fullfilled()
+    }
+  })
+}
+
 function preserializeHook (reply, payload) {
   if (reply.context.preSerialization !== null) {
     onSendHookRunner(