fastify 3.20.1 → 3.20.2

package/docs/Ecosystem.md

@@ -44,6 +44,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-routes`](https://github.com/fastify/fastify-routes) Plugin that provides a `Map` of routes.
 - [`fastify-schedule`](https://github.com/fastify/fastify-schedule) Plugin for scheduling periodic jobs, based on [toad-scheduler](https://github.com/kibertoad/toad-scheduler).
 - [`fastify-sensible`](https://github.com/fastify/fastify-sensible) Defaults for Fastify that everyone can agree on. It adds some useful decorators such as HTTP errors and assertions, but also more request and reply methods.
+- [`@fastify/session`](https://github.com/fastify/session) a session plugin for Fastify.
 - [`fastify-static`](https://github.com/fastify/fastify-static) Plugin for serving static files as fast as possible.
 - [`fastify-swagger`](https://github.com/fastify/fastify-swagger) Plugin for serving Swagger/OpenAPI documentation for Fastify, supporting dynamic generation.
 - [`fastify-websocket`](https://github.com/fastify/fastify-websocket) WebSocket support for Fastify. Built upon [websocket-stream](https://github.com/maxogden/websocket-stream).
@@ -69,6 +70,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`arecibo`](https://github.com/nucleode/arecibo) Fastify ping responder for Kubernetes Liveness and Readiness Probes.
 - [`cls-rtracer`](https://github.com/puzpuzpuz/cls-rtracer) Fastify middleware for CLS-based request ID generation. An out-of-the-box solution for adding request IDs into your logs.
 - [`fastify-405`](https://github.com/Eomm/fastify-405) Fastify plugin that adds 405 HTTP status to your routes
+- [`fastify-allow`](https://github.com/mattbishop/fastify-allow) Fastify plugin that automatically adds an Allow header to responses with routes. Also sends 405 responses for routes that have a handler but not for the request's method.
 - [`fastify-amqp`](https://github.com/RafaelGSS/fastify-amqp) Fastify AMQP connection plugin, to use with RabbitMQ or another connector. Just a wrapper to [`amqplib`](https://github.com/squaremo/amqp.node).
 - [`fastify-angular-universal`](https://github.com/exequiel09/fastify-angular-universal) Angular server-side rendering support using [`@angular/platform-server`](https://github.com/angular/angular/tree/master/packages/platform-server) for Fastify
 - [`fastify-api-key`](https://github.com/arkerone/fastify-api-key) Fastify plugin to authenticate HTTP requests based on api key and signature
@@ -177,7 +179,6 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-sentry`](https://github.com/alex-ppg/fastify-sentry) Fastify plugin to add the Sentry SDK error handler to requests.
 - [`fastify-sequelize`](https://github.com/lyquocnam/fastify-sequelize) Fastify plugin work with Sequelize (adapter for NodeJS -> Sqlite, Mysql, Mssql, Postgres).
 - [`fastify-server-session`](https://github.com/jsumners/fastify-server-session) A session plugin with support for arbitrary backing caches via `fastify-caching`.
-- [`fastify-session`](https://github.com/SerayaEryn/fastify-session) a session plugin for Fastify.
 - [`fastify-slonik`](https://github.com/Unbuttun/fastify-slonik) Fastify Slonik plugin, with this you can use slonik in every part of your server.
 - [`fastify-soap-client`](https://github.com/fastify/fastify-soap-client) a SOAP client plugin for Fastify.
 - [`fastify-socket.io`](https://github.com/alemagio/fastify-socket.io) a Socket.io plugin for Fastify.

package/docs/Getting-Started.md

@@ -200,7 +200,7 @@ As you can see, we used `register` for both the database connector and the regis
 This is one of the best features of Fastify, it will load your plugins in the same order you declare them, and it will load the next plugin only once the current one has been loaded. In this way, we can register the database connector in the first plugin and use it in the second *(read [here](Plugins.md#handle-the-scope) to understand how to handle the scope of a plugin)*.
 Plugin loading starts when you call `fastify.listen()`, `fastify.inject()` or `fastify.ready()`
 
-We have also used the `decorate` API to add custom objects to the Fastify namespace, making them available for use everywhere. Use of this API is encouraged to facilitate easy code reuse and to decrease code or logic duplication.
+The MongoDB plugin uses the `decorate` API to add custom objects to the Fastify instance, making them available for use everywhere. Use of this API is encouraged to facilitate easy code reuse and to decrease code or logic duplication.
 
 To dig deeper into how Fastify plugins work, how to develop new plugins, and for details on how to use the whole Fastify API to deal with the complexity of asynchronously bootstrapping an application, read [the hitchhiker's guide to plugins](Plugins-Guide.md).
 

package/docs/Request.md

@@ -6,7 +6,7 @@ Request is a core Fastify object containing the following fields:
 - `query` - the parsed querystring
 - `body` - the body
 - `params` - the params matching the URL
-- `headers` - the headers
+- [`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)
@@ -26,6 +26,20 @@ Request is a core Fastify object containing the following fields:
 - `context` - A Fastify internal object. You should not use it directly or modify it. It is usefull 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.
+You can set custom headers like this:
+
+```js
+request.headers = {
+  'foo': 'bar',
+  'baz': 'qux'
+}
+```
+
+This operation will add to the request headers the new values that can be read calling `request.headers.bar`.  
+Moreover, you can still access the standard request's headers with the `request.raw.headers` property.
 
 ```js
 fastify.post('/:params', options, function (request, reply) {
@@ -40,6 +54,9 @@ fastify.post('/:params', options, function (request, reply) {
   console.log(request.ips)
   console.log(request.hostname)
   console.log(request.protocol)
+  console.log(request.url)
+  console.log(request.routerMethod)
+  console.log(request.routerPath)
   request.log.info('some info')
 })
 ```

package/docs/TypeScript.md

@@ -85,7 +85,7 @@ The type system heavily relies on generic properties to provide the most accurat
      'h-Custom': string;
    }
    ```
-3. Using the two interfaces, define a new API route and pass them as generics. The shorthand route methods (i.e. `.get`) accept a generic object `RequestGenericInterface` containing four named properties: `Body`, `Querystring`, `Params`, and `Headers`. The interfaces will be passed down through the route method into the route method handler `request` instance.
+3. Using the two interfaces, define a new API route and pass them as generics. The shorthand route methods (i.e. `.get`) accept a generic object `RouteGenericInterface` containing five named properties: `Body`, `Querystring`, `Params`, `Headers` and `Reply`. The interfaces `Body`, `Querystring`, `Params` and `Headers` will be passed down through the route method into the route method handler `request` instance and the `Reply` interface to the `reply` instance.
    ```typescript
    server.get<{
      Querystring: IQuerystring,
@@ -599,7 +599,7 @@ The Fastify API is powered by the `fastify()` method. In JavaScript you would im
      const f = fastify()
      f.listen(8080, () => { console.log('running') })
      ```
-   - Destructuring is still supported, but will also not resolve types
+   - Destructuring is supported and will resolve types properly
      ```typescript
      const { fastify } = require('fastify')
 

package/fastify.js

@@ -541,9 +541,8 @@ function fastify (options) {
 
   function defaultClientErrorHandler (err, socket) {
     // In case of a connection reset, the socket has been destroyed and there is nothing that needs to be done.
-    // https://github.com/fastify/fastify/issues/2036
-    // https://github.com/nodejs/node/issues/33302
-    if (err.code === 'ECONNRESET') {
+    // https://nodejs.org/api/http.html#http_event_clienterror
+    if (err.code === 'ECONNRESET' || socket.destroyed) {
       return
     }
 
@@ -557,11 +556,14 @@ function fastify (options) {
     // In the vast majority of cases, it's a network error and/or some
     // config issue on the load balancer side.
     this.log.trace({ err }, 'client error')
+    // Copying standard node behaviour
+    // https://github.com/nodejs/node/blob/6ca23d7846cb47e84fd344543e394e50938540be/lib/_http_server.js#L666
 
     // If the socket is not writable, there is no reason to try to send data.
-    if (socket.writable) {
-      socket.end(`HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
+    if (socket.writable && socket.bytesWritten === 0) {
+      socket.write(`HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
     }
+    socket.destroy(err)
   }
 
   // If the router does not match any route, every request will land here

package/lib/request.js

@@ -162,7 +162,13 @@ Object.defineProperties(Request.prototype, {
   },
   headers: {
     get () {
+      if (this.additionalHeaders) {
+        return Object.assign({}, this.raw.headers, this.additionalHeaders)
+      }
       return this.raw.headers
+    },
+    set (headers) {
+      this.additionalHeaders = headers
     }
   },
   server: {

package/package.json

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

package/test/request-error.test.js

@@ -127,6 +127,78 @@ test('default clientError handler ignores ECONNRESET', t => {
   })
 })
 
+test('default clientError handler ignores sockets in destroyed state', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    bodyLimit: 1,
+    keepAliveTimeout: 100,
+    logger: {
+      level: 'trace'
+    }
+  })
+  fastify.server.on('clientError', () => {
+    // this handler is called after default handler, so we can make sure end was not called
+    t.pass()
+  })
+  fastify.server.emit('clientError', new Error(), {
+    destroyed: true,
+    end () {
+      t.fail('end should not be called')
+    },
+    destroy () {
+      t.fail('destroy should not be called')
+    }
+  })
+})
+
+test('default clientError handler destroys sockets in writable state', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    bodyLimit: 1,
+    keepAliveTimeout: 100,
+    logger: {
+      level: 'trace'
+    }
+  })
+
+  fastify.server.emit('clientError', new Error(), {
+    destroyed: false,
+    writable: true,
+    encrypted: true,
+    end () {
+      t.fail('end should not be called')
+    },
+    destroy () {
+      t.pass('destroy should be called')
+    }
+  })
+})
+
+test('default clientError handler destroys http sockets in non-writable state', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    bodyLimit: 1,
+    keepAliveTimeout: 100,
+    logger: {
+      level: 'trace'
+    }
+  })
+
+  fastify.server.emit('clientError', new Error(), {
+    destroyed: false,
+    writable: false,
+    end () {
+      t.fail('end should not be called')
+    },
+    destroy () {
+      t.pass('destroy should be called')
+    }
+  })
+})
+
 test('error handler binding', t => {
   t.plan(5)
 

package/test/schema-special-usage.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { test } = require('tap')
+const Joi = require('@hapi/joi')
 const AJV = require('ajv')
 const S = require('fluent-json-schema')
 const Fastify = require('..')
@@ -748,3 +749,34 @@ test('multiple refs with the same ids', t => {
     t.same(res.json(), { hello: 'world' })
   })
 })
+
+test('JOI validation overwrite request headers', t => {
+  t.plan(3)
+  const schemaValidator = ({ schema }) => data => {
+    const validationResult = schema.validate(data)
+    return validationResult
+  }
+
+  const fastify = Fastify()
+  fastify.setValidatorCompiler(schemaValidator)
+
+  fastify.get('/', {
+    schema: {
+      headers: Joi.object({
+        'user-agent': Joi.string().required(),
+        host: Joi.string().required()
+      })
+    }
+  }, (request, reply) => {
+    reply.send(request.headers)
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.same(res.json(), {
+      'user-agent': 'lightMyRequest',
+      host: 'localhost:80'
+    })
+  })
+})