fastify 5.6.0 → 5.6.2

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

@@ -25,20 +25,53 @@ import { Bindings, ChildLoggerOptions } from '../../types/logger'
 
 // FastifyInstance
 // http server
-expectError<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & Promise<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({}))
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ http: {} }))
+expectError<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  Promise<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify())
+expectAssignable<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify())
+expectType<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify())
+expectType<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify({}))
+expectType<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify({ http: {} }))
 // https server
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: {} }))
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: null }))
+expectType<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify({ https: {} }))
+expectType<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify({ https: null }))
 // http2 server
-expectType<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse> & SafePromiseLike<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, http2SessionTimeout: 1000 }))
-expectType<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> & SafePromiseLike<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, https: {}, http2SessionTimeout: 1000 }))
+expectType<
+  FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse> &
+  SafePromiseLike<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>
+>(fastify({ http2: true, http2SessionTimeout: 1000 }))
+expectType<
+  FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> &
+  SafePromiseLike<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse>>
+>(fastify({ http2: true, https: {}, http2SessionTimeout: 1000 }))
 expectType<LightMyRequestChain>(fastify({ http2: true, https: {} }).inject())
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ schemaController: {} }))
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(
+expectType<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(fastify({ schemaController: {} }))
+expectType<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(
   fastify({
     schemaController: {
       compilersFactory: {}
@@ -61,13 +94,18 @@ expectAssignable<InjectOptions>({ query: '' })
 fastify({ http2: true, https: {} }).inject().then((resp) => {
   expectAssignable<LightMyRequestResponse>(resp)
 })
-const lightMyRequestCallback: LightMyRequestCallback = (err: Error | undefined, response: LightMyRequestResponse | undefined) => {
+const lightMyRequestCallback: LightMyRequestCallback = (
+  err: Error | undefined,
+  response: LightMyRequestResponse | undefined
+) => {
   if (err) throw err
 }
 fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
 
 // server options
-expectAssignable<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>(fastify({ http2: true }))
+expectAssignable<
+  FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>
+>(fastify({ http2: true }))
 expectAssignable<FastifyInstance>(fastify({ ignoreTrailingSlash: true }))
 expectAssignable<FastifyInstance>(fastify({ ignoreDuplicateSlashes: true }))
 expectAssignable<FastifyInstance>(fastify({ connectionTimeout: 1000 }))
@@ -81,11 +119,17 @@ expectAssignable<FastifyInstance>(fastify({ requestIdLogLabel: 'request-id' }))
 expectAssignable<FastifyInstance>(fastify({ onProtoPoisoning: 'error' }))
 expectAssignable<FastifyInstance>(fastify({ onConstructorPoisoning: 'error' }))
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { rounding: 'ceil' } }))
-expectAssignable<FastifyInstance>(fastify({ serializerOpts: { ajv: { missingRefs: 'ignore' } } }))
+expectAssignable<FastifyInstance>(
+  fastify({ serializerOpts: { ajv: { missingRefs: 'ignore' } } })
+)
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { schema: {} } }))
 expectAssignable<FastifyInstance>(fastify({ serializerOpts: { otherProp: {} } }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: true }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: true }))
+expectAssignable<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
+>(fastify({ logger: true }))
+expectAssignable<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
+>(fastify({ logger: true }))
 expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({
   logger: {
     level: 'info',
@@ -126,7 +170,9 @@ const customLogger = {
   debug: () => { },
   child: () => customLogger
 }
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>(fastify({ logger: customLogger }))
+expectAssignable<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
+>(fastify({ logger: customLogger }))
 expectAssignable<FastifyInstance>(fastify({ serverFactory: () => http.createServer() }))
 expectAssignable<FastifyInstance>(fastify({ caseSensitive: true }))
 expectAssignable<FastifyInstance>(fastify({ requestIdHeader: 'request-id' }))
@@ -221,7 +267,13 @@ expectAssignable<FastifyInstance>(fastify({
 }))
 
 expectAssignable<FastifyInstance>(fastify({
-  childLoggerFactory: function (this: FastifyInstance, logger: FastifyBaseLogger, bindings: Bindings, opts: ChildLoggerOptions, req: RawRequestDefaultExpression) {
+  childLoggerFactory: function (
+    this: FastifyInstance,
+    logger: FastifyBaseLogger,
+    bindings: Bindings,
+    opts: ChildLoggerOptions,
+    req: RawRequestDefaultExpression
+  ) {
     expectType<FastifyBaseLogger>(logger)
     expectType<Bindings>(bindings)
     expectType<ChildLoggerOptions>(opts)

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

@@ -416,7 +416,12 @@ server.route({
     expectType<FastifyRequest>(request)
     expectType<FastifyReply>(reply)
     expectType<RequestPayload>(payload)
-    expectType<<TError extends Error = FastifyError>(err?: TError | null | undefined, res?: RequestPayload | undefined) => void>(done)
+    expectType<
+      <TError extends Error = FastifyError>(
+        err?: TError | null | undefined,
+        res?: RequestPayload | undefined
+      ) => void
+        >(done)
   },
   preValidation: (request, reply, done) => {
     expectType<FastifyRequest>(request)

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

@@ -42,7 +42,7 @@ expectType<string[]>(server.supportedMethods)
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
-    expectType<FastifyError>(error)
+    expectType<unknown>(error)
     expectAssignable<FastifyInstance>(this)
   })
 )
@@ -127,35 +127,49 @@ server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply)
 
 function notFoundHandler (request: FastifyRequest, reply: FastifyReply) {}
 async function notFoundAsyncHandler (request: FastifyRequest, reply: FastifyReply) {}
-function notFoundpreHandlerHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) { done() }
-async function notFoundpreHandlerAsyncHandler (request: FastifyRequest, reply: FastifyReply) {}
-function notFoundpreValidationHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) { done() }
-async function notFoundpreValidationAsyncHandler (request: FastifyRequest, reply: FastifyReply) {}
+function notFoundpreHandlerHandler (
+  request: FastifyRequest,
+  reply: FastifyReply,
+  done: HookHandlerDoneFunction
+) { done() }
+async function notFoundpreHandlerAsyncHandler (
+  request: FastifyRequest,
+  reply: FastifyReply
+) {}
+function notFoundpreValidationHandler (
+  request: FastifyRequest,
+  reply: FastifyReply,
+  done: HookHandlerDoneFunction
+) { done() }
+async function notFoundpreValidationAsyncHandler (
+  request: FastifyRequest,
+  reply: FastifyReply
+) {}
 
 server.setNotFoundHandler(notFoundHandler)
 server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler }, notFoundHandler)
 server.setNotFoundHandler({ preHandler: notFoundpreHandlerAsyncHandler }, notFoundHandler)
 server.setNotFoundHandler({ preValidation: notFoundpreValidationHandler }, notFoundHandler)
 server.setNotFoundHandler({ preValidation: notFoundpreValidationAsyncHandler }, notFoundHandler)
-server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler }, notFoundHandler)
+server.setNotFoundHandler(
+  { preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler },
+  notFoundHandler
+)
 
 server.setNotFoundHandler(notFoundAsyncHandler)
 server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler }, notFoundAsyncHandler)
 server.setNotFoundHandler({ preHandler: notFoundpreHandlerAsyncHandler }, notFoundAsyncHandler)
 server.setNotFoundHandler({ preValidation: notFoundpreValidationHandler }, notFoundAsyncHandler)
 server.setNotFoundHandler({ preValidation: notFoundpreValidationAsyncHandler }, notFoundAsyncHandler)
-server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler }, notFoundAsyncHandler)
+server.setNotFoundHandler(
+  { preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler },
+  notFoundAsyncHandler
+)
 
 server.setNotFoundHandler(function (_, reply) {
   return reply.send('')
 })
 
-function invalidErrorHandler (error: number) {
-  if (error) throw error
-}
-
-expectError(server.setErrorHandler(invalidErrorHandler))
-
 server.setSchemaController({
   bucket: (parentSchemas: unknown) => {
     return {
@@ -253,7 +267,7 @@ expectAssignable<void>(server.routing({} as RawRequestDefaultExpression, {} as R
 expectType<FastifyInstance>(fastify().get<RouteGenericInterface, { contextKey: string }>('/', {
   handler: () => {},
   errorHandler: (error, request, reply) => {
-    expectAssignable<FastifyError>(error)
+    expectAssignable<unknown>(error)
     expectAssignable<FastifyRequest>(request)
     expectAssignable<{ contextKey: string }>(request.routeOptions.config)
     expectAssignable<FastifyReply>(reply)
@@ -286,7 +300,13 @@ expectAssignable<FastifyInstance>(
   })
 )
 
-function childLoggerFactory (this: FastifyInstance, logger: FastifyBaseLogger, bindings: Bindings, opts: ChildLoggerOptions, req: RawRequestDefaultExpression) {
+function childLoggerFactory (
+  this: FastifyInstance,
+  logger: FastifyBaseLogger,
+  bindings: Bindings,
+  opts: ChildLoggerOptions,
+  req: RawRequestDefaultExpression
+) {
   return logger.child(bindings, opts)
 }
 server.setChildLoggerFactory(childLoggerFactory)

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

@@ -17,12 +17,24 @@ expectType<FastifyLoggerInstance>(fastify().log)
 class Foo {}
 
 ['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(logLevel => {
-  expectType<FastifyLogFn>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel])
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](''))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({}))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({ foo: 'bar' }))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Error()))
-  expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Foo()))
+  expectType<FastifyLogFn>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]('')
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({})
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel]({ foo: 'bar' })
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Error())
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Foo())
+  )
 })
 
 interface CustomLogger extends FastifyBaseLogger {

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

@@ -21,8 +21,15 @@ const testPluginOptsAsync: FastifyPluginAsync<TestOptions> = async function (ins
   expectType<TestOptions>(opts)
 }
 
-const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
-const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
+const testPluginOptsWithType = (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginOptsWithTypeAsync = async (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions
+) => { }
 
 expectError(fastify().register(testPluginOpts, {})) // error because missing required options from generic declaration
 expectError(fastify().register(testPluginOptsAsync, {})) // error because missing required options from generic declaration
@@ -43,16 +50,27 @@ expectAssignable<FastifyInstance>(fastify().register(testPluginCallback, {}))
 const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
 expectAssignable<FastifyInstance>(fastify().register(testPluginAsync, {}))
 
-expectAssignable<FastifyInstance>(fastify().register(function (instance, opts): Promise<void> { return Promise.resolve() }))
+expectAssignable<FastifyInstance>(
+  fastify().register(function (instance, opts): Promise<void> { return Promise.resolve() })
+)
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, () => { }))
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, { logLevel: 'info', prefix: 'foobar' }))
 
 expectError(fastify().register(function (instance, opts, done) { }, { ...testOptions, logLevel: '' })) // must use a valid logLevel
 
 const httpsServer = fastify({ https: {} })
-expectError<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & Promise<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
-expectAssignable<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
+expectError<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  Promise<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(httpsServer)
+expectAssignable<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(httpsServer)
+expectType<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(httpsServer)
 
 // Chainable
 httpsServer

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

@@ -9,7 +9,11 @@ const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
 const testPluginOpts: FastifyPluginCallback = function (instance, opts, done) { }
 const testPluginOptsAsync: FastifyPluginAsync = async function (instance, opts) { }
 
-const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginOptsWithType = (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
 const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
 
 interface TestOptions extends FastifyPluginOptions {
@@ -46,8 +50,15 @@ const serverWithHttp2 = fastify({ http2: true })
 type ServerWithHttp2 = FastifyInstance<Http2Server, Http2ServerRequest, Http2ServerResponse>
 const testPluginWithHttp2: FastifyPluginCallback<TestOptions, Http2Server> = function (instance, opts, done) { }
 const testPluginWithHttp2Async: FastifyPluginAsync<TestOptions, Http2Server> = async function (instance, opts) { }
-const testPluginWithHttp2WithType = (instance: ServerWithHttp2, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
-const testPluginWithHttp2WithTypeAsync = async (instance: ServerWithHttp2, opts: FastifyPluginOptions) => { }
+const testPluginWithHttp2WithType = (
+  instance: ServerWithHttp2,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginWithHttp2WithTypeAsync = async (
+  instance: ServerWithHttp2,
+  opts: FastifyPluginOptions
+) => { }
 const testOptions: TestOptions = {
   option1: 'a',
   option2: false
@@ -82,11 +93,32 @@ expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: Serv
 // With Type Provider
 type TestTypeProvider = { schema: 'test', validator: 'test', serializer: 'test' }
 const serverWithTypeProvider = fastify().withTypeProvider<TestTypeProvider>()
-type ServerWithTypeProvider = FastifyInstance<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance, TestTypeProvider>
-const testPluginWithTypeProvider: FastifyPluginCallback<TestOptions, RawServerDefault, TestTypeProvider> = function (instance, opts, done) { }
-const testPluginWithTypeProviderAsync: FastifyPluginAsync<TestOptions, RawServerDefault, TestTypeProvider> = async function (instance, opts) { }
-const testPluginWithTypeProviderWithType = (instance: ServerWithTypeProvider, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
-const testPluginWithTypeProviderWithTypeAsync = async (instance: ServerWithTypeProvider, opts: FastifyPluginOptions) => { }
+type ServerWithTypeProvider = FastifyInstance<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  FastifyLoggerInstance,
+  TestTypeProvider
+>
+const testPluginWithTypeProvider: FastifyPluginCallback<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider
+> = function (instance, opts, done) { }
+const testPluginWithTypeProviderAsync: FastifyPluginAsync<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider
+> = async function (instance, opts) { }
+const testPluginWithTypeProviderWithType = (
+  instance: ServerWithTypeProvider,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginWithTypeProviderWithTypeAsync = async (
+  instance: ServerWithTypeProvider,
+  opts: FastifyPluginOptions
+) => { }
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginCallback))
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginAsync))
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOpts))
@@ -129,34 +161,77 @@ const customLogger = {
 const serverWithTypeProviderAndLogger = fastify({
   loggerInstance: customLogger
 }).withTypeProvider<TestTypeProvider>()
-type ServerWithTypeProviderAndLogger = FastifyInstance<Server, IncomingMessage, ServerResponse, typeof customLogger, TestTypeProvider>
-const testPluginWithTypeProviderAndLogger: FastifyPluginCallback<TestOptions, RawServerDefault, TestTypeProvider, typeof customLogger> = function (instance, opts, done) { }
-const testPluginWithTypeProviderAndLoggerAsync: FastifyPluginAsync<TestOptions, RawServerDefault, TestTypeProvider, typeof customLogger> = async function (instance, opts) { }
-const testPluginWithTypeProviderAndLoggerWithType = (instance: ServerWithTypeProviderAndLogger, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
-const testPluginWithTypeProviderAndLoggerWithTypeAsync = async (instance: ServerWithTypeProviderAndLogger, opts: FastifyPluginOptions) => { }
+type ServerWithTypeProviderAndLogger = FastifyInstance<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  typeof customLogger,
+  TestTypeProvider
+>
+const testPluginWithTypeProviderAndLogger: FastifyPluginCallback<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider,
+  typeof customLogger
+> = function (instance, opts, done) { }
+const testPluginWithTypeProviderAndLoggerAsync: FastifyPluginAsync<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider,
+  typeof customLogger
+> = async function (instance, opts) { }
+const testPluginWithTypeProviderAndLoggerWithType = (
+  instance: ServerWithTypeProviderAndLogger,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginWithTypeProviderAndLoggerWithTypeAsync = async (
+  instance: ServerWithTypeProviderAndLogger,
+  opts: FastifyPluginOptions
+) => { }
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginCallback))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginAsync))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOpts))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsAsync))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithType))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithTypeAsync))
-// @ts-expect-error
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger, testOptions))
-// @ts-expect-error
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync, testOptions))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithType))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithTypeAsync))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register((instance) => {
-  expectAssignable<FastifyInstance>(instance)
-}))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register((instance: ServerWithTypeProviderAndLogger) => {
-  expectAssignable<ServerWithTypeProviderAndLogger>(instance)
-}))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(async (instance) => {
-  expectAssignable<FastifyInstance>(instance)
-}))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(async (instance: ServerWithTypeProviderAndLogger) => {
-  expectAssignable<ServerWithTypeProviderAndLogger>(instance)
-}))
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  // @ts-expect-error
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger, testOptions)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  // @ts-expect-error
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync, testOptions)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithType)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithTypeAsync)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register((instance) => {
+    expectAssignable<FastifyInstance>(instance)
+  })
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register((instance: ServerWithTypeProviderAndLogger) => {
+    expectAssignable<ServerWithTypeProviderAndLogger>(instance)
+  })
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(async (instance) => {
+    expectAssignable<FastifyInstance>(instance)
+  })
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(async (instance: ServerWithTypeProviderAndLogger) => {
+    expectAssignable<ServerWithTypeProviderAndLogger>(instance)
+  })
+)

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

@@ -20,7 +20,9 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<number>(reply.elapsedTime)
   expectType<number>(reply.statusCode)
   expectType<boolean>(reply.sent)
-  expectType<(hints: Record<string, string | string[]>, callback?: (() => void) | undefined) => void>(reply.writeEarlyHints)
+  expectType<
+          (hints: Record<string, string | string[]>, callback?: (() => void) | undefined) => void
+            >(reply.writeEarlyHints)
   expectType<((payload?: unknown) => FastifyReply)>(reply.send)
   expectAssignable<(key: string, value: any) => FastifyReply>(reply.header)
   expectAssignable<(values: { [key: string]: any }) => FastifyReply>(reply.headers)
@@ -35,14 +37,29 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<(fn: (payload: any) => string) => FastifyReply>(reply.serializer)
   expectType<(payload: any) => string | ArrayBuffer | Buffer>(reply.serialize)
   expectType<(fulfilled: () => void, rejected: (err: Error) => void) => void>(reply.then)
-  expectType<(key: string, fn: ((reply: FastifyReply, payload: string | Buffer | null) => Promise<string>) | ((reply: FastifyReply, payload: string | Buffer | null, done: (err: Error | null, value?: string) => void) => void)) => FastifyReply>(reply.trailer)
+  expectType<
+      (
+      key: string,
+      fn: ((reply: FastifyReply, payload: string | Buffer | null) => Promise<string>) |
+        ((reply: FastifyReply, payload: string | Buffer | null,
+          done: (err: Error | null, value?: string) => void) => void)
+      ) => FastifyReply
+        >(reply.trailer)
   expectType<(key: string) => boolean>(reply.hasTrailer)
   expectType<(key: string) => FastifyReply>(reply.removeTrailer)
   expectType<FastifyInstance>(reply.server)
-  expectAssignable<((httpStatus: string) => DefaultSerializationFunction | undefined)>(reply.getSerializationFunction)
-  expectAssignable<((schema: { [key: string]: unknown }) => DefaultSerializationFunction | undefined)>(reply.getSerializationFunction)
-  expectAssignable<((schema: { [key: string]: unknown }, httpStatus?: string) => DefaultSerializationFunction)>(reply.compileSerializationSchema)
-  expectAssignable<((input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpStatus?: string) => unknown)>(reply.serializeInput)
+  expectAssignable<
+          ((httpStatus: string) => DefaultSerializationFunction | undefined)
+            >(reply.getSerializationFunction)
+  expectAssignable<
+          ((schema: { [key: string]: unknown }) => DefaultSerializationFunction | undefined)
+            >(reply.getSerializationFunction)
+  expectAssignable<
+          ((schema: { [key: string]: unknown }, httpStatus?: string) => DefaultSerializationFunction)
+            >(reply.compileSerializationSchema)
+  expectAssignable<
+          ((input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpStatus?: string) => unknown)
+            >(reply.serializeInput)
   expectAssignable<((input: { [key: string]: unknown }, httpStatus: string) => unknown)>(reply.serializeInput)
   expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(reply.routeOptions.config)
   expectType<string>(reply.getDecorator<string>('foo'))

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

@@ -91,7 +91,9 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifyInstance>(request.server)
   expectAssignable<(httpPart: HTTPRequestPart) => ExpectedGetValidationFunction>(request.getValidationFunction)
   expectAssignable<(schema: { [key: string]: unknown }) => ExpectedGetValidationFunction>(request.getValidationFunction)
-  expectAssignable<(input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
+  expectAssignable<
+          (input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean
+            >(request.validateInput)
   expectAssignable<(input: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
   expectType<string>(request.getDecorator<string>('foo'))
   expectType<void>(request.setDecorator('foo', 'hello'))
@@ -99,14 +101,25 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectError(request.setDecorator<string>('foo', true))
 }
 
-const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, CustomLoggerInterface> = function (request, _reply) {
+const getHandlerWithCustomLogger: RouteHandlerMethod<
+  RawServerDefault,
+  RawRequestDefaultExpression,
+  RawReplyDefaultExpression,
+  RouteGenericInterface,
+  ContextConfigDefault,
+  FastifySchema,
+  FastifyTypeProviderDefault,
+  CustomLoggerInterface
+> = function (request, _reply) {
   expectType<CustomLoggerInterface>(request.log)
 }
 
 const postHandler: Handler = function (request) {
   expectType<RequestBody>(request.body)
   expectType<RequestParams>(request.params)
-  expectType<RequestHeaders & RawRequestDefaultExpression['headers']>(request.headers)
+  expectType<RequestHeaders & RawRequestDefaultExpression['headers']>(
+    request.headers
+  )
   expectType<RequestQuerystring>(request.query)
   expectType<string>(request.body.content)
   expectType<string>(request.query.from)
@@ -154,15 +167,21 @@ const customLogger: CustomLoggerInterface = {
 const serverWithCustomLogger = fastify({ loggerInstance: customLogger })
 expectError<
 FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
-& Promise<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+& Promise<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
 >(serverWithCustomLogger)
 expectAssignable<
 FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
-& PromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+& PromiseLike<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
 >(serverWithCustomLogger)
 expectType<
 FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
-& SafePromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+& SafePromiseLike<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
 >(serverWithCustomLogger)
 
 serverWithCustomLogger.get('/get', getHandlerWithCustomLogger)

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

@@ -23,7 +23,16 @@ declare module '../../fastify' {
   }
 
   /* eslint-disable @typescript-eslint/no-unused-vars */
-  interface FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger, RequestType> {
+  interface FastifyRequest<
+    RouteGeneric,
+    RawServer,
+    RawRequest,
+    SchemaCompiler,
+    TypeProvider,
+    ContextConfig,
+    Logger,
+    RequestType
+  > {
     message: ContextConfig extends { includeMessage: true }
       ? string
       : null;