fastify 4.27.0 → 5.0.0-alpha.2

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

@@ -59,8 +59,6 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FORCE_CLOSE_CONNECT
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DUPLICATED_ROUTE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_URL)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ASYNC_CONSTRAINT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEFAULT_ROUTE_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INVALID_URL)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_OPTIONS_NOT_OBJ)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_DUPLICATED_HANDLER)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_HANDLER_NOT_FN)

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

@@ -11,30 +11,32 @@ import fastify, {
   RawRequestDefaultExpression,
   RouteGenericInterface,
   FastifyErrorCodes,
-  FastifyError
+  FastifyError,
+  SafePromiseLike
 } from '../../fastify'
 import { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'http'
 import * as https from 'https'
 import * as http2 from 'http2'
 import { expectType, expectError, expectAssignable, expectNotAssignable } from 'tsd'
-import { FastifyLoggerInstance } from '../../types/logger'
 import { Socket } from 'net'
 
 // FastifyInstance
 // http server
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({}))
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<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> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: {} }))
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<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> & PromiseLike<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, http2SessionTimeout: 1000 }))
-expectType<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> & PromiseLike<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> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ schemaController: {} }))
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<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: {}
@@ -92,7 +94,7 @@ expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerR
           method: 'GET',
           url: '/',
           version: '1.0.0',
-          hostname: 'localhost',
+          host: 'localhost',
           remoteAddress: '127.0.0.1',
           remotePort: 3000
         }

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

@@ -14,6 +14,7 @@ import fastify, {
   RegisterOptions,
   RouteOptions,
   // preClose hook types should be exported correctly https://github.com/fastify/fastify/pull/5335
+  /* eslint-disable @typescript-eslint/no-unused-vars */
   preCloseAsyncHookHandler,
   preCloseHookHandler
 } from '../../fastify'

package/test/types/import.ts

@@ -1 +1,2 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { FastifyListenOptions, FastifyLogFn } from '../../fastify'

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

@@ -1,4 +1,4 @@
-import { expectAssignable, expectDeprecated, expectError, expectNotDeprecated, expectType } from 'tsd'
+import { expectAssignable, expectError, expectNotDeprecated, expectType } from 'tsd'
 import fastify, {
   FastifyBaseLogger,
   FastifyBodyParser,
@@ -12,7 +12,6 @@ import fastify, {
 import { HookHandlerDoneFunction } from '../../types/hooks'
 import { FastifyReply } from '../../types/reply'
 import { FastifyRequest } from '../../types/request'
-import { DefaultRoute } from '../../types/route'
 import { FastifySchemaControllerOptions, FastifySchemaCompiler, FastifySerializerCompiler } from '../../types/schema'
 import { AddressInfo } from 'net'
 import { Bindings, ChildLoggerOptions } from '../../types/logger'
@@ -194,48 +193,6 @@ function invalidSchemaErrorFormatter (err: Error) {
 }
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
-// test listen method callback
-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) => {
-  expectAssignable<Error|null>(err)
-  expectAssignable<string>(address)
-}))
-
-// test listen method promise
-expectAssignable<PromiseLike<string>>(server.listen(3000))
-expectAssignable<PromiseLike<string>>(server.listen('3000'))
-expectAssignable<PromiseLike<string>>(server.listen(3000, '', 0))
-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 }))
@@ -279,6 +236,12 @@ expectAssignable<FastifyInstance>(server.ready())
 expectAssignable<FastifyInstance>(server.ready((err) => {
   expectType<Error | null>(err)
 }))
+expectAssignable<FastifyInstance>(server.ready(async (err) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<Parameters<typeof server.ready>[0]>(async (err) => {
+  expectType<Error | null>(err)
+})
 
 expectAssignable<void>(server.routing({} as RawRequestDefaultExpression, {} as RawReplyDefaultExpression))
 
@@ -453,7 +416,7 @@ server.decorate('typedTestProperty', {
 })
 server.decorate('typedTestProperty')
 server.decorate('typedTestProperty', null, ['foo'])
-server.decorate('typedTestProperty', null)
+expectError(server.decorate('typedTestProperty', null))
 expectError(server.decorate('typedTestProperty', 'foo'))
 expectError(server.decorate('typedTestProperty', {
   getter () {
@@ -493,7 +456,7 @@ server.decorateRequest('typedTestRequestProperty', {
 })
 server.decorateRequest('typedTestRequestProperty')
 server.decorateRequest('typedTestRequestProperty', null, ['foo'])
-server.decorateRequest('typedTestRequestProperty', null)
+expectError(server.decorateRequest('typedTestRequestProperty', null))
 expectError(server.decorateRequest('typedTestRequestProperty', 'foo'))
 expectError(server.decorateRequest('typedTestRequestProperty', {
   getter () {
@@ -533,7 +496,7 @@ server.decorateReply('typedTestReplyProperty', {
 })
 server.decorateReply('typedTestReplyProperty')
 server.decorateReply('typedTestReplyProperty', null, ['foo'])
-server.decorateReply('typedTestReplyProperty', null)
+expectError(server.decorateReply('typedTestReplyProperty', null))
 expectError(server.decorateReply('typedTestReplyProperty', 'foo'))
 expectError(server.decorateReply('typedTestReplyProperty', {
   getter () {
@@ -570,9 +533,5 @@ const versionConstraintStrategy = {
 expectType<void>(server.addConstraintStrategy(versionConstraintStrategy))
 expectType<boolean>(server.hasConstraintStrategy(versionConstraintStrategy.name))
 
-expectType<boolean>(server.hasPlugin(''))
-
-expectAssignable<DefaultRoute<RawRequestDefaultExpression, RawReplyDefaultExpression>>(server.getDefaultRoute())
-
 expectType<FastifySchemaCompiler<any> | undefined>(server.validatorCompiler)
 expectType<FastifySerializerCompiler<any> | undefined>(server.serializerCompiler)

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

@@ -5,8 +5,7 @@ import fastify, {
   FastifyLoggerInstance,
   FastifyRequest,
   FastifyReply,
-  FastifyBaseLogger,
-  FastifyInstance
+  FastifyBaseLogger
 } from '../../fastify'
 import { Server, IncomingMessage, ServerResponse } from 'http'
 import * as fs from 'fs'
@@ -121,14 +120,52 @@ const serverAutoInferringTypes = fastify({
 
 expectType<FastifyBaseLogger>(serverAutoInferringTypes.log)
 
-const serverWithAutoInferredPino = fastify({
-  logger: P({
+const serverWithLoggerInstance = fastify({
+  loggerInstance: P({
     level: 'info',
     redact: ['x-userinfo']
   })
 })
 
-expectType<P.Logger>(serverWithAutoInferredPino.log)
+expectType<P.Logger>(serverWithLoggerInstance.log)
+
+const serverWithPinoConfig = fastify({
+  logger: {
+    level: 'info',
+    serializers: {
+      req (IncomingMessage) {
+        expectType<FastifyRequest>(IncomingMessage)
+        return {
+          method: 'method',
+          url: 'url',
+          version: 'version',
+          host: 'hostname',
+          remoteAddress: 'remoteAddress',
+          remotePort: 80,
+          other: ''
+        }
+      },
+      res (ServerResponse) {
+        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
+        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
+        expectNotAssignable<FastifyReply>(ServerResponse)
+        return {
+          statusCode: 'statusCode'
+        }
+      },
+      err (FastifyError) {
+        return {
+          other: '',
+          type: 'type',
+          message: 'msg',
+          stack: 'stack'
+        }
+      }
+    }
+  }
+})
+
+expectType<FastifyBaseLogger>(serverWithPinoConfig.log)
 
 const serverAutoInferredFileOption = fastify({
   logger: {
@@ -165,7 +202,7 @@ const serverAutoInferredSerializerObjectOption = fastify({
           method: 'method',
           url: 'url',
           version: 'version',
-          hostname: 'hostname',
+          host: 'hostname',
           remoteAddress: 'remoteAddress',
           remotePort: 80,
           other: ''

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

@@ -1,4 +1,4 @@
-import fastify, { FastifyInstance, FastifyPluginOptions } from '../../fastify'
+import fastify, { FastifyInstance, FastifyPluginOptions, SafePromiseLike } from '../../fastify'
 import * as http from 'http'
 import * as https from 'https'
 import { expectType, expectError, expectAssignable } from 'tsd'
@@ -42,7 +42,9 @@ expectAssignable<FastifyInstance>(fastify().register(async function (instance, o
 expectError(fastify().register(function (instance, opts, done) { }, { logLevel: '' })) // must use a valid logLevel
 
 const httpsServer = fastify({ https: {} })
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<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
@@ -61,6 +63,7 @@ expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWith
 expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithType, { prefix: '/test' }))
 expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithTypeAsync, { prefix: '/test' }))
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
 async function testAsync (): Promise<void> {
   await httpsServer
     .register(testPluginOpts)

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

@@ -72,7 +72,7 @@ expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: Serv
 }))
 
 // With Type Provider
-type TestTypeProvider = { input: 'test', output: 'test' }
+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) { }
@@ -115,7 +115,7 @@ const customLogger = {
   silent: () => { }
 }
 const serverWithTypeProviderAndLogger = fastify({
-  logger: customLogger
+  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) { }

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

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer'
-import { expectAssignable, expectDeprecated, expectError, expectType } from 'tsd'
-import fastify, { FastifyReplyContext, FastifyReply, FastifyRequest, FastifySchema, FastifySchemaCompiler, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
+import { expectAssignable, expectError, expectType } from 'tsd'
+import fastify, { FastifyReplyContext, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { ResolveReplyTypeWithRouteGeneric } from '../../types/reply'
@@ -22,18 +22,17 @@ 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<((payload?: unknown) => FastifyReply)>(reply.send)
   expectAssignable<(key: string, value: any) => FastifyReply>(reply.header)
-  expectAssignable<(values: {[key: string]: any}) => FastifyReply>(reply.headers)
+  expectAssignable<(values: { [key: string]: any }) => FastifyReply>(reply.headers)
   expectAssignable<(key: string) => number | string | string[] | undefined>(reply.getHeader)
   expectAssignable<() => { [key: string]: number | string | string[] | undefined }>(reply.getHeaders)
   expectAssignable<(key: string) => FastifyReply>(reply.removeHeader)
   expectAssignable<(key: string) => boolean>(reply.hasHeader)
-  expectType<{(statusCode: number, url: string): FastifyReply; (url: string): FastifyReply }>(reply.redirect)
+  expectType<{ (statusCode: number, url: string): FastifyReply;(url: string, statusCode?: number): FastifyReply; }>(reply.redirect)
   expectType<() => FastifyReply>(reply.hijack)
   expectType<() => void>(reply.callNotFound)
-  // Test reply.getResponseTime() deprecation
-  expectDeprecated(reply.getResponseTime)
   expectType<(contentType: string) => FastifyReply>(reply.type)
   expectType<(fn: (payload: any) => string) => FastifyReply>(reply.serializer)
   expectType<(payload: any) => string | ArrayBuffer | Buffer>(reply.serialize)
@@ -43,10 +42,10 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   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<((input: {[key: string]: unknown}, httpStatus: string) => unknown)>(reply.serializeInput)
+  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)
 }
 
 interface ReplyPayload {
@@ -165,10 +164,12 @@ server.get<InvalidReplyHttpCodes>('get-invalid-http-codes-reply-error', async fu
   })
 })
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
 const httpHeaderHandler: RouteHandlerMethod = function (_request, reply) {
   // accept is a header provided by @types/node
   reply.getHeader('accept')
-  reply.getHeaders().accept // eslint-disable-line no-unused-expressions
+  /* eslint-disable @typescript-eslint/no-unused-expressions */
+  reply.getHeaders().accept
   reply.hasHeader('accept')
   reply.header('accept', 'test')
   reply.headers({ accept: 'test' })
@@ -177,7 +178,7 @@ const httpHeaderHandler: RouteHandlerMethod = function (_request, reply) {
   // x-fastify-test is not a header provided by @types/node
   // and should not result in a typing error
   reply.getHeader('x-fastify-test')
-  reply.getHeaders()['x-fastify-test'] // eslint-disable-line no-unused-expressions
+  reply.getHeaders()['x-fastify-test']
   reply.hasHeader('x-fastify-test')
   reply.header('x-fastify-test', 'test')
   reply.headers({ 'x-fastify-test': 'test' })

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

@@ -1,4 +1,4 @@
-import { expectAssignable, expectType } from 'tsd'
+import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, {
   ContextConfigDefault,
   FastifyRequestContext,
@@ -12,7 +12,8 @@ import fastify, {
   RequestBodyDefault,
   RequestGenericInterface,
   RouteHandler,
-  RouteHandlerMethod
+  RouteHandlerMethod,
+  SafePromiseLike
 } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'
 import { FastifyLoggerInstance } from '../../types/logger'
@@ -54,7 +55,7 @@ type CustomRequest = FastifyRequest<{
 }>
 
 type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
-type ExpectedGetValidationFunction = (input: {[key: string]: unknown}) => boolean
+type ExpectedGetValidationFunction = (input: { [key: string]: unknown }) => boolean
 
 interface CustomLoggerInterface extends FastifyLoggerInstance {
   foo: FastifyLogFn; // custom severity logger method
@@ -69,6 +70,8 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<Readonly<RequestRouteOptions>>(request.routeOptions)
   expectType<boolean>(request.is404)
   expectType<string>(request.hostname)
+  expectType<string>(request.host)
+  expectType<number>(request.port)
   expectType<string>(request.ip)
   expectType<string[] | undefined>(request.ips)
   expectType<RawRequestDefaultExpression>(request.raw)
@@ -94,9 +97,9 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<Error & { validation: any; validationContext: string } | undefined>(request.validationError)
   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}, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
+  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 }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
 }
 
 const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, CustomLoggerInterface> = function (request, _reply) {
@@ -153,10 +156,18 @@ const customLogger: CustomLoggerInterface = {
   child: () => customLogger
 }
 
-const serverWithCustomLogger = fastify({ logger: customLogger })
-expectType<
+const serverWithCustomLogger = fastify({ loggerInstance: customLogger })
+expectError<
+FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+& Promise<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+>(serverWithCustomLogger)
+expectAssignable<
 FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
 & PromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
 >(serverWithCustomLogger)
+expectType<
+FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+& SafePromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+>(serverWithCustomLogger)
 
 serverWithCustomLogger.get('/get', getHandlerWithCustomLogger)

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

@@ -19,6 +19,14 @@ declare module '../../fastify' {
   interface FastifyContextConfig {
     foo: string;
     bar: number;
+    includeMessage?: boolean;
+  }
+
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  interface FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger, RequestType> {
+    message: ContextConfig extends { includeMessage: true }
+      ? string
+      : null;
   }
 }
 
@@ -36,9 +44,29 @@ const routeHandlerWithReturnValue: RouteHandlerMethod = function (request, reply
   return reply.send()
 }
 
-type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options';
+fastify().get(
+  '/',
+  { config: { foo: 'bar', bar: 100, includeMessage: true } },
+  (req) => {
+    expectType<string>(req.message)
+  }
+)
+
+fastify().get(
+  '/',
+  { config: { foo: 'bar', bar: 100, includeMessage: false } },
+  (req) => {
+    expectType<null>(req.message)
+  }
+)
+
+type LowerCaseHTTPMethods = 'delete' | 'get' | 'head' | 'patch' | 'post' | 'put' |
+'options' | 'propfind' | 'proppatch' | 'mkcol' | 'copy' | 'move' | 'lock' |
+'unlock' | 'trace' | 'search' | 'mkcalendar' | 'report'
 
-['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'DELETE', 'OPTIONS'].forEach(method => {
+;['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS', 'PROPFIND',
+  'PROPPATCH', 'MKCOL', 'COPY', 'MOVE', 'LOCK', 'UNLOCK', 'TRACE', 'SEARCH', 'MKCALENDAR', 'REPORT'
+].forEach(method => {
   // route method
   expectType<FastifyInstance>(fastify().route({
     method: method as HTTPMethods,

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

@@ -70,7 +70,7 @@ expectAssignable<FastifyInstance>(server.setSerializerCompiler<FastifySchema & {
     storeFunction (routeOpts, schemaValidationCode) { }
   })
 
-  const app = fastify({
+  fastify({
     jsonShorthand: false,
     schemaController: {
       compilersFactory: {
@@ -86,7 +86,7 @@ expectAssignable<FastifyInstance>(server.setSerializerCompiler<FastifySchema & {
     storeFunction (routeOpts, schemaValidationCode) { }
   })
 
-  const app = fastify({
+  fastify({
     jsonShorthand: false,
     schemaController: {
       compilersFactory: {

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

@@ -3,7 +3,7 @@ import * as http from 'http'
 import { expectType } from 'tsd'
 
 // Custom Server
-type CustomType = void;
+type CustomType = void
 interface CustomIncomingMessage extends http.IncomingMessage {
   fakeMethod?: () => CustomType;
 }