fastify 3.21.2 → 3.21.3

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

@@ -10,25 +10,25 @@ Request is a core Fastify object containing the following fields:
 - `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)
 - `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+ */)
@@ -333,7 +333,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 })
@@ -497,7 +497,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 +519,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 +649,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 +962,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 +985,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 +1006,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 +1031,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

@@ -75,10 +75,12 @@ 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)
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.21.2",
+  "version": "3.21.3",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

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()

package/test/same-shape.test.js

@@ -33,6 +33,36 @@ test('same shape on Request', async (t) => {
   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)
 
@@ -62,3 +92,33 @@ test('same shape on Reply', async (t) => {
   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('/')
+})