fastify 4.24.3 → 4.25.1

package/test/hooks.on-ready.test.js

@@ -35,6 +35,22 @@ t.test('onReady should be called in order', t => {
   fastify.ready(err => t.error(err))
 })
 
+t.test('onReady should be called once', async (t) => {
+  const app = Fastify()
+  let counter = 0
+
+  app.addHook('onReady', async function () {
+    counter++
+  })
+
+  const promises = [1, 2, 3, 4, 5].map((id) => app.ready().then(() => id))
+
+  const result = await Promise.race(promises)
+
+  t.strictSame(result, 1, 'Should resolve in order')
+  t.equal(counter, 1, 'Should call onReady only once')
+})
+
 t.test('async onReady should be called in order', async t => {
   t.plan(7)
   const fastify = Fastify()

package/test/hooks.test.js

@@ -3469,7 +3469,7 @@ test('onRequestAbort should support encapsulation', t => {
     done()
   })
 
-  fastify.register(async function (_child, _, done) {
+  fastify.register(async function (_child, _) {
     child = _child
 
     fastify.addHook('onRequestAbort', async function (req) {
@@ -3488,8 +3488,6 @@ test('onRequestAbort should support encapsulation', t => {
         t.equal(++order, 3, 'called in route')
       }
     })
-
-    done()
   })
 
   fastify.listen({ port: 0 }, err => {

package/test/http2/constraint.test.js

@@ -28,7 +28,7 @@ test('A route supports host constraints under http2 protocol and secure connecti
     t.fail('Key/cert loading failed', e)
   }
 
-  const constrain = 'fastify.io'
+  const constrain = 'fastify.dev'
 
   fastify.route({
     method: 'GET',

package/test/internals/errors.test.js

@@ -292,7 +292,7 @@ test('FST_ERR_MISSING_MIDDLEWARE', t => {
   const error = new errors.FST_ERR_MISSING_MIDDLEWARE()
   t.equal(error.name, 'FastifyError')
   t.equal(error.code, 'FST_ERR_MISSING_MIDDLEWARE')
-  t.equal(error.message, 'You must register a plugin for handling middlewares, visit fastify.io/docs/latest/Reference/Middleware/ for more info.')
+  t.equal(error.message, 'You must register a plugin for handling middlewares, visit fastify.dev/docs/latest/Reference/Middleware/ for more info.')
   t.equal(error.statusCode, 500)
   t.ok(error instanceof Error)
 })
@@ -817,6 +817,31 @@ test('FST_ERR_LISTEN_OPTIONS_INVALID', t => {
   t.ok(error instanceof TypeError)
 })
 
+test('Ensure that all errors are in Errors.md TOC', t => {
+  t.plan(78)
+  const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
+
+  const exportedKeys = Object.keys(errors)
+  for (const key of exportedKeys) {
+    if (errors[key].name === 'FastifyError') {
+      t.ok(errorsMd.includes(`  - [${key.toUpperCase()}](#${key.toLowerCase()})`), key)
+    }
+  }
+})
+
+test('Ensure that non-existing errors are not in Errors.md TOC', t => {
+  t.plan(78)
+  const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
+
+  const matchRE = / {4}- \[([A-Z0-9_]+)\]\(#[a-z0-9_]+\)/g
+  const matches = errorsMd.matchAll(matchRE)
+  const exportedKeys = Object.keys(errors)
+
+  for (const match of matches) {
+    t.ok(exportedKeys.indexOf(match[1]) !== -1, match[1])
+  }
+})
+
 test('Ensure that all errors are in Errors.md documented', t => {
   t.plan(78)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
@@ -824,7 +849,7 @@ test('Ensure that all errors are in Errors.md documented', t => {
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
-      t.ok(errorsMd.includes(`#### ${key}\n`), key)
+      t.ok(errorsMd.includes(`<a id="${key.toLowerCase()}">${key.toUpperCase()}</a>`), key)
     }
   }
 })
@@ -833,7 +858,7 @@ test('Ensure that non-existing errors are not in Errors.md documented', t => {
   t.plan(78)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
-  const matchRE = /#### ([0-9a-zA-Z_]+)\n/g
+  const matchRE = /<a id="[0-9a-zA-Z_]+">([0-9a-zA-Z_]+)<\/a>/g
   const matches = errorsMd.matchAll(matchRE)
   const exportedKeys = Object.keys(errors)
 

package/test/internals/reply.test.js

@@ -19,7 +19,7 @@ const {
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
-const warning = require('../../lib/warnings')
+const { FSTDEP019, FSTDEP010 } = require('../../lib/warnings')
 
 const agent = new http.Agent({ keepAlive: false })
 
@@ -1466,14 +1466,13 @@ test('should emit deprecation warning when trying to modify the reply.sent prope
   t.plan(4)
   const fastify = Fastify()
 
-  const deprecationCode = 'FSTDEP010'
-  warning.emitted.delete(deprecationCode)
+  FSTDEP010.emitted = false
 
   process.removeAllListeners('warning')
   process.on('warning', onWarning)
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyDeprecation')
-    t.equal(warning.code, deprecationCode)
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP010.code)
   }
 
   fastify.get('/', (req, reply) => {
@@ -1494,14 +1493,13 @@ test('should emit deprecation warning when trying to use the reply.context.confi
   t.plan(4)
   const fastify = Fastify()
 
-  const deprecationCode = 'FSTDEP019'
-  warning.emitted.delete(deprecationCode)
+  FSTDEP019.emitted = false
 
   process.removeAllListeners('warning')
   process.on('warning', onWarning)
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyDeprecation')
-    t.equal(warning.code, deprecationCode)
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP019.code)
   }
 
   fastify.get('/', (req, reply) => {
@@ -2148,3 +2146,29 @@ test('reply.send will intercept ERR_HTTP_HEADERS_SENT and log an error message',
     t.equal(err.code, 'ERR_HTTP_HEADERS_SENT')
   }
 })
+
+test('Uint8Array view of ArrayBuffer returns correct byteLength', t => {
+  t.plan(5)
+  const fastify = Fastify()
+
+  const arrBuf = new ArrayBuffer(100)
+  const arrView = new Uint8Array(arrBuf, 0, 10)
+  fastify.get('/', function (req, reply) {
+    return reply.send(arrView)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.inject({
+      method: 'GET',
+      url: '/'
+    }, (err, response) => {
+      t.error(err)
+      t.equal(response.headers['content-type'], 'application/octet-stream')
+      t.equal(response.headers['content-length'], '10')
+      t.same(response.rawPayload.byteLength, arrView.byteLength)
+    })
+  })
+})

package/test/logger/instantiation.test.js

@@ -151,7 +151,8 @@ t.test('logger instantiation', (t) => {
     ]
 
     const { file, cleanup } = createTempFile(t)
-    if (process.env.CITGM) { fs.writeFileSync(file, '') }
+    // 0600 permissions (read/write for owner only)
+    if (process.env.CITGM) { fs.writeFileSync(file, '', { mode: 0o600 }) }
 
     const fastify = Fastify({
       logger: { file }

package/test/plugin.4.test.js

@@ -414,3 +414,50 @@ test('hasPlugin returns true when using encapsulation', async t => {
 
   await fastify.ready()
 })
+
+test('registering plugins with mixed style should return a warning', async t => {
+  t.plan(12)
+
+  const pluginNames = ['error-plugin', 'anonymous', 'anotherPlugin', 'anotherPluginNamed']
+
+  const oldWarnings = process.listeners('warning')
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.match(warning.message, new RegExp(`.*${pluginNames.shift()} plugin being registered mixes async and callback styles.*`))
+    t.equal(warning.name, 'FastifyWarning')
+    t.equal(warning.code, 'FSTWRN002')
+  }
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    for (const warning of oldWarnings) {
+      process.on('warning', warning)
+    }
+  })
+
+  const fastify = Fastify()
+
+  const pluginName = 'error-plugin'
+  const errorPlugin = async (app, opts, done) => {
+    done()
+  }
+
+  const namedPlugin = fp(errorPlugin, { name: pluginName })
+
+  async function anotherPlugin (app, opts, done) {
+    done()
+  }
+
+  const anotherPluginNamed = async function (app, opts, done) {
+    done()
+  }
+
+  fastify.register(namedPlugin)
+  fastify.register(async (app, opts, done) => {
+    done()
+  })
+  fastify.register(anotherPlugin)
+  fastify.register(anotherPluginNamed)
+
+  await fastify.ready()
+})

package/test/register.test.js

@@ -105,20 +105,20 @@ test('awaitable register and after', async t => {
   let second = false
   let third = false
 
-  await fastify.register(async (instance, opts, done) => {
+  await fastify.register(async (instance, opts) => {
     first = true
   })
 
   t.equal(first, true)
 
-  fastify.register(async (instance, opts, done) => {
+  fastify.register(async (instance, opts) => {
     second = true
   })
 
   await fastify.after()
   t.equal(second, true)
 
-  fastify.register(async (instance, opts, done) => {
+  fastify.register(async (instance, opts) => {
     third = true
   })
 
@@ -145,7 +145,7 @@ test('awaitable register error handling', async t => {
 
   await t.rejects(fastify.after(), e)
 
-  fastify.register(async (instance, opts, done) => {
+  fastify.register(async (instance, opts) => {
     t.fail('should not be executed')
   })
 
@@ -167,7 +167,7 @@ test('awaitable after error handling', async t => {
 
   await t.rejects(fastify.after(), e)
 
-  fastify.register(async (instance, opts, done) => {
+  fastify.register(async (instance, opts) => {
     t.fail('should not be executed')
   })
 

package/test/reply-trailers.test.js

@@ -200,7 +200,7 @@ test('should emit deprecation warning when using direct return', t => {
 
   process.on('warning', onWarning)
   function onWarning (warning) {
-    t.equal(warning.name, 'FastifyDeprecation')
+    t.equal(warning.name, 'DeprecationWarning')
     t.equal(warning.code, 'FSTDEP013')
   }
   t.teardown(() => process.removeListener('warning', onWarning))

package/test/route.7.test.js

@@ -178,14 +178,15 @@ test('Set a custom HEAD route before GET one without disabling exposeHeadRoutes
 test('Set a custom HEAD route before GET one without disabling exposeHeadRoutes (route)', t => {
   t.plan(7)
 
-  function onWarning (code) {
-    t.equal(code, 'FSTDEP007')
-  }
-  const warning = {
-    emit: onWarning
+  function onWarning () {
+    t.pass('warning emitted')
   }
 
-  const route = proxyquire('../lib/route', { './warnings': warning })
+  const route = proxyquire('../lib/route', {
+    './warnings': {
+      FSTDEP007: onWarning
+    }
+  })
   const fastify = proxyquire('..', { './lib/route.js': route })()
 
   const resBuffer = Buffer.from('I am a coffee!')

package/test/schema-examples.test.js

@@ -540,7 +540,7 @@ test('should be able to handle formats of ajv-formats when added by plugins opti
     method: 'POST',
     payload: {
       id: '254381a5-888c-4b41-8116-e3b1a54980bd',
-      email: 'info@fastify.io'
+      email: 'info@fastify.dev'
     },
     url: '/'
   }, (_err, res) => {
@@ -552,7 +552,7 @@ test('should be able to handle formats of ajv-formats when added by plugins opti
     method: 'POST',
     payload: {
       id: 'invalid',
-      email: 'info@fastify.io'
+      email: 'info@fastify.dev'
     },
     url: '/'
   }, (_err, res) => {

package/test/schema-feature.test.js

@@ -6,7 +6,7 @@ const fp = require('fastify-plugin')
 const deepClone = require('rfdc')({ circles: true, proto: false })
 const Ajv = require('ajv')
 const { kSchemaController } = require('../lib/symbols.js')
-const warning = require('../lib/warnings')
+const { FSTWRN001 } = require('../lib/warnings')
 
 const echoParams = (req, reply) => { reply.send(req.params) }
 const echoBody = (req, reply) => { reply.send(req.body) }
@@ -261,12 +261,12 @@ test('Should emit warning if the schema headers is undefined', t => {
   process.on('warning', onWarning)
   function onWarning (warning) {
     t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, 'FSTWRN001')
+    t.equal(warning.code, FSTWRN001.code)
   }
 
   t.teardown(() => {
     process.removeListener('warning', onWarning)
-    warning.emitted.set('FSTWRN001', false)
+    FSTWRN001.emitted = false
   })
 
   fastify.post('/:id', {
@@ -292,12 +292,12 @@ test('Should emit warning if the schema body is undefined', t => {
   process.on('warning', onWarning)
   function onWarning (warning) {
     t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, 'FSTWRN001')
+    t.equal(warning.code, FSTWRN001.code)
   }
 
   t.teardown(() => {
     process.removeListener('warning', onWarning)
-    warning.emitted.set('FSTWRN001', false)
+    FSTWRN001.emitted = false
   })
 
   fastify.post('/:id', {
@@ -323,12 +323,12 @@ test('Should emit warning if the schema query is undefined', t => {
   process.on('warning', onWarning)
   function onWarning (warning) {
     t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, 'FSTWRN001')
+    t.equal(warning.code, FSTWRN001.code)
   }
 
   t.teardown(() => {
     process.removeListener('warning', onWarning)
-    warning.emitted.set('FSTWRN001', false)
+    FSTWRN001.emitted = false
   })
 
   fastify.post('/:id', {
@@ -354,12 +354,12 @@ test('Should emit warning if the schema params is undefined', t => {
   process.on('warning', onWarning)
   function onWarning (warning) {
     t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, 'FSTWRN001')
+    t.equal(warning.code, FSTWRN001.code)
   }
 
   t.teardown(() => {
     process.removeListener('warning', onWarning)
-    warning.emitted.set('FSTWRN001', false)
+    FSTWRN001.emitted = false
   })
 
   fastify.post('/:id', {
@@ -390,14 +390,14 @@ test('Should emit a warning for every route with undefined schema', t => {
   // => 3 x 4 assertions = 12 assertions
   function onWarning (warning) {
     t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, 'FSTWRN001')
+    t.equal(warning.code, FSTWRN001.code)
     t.equal(runs++, expectedWarningEmitted.shift())
   }
 
   process.on('warning', onWarning)
   t.teardown(() => {
     process.removeListener('warning', onWarning)
-    warning.emitted.set('FSTWRN001', false)
+    FSTWRN001.emitted = false
   })
 
   fastify.get('/undefinedParams/:id', {

package/test/server.test.js

@@ -4,6 +4,7 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 const semver = require('semver')
+const undici = require('undici')
 
 test('listen should accept null port', t => {
   t.plan(1)
@@ -123,3 +124,53 @@ test('abort signal', { skip: semver.lt(process.version, '16.0.0') }, t => {
 
   t.end()
 })
+
+t.test('#5180 - preClose should be called before closing secondary server', t => {
+  t.plan(2)
+  const fastify = Fastify({ forceCloseConnections: true })
+  let flag = false
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.addHook('preClose', async () => {
+    flag = true
+  })
+
+  fastify.get('/', async (req, reply) => {
+    await new Promise((resolve) => {
+      setTimeout(() => resolve(1), 1000)
+    })
+
+    return { hello: 'world' }
+  })
+
+  fastify.listen({ port: 0 }, (err) => {
+    t.error(err)
+    const addresses = fastify.addresses()
+    const mainServerAddress = fastify.server.address()
+    let secondaryAddress
+    for (const addr of addresses) {
+      if (addr.family !== mainServerAddress.family) {
+        secondaryAddress = addr
+        secondaryAddress.address = secondaryAddress.family === 'IPv6'
+          ? `[${secondaryAddress.address}]`
+          : secondaryAddress.address
+        break
+      }
+    }
+
+    if (!secondaryAddress) {
+      t.pass('no secondary server')
+      return
+    }
+
+    undici.request(`http://${secondaryAddress.address}:${secondaryAddress.port}/`)
+      .then(
+        () => { t.fail('Request should not succeed') },
+        () => { t.ok(flag) }
+      )
+
+    setTimeout(() => {
+      fastify.close()
+    }, 250)
+  })
+})

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

@@ -14,7 +14,7 @@ import fastify, {
   RegisterOptions,
   RouteOptions
 } from '../../fastify'
-import { RequestPayload, preHandlerAsyncHookHandler } from '../../types/hooks'
+import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, preHandlerAsyncHookHandler } from '../../types/hooks'
 import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
 
 const server = fastify()
@@ -392,6 +392,129 @@ server.route<RouteGenericInterface, CustomContextConfig>({
   }
 })
 
+server.route({
+  method: 'GET',
+  url: '/',
+  handler: (request, reply) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+  },
+  onRequest: (request, reply, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<HookHandlerDoneFunction>(done)
+  },
+  onRequestAbort: (request, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<HookHandlerDoneFunction>(done)
+  },
+  preParsing: (request, reply, payload, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<RequestPayload>(payload)
+    expectType<<TError extends Error = FastifyError>(err?: TError | null | undefined, res?: RequestPayload | undefined) => void>(done)
+  },
+  preValidation: (request, reply, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<HookHandlerDoneFunction>(done)
+  },
+  preHandler: (request, reply, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<HookHandlerDoneFunction>(done)
+  },
+  preSerialization: (request, reply, payload, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<unknown>(payload)
+    expectType<DoneFuncWithErrOrRes>(done)
+  },
+  onSend: (request, reply, payload, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<unknown>(payload)
+    expectType<DoneFuncWithErrOrRes>(done)
+  },
+  onResponse: (request, reply, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<HookHandlerDoneFunction>(done)
+  },
+  onTimeout: (request, reply, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<HookHandlerDoneFunction>(done)
+  },
+  onError: (request, reply, error, done) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<FastifyError>(error)
+    expectType<() => void>(done)
+  }
+})
+
+server.get('/', {
+  onRequest: async (request, reply) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+  },
+  onRequestAbort: async (request, reply) => {
+    expectType<FastifyRequest>(request)
+  },
+  preParsing: async (request, reply, payload) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<RequestPayload>(payload)
+  },
+  preValidation: async (request, reply) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+  },
+  preHandler: async (request, reply) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+  },
+  preSerialization: async (request, reply, payload) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<unknown>(payload)
+  },
+  onSend: async (request, reply, payload) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<unknown>(payload)
+  },
+  onResponse: async (request, reply) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+  },
+  onTimeout: async (request, reply) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+  },
+  onError: async (request, reply, error) => {
+    expectType<FastifyRequest>(request)
+    expectType<FastifyReply>(reply)
+    expectType<FastifyError>(error)
+  }
+}, async (request, reply) => {
+  expectType<FastifyRequest>(request)
+  expectType<FastifyReply>(reply)
+})
+
+// TODO: Should throw errors
+// expectError(server.get('/', { onRequest: async (request, reply, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { onRequestAbort: async (request, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { preParsing: async (request, reply, payload, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { preValidation: async (request, reply, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { preHandler: async (request, reply, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { preSerialization: async (request, reply, payload, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { onSend: async (request, reply, payload, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { onResponse: async (request, reply, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { onTimeout: async (request, reply, done) => {} }, async (request, reply) => {}))
+// expectError(server.get('/', { onError: async (request, reply, error, done) => {} }, async (request, reply) => {}))
+
 server.addHook('preClose', function (done) {
   expectType<FastifyInstance>(this)
   expectAssignable<(err?: FastifyError) => void>(done)

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

@@ -256,6 +256,18 @@ expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 },
 expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42, exclusive: true }, () => {}))
 expectNotDeprecated(server.listen({ port: 3000, host: '::/0', ipv6Only: true }, () => {}))
 
+// test after method
+expectAssignable<FastifyInstance>(server.after())
+expectAssignable<FastifyInstance>(server.after((err) => {
+  expectType<Error | null>(err)
+}))
+
+// test ready method
+expectAssignable<FastifyInstance>(server.ready())
+expectAssignable<FastifyInstance>(server.ready((err) => {
+  expectType<Error | null>(err)
+}))
+
 expectAssignable<void>(server.routing({} as RawRequestDefaultExpression, {} as RawReplyDefaultExpression))
 
 expectType<FastifyInstance>(fastify().get<RouteGenericInterface, { contextKey: string }>('/', {

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

@@ -74,6 +74,20 @@ P.Logger
 
 expectType<P.Logger>(serverWithPino.log)
 
+serverWithPino.route({
+  method: 'GET',
+  url: '/',
+  handler (request) {
+    expectType<P.Logger>(this.log)
+    expectType<P.Logger>(request.log)
+  }
+})
+
+serverWithPino.get('/', function (request) {
+  expectType<P.Logger>(this.log)
+  expectType<P.Logger>(request.log)
+})
+
 const serverWithLogOptions = fastify<
 Server,
 IncomingMessage,