fastify 3.9.2 → 3.12.0

package/lib/errors.js

@@ -200,6 +200,12 @@ const codes = {
     "'%s' is not a valid url component",
     400
   ),
+  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE: createError(
+    'FST_ERR_DEFAULT_ROUTE_INVALID_TYPE',
+    'The defaultRoute type should be a function',
+    500,
+    TypeError
+  ),
 
   /**
    *  again listen when close server

package/lib/headRoute.js

@@ -0,0 +1,31 @@
+'use strict'
+function headRouteOnSendHandler (req, reply, payload, done) {
+  // If payload is undefined
+  if (payload === undefined) {
+    reply.header('content-length', '0')
+    return done(null, null)
+  }
+
+  if (typeof payload.resume === 'function') {
+    payload.on('error', (err) => {
+      reply.log.error({ err }, 'Error on Stream found for HEAD route')
+    })
+    payload.resume()
+    return done(null, null)
+  }
+
+  const size = '' + Buffer.byteLength(payload)
+
+  reply.header('content-length', size)
+
+  done(null, null)
+}
+
+function parseHeadOnSendHandlers (onSendHandlers) {
+  if (onSendHandlers == null) return headRouteOnSendHandler
+  return Array.isArray(onSendHandlers) ? [...onSendHandlers, headRouteOnSendHandler] : [onSendHandlers, headRouteOnSendHandler]
+}
+
+module.exports = {
+  parseHeadOnSendHandlers
+}

package/lib/pluginOverride.js

@@ -7,7 +7,7 @@ const {
   kLogLevel,
   kLogSerializers,
   kHooks,
-  kSchemas,
+  kSchemaController,
   kContentTypeParser,
   kReply,
   kRequest,
@@ -17,9 +17,9 @@ const {
 
 const Reply = require('./reply')
 const Request = require('./request')
+const SchemaController = require('./schema-controller')
 const ContentTypeParser = require('./contentTypeParser')
 const { buildHooks } = require('./hooks')
-const { buildSchemas } = require('./schemas')
 const pluginUtils = require('./pluginUtils')
 
 // Function that runs the encapsulation magic.
@@ -43,9 +43,9 @@ module.exports = function override (old, fn, opts) {
   instance[kHooks] = buildHooks(instance[kHooks])
   instance[kRoutePrefix] = buildRoutePrefix(instance[kRoutePrefix], opts.prefix)
   instance[kLogLevel] = opts.logLevel || instance[kLogLevel]
-  instance[kSchemas] = buildSchemas(old[kSchemas])
-  instance.getSchema = instance[kSchemas].getSchema.bind(instance[kSchemas])
-  instance.getSchemas = instance[kSchemas].getSchemas.bind(instance[kSchemas])
+  instance[kSchemaController] = SchemaController.buildSchemaController(old[kSchemaController])
+  instance.getSchema = instance[kSchemaController].getSchema.bind(instance[kSchemaController])
+  instance.getSchemas = instance[kSchemaController].getSchemas.bind(instance[kSchemaController])
   instance[pluginUtils.registeredPlugins] = Object.create(instance[pluginUtils.registeredPlugins])
   instance[kPluginNameChain] = [pluginUtils.getPluginName(fn) || pluginUtils.getFuncPreview(fn)]
 

package/lib/pluginUtils.js

@@ -67,21 +67,22 @@ function checkDecorators (fn) {
   const meta = getMeta(fn)
   if (!meta) return
 
-  const decorators = meta.decorators
+  const { decorators, name } = meta
   if (!decorators) return
 
-  if (decorators.fastify) _checkDecorators.call(this, 'Fastify', decorators.fastify)
-  if (decorators.reply) _checkDecorators.call(this[kReply], 'Reply', decorators.reply)
-  if (decorators.request) _checkDecorators.call(this[kRequest], 'Request', decorators.request)
+  if (decorators.fastify) _checkDecorators.call(this, 'Fastify', decorators.fastify, name)
+  if (decorators.reply) _checkDecorators.call(this[kReply], 'Reply', decorators.reply, name)
+  if (decorators.request) _checkDecorators.call(this[kRequest], 'Request', decorators.request, name)
 }
 
-function _checkDecorators (instance, decorators) {
+function _checkDecorators (instance, decorators, name) {
   assert(Array.isArray(decorators), 'The decorators should be an array of strings')
 
   decorators.forEach(decorator => {
+    const withPluginName = typeof name === 'string' ? ` required by '${name}'` : ''
     assert(
       instance === 'Fastify' ? decorator in this : decorator in this.prototype,
-      `The decorator '${decorator}' is not present in ${instance}`
+      `The decorator '${decorator}'${withPluginName} is not present in ${instance}`
     )
   })
 }

package/lib/reply.js

@@ -104,6 +104,11 @@ Object.defineProperties(Reply.prototype, {
   }
 })
 
+Reply.prototype.hijack = function () {
+  this[kReplySent] = true
+  return this
+}
+
 Reply.prototype.send = function (payload) {
   if (this[kReplyIsRunningOnErrorHook] === true) {
     throw new FST_ERR_SEND_INSIDE_ONERR()
@@ -144,7 +149,12 @@ Reply.prototype.send = function (payload) {
   }
 
   if (this[kReplySerializer] !== null) {
-    payload = this[kReplySerializer](payload)
+    if (typeof payload !== 'string') {
+      preserializeHook(this, payload)
+      return this
+    } else {
+      payload = this[kReplySerializer](payload)
+    }
 
   // 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) {
@@ -342,7 +352,9 @@ function preserializeHookEnd (err, request, reply, payload) {
     return
   }
 
-  if (reply.context && reply.context[kReplySerializerDefault]) {
+  if (reply[kReplySerializer] !== null) {
+    payload = reply[kReplySerializer](payload)
+  } else if (reply.context && reply.context[kReplySerializerDefault]) {
     payload = reply.context[kReplySerializerDefault](payload, reply.raw.statusCode)
   } else {
     payload = serialize(reply.context, payload, reply.raw.statusCode)

package/lib/reqIdGenFactory.js

@@ -1,6 +1,11 @@
 'use strict'
 
 module.exports = function () {
+  // 2,147,483,647 (2^31 − 1) stands for max SMI value (an internal optimization of V8).
+  // With this upper bound, if you'll be generating 1k ids/sec, you're going to hit it in ~25 days.
+  // This is very likely to happen in real-world applications, hence the limit is enforced.
+  // Growing beyond this value will make the id generation slower and cause a deopt.
+  // In the worst cases, it will become a float, losing accuracy.
   const maxInt = 2147483647
   let nextReqId = 0
   return function genReqId (req) {

package/lib/request.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const proxyAddr = require('proxy-addr')
+const proxyAddr = require('@fastify/proxy-addr')
 const semver = require('semver')
 const warning = require('./warnings')
 

package/lib/route.js

@@ -6,10 +6,7 @@ const handleRequest = require('./handleRequest')
 const { hookRunner, hookIterator, lifecycleHooks } = require('./hooks')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
 const { normalizeSchema } = require('./schemas')
-const {
-  ValidatorSelector,
-  SerializerCompiler: buildDefaultSerializer
-} = require('./schema-compilers')
+const { parseHeadOnSendHandlers } = require('./headRoute')
 const warning = require('./warnings')
 
 const {
@@ -19,7 +16,8 @@ const {
 
 const {
   FST_ERR_SCH_VALIDATION_BUILD,
-  FST_ERR_SCH_SERIALIZATION_BUILD
+  FST_ERR_SCH_SERIALIZATION_BUILD,
+  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE
 } = require('./errors')
 
 const {
@@ -28,10 +26,8 @@ const {
   kLogSerializers,
   kHooks,
   kHooksDeprecatedPreParsing,
-  kSchemas,
+  kSchemaController,
   kOptions,
-  kValidatorCompiler,
-  kSerializerCompiler,
   kContentTypeParser,
   kReply,
   kReplySerializerDefault,
@@ -59,7 +55,7 @@ function buildRouting (options) {
   let disableRequestLogging
   let ignoreTrailingSlash
   let return503OnClosing
-  let buildPerformanceValidator
+  let globalExposeHeadRoutes
 
   let closing = false
 
@@ -72,6 +68,7 @@ function buildRouting (options) {
       setupResponseListeners = fastifyArgs.setupResponseListeners
       throwIfAlreadyStarted = fastifyArgs.throwIfAlreadyStarted
 
+      globalExposeHeadRoutes = options.exposeHeadRoutes
       requestIdHeader = options.requestIdHeader
       querystringParser = options.querystringParser
       requestIdLogLabel = options.requestIdLogLabel
@@ -79,11 +76,20 @@ function buildRouting (options) {
       disableRequestLogging = options.disableRequestLogging
       ignoreTrailingSlash = options.ignoreTrailingSlash
       return503OnClosing = Object.prototype.hasOwnProperty.call(options, 'return503OnClosing') ? options.return503OnClosing : true
-      buildPerformanceValidator = ValidatorSelector()
     },
     routing: router.lookup.bind(router), // router func to find the right handler to call
     route, // configure a route in the fastify instance
     prepareRoute,
+    getDefaultRoute: function () {
+      return router.defaultRoute
+    },
+    setDefaultRoute: function (defaultRoute) {
+      if (typeof defaultRoute !== 'function') {
+        throw new FST_ERR_DEFAULT_ROUTE_INVALID_TYPE()
+      }
+
+      router.defaultRoute = defaultRoute
+    },
     routeHandler,
     closeRoutes: () => { closing = true },
     printRoutes: router.prettyPrint.bind(router)
@@ -109,6 +115,7 @@ function buildRouting (options) {
     options = Object.assign({}, options, {
       method,
       url,
+      path: url,
       handler: handler || (options && options.handler)
     })
 
@@ -149,34 +156,41 @@ function buildRouting (options) {
 
     this.after((notHandledErr, done) => {
       const path = opts.url || opts.path
-      if (path === '/' && prefix.length > 0) {
+      if (path === '/' && prefix.length > 0 && opts.method !== 'HEAD') {
         switch (opts.prefixTrailingSlash) {
           case 'slash':
-            afterRouteAdded.call(this, path, notHandledErr, done)
+            afterRouteAdded.call(this, { path }, notHandledErr, done)
             break
           case 'no-slash':
-            afterRouteAdded.call(this, '', notHandledErr, done)
+            afterRouteAdded.call(this, { path: '' }, notHandledErr, done)
             break
           case 'both':
           default:
-            afterRouteAdded.call(this, '', notHandledErr, done)
+            afterRouteAdded.call(this, { path: '' }, notHandledErr, done)
             // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
             if (ignoreTrailingSlash !== true) {
-              afterRouteAdded.call(this, path, notHandledErr, done)
+              afterRouteAdded.call(this, { path, prefixing: true }, notHandledErr, done)
             }
         }
       } else if (path[0] === '/' && prefix.endsWith('/')) {
         // Ensure that '/prefix/' + '/route' gets registered as '/prefix/route'
-        afterRouteAdded.call(this, path.slice(1), notHandledErr, done)
+        afterRouteAdded.call(this, { path: path.slice(1) }, notHandledErr, done)
       } else {
-        afterRouteAdded.call(this, path, notHandledErr, done)
+        afterRouteAdded.call(this, { path }, notHandledErr, done)
       }
     })
 
     // chainable api
     return this
 
-    function afterRouteAdded (path, notHandledErr, done) {
+    /**
+     * This function sets up a new route, its log serializers, and triggers route hooks.
+     *
+     * @param {object} opts contains route `path` and `prefixing` flag which indicates if this is an auto-prefixed route, e.g. `fastify.register(routes, { prefix: '/foo' })`
+     * @param {*} notHandledErr error object to be passed back to the original invoker
+     * @param {*} done callback
+     */
+    function afterRouteAdded ({ path, prefixing = false }, notHandledErr, done) {
       const url = prefix + path
 
       opts.url = url
@@ -193,19 +207,23 @@ function buildRouting (options) {
         opts.attachValidation = false
       }
 
+      if (prefixing === false) {
       // run 'onRoute' hooks
-      for (const hook of this[kHooks].onRoute) {
-        try {
-          hook.call(this, opts)
-        } catch (error) {
-          done(error)
-          return
+        for (const hook of this[kHooks].onRoute) {
+          try {
+            hook.call(this, opts)
+          } catch (error) {
+            done(error)
+            return
+          }
         }
       }
 
-      const config = opts.config || {}
-      config.url = url
-      config.method = opts.method
+      const config = {
+        ...opts.config,
+        url,
+        method: opts.method
+      }
 
       const context = new Context(
         opts.schema,
@@ -223,6 +241,8 @@ function buildRouting (options) {
         opts.schemaErrorFormatter || this[kSchemaErrorFormatter]
       )
 
+      const headRouteExists = router.find('HEAD', path) != null
+
       try {
         router.on(opts.method, opts.url, { version: opts.version }, routeHandler, context)
       } catch (err) {
@@ -230,8 +250,19 @@ function buildRouting (options) {
         return
       }
 
+      const { exposeHeadRoute } = opts
+      const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
+      const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
+
+      if (shouldExposeHead && options.method === 'GET' && !headRouteExists) {
+        const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
+        prepareRoute.call(this, 'HEAD', path, { ...opts, onSend: onSendHandlers })
+      } else if (headRouteExists && exposeHeadRoute) {
+        warning.emit('FSTDEP007')
+      }
+
       // It can happen that a user registers a plugin with some hooks *after*
-      // the route registration. To be sure to also load also those hooks,
+      // the route registration. To be sure to also load those hooks,
       // we must listen for the avvio's preReady event, and update the context object accordingly.
       avvio.once('preReady', () => {
         for (const hook of lifecycleHooks) {
@@ -261,27 +292,21 @@ function buildRouting (options) {
         if (opts.schema) {
           context.schema = normalizeSchema(context.schema)
 
-          const schemaBucket = this[kSchemas]
-          if (!opts.validatorCompiler && (
-            !this[kValidatorCompiler] ||
-            (this[kValidatorCompiler] && schemaBucket.hasNewSchemas()))) {
-            // if the instance doesn't have a validator, build the default one for the single fastify instance
-            this.setValidatorCompiler(buildPerformanceValidator(schemaBucket.getSchemas(), this[kOptions].ajv))
+          const schemaController = this[kSchemaController]
+          if (!opts.validatorCompiler) {
+            schemaController.setupValidator(this[kOptions])
           }
           try {
-            compileSchemasForValidation(context, opts.validatorCompiler || this[kValidatorCompiler])
+            compileSchemasForValidation(context, opts.validatorCompiler || schemaController.validatorCompiler)
           } catch (error) {
             throw new FST_ERR_SCH_VALIDATION_BUILD(opts.method, url, error.message)
           }
 
-          if (opts.schema.response &&
-            !opts.serializerCompiler &&
-            (!this[kSerializerCompiler] || (this[kSerializerCompiler] && schemaBucket.hasNewSchemas()))) {
-            // if the instance doesn't have a serializer, build the default one for the single fastify instance
-            this.setSerializerCompiler(buildDefaultSerializer(schemaBucket.getSchemas()))
+          if (opts.schema.response && !opts.serializerCompiler) {
+            schemaController.setupSerializer(this[kOptions])
           }
           try {
-            compileSchemasForSerialization(context, opts.serializerCompiler || this[kSerializerCompiler])
+            compileSchemasForSerialization(context, opts.serializerCompiler || schemaController.serializerCompiler)
           } catch (error) {
             throw new FST_ERR_SCH_SERIALIZATION_BUILD(opts.method, url, error.message)
           }

package/lib/schema-compilers.js

@@ -43,9 +43,12 @@ function ValidatorCompiler (externalSchemas, options, cache) {
     }
   }
 
-  Object.values(externalSchemas).forEach(s => ajv.addSchema(s))
+  const sourceSchemas = Object.values(externalSchemas)
+  for (const extSchema of sourceSchemas) {
+    ajv.addSchema(extSchema)
+  }
 
-  return ({ schema, method, url, httpPart }) => {
+  return function ({ schema, method, url, httpPart }) {
     return ajv.compile(schema)
   }
 }
@@ -56,6 +59,5 @@ function SerializerCompiler (externalSchemas) {
   }
 }
 
-module.exports.ValidatorCompiler = ValidatorCompiler
 module.exports.ValidatorSelector = ValidatorSelector
 module.exports.SerializerCompiler = SerializerCompiler

package/lib/schema-controller.js

@@ -0,0 +1,106 @@
+'use strict'
+
+const { buildSchemas } = require('./schemas')
+const {
+  ValidatorSelector,
+  SerializerCompiler: buildDefaultSerializer
+} = require('./schema-compilers')
+
+/**
+ * Called at every fastify context that is being created.
+ * @param {object} parentSchemaCtrl: the SchemaController instance of the Fastify parent context
+ * @return {object}:a new SchemaController
+ */
+function buildSchemaController (parentSchemaCtrl, opts) {
+  if (parentSchemaCtrl) {
+    return new SchemaController(parentSchemaCtrl, opts)
+  }
+
+  const option = Object.assign({
+    bucket: buildSchemas,
+    compilersFactory: {
+      buildValidator: ValidatorSelector(),
+      buildSerializer: buildDefaultSerializer
+    }
+  }, opts)
+
+  return new SchemaController(undefined, option)
+}
+
+class SchemaController {
+  constructor (parent, options) {
+    this.opts = options || (parent && parent.opts)
+    this.addedSchemas = false
+
+    this.compilersFactory = this.opts.compilersFactory
+
+    if (parent) {
+      this.schemaBucket = this.opts.bucket(parent.getSchemas())
+      this.validatorCompiler = parent.getValidatorCompiler()
+      this.serializerCompiler = parent.getSerializerCompiler()
+      this.parent = parent
+    } else {
+      this.schemaBucket = this.opts.bucket()
+    }
+  }
+
+  // Bucket interface
+  add (schema) {
+    this.addedSchemas = true
+    return this.schemaBucket.add(schema)
+  }
+
+  getSchema (schemaId) {
+    return this.schemaBucket.getSchema(schemaId)
+  }
+
+  getSchemas () {
+    return this.schemaBucket.getSchemas()
+  }
+
+  // Schema Controller compilers holder
+  setValidatorCompiler (validatorCompiler) {
+    this.validatorCompiler = validatorCompiler
+  }
+
+  setSerializerCompiler (serializerCompiler) {
+    this.serializerCompiler = serializerCompiler
+  }
+
+  getValidatorCompiler () {
+    return this.validatorCompiler || (this.parent && this.parent.getValidatorCompiler())
+  }
+
+  getSerializerCompiler () {
+    return this.serializerCompiler || (this.parent && this.parent.getSerializerCompiler())
+  }
+
+  /**
+   * This method will be called when a validator must be setup.
+   * Do not setup the compiler more than once
+   * @param {object} serverOptions: the fastify server option
+   */
+  setupValidator (serverOption) {
+    const isReady = this.validatorCompiler !== undefined && !this.addedSchemas
+    if (isReady) {
+      return
+    }
+    this.validatorCompiler = this.compilersFactory.buildValidator(this.schemaBucket.getSchemas(), serverOption.ajv)
+  }
+
+  /**
+   * This method will be called when a serializer must be setup.
+   * Do not setup the compiler more than once
+   * @param {object} serverOptions: the fastify server option
+   */
+  setupSerializer (serverOption) {
+    const isReady = this.serializerCompiler !== undefined && !this.addedSchemas
+    if (isReady) {
+      return
+    }
+    this.serializerCompiler = this.compilersFactory.buildSerializer(this.schemaBucket.getSchemas())
+  }
+}
+
+module.exports = SchemaController
+module.exports.buildSchemaController = buildSchemaController

package/lib/schemas.js

@@ -10,13 +10,14 @@ const {
   FST_ERR_SCH_DUPLICATE
 } = require('./errors')
 
-function Schemas () {
-  this.store = {}
-  this.newSchemasAdded = false
+const SCHEMAS_SOURCE = ['params', 'body', 'querystring', 'query', 'headers']
+
+function Schemas (initStore) {
+  this.store = initStore || {}
 }
 
 Schemas.prototype.add = function (inputSchema) {
-  const schema = fastClone((inputSchema.isFluentSchema || inputSchema[kFluentSchema])
+  const schema = fastClone((inputSchema.isFluentSchema || inputSchema.isFluentJSONSchema || inputSchema[kFluentSchema])
     ? inputSchema.valueOf()
     : inputSchema
   )
@@ -32,7 +33,6 @@ Schemas.prototype.add = function (inputSchema) {
   }
 
   this.store[id] = schema
-  this.newSchemasAdded = true
 }
 
 Schemas.prototype.getSchemas = function () {
@@ -43,10 +43,6 @@ Schemas.prototype.getSchema = function (schemaId) {
   return this.store[schemaId]
 }
 
-Schemas.prototype.hasNewSchemas = function () {
-  return this.newSchemasAdded
-}
-
 function normalizeSchema (routeSchemas) {
   if (routeSchemas[kSchemaVisited]) {
     return routeSchemas
@@ -87,9 +83,10 @@ function normalizeSchema (routeSchemas) {
   }
 
   if (routeSchemas.response) {
-    Object.keys(routeSchemas.response).forEach(code => {
+    const httpCodes = Object.keys(routeSchemas.response)
+    for (const code of httpCodes) {
       routeSchemas.response[code] = getSchemaAnyway(routeSchemas.response[code])
-    })
+    }
   }
 
   routeSchemas[kSchemaVisited] = true
@@ -97,18 +94,19 @@ function normalizeSchema (routeSchemas) {
 }
 
 function generateFluentSchema (schema) {
-  ;['params', 'body', 'querystring', 'query', 'headers'].forEach(key => {
+  for (const key of SCHEMAS_SOURCE) {
     if (schema[key] && (schema[key].isFluentSchema || schema[key][kFluentSchema])) {
       schema[key] = schema[key].valueOf()
     }
-  })
+  }
 
   if (schema.response) {
-    Object.keys(schema.response).forEach(code => {
+    const httpCodes = Object.keys(schema.response)
+    for (const code of httpCodes) {
       if (schema.response[code].isFluentSchema || schema.response[code][kFluentSchema]) {
         schema.response[code] = schema.response[code].valueOf()
       }
-    })
+    }
   }
 }
 
@@ -123,15 +121,7 @@ function getSchemaAnyway (schema) {
   return schema
 }
 
-function buildSchemas (s) {
-  const schema = new Schemas()
-  Object.values(s.getSchemas()).forEach(_ => schema.add(_))
-  schema.newSchemasAdded = false
-  return schema
-}
-
 module.exports = {
-  Schemas,
-  buildSchemas,
+  buildSchemas (initStore) { return new Schemas(initStore) },
   normalizeSchema
 }

package/lib/server.js

@@ -17,6 +17,7 @@ function createServer (options, httpHandler) {
   } else if (options.https) {
     if (options.http2) {
       server = http2().createSecureServer(options.https, httpHandler)
+      server.on('session', sessionTimeout(options.http2SessionTimeout))
     } else {
       server = https.createServer(options.https, httpHandler)
       server.keepAliveTimeout = options.keepAliveTimeout

package/lib/symbols.js

@@ -9,15 +9,13 @@ const keys = {
   kLogSerializers: Symbol('fastify.logSerializers'),
   kHooks: Symbol('fastify.hooks'),
   kHooksDeprecatedPreParsing: Symbol('fastify.hooks.DeprecatedPreParsing'),
-  kSchemas: Symbol('fastify.schemas'),
+  kSchemaController: Symbol('fastify.schemaController'),
   kSchemaHeaders: Symbol('headers-schema'),
   kSchemaParams: Symbol('params-schema'),
   kSchemaQuerystring: Symbol('querystring-schema'),
   kSchemaBody: Symbol('body-schema'),
   kSchemaResponse: Symbol('response-schema'),
-  kValidatorCompiler: Symbol('fastify.validatorCompiler'),
   kSchemaErrorFormatter: Symbol('fastify.schemaErrorFormatter'),
-  kSerializerCompiler: Symbol('fastify.serializerCompiler'),
   kReplySerializerDefault: Symbol('fastify.replySerializerDefault'),
   kContentTypeParser: Symbol('fastify.contentTypeParser'),
   kReply: Symbol('fastify.Reply'),

package/lib/warnings.js

@@ -23,4 +23,6 @@ warning.create('FastifyDeprecation', 'FSTDEP005', 'You are accessing the depreca
 
 warning.create('FastifyDeprecation', 'FSTDEP006', 'You are decorating Request/Reply with a reference type. This reference is shared amongst all requests. Use onRequest hook instead. Property: %s')
 
+warning.create('FastifyDeprecation', 'FSTDEP007', 'You are trying to set a HEAD route using "exposeHeadRoute" route flag when a sibling route is already set. See documentation for more info.')
+
 module.exports = warning

package/lib/wrapThenable.js

@@ -30,10 +30,11 @@ function wrapThenable (thenable, reply) {
       reply.log.error({ err: new FST_ERR_PROMISE_NOT_FULFILLED() }, "Promise may not be fulfilled with 'undefined' when statusCode is not 204")
     }
   }, function (err) {
-    if (reply[kReplySentOverwritten] === true) {
+    if (reply[kReplySentOverwritten] === true || reply.sent === true) {
       reply.log.error({ err }, 'Promise errored, but reply.sent = true was set')
       return
     }
+
     reply[kReplySent] = false
     reply[kReplyIsError] = true
     reply.send(err)