fastify 3.24.0 → 3.25.2

package/test/listen.test.js

@@ -3,15 +3,29 @@
 const os = require('os')
 const path = require('path')
 const fs = require('fs')
-const test = require('tap').test
+const { test, before } = require('tap')
 const Fastify = require('..')
+const dns = require('dns').promises
+
+let localhost
+let localhostForURL
+
+before(async function () {
+  const lookup = await dns.lookup('localhost')
+  localhost = lookup.address
+  if (lookup.family === 6) {
+    localhostForURL = `[${lookup.address}]`
+  } else {
+    localhostForURL = localhost
+  }
+})
 
 test('listen accepts a callback', t => {
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen((err) => {
-    t.equal(fastify.server.address().address, '127.0.0.1')
+    t.equal(fastify.server.address().address, localhost)
     t.error(err)
   })
 })
@@ -21,7 +35,7 @@ test('listen accepts a port and a callback', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err) => {
-    t.equal(fastify.server.address().address, '127.0.0.1')
+    t.equal(fastify.server.address().address, localhost)
     t.error(err)
   })
 })
@@ -31,7 +45,7 @@ test('listen accepts a port and a callback with (err, address)', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err, address) => {
-    t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err)
   })
 })
@@ -40,7 +54,7 @@ test('listen accepts a port, address, and callback', t => {
   t.plan(1)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', (err) => {
+  fastify.listen(0, localhost, (err) => {
     t.error(err)
   })
 })
@@ -78,8 +92,8 @@ test('listen accepts a port, address and a callback with (err, address)', t => {
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', (err, address) => {
-    t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+  fastify.listen(0, localhost, (err, address) => {
+    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err)
   })
 })
@@ -88,7 +102,7 @@ test('listen accepts a port, address, backlog and callback', t => {
   t.plan(1)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', 511, (err) => {
+  fastify.listen(0, localhost, 511, (err) => {
     t.error(err)
   })
 })
@@ -97,8 +111,8 @@ test('listen accepts a port, address, backlog and callback with (err, address)',
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', 511, (err, address) => {
-    t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+  fastify.listen(0, localhost, 511, (err, address) => {
+    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err)
   })
 })
@@ -111,7 +125,7 @@ test('listen after Promise.resolve()', t => {
     .then(() => {
       f.listen(0, (err, address) => {
         f.server.unref()
-        t.equal(address, 'http://127.0.0.1:' + f.server.address().port)
+        t.equal(address, `http://${localhostForURL}:${f.server.address().port}`)
         t.error(err)
       })
     })
@@ -153,7 +167,7 @@ test('double listen errors callback with (err, address)', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err1, address1) => {
-    t.equal(address1, 'http://127.0.0.1:' + fastify.server.address().port)
+    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err1)
     fastify.listen(fastify.server.address().port, (err2, address2) => {
       t.equal(address2, null)
@@ -167,7 +181,7 @@ test('listen twice on the same port', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err1, address1) => {
-    t.equal(address1, 'http://127.0.0.1:' + fastify.server.address().port)
+    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err1)
     const s2 = Fastify()
     t.teardown(s2.close.bind(s2))
@@ -184,7 +198,7 @@ test('listen twice on the same port callback with (err, address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err1, address1) => {
     const _port = fastify.server.address().port
-    t.equal(address1, 'http://127.0.0.1:' + _port)
+    t.equal(address1, `http://${localhostForURL}:${_port}`)
     t.error(err1)
     const s2 = Fastify()
     t.teardown(s2.close.bind(s2))
@@ -221,7 +235,7 @@ test('listen without callback (port zero)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0)
     .then(() => {
-      t.equal(fastify.server.address().address, '127.0.0.1')
+      t.equal(fastify.server.address().address, localhost)
     })
 })
 
@@ -231,7 +245,7 @@ test('listen without callback (port not given)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen()
     .then(() => {
-      t.equal(fastify.server.address().address, '127.0.0.1')
+      t.equal(fastify.server.address().address, localhost)
     })
 })
 
@@ -241,7 +255,7 @@ test('listen null without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(null)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -251,7 +265,7 @@ test('listen without port without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen()
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -261,7 +275,7 @@ test('listen with undefined without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(undefined)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -271,7 +285,7 @@ test('listen without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -295,7 +309,7 @@ test('double listen without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
       fastify.listen(0)
         .catch(err => {
           t.ok(err)
@@ -329,7 +343,7 @@ test('listen twice on the same port without callback rejects with (address)', t
     .then(address => {
       const s2 = Fastify()
       t.teardown(s2.close.bind(s2))
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
       s2.listen(fastify.server.address().port)
         .catch(err => {
           t.ok(err)

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/request-error.test.js

@@ -157,10 +157,7 @@ test('default clientError handler destroys sockets in writable state', t => {
 
   const fastify = Fastify({
     bodyLimit: 1,
-    keepAliveTimeout: 100,
-    logger: {
-      level: 'trace'
-    }
+    keepAliveTimeout: 100
   })
 
   fastify.server.emit('clientError', new Error(), {
@@ -181,10 +178,7 @@ test('default clientError handler destroys http sockets in non-writable state',
 
   const fastify = Fastify({
     bodyLimit: 1,
-    keepAliveTimeout: 100,
-    logger: {
-      level: 'trace'
-    }
+    keepAliveTimeout: 100
   })
 
   fastify.server.emit('clientError', new Error(), {

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/router-options.test.js

@@ -5,6 +5,15 @@ const sget = require('simple-get')
 const Fastify = require('../')
 const { FST_ERR_BAD_URL } = require('../lib/errors')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('Should honor ignoreTrailingSlash option', t => {
   t.plan(4)
   const fastify = Fastify({
@@ -19,7 +28,7 @@ test('Should honor ignoreTrailingSlash option', t => {
     fastify.server.unref()
     if (err) t.threw(err)
 
-    const baseUrl = 'http://127.0.0.1:' + fastify.server.address().port
+    const baseUrl = getUrl(fastify)
 
     sget.concat(baseUrl + '/test', (err, res, data) => {
       if (err) t.threw(err)

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/stream.test.js

@@ -16,6 +16,15 @@ const Readable = require('stream').Readable
 const split = require('split2')
 const { kDisableRequestLogging, kReplySent } = require('../lib/symbols.js')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('should respond with a stream', t => {
   t.plan(8)
   const fastify = Fastify()
@@ -573,7 +582,7 @@ test('return a 404 if the stream emits a 404 error', t => {
   })
 })
 
-test('should support send module 200 and 404', t => {
+test('should support send module 200 and 404', { only: true }, t => {
   t.plan(8)
   const fastify = Fastify()
 
@@ -591,7 +600,9 @@ test('should support send module 200 and 404', t => {
     t.error(err)
     fastify.server.unref()
 
-    sget(`http://localhost:${fastify.server.address().port}`, function (err, response, data) {
+    const url = getUrl(fastify)
+
+    sget(url, function (err, response, data) {
       t.error(err)
       t.equal(response.headers['content-type'], 'application/octet-stream')
       t.equal(response.statusCode, 200)
@@ -602,7 +613,7 @@ test('should support send module 200 and 404', t => {
       })
     })
 
-    sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
+    sget(url + '/error', function (err, response) {
       t.error(err)
       t.equal(response.statusCode, 404)
     })

package/test/trust-proxy.test.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const t = require('tap')
-const test = t.test
+const { test, before } = t
 const sget = require('simple-get').concat
 const fastify = require('..')
+const dns = require('dns').promises
 
 const sgetForwardedRequest = (app, forHeader, path, protoHeader) => {
   const headers = {
@@ -38,6 +39,13 @@ const testRequestValues = (t, req, options) => {
   }
 }
 
+let localhost
+
+before(async function () {
+  const lookup = await dns.lookup('localhost')
+  localhost = lookup.address
+})
+
 test('trust proxy, not add properties to node req', (t) => {
   t.plan(8)
   const app = fastify({
@@ -49,7 +57,7 @@ test('trust proxy, not add properties to node req', (t) => {
   })
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '2.2.2.2', ips: ['127.0.0.1', '1.1.1.1', '2.2.2.2'] })
+    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'] })
     reply.code(200).send({ ip: req.ip, hostname: req.hostname })
   })
 
@@ -66,7 +74,7 @@ test('trust proxy, not add properties to node req', (t) => {
 test('trust proxy chain', (t) => {
   t.plan(3)
   const app = fastify({
-    trustProxy: ['127.0.0.1', '192.168.1.1']
+    trustProxy: [localhost, '192.168.1.1']
   })
 
   app.get('/trustproxychain', function (req, reply) {
@@ -86,7 +94,7 @@ test('trust proxy chain', (t) => {
 test('trust proxy function', (t) => {
   t.plan(3)
   const app = fastify({
-    trustProxy: (address) => address === '127.0.0.1'
+    trustProxy: (address) => address === localhost
   })
   app.get('/trustproxyfunc', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1' })
@@ -108,7 +116,7 @@ test('trust proxy number', (t) => {
     trustProxy: 1
   })
   app.get('/trustproxynumber', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: ['127.0.0.1', '1.1.1.1'] })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
     reply.code(200).send({ ip: req.ip, hostname: req.hostname })
   })
 
@@ -124,10 +132,10 @@ test('trust proxy number', (t) => {
 test('trust proxy IP addresses', (t) => {
   t.plan(4)
   const app = fastify({
-    trustProxy: '127.0.0.1, 2.2.2.2'
+    trustProxy: `${localhost}, 2.2.2.2`
   })
   app.get('/trustproxyipaddrs', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: ['127.0.0.1', '1.1.1.1'] })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
     reply.code(200).send({ ip: req.ip, hostname: req.hostname })
   })
 

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

@@ -3,7 +3,8 @@ import fastify, {
   FastifyError,
   FastifyInstance,
   RawReplyDefaultExpression,
-  RawRequestDefaultExpression
+  RawRequestDefaultExpression,
+  RawServerDefault
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import { FastifyRequest } from '../../types/request'
@@ -51,6 +52,50 @@ server.setErrorHandler(nodeJSErrorHandler)
 function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {}
 server.setErrorHandler(asyncNodeJSErrorHandler)
 
+class CustomError extends Error {
+  private __brand: any;
+}
+interface ReplyPayload {
+  Reply: {
+    test: boolean;
+  };
+}
+// typed sync error handler
+server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+  expectType<CustomError>(error)
+  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ReplyPayload>)>(reply.send)
+})
+// typed async error handler send
+server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ReplyPayload>)>(reply.send)
+})
+// typed async error handler return
+server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  return { test: true }
+})
+// typed sync error handler send error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+  expectType<CustomError>(error)
+  reply.send({ test: 'foo' })
+}))
+// typed sync error handler return error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+  expectType<CustomError>(error)
+  return { test: 'foo' }
+}))
+// typed async error handler send error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  reply.send({ test: 'foo' })
+}))
+// typed async error handler return error
+expectError(server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
+  expectType<CustomError>(error)
+  return { test: 'foo' }
+}))
+
 function notFoundHandler (request: FastifyRequest, reply: FastifyReply) {}
 function notFoundpreHandlerHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) { done() }
 async function notFoundpreHandlerAsyncHandler (request: FastifyRequest, reply: FastifyReply) {}
@@ -90,6 +135,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()