fastify 3.21.1 → 3.21.5

package/.taprc

@@ -3,3 +3,4 @@ jsx: false
 flow: false
 check-coverage: true
 coverage: true
+node-arg: --allow-natives-syntax

package/README.md

@@ -1,5 +1,7 @@
 <div align="center">
-<img src="https://github.com/fastify/graphics/raw/HEAD/fastify-landscape-outlined.svg" width="650" height="auto"/>
+  <a href="https://fastify.io/">
+    <img src="https://github.com/fastify/graphics/raw/HEAD/fastify-landscape-outlined.svg" width="650" height="auto"/>
+  </a>
 </div>
 
 <div align="center">

package/docs/Recommendations.md

@@ -238,7 +238,7 @@ server {
 }
 ```
 
-[nginx]: http://nginx.org/
+[nginx]: https://nginx.org/
 
 ## Kubernetes
 <a id="kubernetes"></a>

package/docs/Reply.md

@@ -335,7 +335,7 @@ If you pass to *send* an object that is an instance of *Error*, Fastify will aut
 }
 ```
 
-You can add some custom property to the Error object, such as `headers`, that will be used to enhance the HTTP response.<br>
+You can add custom properties to the Error object, such as `headers`, that will be used to enhance the HTTP response.<br>
 *Note: If you are passing an error to `send` and the statusCode is less than 400, Fastify will automatically set it at 500.*
 
 Tip: you can simplify errors by using the [`http-errors`](https://npm.im/http-errors) module or [`fastify-sensible`](https://github.com/fastify/fastify-sensible) plugin to generate errors:
@@ -376,7 +376,7 @@ fastify.get('/', {
 })
 ```
 
-If you want to completely customize the error handling, check out [`setErrorHandler`](Server.md#seterrorhandler) API.<br>
+If you want to customize error handling, check out [`setErrorHandler`](Server.md#seterrorhandler) API.<br>
 *Note: you are responsible for logging when customizing the error handler*
 
 API:

package/docs/Request.md

@@ -3,32 +3,32 @@
 ## Request
 The first parameter of the handler function is `Request`.<br>
 Request is a core Fastify object containing the following fields:
-- `query` - the parsed querystring
+- `query` - the parsed querystring, its format is specified by [`querystringParser`](Server.md#querystringParser)
 - `body` - the body
 - `params` - the params matching the URL
 - [`headers`](#headers) - the headers getter and setter
 - `raw` - the incoming HTTP request from Node core
 - `req` *(deprecated, use `.raw` instead)* - the incoming HTTP request from Node core
 - `server` - The Fastify server instance, scoped to the current [encapsulation context](Encapsulation.md)
-- `id` - the request id
+- `id` - the request ID
 - `log` - the logger instance of the incoming request
 - `ip` - the IP address of the incoming request
 - `ips` - an array of the IP addresses, ordered from closest to furthest, in the `X-Forwarded-For` header of the incoming request (only when the [`trustProxy`](Server.md#factory-trust-proxy) option is enabled)
-- `hostname` - the hostname of the incoming request (derived from `X-Forwarded-Host` header when the [`trustProxy`](Server.md#factory-trust-proxy) option is enabled)
+- `hostname` - the host of the incoming request (derived from `X-Forwarded-Host` header when the [`trustProxy`](Server.md#factory-trust-proxy) option is enabled). For HTTP/2 compatibility it returns `:authority` if no host header exists.
 - `protocol` - the protocol of the incoming request (`https` or `http`)
 - `method` - the method of the incoming request
-- `url` - the url of the incoming request
+- `url` - the URL of the incoming request
 - `routerMethod` - the method defined for the router that is handling the request
 - `routerPath` - the path pattern defined for the router that is handling the request
 - `is404` - true if request is being handled by 404 handler, false if it is not
 - `connection` - Deprecated, use `socket` instead. The underlying connection of the incoming request.
 - `socket` - the underlying connection of the incoming request
-- `context` - A Fastify internal object. You should not use it directly or modify it. It is usefull to access one special key:
+- `context` - A Fastify internal object. You should not use it directly or modify it. It is useful to access one special key:
   - `context.config` - The route [`config`](Routes.md#routes-config) object.
 
 ### Headers
 
-The `request.headers` is a getter that return an Object with the headers of the incoming request.
+The `request.headers` is a getter that returns an Object with the headers of the incoming request.
 You can set custom headers like this:
 
 ```js

package/docs/Server.md

@@ -110,7 +110,7 @@ fastify.get('/bar', function (req, reply) {
 
 <a name="factory-max-param-length"></a>
 ### `maxParamLength`
-You can set a custom length for parameters in parametric (standard, regex, and multi) routes by using `maxParamLength` option, the default value is 100 characters.<br>
+You can set a custom length for parameters in parametric (standard, regex, and multi) routes by using `maxParamLength` option; the default value is 100 characters.<br>
 This can be useful especially if you have some regex based route, protecting you against [DoS attacks](https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS).<br>
 *If the maximum length limit is reached, the not found route will be invoked.*
 
@@ -167,7 +167,7 @@ are not present on the object, they will be added accordingly:
     * `level`: the minimum logging level. If not set, it will be set to `'info'`.
     * `serializers`: a hash of serialization functions. By default, serializers
       are added for `req` (incoming request objects), `res` (outgoing response
-      objets), and `err` (standard `Error` objects). When a log method receives
+      objects), and `err` (standard `Error` objects). When a log method receives
       an object with any of these properties then the respective serializer will
       be used for that property. For example:
         ```js
@@ -228,7 +228,7 @@ Please note that this setting will also disable an error log written by the defa
 <a name="custom-http-server"></a>
 ### `serverFactory`
 You can pass a custom HTTP server to Fastify by using the `serverFactory` option.<br/>
-`serverFactory` is a function that takes an `handler` parameter, which takes the `request` and `response` objects as parameters, and an options object, which is the same you have passed to Fastify.
+`serverFactory` is a function that takes a `handler` parameter, which takes the `request` and `response` objects as parameters, and an options object, which is the same you have passed to Fastify.
 
 ```js
 const serverFactory = (handler, opts) => {
@@ -255,7 +255,7 @@ Internally Fastify uses the API of Node core HTTP server, so if you are using a
 
 + Default: `true`
 
-Internally, and by default, Fastify will automatically infer the root properties of JSON Schemas if it doesn't find valid root properties according to the JSON Schema spec. If you wish to implement your own schema validation compiler, for example: to parse schemas as JTD instead of JSON Schema, then you can explicitly set this option to `false` to make sure the schemas you receive are unmodified and are not being treated internally as JSON Schema.
+Internally, and by default, Fastify will automatically infer the root properties of JSON Schemas if it does not find valid root properties according to the JSON Schema spec. If you wish to implement your own schema validation compiler, for example: to parse schemas as JTD instead of JSON Schema, then you can explicitly set this option to `false` to make sure the schemas you receive are unmodified and are not being treated internally as JSON Schema.
 
 ```js
 const AjvJTD = require('ajv/dist/jtd'/* only valid for AJV v7+ */)
@@ -298,6 +298,8 @@ fastify.get('/user/:username', (request, reply) => {
 Please note that setting this option to `false` goes against
 [RFC3986](https://tools.ietf.org/html/rfc3986#section-6.2.2.1).
 
+Also note, this setting will not affect query strings. If you want to change the way query strings are handled take a look at [`querystringParser`](./Server.md#querystringParser).
+
 <a name="factory-request-id-header"></a>
 ### `requestIdHeader`
 
@@ -333,7 +335,7 @@ const fastify = require('fastify')({
 <a name="factory-trust-proxy"></a>
 ### `trustProxy`
 
-By enabling the `trustProxy` option, Fastify will have knowledge that it's sitting behind a proxy and that the `X-Forwarded-*` header fields may be trusted, which otherwise may be easily spoofed.
+By enabling the `trustProxy` option, Fastify will know that it is sitting behind a proxy and that the `X-Forwarded-*` header fields may be trusted, which otherwise may be easily spoofed.
 
 ```js
 const fastify = Fastify({ trustProxy: true })
@@ -388,6 +390,17 @@ const fastify = require('fastify')({
 })
 ```
 
+You can also use Fastify's default parser but change some handling behaviour, like the example below for case insensitive keys and values:
+
+```js
+const querystring = require('querystring')
+const fastify = require('fastify')({
+  querystringParser: str => querystring.parse(str.toLowerCase())
+})
+```
+
+Note, if you only want the keys (and not the values) to be case insensitive we recommend using a custom parser to convert only the keys to lowercase.
+
 <a name="exposeHeadRoutes"></a>
 ### `exposeHeadRoutes`
 
@@ -497,7 +510,7 @@ increased to fit the use case. Node core defaults this to `0`. `
 + Default: `null`
 
 Fastify provides default error handlers for the most common use cases.
-Using this option it is possible to override one or more of those handlers with custom code.
+It is possible to override one or more of those handlers with custom code using this option.
 
 *Note: Only `FST_ERR_BAD_URL` is implemented at the moment.*
 
@@ -519,7 +532,7 @@ const fastify = require('fastify')({
 
 Set a [clientErrorHandler](https://nodejs.org/api/http.html#http_event_clienterror) that listens to `error` events emitted by client connections and responds with a `400`.
 
-Using this option it is possible to override the default `clientErrorHandler`.
+It is possible to override the default `clientErrorHandler` using this option.
 
 + Default:
 ```js
@@ -649,7 +662,7 @@ fastify.ready().then(() => {
 
 <a name="listen"></a>
 #### listen
-Starts the server on the given port after all the plugins are loaded, internally waits for the `.ready()` event. The callback is the same as the Node core. By default, the server will listen on the address resolved by `localhost` when no specific address is provided (`127.0.0.1` or `::1` depending on the operating system). If listening on any available interface is desired, then specifying `0.0.0.0` for the address will listen on all IPv4 address. Using `::` for the address will listen on all IPv6 addresses, and, depending on OS, may also listen on all IPv4 addresses. Be careful when deciding to listen on all interfaces; it comes with inherent [security risks](https://web.archive.org/web/20170831174611/https://snyk.io/blog/mongodb-hack-and-secure-defaults/).
+Starts the server on the given port after all the plugins are loaded, internally waits for the `.ready()` event. The callback is the same as the Node core. By default, the server will listen on the address resolved by `localhost` when no specific address is provided (`127.0.0.1` or `::1` depending on the operating system). If listening on any available interface is desired, then specifying `0.0.0.0` for the address will listen on all IPv4 addresses. Using `::` for the address will listen on all IPv6 addresses and, depending on OS, may also listen on all IPv4 addresses. Be careful when deciding to listen on all interfaces; it comes with inherent [security risks](https://web.archive.org/web/20170831174611/https://snyk.io/blog/mongodb-hack-and-secure-defaults/).
 
 ```js
 fastify.listen(3000, (err, address) => {
@@ -962,15 +975,15 @@ const fastify = Fastify({
     },
 
     /**
-     * The compilers factory let you to fully control the validator and serializer
+     * The compilers factory let you fully control the validator and serializer
      * in the Fastify's lifecycle, providing the encapsulation to your compilers.
      */
     compilersFactory: {
       /**
        * This factory is called whenever a new validator instance is needed.
-       * It may be called whenever `fastify.register()` is called only if new schemas has been added to the
+       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
        * encapsulation context.
-       * It may receive as input the schemas of the parent context if some schemas has been added.
+       * It may receive as input the schemas of the parent context if some schemas have been added.
        * @param {object} externalSchemas these schemas will be returned by the `bucket.getSchemas()`. Needed to resolve the external references $ref.
        * @param {object} ajvServerOption the server `ajv` options to build your compilers accordingly 
        */
@@ -985,9 +998,9 @@ const fastify = Fastify({
 
       /**
        * This factory is called whenever a new serializer instance is needed.
-       * It may be called whenever `fastify.register()` is called only if new schemas has been added to the
+       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
        * encapsulation context.
-       * It may receive as input the schemas of the parent context if some schemas has been added.
+       * It may receive as input the schemas of the parent context if some schemas have been added.
        * @param {object} externalSchemas these schemas will be returned by the `bucket.getSchemas()`. Needed to resolve the external references $ref.
        * @param {object} serializerOptsServerOption the server `serializerOpts` options to build your compilers accordingly 
        */
@@ -1006,7 +1019,7 @@ const fastify = Fastify({
 ##### Ajv 8 as default schema validator
 
 Ajv 8 is the evolution of Ajv 6, and it has a lot of improvements and new features.
-To use the new Ajv 8 features such as JTD or the Standalone mode, refers to the [`@fastify/ajv-compiler` documentation](https://github.com/fastify/ajv-compiler#usage).
+To use the new Ajv 8 features such as JTD or the Standalone mode, refer to the [`@fastify/ajv-compiler` documentation](https://github.com/fastify/ajv-compiler#usage).
 
 To use Ajv 8 as default schema validator, you can use the following code:
 
@@ -1031,7 +1044,7 @@ const app = fastify({
   }
 })
 
-// Done! You can now use Ajv 8 options and keywords into your schemas!
+// Done! You can now use Ajv 8 options and keywords in your schemas!
 ```
 
 <a name="set-not-found-handler"></a>

package/lib/decorate.js

@@ -22,21 +22,35 @@ function decorate (instance, name, fn, dependencies) {
     throw new FST_ERR_DEC_ALREADY_PRESENT(name)
   }
 
-  if (dependencies) {
-    if (!Array.isArray(dependencies)) {
-      throw new FST_ERR_DEC_DEPENDENCY_INVALID_TYPE(name)
-    }
+  checkDependencies(instance, name, dependencies)
 
-    checkDependencies(instance, dependencies)
+  if (fn && (typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
+    Object.defineProperty(instance, name, {
+      get: fn.getter,
+      set: fn.setter
+    })
+  } else {
+    instance[name] = fn
   }
+}
+
+function decorateConstructor (konstructor, name, fn, dependencies) {
+  const instance = konstructor.prototype
+  if (instance.hasOwnProperty(name) || konstructor.props.includes(name)) {
+    throw new FST_ERR_DEC_ALREADY_PRESENT(name)
+  }
+
+  checkDependencies(instance, name, dependencies)
 
   if (fn && (typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
     Object.defineProperty(instance, name, {
       get: fn.getter,
       set: fn.setter
     })
-  } else {
+  } else if (fn !== undefined && fn !== null) {
     instance[name] = fn
+  } else {
+    konstructor.props.push(name)
   }
 }
 
@@ -61,14 +75,24 @@ function checkExistence (instance, name) {
 }
 
 function checkRequestExistence (name) {
+  if (name && this[kRequest].props.includes(name)) return true
   return checkExistence(this[kRequest].prototype, name)
 }
 
 function checkReplyExistence (name) {
+  if (name && this[kReply].props.includes(name)) return true
   return checkExistence(this[kReply].prototype, name)
 }
 
-function checkDependencies (instance, deps) {
+function checkDependencies (instance, name, deps) {
+  if (deps === undefined || deps === null) {
+    return
+  }
+
+  if (!Array.isArray(deps)) {
+    throw new FST_ERR_DEC_DEPENDENCY_INVALID_TYPE(name)
+  }
+
   // eslint-disable-next-line no-var
   for (var i = 0; i !== deps.length; ++i) {
     if (!checkExistence(instance, deps[i])) {
@@ -80,14 +104,14 @@ function checkDependencies (instance, deps) {
 function decorateReply (name, fn, dependencies) {
   assertNotStarted(this, name)
   checkReferenceType(name, fn)
-  decorate(this[kReply].prototype, name, fn, dependencies)
+  decorateConstructor(this[kReply], name, fn, dependencies)
   return this
 }
 
 function decorateRequest (name, fn, dependencies) {
   assertNotStarted(this, name)
   checkReferenceType(name, fn)
-  decorate(this[kRequest].prototype, name, fn, dependencies)
+  decorateConstructor(this[kRequest], name, fn, dependencies)
   return this
 }
 

package/lib/pluginUtils.js

@@ -4,10 +4,9 @@ const semver = require('semver')
 const assert = require('assert')
 const registeredPlugins = Symbol.for('registered-plugin')
 const {
-  kReply,
-  kRequest,
   kTestInternals
 } = require('./symbols.js')
+const { exist, existReply, existRequest } = require('./decorate')
 const { FST_ERR_PLUGIN_VERSION_MISMATCH } = require('./errors')
 
 function getMeta (fn) {
@@ -71,20 +70,25 @@ function checkDecorators (fn) {
   const { decorators, name } = meta
   if (!decorators) return
 
-  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)
+  if (decorators.fastify) _checkDecorators(this, 'Fastify', decorators.fastify, name)
+  if (decorators.reply) _checkDecorators(this, 'Reply', decorators.reply, name)
+  if (decorators.request) _checkDecorators(this, 'Request', decorators.request, name)
 }
 
-function _checkDecorators (instance, decorators, name) {
+const checks = {
+  Fastify: exist,
+  Request: existRequest,
+  Reply: existReply
+}
+
+function _checkDecorators (that, 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}'${withPluginName} is not present in ${instance}`
-    )
+    if (!checks[instance].call(that, decorator)) {
+      throw new Error(`The decorator '${decorator}'${withPluginName} is not present in ${instance}`)
+    }
   })
 }
 

package/lib/reply.js

@@ -63,6 +63,7 @@ function Reply (res, request, log) {
   this[kReplyStartTime] = undefined
   this.log = log
 }
+Reply.props = []
 
 Object.defineProperties(Reply.prototype, {
   context: {
@@ -422,6 +423,8 @@ function onSendEnd (reply, payload) {
   }
 
   if (typeof payload.pipe === 'function') {
+    reply[kReplySent] = true
+
     sendStream(payload, res, reply)
     return
   }
@@ -656,6 +659,8 @@ function onResponseCallback (err, request, reply) {
 }
 
 function buildReply (R) {
+  const props = [...R.props]
+
   function _Reply (res, request, log) {
     this.raw = res
     this[kReplyIsError] = false
@@ -667,8 +672,14 @@ function buildReply (R) {
     this[kReplyHeaders] = {}
     this[kReplyStartTime] = undefined
     this.log = log
+
+    // eslint-disable-next-line no-var
+    for (var i = 0; i < props.length; i++) {
+      this[props[i]] = null
+    }
   }
   _Reply.prototype = new R()
+  _Reply.props = props
   return _Reply
 }
 

package/lib/request.js

@@ -13,6 +13,7 @@ function Request (id, params, req, query, log, context) {
   this.log = log
   this.body = null
 }
+Request.props = []
 
 function getTrustProxyFn (tp) {
   if (typeof tp === 'function') {
@@ -43,6 +44,7 @@ function buildRequest (R, trustProxy) {
 }
 
 function buildRegularRequest (R) {
+  const props = [...R.props]
   function _Request (id, params, req, query, log, context) {
     this.id = id
     this.context = context
@@ -51,8 +53,14 @@ function buildRegularRequest (R) {
     this.query = query
     this.log = log
     this.body = null
+
+    // eslint-disable-next-line no-var
+    for (var i = 0; i < props.length; i++) {
+      this[props[i]] = null
+    }
   }
   _Request.prototype = new R()
+  _Request.props = props
 
   return _Request
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.21.1",
+  "version": "3.21.5",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -194,7 +194,8 @@
       "lib/configValidator.js",
       "fastify.d.ts",
       "types/*",
-      "test/types/*"
+      "test/types/*",
+      "test/same-shape.test.js"
     ]
   },
   "tsd": {

package/test/decorator.test.js

@@ -17,6 +17,15 @@ test('server methods should exist', t => {
   t.ok(fastify.hasDecorator)
 })
 
+test('should check if the given decoration already exist when null', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  fastify.decorate('null', null)
+  fastify.ready(() => {
+    t.ok(fastify.hasDecorator('null'))
+  })
+})
+
 test('server methods should be encapsulated via .register', t => {
   t.plan(2)
   const fastify = Fastify()
@@ -425,6 +434,15 @@ test('hasRequestDecorator', t => {
     t.ok(fastify.hasRequestDecorator(requestDecoratorName))
   })
 
+  t.test('should check if the given request decoration already exist when null', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    t.notOk(fastify.hasRequestDecorator(requestDecoratorName))
+    fastify.decorateRequest(requestDecoratorName, null)
+    t.ok(fastify.hasRequestDecorator(requestDecoratorName))
+  })
+
   t.test('should be plugin encapsulable', t => {
     t.plan(4)
     const fastify = Fastify()
@@ -481,6 +499,15 @@ test('hasReplyDecorator', t => {
     t.ok(fastify.hasReplyDecorator(replyDecoratorName))
   })
 
+  t.test('should check if the given reply decoration already exist when null', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    t.notOk(fastify.hasReplyDecorator(replyDecoratorName))
+    fastify.decorateReply(replyDecoratorName, null)
+    t.ok(fastify.hasReplyDecorator(replyDecoratorName))
+  })
+
   t.test('should be plugin encapsulable', t => {
     t.plan(4)
     const fastify = Fastify()
@@ -877,3 +904,125 @@ test('Request/reply decorators should be able to access the server instance', as
     t.equal(this.server.foo, 'bar')
   }
 })
+
+test('plugin required decorators', async t => {
+  const plugin1 = fp(
+    async (instance) => {
+      instance.decorateRequest('someThing', null)
+
+      instance.addHook('onRequest', async (request, reply) => {
+        request.someThing = 'hello'
+      })
+    },
+    {
+      name: 'custom-plugin-one',
+      fastify: '3.x'
+    }
+  )
+
+  const plugin2 = fp(
+    async () => {
+      // nothing
+    },
+    {
+      name: 'custom-plugin-two',
+      fastify: '3.x',
+      dependencies: ['custom-plugin-one'],
+      decorators: {
+        request: ['someThing']
+      }
+    }
+  )
+
+  const app = Fastify()
+  app.register(plugin1)
+  app.register(plugin2)
+  await app.ready()
+})
+
+test('decorateRequest/decorateReply empty string', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.decorateRequest('test', '')
+  fastify.decorateReply('test2', '')
+  fastify.get('/yes', (req, reply) => {
+    t.equal(req.test, '')
+    t.equal(reply.test2, '')
+    reply.send({ hello: 'world' })
+  })
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/yes'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+      t.same(JSON.parse(body), { hello: 'world' })
+    })
+  })
+})
+
+test('decorateRequest/decorateReply is undefined', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.decorateRequest('test', undefined)
+  fastify.decorateReply('test2', undefined)
+  fastify.get('/yes', (req, reply) => {
+    t.equal(req.test, null)
+    t.equal(reply.test2, null)
+    reply.send({ hello: 'world' })
+  })
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/yes'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+      t.same(JSON.parse(body), { hello: 'world' })
+    })
+  })
+})
+
+test('decorateRequest/decorateReply is not set to a value', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.decorateRequest('test')
+  fastify.decorateReply('test2')
+  fastify.get('/yes', (req, reply) => {
+    t.equal(req.test, null)
+    t.equal(reply.test2, null)
+    reply.send({ hello: 'world' })
+  })
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + '/yes'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+      t.same(JSON.parse(body), { hello: 'world' })
+    })
+  })
+})

package/test/internals/decorator.test.js

@@ -89,7 +89,7 @@ test('checkDependencies should throw if a dependency is not present', t => {
   t.plan(2)
   const instance = {}
   try {
-    decorator.dependencies(instance, ['test'])
+    decorator.dependencies(instance, 'foo', ['test'])
     t.fail()
   } catch (e) {
     t.equal(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')

package/test/internals/plugin.test.js

@@ -53,8 +53,8 @@ test('checkDecorators should check if the given decorator is present in the inst
 
   function context () {}
   context.plugin = true
-  context[symbols.kReply] = { prototype: { plugin: true } }
-  context[symbols.kRequest] = { prototype: { plugin: true } }
+  context[symbols.kReply] = { prototype: { plugin: true }, props: [] }
+  context[symbols.kRequest] = { prototype: { plugin: true }, props: [] }
 
   try {
     pluginUtils.checkDecorators.call(context, fn)
@@ -79,8 +79,8 @@ test('checkDecorators should check if the given decorator is present in the inst
 
   function context () {}
   context.plugin = true
-  context[symbols.kReply] = { prototype: { plugin: true } }
-  context[symbols.kRequest] = { prototype: {} }
+  context[symbols.kReply] = { prototype: { plugin: true }, props: [] }
+  context[symbols.kRequest] = { prototype: {}, props: [] }
 
   try {
     pluginUtils.checkDecorators.call(context, fn)

package/test/same-shape.test.js

@@ -0,0 +1,124 @@
+'use strict'
+
+const { test } = require('tap')
+const fastify = require('..')
+
+test('same shape on Request', async (t) => {
+  t.plan(1)
+
+  const app = fastify()
+
+  let request
+
+  app.decorateRequest('user')
+
+  app.addHook('preHandler', (req, reply, done) => {
+    if (request) {
+      req.user = 'User'
+    }
+    done()
+  })
+
+  app.get('/', (req, reply) => {
+    if (request) {
+      t.equal(%HaveSameMap(request, req), true)
+    }
+
+    request = req
+
+    return 'hello world'
+  })
+
+  await app.inject('/')
+  await app.inject('/')
+})
+
+test('same shape on Request when object', async (t) => {
+  t.plan(1)
+
+  const app = fastify()
+
+  let request
+
+  app.decorateRequest('object', null)
+
+  app.addHook('preHandler', (req, reply, done) => {
+    if (request) {
+      req.object = {}
+    }
+    done()
+  })
+
+  app.get('/', (req, reply) => {
+    if (request) {
+      t.equal(%HaveSameMap(request, req), true)
+    }
+
+    request = req
+
+    return 'hello world'
+  })
+
+  await app.inject('/')
+  await app.inject('/')
+})
+
+test('same shape on Reply', async (t) => {
+  t.plan(1)
+
+  const app = fastify()
+
+  let _reply
+
+  app.decorateReply('user')
+
+  app.addHook('preHandler', (req, reply, done) => {
+    if (_reply) {
+      reply.user = 'User'
+    }
+    done()
+  })
+
+  app.get('/', (req, reply) => {
+    if (_reply) {
+      t.equal(%HaveSameMap(_reply, reply), true)
+    }
+
+    _reply = reply
+
+    return 'hello world'
+  })
+
+  await app.inject('/')
+  await app.inject('/')
+})
+
+test('same shape on Reply when object', async (t) => {
+  t.plan(1)
+
+  const app = fastify()
+
+  let _reply
+
+  app.decorateReply('object', null)
+
+  app.addHook('preHandler', (req, reply, done) => {
+    if (_reply) {
+      reply.object = {}
+    }
+    done()
+  })
+
+  app.get('/', (req, reply) => {
+    if (_reply) {
+      t.equal(%HaveSameMap(_reply, reply), true)
+    }
+
+    _reply = reply
+
+    return 'hello world'
+  })
+
+  await app.inject('/')
+  await app.inject('/')
+})

package/test/stream.test.js

@@ -14,7 +14,7 @@ const JSONStream = require('JSONStream')
 const send = require('send')
 const Readable = require('stream').Readable
 const split = require('split2')
-const { kDisableRequestLogging } = require('../lib/symbols.js')
+const { kDisableRequestLogging, kReplySent } = require('../lib/symbols.js')
 
 test('should respond with a stream', t => {
   t.plan(8)
@@ -636,3 +636,39 @@ test('should destroy stream when response is ended', t => {
     })
   })
 })
+
+test('should mark reply as sent before pumping the payload stream into response for async route handler', t => {
+  t.plan(3)
+
+  const handleRequest = proxyquire('../lib/handleRequest', {
+    './wrapThenable': (thenable, reply) => {
+      thenable.then(function (payload) {
+        t.equal(reply[kReplySent], true)
+      })
+    }
+  })
+
+  const route = proxyquire('../lib/route', {
+    './handleRequest': handleRequest
+  })
+
+  const Fastify = proxyquire('..', {
+    './lib/route': route
+  })
+
+  const fastify = Fastify()
+
+  fastify.get('/', async function (req, reply) {
+    const stream = fs.createReadStream(__filename, 'utf8')
+    reply.code(200).send(stream)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.payload, fs.readFileSync(__filename, 'utf8'))
+    fastify.close()
+  })
+})