fastify 3.27.4 → 4.0.0-alpha.3

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

@@ -7,7 +7,7 @@ import fastify, {
   LightMyRequestChain,
   LightMyRequestResponse,
   LightMyRequestCallback,
-  InjectOptions
+  InjectOptions, FastifyBaseLogger
 } from '../../fastify'
 import * as http from 'http'
 import * as https from 'https'
@@ -50,7 +50,9 @@ expectAssignable<InjectOptions>({ query: '' })
 fastify({ http2: true, https: {} }).inject().then((resp) => {
   expectAssignable<LightMyRequestResponse>(resp)
 })
-const lightMyRequestCallback: LightMyRequestCallback = (err: Error, response: LightMyRequestResponse) => {}
+const lightMyRequestCallback: LightMyRequestCallback = (err: Error, response: LightMyRequestResponse) => {
+  if (err) throw err
+}
 fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
 
 // server options
@@ -70,9 +72,9 @@ expectAssignable<FastifyInstance>(fastify({ serializerOpts: { rounding: 'ceil' }
 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>>(fastify({ logger: true }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({ logger: true }))
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({
+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',
     genReqId: () => 'request-id',
@@ -103,6 +105,7 @@ expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerR
   }
 }))
 const customLogger = {
+  level: 'info',
   info: () => { },
   warn: () => { },
   error: () => { },
@@ -111,7 +114,7 @@ const customLogger = {
   debug: () => { },
   child: () => customLogger
 }
-expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(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' }))
@@ -174,24 +177,13 @@ expectAssignable<FastifyInstance>(fastify({ return503OnClosing: true }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {
     customOptions: {
-      nullable: false
+      removeAdditional: 'all'
     },
     plugins: [() => { }]
   }
 }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {
-    customOptions: {
-      nullable: false
-    },
-    plugins: [[() => { }, 'keyword']]
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({
-  ajv: {
-    customOptions: {
-      nullable: false
-    },
     plugins: [[() => { }, ['keyword1', 'keyword2']]]
   }
 }))

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

@@ -6,12 +6,16 @@ import fastify, {
   FastifyRequest,
   RawReplyDefaultExpression,
   RawRequestDefaultExpression,
-  RawServerBase,
   RouteOptions,
   RegisterOptions,
-  FastifyPluginOptions
+  FastifyPluginOptions,
+  FastifySchema,
+  FastifyTypeProviderDefault,
+  ContextConfigDefault, FastifyContextConfig, RawServerDefault
 } from '../../fastify'
 import { preHandlerAsyncHookHandler, RequestPayload } from '../../types/hooks'
+import { RouteGenericInterface } from '../../types/route'
+import { ResolveFastifyRequestType } from '../../types/type-provider'
 
 const server = fastify()
 
@@ -213,11 +217,15 @@ server.addHook('onClose', async (instance) => {
 // Use case to monitor any regression on issue #3620
 // ref.: https://github.com/fastify/fastify/issues/3620
 const customTypedHook: preHandlerAsyncHookHandler<
-RawServerBase,
+RawServerDefault,
 RawRequestDefaultExpression,
 RawReplyDefaultExpression,
-Record<string, unknown>
-> = async function (request, reply) {
+RouteGenericInterface,
+ContextConfigDefault,
+FastifySchema,
+FastifyTypeProviderDefault,
+ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>
+> = async function (request, reply): Promise<void> {
   expectType<FastifyInstance>(this)
   expectAssignable<FastifyRequest>(request)
   expectAssignable<FastifyReply>(reply)
@@ -226,3 +234,51 @@ Record<string, unknown>
 server.register(async (instance) => {
   instance.addHook('preHandler', customTypedHook)
 })
+
+// Test custom Context Config types for hooks
+type CustomContextConfig = FastifyContextConfig & {
+  foo: string;
+  bar: number;
+}
+
+server.route<RouteGenericInterface, CustomContextConfig>({
+  method: 'GET',
+  url: '/',
+  handler: () => {},
+  onRequest: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preParsing: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preValidation: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preHandler: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preSerialization: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onSend: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onResponse: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onTimeout: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onError: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  }
+})

package/test/types/import.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

package/test/types/import.ts

@@ -0,0 +1 @@
+import { FastifyLogFn } from '../../fastify'

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

@@ -1,3 +1,4 @@
+import { expectAssignable, expectDeprecated, expectError, expectNotDeprecated, expectType } from 'tsd'
 import fastify, {
   FastifyBodyParser,
   FastifyError,
@@ -6,10 +7,9 @@ import fastify, {
   RawRequestDefaultExpression,
   RawServerDefault
 } from '../../fastify'
-import { expectAssignable, expectError, expectType } from 'tsd'
-import { FastifyRequest } from '../../types/request'
-import { FastifyReply } from '../../types/reply'
 import { HookHandlerDoneFunction } from '../../types/hooks'
+import { FastifyReply } from '../../types/reply'
+import { FastifyRequest } from '../../types/request'
 import { FastifySchemaControllerOptions } from '../../types/schema'
 
 const server = fastify()
@@ -31,6 +31,7 @@ expectType<string>(server.printPlugins())
 
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
+    expectType<FastifyError>(error)
     expectAssignable<FastifyInstance>(this)
   })
 )
@@ -47,10 +48,14 @@ server.setErrorHandler(fastifyErrorHandler)
 async function asyncFastifyErrorHandler (this: FastifyInstance, error: FastifyError) {}
 server.setErrorHandler(asyncFastifyErrorHandler)
 
-function nodeJSErrorHandler (error: NodeJS.ErrnoException) {}
+function nodeJSErrorHandler (error: NodeJS.ErrnoException) {
+  if (error) { throw error }
+}
 server.setErrorHandler(nodeJSErrorHandler)
 
-function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {}
+function asyncNodeJSErrorHandler (error: NodeJS.ErrnoException) {
+  if (error) { throw error }
+}
 server.setErrorHandler(asyncNodeJSErrorHandler)
 
 class CustomError extends Error {
@@ -82,20 +87,20 @@ expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, r
   reply.send({ test: 'foo' })
 }))
 // typed sync error handler return error
-expectError(server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
+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) => {
+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() }
@@ -110,7 +115,9 @@ server.setNotFoundHandler({ preValidation: notFoundpreValidationHandler }, notFo
 server.setNotFoundHandler({ preValidation: notFoundpreValidationAsyncHandler }, notFoundHandler)
 server.setNotFoundHandler({ preHandler: notFoundpreHandlerHandler, preValidation: notFoundpreValidationHandler }, notFoundHandler)
 
-function invalidErrorHandler (error: number) {}
+function invalidErrorHandler (error: number) {
+  if (error) throw error
+}
 expectError(server.setErrorHandler(invalidErrorHandler))
 
 server.setSchemaController({
@@ -148,16 +155,30 @@ expectError(server.setReplySerializer(invalidReplySerializer))
 function serializerWithInvalidReturn (payload: unknown, statusCode: number) {}
 expectError(server.setReplySerializer(serializerWithInvalidReturn))
 
-function invalidSchemaErrorFormatter () {}
+function invalidSchemaErrorFormatter (err: Error) {
+  if (err) { throw err }
+}
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
 // test listen method callback
-expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {}))
-expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {}))
-expectAssignable<void>(server.listen(3000, '', (err, address) => {}))
-expectAssignable<void>(server.listen('3000', '', (err, address) => {}))
-expectAssignable<void>(server.listen(3000, (err, address) => {}))
-expectAssignable<void>(server.listen('3000', (err, address) => {}))
+expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen(3000, '', (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', '', (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen(3000, (err, address) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<void>(server.listen('3000', (err, address) => {
+  expectType<Error | null>(err)
+}))
 
 // test listen method callback types
 expectAssignable<void>(server.listen('3000', (err, address) => {
@@ -173,13 +194,43 @@ expectAssignable<PromiseLike<string>>(server.listen('3000', '', 0))
 expectAssignable<PromiseLike<string>>(server.listen(3000, ''))
 expectAssignable<PromiseLike<string>>(server.listen('3000', ''))
 
+// Test variadic listen signatures Typescript deprecation
+expectDeprecated(server.listen(3000))
+expectDeprecated(server.listen('3000'))
+expectDeprecated(server.listen(3000, '', 0))
+expectDeprecated(server.listen('3000', '', 0))
+expectDeprecated(server.listen(3000, ''))
+expectDeprecated(server.listen('3000', ''))
+
 // test listen opts objects
+expectAssignable<PromiseLike<string>>(server.listen())
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000 }))
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0' }))
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 }))
+expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42, exclusive: true }))
+expectAssignable<PromiseLike<string>>(server.listen({ port: 3000, host: '::/0', ipv6Only: true }))
+
+expectAssignable<void>(server.listen(() => {}))
 expectAssignable<void>(server.listen({ port: 3000 }, () => {}))
 expectAssignable<void>(server.listen({ port: 3000, host: '0.0.0.0' }, () => {}))
 expectAssignable<void>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42 }, () => {}))
+expectAssignable<void>(server.listen({ port: 3000, host: '0.0.0.0', backlog: 42, exclusive: true }, () => {}))
+expectAssignable<void>(server.listen({ port: 3000, host: '::/0', ipv6Only: true }, () => {}))
+
+// test listen opts objects Typescript deprectation exclusion
+expectNotDeprecated(server.listen())
+expectNotDeprecated(server.listen({ port: 3000 }))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0' }))
+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 }))
+
+expectNotDeprecated(server.listen(() => {}))
+expectNotDeprecated(server.listen({ port: 3000 }, () => {}))
+expectNotDeprecated(server.listen({ port: 3000, host: '0.0.0.0' }, () => {}))
+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 }, () => {}))
 
 expectAssignable<void>(server.routing({} as RawRequestDefaultExpression, {} as RawReplyDefaultExpression))
 

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

@@ -1,8 +1,15 @@
 import { expectType } from 'tsd'
-import fastify, { FastifyLogFn, LogLevel, FastifyLoggerInstance, FastifyError, FastifyRequest, FastifyReply } from '../../fastify'
+import fastify, {
+  FastifyLogFn,
+  LogLevel,
+  FastifyLoggerInstance,
+  FastifyRequest,
+  FastifyReply,
+  FastifyBaseLogger
+} from '../../fastify'
 import { Server, IncomingMessage, ServerResponse } from 'http'
-import pino from 'pino'
 import * as fs from 'fs'
+import P from 'pino'
 
 expectType<FastifyLoggerInstance>(fastify().log)
 
@@ -15,14 +22,17 @@ class Foo {}
   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<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](0))
 })
 
-interface CustomLogger extends FastifyLoggerInstance {
+/*
+// TODO make pino export BaseLogger again
+interface CustomLogger extends FastifyBaseLogger {
   customMethod(msg: string, ...args: unknown[]): void;
 }
 
+//   // ToDo https://github.com/pinojs/pino/issues/1100
 class CustomLoggerImpl implements CustomLogger {
+  level = 'info'
   customMethod (msg: string, ...args: unknown[]) { console.log(msg, args) }
 
   // Implementation signature must be compatible with all overloads of FastifyLogFn
@@ -35,7 +45,9 @@ class CustomLoggerImpl implements CustomLogger {
   fatal (...args: unknown[]) { console.log(args) }
   trace (...args: unknown[]) { console.log(args) }
   debug (...args: unknown[]) { console.log(args) }
-  child () { return new CustomLoggerImpl() }
+  silent (...args: unknown[]) { }
+
+  child (bindings: P.Bindings, options?: P.ChildLoggerOptions): CustomLoggerImpl { return new CustomLoggerImpl() }
 }
 
 const customLogger = new CustomLoggerImpl()
@@ -48,20 +60,21 @@ CustomLoggerImpl
 >({ logger: customLogger })
 
 expectType<CustomLoggerImpl>(serverWithCustomLogger.log)
+*/
 
 const serverWithPino = fastify<
 Server,
 IncomingMessage,
 ServerResponse,
-pino.Logger
+P.Logger
 >({
-  logger: pino({
+  logger: P({
     level: 'info',
     redact: ['x-userinfo']
   })
 })
 
-expectType<pino.Logger>(serverWithPino.log)
+expectType<P.Logger>(serverWithPino.log)
 
 const serverWithLogOptions = fastify<
 Server,
@@ -94,16 +107,16 @@ const serverAutoInferringTypes = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferringTypes.log)
+expectType<FastifyBaseLogger>(serverAutoInferringTypes.log)
 
 const serverWithAutoInferredPino = fastify({
-  logger: pino({
+  logger: P({
     level: 'info',
     redact: ['x-userinfo']
   })
 })
 
-expectType<pino.Logger>(serverWithAutoInferredPino.log)
+expectType<P.Logger>(serverWithAutoInferredPino.log)
 
 const serverAutoInferredFileOption = fastify({
   logger: {
@@ -112,7 +125,7 @@ const serverAutoInferredFileOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredFileOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredFileOption.log)
 
 const serverAutoInferredPinoPrettyBooleanOption = fastify({
   logger: {
@@ -120,7 +133,7 @@ const serverAutoInferredPinoPrettyBooleanOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredPinoPrettyBooleanOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredPinoPrettyBooleanOption.log)
 
 const serverAutoInferredPinoPrettyObjectOption = fastify({
   logger: {
@@ -141,7 +154,7 @@ const serverAutoInferredPinoPrettyObjectOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredPinoPrettyObjectOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredPinoPrettyObjectOption.log)
 
 const serverAutoInferredSerializerObjectOption = fastify({
   logger: {
@@ -176,10 +189,26 @@ const serverAutoInferredSerializerObjectOption = fastify({
   }
 })
 
-expectType<FastifyLoggerInstance>(serverAutoInferredSerializerObjectOption.log)
+expectType<FastifyBaseLogger>(serverAutoInferredSerializerObjectOption.log)
 
 const passStreamAsOption = fastify({
   logger: {
     stream: fs.createWriteStream('/tmp/stream.out')
   }
 })
+
+expectType<FastifyBaseLogger>(passStreamAsOption.log)
+
+const passPinoOption = fastify({
+  logger: {
+    redact: ['custom'],
+    messageKey: 'msg',
+    nestedKey: 'nested',
+    prettyPrint: {
+
+    },
+    enabled: true
+  }
+})
+
+expectType<FastifyBaseLogger>(passPinoOption.log)

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

@@ -4,6 +4,7 @@ import { RawServerDefault, RawReplyDefaultExpression, ContextConfigDefault } fro
 import { FastifyLoggerInstance } from '../../types/logger'
 import { RouteGenericInterface } from '../../types/route'
 import { FastifyInstance } from '../../types/instance'
+import { Buffer } from 'buffer'
 
 const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<RawReplyDefaultExpression>(reply.raw)
@@ -28,7 +29,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<() => number>(reply.getResponseTime)
   expectType<(contentType: string) => FastifyReply>(reply.type)
   expectType<(fn: (payload: any) => string) => FastifyReply>(reply.serializer)
-  expectType<(payload: any) => string>(reply.serialize)
+  expectType<(payload: any) => string | ArrayBuffer | Buffer>(reply.serialize)
   expectType<(fulfilled: () => void, rejected: (err: Error) => void) => void>(reply.then)
   expectType<FastifyInstance>(reply.server)
 }

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

@@ -1,10 +1,27 @@
 import { expectType } from 'tsd'
-import fastify, { RouteHandler, RawRequestDefaultExpression, RequestBodyDefault, RequestGenericInterface, FastifyContext, ContextConfigDefault, FastifyContextConfig } from '../../fastify'
+import pino from 'pino'
+import fastify, {
+  RouteHandler,
+  RawRequestDefaultExpression,
+  RequestBodyDefault,
+  RequestGenericInterface,
+  FastifyContext,
+  ContextConfigDefault,
+  FastifyContextConfig,
+  FastifyLogFn,
+  RouteHandlerMethod,
+  RawServerDefault,
+  RawReplyDefaultExpression,
+  FastifySchema,
+  FastifyTypeProviderDefault
+} from '../../fastify'
 import { RequestParamsDefault, RequestHeadersDefault, RequestQuerystringDefault } from '../../types/utils'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { FastifyRequest } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
 import { FastifyInstance } from '../../types/instance'
+import { RouteGenericInterface } from '../../types/route'
+import { ResolveFastifyReplyReturnType, ResolveFastifyRequestType } from '../../types/type-provider'
 
 interface RequestBody {
   content: string;
@@ -38,6 +55,10 @@ type CustomRequest = FastifyRequest<{
   Headers: RequestHeaders;
 }>
 
+interface CustomLoggerInterface extends FastifyLoggerInstance {
+  foo: FastifyLogFn; // custom severity logger method
+}
+
 const getHandler: RouteHandler = function (request, _reply) {
   expectType<string>(request.url)
   expectType<string>(request.method)
@@ -64,6 +85,10 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifyInstance>(request.server)
 }
 
+const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, ResolveFastifyReplyReturnType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>, ResolveFastifyRequestType<FastifyTypeProviderDefault, FastifySchema, RouteGenericInterface>, CustomLoggerInterface> = function (request, _reply) {
+  expectType<CustomLoggerInterface>(request.log)
+}
+
 const postHandler: Handler = function (request) {
   expectType<RequestBody>(request.body)
   expectType<RequestParams>(request.params)
@@ -96,3 +121,48 @@ const server = fastify()
 server.get('/get', getHandler)
 server.post('/post', postHandler)
 server.put('/put', putHandler)
+
+const customLogger: CustomLoggerInterface = {
+  level: 'info',
+  version: '5.0',
+  useOnlyCustomLevels: false,
+  useLevelLabels: false,
+  levels: { labels: [], values: {} },
+  eventNames: () => [],
+  listenerCount: (eventName: string | symbol) => 0,
+  bindings: () => ({}),
+  flush: () => () => {},
+  customLevels: { foo: 1 },
+  isLevelEnabled: () => false,
+  levelVal: 0,
+  silent: () => { },
+  info: () => { },
+  warn: () => { },
+  error: () => { },
+  fatal: () => { },
+  trace: () => { },
+  debug: () => { },
+  foo: () => { }, // custom severity logger method
+  on: (event, listener) => customLogger,
+  emit: (event, listener) => false,
+  off: (event, listener) => customLogger,
+  addListener: (event, listener) => customLogger,
+  prependListener: (event, listener) => customLogger,
+  prependOnceListener: (event, listener) => customLogger,
+  removeListener: (event, listener) => customLogger,
+  removeAllListeners: (event) => customLogger,
+  setMaxListeners: (n) => customLogger,
+  getMaxListeners: () => 0,
+  listeners: () => [],
+  rawListeners: () => [],
+  once: (event, listener) => customLogger,
+  child: () => customLogger as pino.Logger<never>
+}
+
+const serverWithCustomLogger = fastify({ logger: customLogger })
+expectType<
+FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+& PromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+>(serverWithCustomLogger)
+
+serverWithCustomLogger.get('/get', getHandlerWithCustomLogger)

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

@@ -1,5 +1,5 @@
 import fastify, { FastifyInstance, FastifyRequest, FastifyReply, RouteHandlerMethod } from '../../fastify'
-import { expectType, expectError, expectAssignable } from 'tsd'
+import { expectType, expectError, expectAssignable, printType } from 'tsd'
 import { HTTPMethods } from '../../types/utils'
 import * as http from 'http'
 import { RequestPayload } from '../../types/hooks'
@@ -44,7 +44,13 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
   expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', {}, routeHandler))
   expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', { handler: routeHandler }))
 
-  expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', { handler: routeHandler, errorHandler: (error, request, reply) => reply.send('error') }))
+  expectType<FastifyInstance>(fastify()[lowerCaseMethod]('/', {
+    handler: routeHandler,
+    errorHandler: (error, request, reply) => {
+      expectType<FastifyError>(error)
+      reply.send('error')
+    }
+  }))
 
   interface BodyInterface { prop: string }
   interface QuerystringInterface { prop: number }