fastify 3.24.0 → 3.24.1

package/docs/Ecosystem.md

@@ -91,6 +91,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-cloudevents`](https://github.com/smartiniOnGitHub/fastify-cloudevents) Fastify plugin to generate and forward Fastify events in the Cloudevents format.
 - [`fastify-cockroachdb`](https://github.com/alex-ppg/fastify-cockroachdb) Fastify plugin to connect to a CockroachDB PostgreSQL instance via the Sequelize ORM.
 - [`fastify-couchdb`](https://github.com/nigelhanlon/fastify-couchdb) Fastify plugin to add CouchDB support via [nano](https://github.com/apache/nano).
+- [`fastify-crud-generator`](https://github.com/heply/fastify-crud-generator) A plugin to rapidly generate CRUD routes for any entity.
 - [`fastify-custom-healthcheck`](https://github.com/gkampitakis/fastify-custom-healthcheck) Fastify plugin to add health route in your server that asserts custom functions.
 - [`fastify-decorators`](https://github.com/L2jLiga/fastify-decorators) Fastify plugin that provides the set of TypeScript decorators.
 - [`fastify-disablecache`](https://github.com/Fdawgs/fastify-disablecache) Fastify plugin to disable client-side caching, inspired by [nocache](https://github.com/helmetjs/nocache).
@@ -158,6 +159,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-orientdb`](https://github.com/mahmed8003/fastify-orientdb) Fastify OrientDB connection plugin, with which you can share the OrientDB connection across every part of your server.
 - [`fastify-piscina`](https://github.com/piscinajs/fastify-piscina) A worker thread pool plugin using [Piscina](https://github.com/piscinajs/piscina).
 - [`fastify-peekaboo`](https://github.com/simone-sanfratello/fastify-peekaboo) Fastify plugin for memoize responses by expressive settings.
+- [`fastify-polyglot`](https://github.com/heply/fastify-polyglot) A plugin to handle i18n using [node-polyglot](https://www.npmjs.com/package/node-polyglot).
 - [`fastify-postgraphile`](https://github.com/alemagio/fastify-postgraphile) Plugin to integrate [PostGraphile](https://www.graphile.org/postgraphile/) in a Fastify project.
 - [`fastify-prettier`](https://github.com/hsynlms/fastify-prettier) A Fastify plugin that uses [prettier](https://github.com/prettier/prettier) under the hood to beautify outgoing responses and/or other things in the Fastify server.
 - [`fastify-print-routes`](https://github.com/ShogunPanda/fastify-print-routes) A Fastify plugin that prints all available routes.

package/docs/Getting-Started.md

@@ -262,6 +262,24 @@ async function routes (fastify, options) {
     }
     return result
   })
+
+  const animalBodyJsonSchema = {
+    type: 'object',
+    required: ['animal'],
+    properties: {
+      animal: { type: 'string' },
+    },
+  }
+
+  const schema = {
+    body: animalBodyJsonSchema,
+  }
+
+  fastify.post('/animals', { schema }, async (request, reply) => {
+    // we can use the `request.body` object to get the data sent by the client
+    const result = await collection.insertOne({ animal: request.body.animal })
+    return result
+  })
 }
 
 module.exports = routes

package/docs/Logging.md

@@ -2,6 +2,7 @@
 
 ## Logging
 
+### Enable logging
 Logging is disabled by default, and you can enable it by passing
 `{ logger: true }` or `{ logger: { level: 'info' } }` when you create
 a fastify instance. Note that if the logger is disabled, it is impossible to
@@ -11,13 +12,34 @@ this purpose.
 
 As Fastify is focused on performance, it uses [pino](https://github.com/pinojs/pino) as its logger, with the default log level, when enabled, set to `'info'`.
 
-Enabling the logger is extremely easy:
+Enabling the production JSON logger:
 
 ```js
 const fastify = require('fastify')({
   logger: true
 })
+```
+
+Enabling the logger with appropriate configuration for both local development and production environment requires bit more configuration:
+```js
+const fastify = require('fastify')({
+  logger: {
+      prettyPrint:
+        environment === 'development'
+          ? {
+              translateTime: 'HH:MM:ss Z',
+              ignore: 'pid,hostname'
+            }
+          : false
+    }
+})
+```
+⚠️ `pino-pretty` needs to be installed as a dev dependency, it is not included by default for performance reasons.
 
+### Usage
+You can use the logger like this in your route handlers:
+
+```js
 fastify.get('/', options, function (request, reply) {
   request.log.info('Some info about the current request')
   reply.send({ hello: 'world' })

package/docs/Plugins.md

@@ -4,7 +4,7 @@
 Fastify allows the user to extend its functionalities with plugins.
 A plugin can be a set of routes, a server [decorator](Decorators.md), or whatever. The API that you will need to use one or more plugins, is `register`.<br>
 
-By default, `register` creates a *new scope*, this means that if you make some changes to the Fastify instance (via `decorate`), this change will not be reflected by the current context ancestors, but only to its sons. This feature allows us to achieve plugin *encapsulation* and *inheritance*, in this way we create a *direct acyclic graph* (DAG) and we will not have issues caused by cross dependencies.
+By default, `register` creates a *new scope*, this means that if you make some changes to the Fastify instance (via `decorate`), this change will not be reflected by the current context ancestors, but only to its descendants. This feature allows us to achieve plugin *encapsulation* and *inheritance*, in this way we create a *direct acyclic graph* (DAG) and we will not have issues caused by cross dependencies.
 
 You already see in the [getting started](Getting-Started.md#register) section how using this API is pretty straightforward.
 ```

package/docs/Reply.md

@@ -7,6 +7,7 @@
   - [.statusCode](#statusCode)
   - [.server](#server)
   - [.header(key, value)](#headerkey-value)
+      - [set-cookie](#set-cookie)
   - [.headers(object)](#headersobject)
   - [.getHeader(key)](#getheaderkey)
   - [.getHeaders()](#getheaders)
@@ -106,11 +107,23 @@ fastify.get('/', async function (req, rep) {
 
 <a name="header"></a>
 ### .header(key, value)
-Sets a response header. If the value is omitted or undefined, it is coerced
-to `''`.
-
+Sets a response header. If the value is omitted or undefined, it is coerced to `''`.
 For more information, see [`http.ServerResponse#setHeader`](https://nodejs.org/dist/latest-v14.x/docs/api/http.html#http_response_setheader_name_value).
 
+<a name="set-cookie"></a>
+- ### set-cookie
+    - When sending different values as a cookie with `set-cookie` as the key, every value will be sent as a cookie instead of replacing the previous value.
+
+    ```js
+    reply.header('set-cookie', 'foo');
+    reply.header('set-cookie', 'bar');
+    ```
+  - The browser will only consider the latest reference of a key for the `set-cookie` header. This is done to avoid parsing the `set-cookie` header when added to a reply and speeds up the serialization of the reply.
+
+  - To reset the `set-cookie` header, you need to make an explicit call to `reply.removeHeader('set-cookie')`, read more about `.removeHeader(key)` [here](#removeheaderkey).
+
+
+
 <a name="headers"></a>
 ### .headers(object)
 Sets all the keys of the object as response headers. [`.header`](#headerkey-value) will be called under the hood.

package/docs/Serverless.md

@@ -22,6 +22,7 @@ choice with an additional snippet of code.
 ### Contents
 
 - [AWS Lambda](#aws-lambda)
+- [Google Cloud Functions](#google-cloud-functions)
 - [Google Cloud Run](#google-cloud-run)
 - [Netlify Lambda](#netlify-lambda)
 - [Vercel](#vercel)
@@ -100,6 +101,128 @@ An example deployable with [claudia.js](https://claudiajs.com/tutorials/serverle
 - API Gateway does not support streams yet, so you are not able to handle [streams](https://www.fastify.io/docs/latest/Reply/#streams).
 - API Gateway has a timeout of 29 seconds, so it is important to provide a reply during this time.
 
+## Google Cloud Functions
+
+### Creation of Fastify instance
+```js
+const fastify = require("fastify")({
+  logger: true // you can also define the level passing an object configuration to logger: {level: 'debug'}
+});
+```
+
+### Add Custom `contentTypeParser` to Fastify instance
+
+As explained [in issue #946](https://github.com/fastify/fastify/issues/946#issuecomment-766319521), since the Google Cloud Functions platform parses the body of the request before it arrives into Fastify instance, troubling the body request in case of `POST` and `PATCH` methods, you need to add a custom [`ContentTypeParser`](https://www.fastify.io/docs/latest/ContentTypeParser/) to mitigate this behavior.
+
+```js
+fastify.addContentTypeParser('application/json', {}, (req, body, done) => {
+  done(null, body.body);
+});
+```
+
+### Define your endpoint (examples)
+
+A simple `GET` endpoint:
+```js
+fastify.get('/', async (request, reply) => {
+  reply.send({message: 'Hello World!'})
+})
+```
+
+Or a more complete `POST` endpoint with schema validation: 
+```js
+fastify.route({
+  method: 'POST',
+  url: '/hello',
+  schema: {
+    body: {
+      type: 'object',
+      properties: {
+        name: { type: 'string'}
+      },
+      required: ['name']
+    },
+    response: {
+      200: {
+        type: 'object', 
+        properties: {
+          message: {type: 'string'}
+        }
+      }
+    },
+  },
+  handler: async (request, reply) => {
+    const { name } = request.body;
+    reply.code(200).send({
+      message: `Hello ${name}!`
+    })
+  }
+})
+```
+
+### Implement and export the function
+
+Final step, implement the function to handle the request and pass it to Fastify by emitting `request` event to `fastify.server`:
+
+```js
+const fastifyFunction = async (request, reply) => {
+  await fastify.ready();
+  fastify.server.emit('request', request, reply)
+}
+
+export.fastifyFunction = fastifyFunction;
+```
+
+### Local test
+
+Install [Google Functions Framework for Node.js](https://github.com/GoogleCloudPlatform/functions-framework-nodejs).
+
+You can install it globally:
+```bash
+npm i -g @google-cloud/functions-framework
+```
+
+Or as a development library:
+```bash
+npm i --save-dev @google-cloud/functions-framework
+```
+
+Than you can run your function locally with Functions Framework:
+``` bash
+npx @google-cloud/functions-framework --target=fastifyFunction
+```
+
+Or add this command to your `package.json` scripts:
+```json
+"scripts": {
+...
+"dev": "npx @google-cloud/functions-framework --target=fastifyFunction"
+...
+}
+```
+and run it with `npm run dev`.
+
+
+### Deploy
+```bash
+gcloud functions deploy fastifyFunction \
+--runtime nodejs14 --trigger-http --region $GOOGLE_REGION --allow-unauthenticated
+```
+
+#### Read logs
+```bash
+gcloud functions logs read
+```
+
+#### Example request to `/hello` endpoint
+```bash
+curl -X POST https://$GOOGLE_REGION-$GOOGLE_PROJECT.cloudfunctions.net/me -H "Content-Type: application/json" -d '{ "name": "Fastify" }'
+{"message":"Hello Fastify!"}
+```
+
+### References
+- [Google Cloud Functions - Node.js Quickstart ](https://cloud.google.com/functions/docs/quickstart-nodejs)
+
 ## Google Cloud Run
 
 Unlike AWS Lambda or Google Cloud Functions, Google Cloud Run is a serverless **container** environment. Its primary purpose is to provide an infrastructure-abstracted environment to run arbitrary containers. As a result, Fastify can be deployed to Google Cloud Run with little-to-no code changes from the way you would write your Fastify app normally.

package/docs/Validation-and-Serialization.md

@@ -549,7 +549,7 @@ fastify.post('/the/url', { schema }, handler)
 <a name="schema-serializer"></a>
 #### Serializer Compiler
 
-The `serializerCompiler` is a function that returns a function that must return a string from an input object. You must provide a function to serialize every route where you have defined a `response` JSON Schema.
+The `serializerCompiler` is a function that returns a function that must return a string from an input object. When you define a response JSON Schema, you can change the default serialization method by providing a function to serialize every route where you do.
 
 ```js
 fastify.setSerializerCompiler(({ schema, method, url, httpStatus }) => {

package/examples/typescript-server.ts

@@ -73,6 +73,6 @@ server.get<{
 server.listen(8080, (err, address) => {
   if (err) {
     console.error(err);
-    process.exit(0);
+    process.exit(1);
   }
 });

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '3.24.0'
+const VERSION = '3.24.1'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -631,8 +631,7 @@ function fastify (options) {
   function setSchemaController (schemaControllerOpts) {
     throwIfAlreadyStarted('Cannot call "setSchemaController" when fastify instance is already started!')
     const old = this[kSchemaController]
-    const parent = old.parent || old
-    const schemaController = SchemaController.buildSchemaController(parent, Object.assign({}, old.opts, schemaControllerOpts))
+    const schemaController = SchemaController.buildSchemaController(old, Object.assign({}, old.opts, schemaControllerOpts))
     this[kSchemaController] = schemaController
     this.getSchema = schemaController.getSchema.bind(schemaController)
     this.getSchemas = schemaController.getSchemas.bind(schemaController)

package/lib/logger.js

@@ -50,7 +50,7 @@ const serializers = {
     return {
       method: req.method,
       url: req.url,
-      version: req.headers['accept-version'],
+      version: req.headers && req.headers['accept-version'],
       hostname: req.hostname,
       remoteAddress: req.ip,
       remotePort: req.socket ? req.socket.remotePort : undefined

package/lib/server.js

@@ -14,19 +14,20 @@ function createServer (options, httpHandler) {
   let server = null
   if (options.serverFactory) {
     server = options.serverFactory(httpHandler, options)
-  } else if (options.https) {
-    if (options.http2) {
+  } else if (options.http2) {
+    if (options.https) {
       server = http2().createSecureServer(options.https, httpHandler)
-      server.on('session', sessionTimeout(options.http2SessionTimeout))
     } else {
-      server = https.createServer(options.https, httpHandler)
-      server.keepAliveTimeout = options.keepAliveTimeout
+      server = http2().createServer(httpHandler)
     }
-  } else if (options.http2) {
-    server = http2().createServer(httpHandler)
     server.on('session', sessionTimeout(options.http2SessionTimeout))
   } else {
-    server = http.createServer(httpHandler)
+    // this is http1
+    if (options.https) {
+      server = https.createServer(options.https, httpHandler)
+    } else {
+      server = http.createServer(httpHandler)
+    }
     server.keepAliveTimeout = options.keepAliveTimeout
     server.requestTimeout = options.requestTimeout
     // we treat zero as null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.24.0",
+  "version": "3.24.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -166,7 +166,7 @@
     "tap": "^15.0.5",
     "tap-mocha-reporter": "^5.0.1",
     "then-sleep": "^1.0.1",
-    "tsd": "^0.18.0",
+    "tsd": "^0.19.0",
     "typescript": "^4.0.2",
     "undici": "^3.3.5",
     "x-xss-protection": "^2.0.0",

package/test/logger.test.js

@@ -1516,3 +1516,19 @@ test('should create a default logger if provided one is invalid', t => {
 
   t.pass()
 })
+
+test('should not throw error when serializing custom req', t => {
+  t.plan(1)
+
+  const lines = []
+  const dest = new stream.Writable({
+    write: function (chunk, enc, cb) {
+      lines.push(JSON.parse(chunk))
+      cb()
+    }
+  })
+  const fastify = Fastify({ logger: { level: 'info', stream: dest } })
+  fastify.log.info({ req: {} })
+
+  t.same(lines[0].req, {})
+})

package/test/maxRequestsPerSocket.test.js

@@ -102,3 +102,13 @@ test('maxRequestsPerSocket should 0', async (t) => {
   const initialConfig = Fastify().initialConfig
   t.same(initialConfig.maxRequestsPerSocket, 0)
 })
+
+test('requestTimeout passed to server', t => {
+  t.plan(2)
+
+  const httpServer = Fastify({ maxRequestsPerSocket: 5 }).server
+  t.equal(httpServer.maxRequestsPerSocket, 5)
+
+  const httpsServer = Fastify({ maxRequestsPerSocket: 5, https: true }).server
+  t.equal(httpsServer.maxRequestsPerSocket, 5)
+})

package/test/requestTimeout.test.js

@@ -5,7 +5,7 @@ const { test } = require('tap')
 const Fastify = require('../fastify')
 
 test('requestTimeout passed to server', t => {
-  t.plan(4)
+  t.plan(5)
 
   try {
     Fastify({ requestTimeout: 500.1 })
@@ -24,6 +24,9 @@ test('requestTimeout passed to server', t => {
   const httpServer = Fastify({ requestTimeout: 1000 }).server
   t.equal(httpServer.requestTimeout, 1000)
 
+  const httpsServer = Fastify({ requestTimeout: 1000, https: true }).server
+  t.equal(httpsServer.requestTimeout, 1000)
+
   const serverFactory = (handler, _) => {
     const server = http.createServer((req, res) => {
       handler(req, res)

package/test/schema-feature.test.js

@@ -1604,3 +1604,149 @@ test('setSchemaController: Inherits buildValidator from parent if not present wi
   t.equal(childSerializerCalled, 1, 'Should be called from the child')
   t.equal(res.statusCode, 400, 'Should not coearce the string into array')
 })
+
+test('Should throw if not default validator passed', async t => {
+  t.plan(4)
+  const customAjv = new Ajv({ coerceTypes: false })
+  const someSchema = {
+    $id: 'some',
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }
+  const anotherSchema = {
+    $id: 'another',
+    type: 'integer'
+  }
+  const plugin = fp(function (pluginInstance, _, pluginDone) {
+    pluginInstance.setSchemaController({
+      compilersFactory: {
+        buildValidator: function (externalSchemas) {
+          const schemaKeys = Object.keys(externalSchemas)
+          t.equal(schemaKeys.length, 2)
+          t.same(schemaKeys, ['some', 'another'])
+
+          for (const key of schemaKeys) {
+            if (customAjv.getSchema(key) == null) {
+              customAjv.addSchema(externalSchemas[key], key)
+            }
+          }
+          return function validatorCompiler ({ schema }) {
+            return customAjv.compile(schema)
+          }
+        }
+      }
+    })
+
+    pluginDone()
+  })
+  const server = Fastify()
+
+  server.addSchema(someSchema)
+
+  server.register((instance, opts, done) => {
+    instance.addSchema(anotherSchema)
+
+    instance.register(plugin, {})
+
+    instance.post(
+      '/',
+      {
+        schema: {
+          query: {
+            msg: {
+              $ref: 'some#'
+            }
+          },
+          headers: {
+            'x-another': {
+              $ref: 'another#'
+            }
+          }
+        }
+      },
+      (req, reply) => {
+        reply.send({ noop: 'noop' })
+      }
+    )
+
+    done()
+  })
+
+  try {
+    const res = await server.inject({
+      method: 'POST',
+      url: '/',
+      query: {
+        msg: ['string']
+      }
+    })
+
+    t.equal(res.json().message, 'querystring.msg should be array')
+    t.equal(res.statusCode, 400, 'Should not coearce the string into array')
+  } catch (err) {
+    t.error(err)
+  }
+})
+
+test('Should throw if not default validator passed', async t => {
+  t.plan(2)
+  const someSchema = {
+    $id: 'some',
+    type: 'array',
+    items: {
+      type: 'string'
+    }
+  }
+  const anotherSchema = {
+    $id: 'another',
+    type: 'integer'
+  }
+
+  const server = Fastify()
+
+  server.addSchema(someSchema)
+
+  server.register((instance, opts, done) => {
+    instance.addSchema(anotherSchema)
+
+    instance.post(
+      '/',
+      {
+        schema: {
+          query: {
+            msg: {
+              $ref: 'some#'
+            }
+          },
+          headers: {
+            'x-another': {
+              $ref: 'another#'
+            }
+          }
+        }
+      },
+      (req, reply) => {
+        reply.send({ noop: 'noop' })
+      }
+    )
+
+    done()
+  })
+
+  try {
+    const res = await server.inject({
+      method: 'POST',
+      url: '/',
+      query: {
+        msg: ['string']
+      }
+    })
+
+    t.equal(res.json().message, 'querystring.msg should be array')
+    t.equal(res.statusCode, 400, 'Should not coearce the string into array')
+  } catch (err) {
+    t.error(err)
+  }
+})

package/test/types/instance.test-d.ts

@@ -90,6 +90,12 @@ expectAssignable<void>(server.listen('3000', '', (err, address) => {}))
 expectAssignable<void>(server.listen(3000, (err, address) => {}))
 expectAssignable<void>(server.listen('3000', (err, address) => {}))
 
+// test listen method callback types
+expectAssignable<void>(server.listen('3000', (err, address) => {
+  expectAssignable<Error|null>(err)
+  expectAssignable<string>(address)
+}))
+
 // test listen method promise
 expectAssignable<PromiseLike<string>>(server.listen(3000))
 expectAssignable<PromiseLike<string>>(server.listen('3000'))

package/test/types/request.test-d.ts

@@ -1,5 +1,5 @@
 import { expectType } from 'tsd'
-import fastify, { RouteHandler, RawRequestDefaultExpression, RequestBodyDefault, RequestGenericInterface } from '../../fastify'
+import fastify, { RouteHandler, RawRequestDefaultExpression, RequestBodyDefault, RequestGenericInterface, FastifyContext, ContextConfigDefault, FastifyContextConfig } from '../../fastify'
 import { RequestParamsDefault, RequestHeadersDefault, RequestQuerystringDefault } from '../../types/utils'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { FastifyRequest } from '../../types/request'
@@ -50,6 +50,8 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<RawRequestDefaultExpression>(request.raw)
   expectType<RequestBodyDefault>(request.body)
   expectType<RequestParamsDefault>(request.params)
+  expectType<FastifyContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyContextConfig>(request.context.config)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
   request.headers = {}
@@ -72,6 +74,8 @@ const postHandler: Handler = function (request) {
   expectType<number>(request.params.id)
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
+  expectType<FastifyContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyContextConfig>(request.context.config)
 }
 
 function putHandler (request: CustomRequest, reply: FastifyReply) {
@@ -84,6 +88,8 @@ function putHandler (request: CustomRequest, reply: FastifyReply) {
   expectType<number>(request.params.id)
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
+  expectType<FastifyContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyContextConfig>(request.context.config)
 }
 
 const server = fastify()

package/test/types/route.test-d.ts

@@ -65,6 +65,9 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
     expectType<QuerystringInterface>(req.query)
     expectType<ParamsInterface>(req.params)
     expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+    expectType<string>(req.context.config.foo)
+    expectType<number>(req.context.config.bar)
+    expectType<boolean>(req.context.config.extra)
     expectType<string>(res.context.config.foo)
     expectType<number>(res.context.config.bar)
     expectType<boolean>(res.context.config.extra)
@@ -80,6 +83,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
     },
@@ -88,6 +93,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
       expectType<RequestPayload>(payload)
@@ -99,6 +106,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
     },
@@ -107,6 +116,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
     },
@@ -115,6 +126,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
       expectType<number>(res.statusCode)
@@ -124,6 +137,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
     },
@@ -132,6 +147,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
     },
@@ -140,6 +157,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
     },
@@ -148,6 +167,8 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
       expectType<QuerystringInterface>(req.query)
       expectType<ParamsInterface>(req.params)
       expectType<http.IncomingHttpHeaders & HeadersInterface>(req.headers)
+      expectType<string>(req.context.config.foo)
+      expectType<number>(req.context.config.bar)
       expectType<string>(res.context.config.foo)
       expectType<number>(res.context.config.bar)
     }

package/types/instance.d.ts

@@ -70,11 +70,11 @@ export interface FastifyInstance<
   inject(opts: InjectOptions | string): Promise<LightMyRequestResponse>;
   inject(): LightMyRequestChain;
 
-  listen(port: number | string, address: string, backlog: number, callback: (err: Error, address: string) => void): void;
-  listen(port: number | string, address: string, callback: (err: Error, address: string) => void): void;
-  listen(port: number | string, callback: (err: Error, address: string) => void): void;
+  listen(port: number | string, address: string, backlog: number, callback: (err: Error|null, address: string) => void): void;
+  listen(port: number | string, address: string, callback: (err: Error|null, address: string) => void): void;
+  listen(port: number | string, callback: (err: Error|null, address: string) => void): void;
   listen(port: number | string, address?: string, backlog?: number): Promise<string>;
-  listen(opts: { port: number; host?: string; backlog?: number }, callback: (err: Error, address: string) => void): void;
+  listen(opts: { port: number; host?: string; backlog?: number }, callback: (err: Error|null, address: string) => void): void;
   listen(opts: { port: number; host?: string; backlog?: number }): Promise<string>;
 
   ready(): FastifyInstance<RawServer, RawRequest, RawReply> & PromiseLike<undefined>;

package/types/request.d.ts

@@ -1,7 +1,8 @@
 import { FastifyLoggerInstance } from './logger'
-import { RawServerBase, RawServerDefault, RawRequestDefaultExpression, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './utils'
+import { ContextConfigDefault, RawServerBase, RawServerDefault, RawRequestDefaultExpression, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './utils'
 import { RouteGenericInterface } from './route'
 import { FastifyInstance } from './instance'
+import { FastifyContext } from './context'
 
 export interface RequestGenericInterface {
   Body?: RequestBodyDefault;
@@ -18,6 +19,7 @@ export interface FastifyRequest<
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   RawServer extends RawServerBase = RawServerDefault,
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  ContextConfig = ContextConfigDefault,
 > {
   id: any;
   params: RouteGeneric['Params'];
@@ -27,6 +29,7 @@ export interface FastifyRequest<
   log: FastifyLoggerInstance;
   server: FastifyInstance;
   body: RouteGeneric['Body'];
+  context: FastifyContext<ContextConfig>;
 
   /** in order for this to be used the user should ensure they have set the attachValidation option. */
   validationError?: Error & { validation: any; validationContext: string };

package/types/route.d.ts

@@ -59,7 +59,7 @@ export type RouteHandlerMethod<
   ContextConfig = ContextConfigDefault
 > = (
   this: FastifyInstance<RawServer, RawRequest, RawReply>,
-  request: FastifyRequest<RouteGeneric, RawServer, RawRequest>,
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, ContextConfig>,
   reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig>
 ) => void | Promise<RouteGeneric['Reply'] | void>