fastify 5.8.4 → 5.9.0

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

@@ -1,237 +0,0 @@
-import { expectAssignable, expectError, expectType } from 'tsd'
-import { IncomingMessage, Server, ServerResponse } from 'node:http'
-import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'node:http2'
-import fastify, { FastifyInstance, FastifyError, FastifyBaseLogger, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
-
-const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
-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 testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
-
-interface TestOptions extends FastifyPluginOptions {
-  option1: string;
-  option2: boolean;
-}
-
-// Type validation
-expectError(fastify().register(testPluginOptsAsync, { prefix: 1 }))
-expectError(fastify().register(testPluginOptsAsync, { logLevel: () => ({}) }))
-expectError(fastify().register(testPluginOptsAsync, { logSerializers: () => ({}) }))
-expectError(fastify().register({}))
-
-expectAssignable<FastifyInstance>(
-  fastify().register(
-    testPluginOptsAsync, { prefix: '/example', logLevel: 'info', logSerializers: { key: (value: any) => `${value}` } }
-  )
-)
-
-expectAssignable<FastifyInstance>(
-  fastify().register(testPluginOptsAsync, () => {
-    return {}
-  })
-)
-
-expectAssignable<FastifyInstance>(
-  fastify().register(testPluginOptsAsync, (instance) => {
-    expectType<FastifyInstance>(instance)
-  })
-)
-
-// With Http2
-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 testOptions: TestOptions = {
-  option1: 'a',
-  option2: false
-}
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginCallback))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginAsync))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOpts))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsAsync))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithType))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithTypeAsync))
-// @ts-expect-error
-serverWithHttp2.register(testPluginWithHttp2)
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2, testOptions))
-// @ts-expect-error
-serverWithHttp2.register(testPluginWithHttp2Async)
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2Async, testOptions))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithType))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithTypeAsync))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance) => {
-  expectAssignable<FastifyInstance>(instance)
-}))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance: ServerWithHttp2) => {
-  expectAssignable<ServerWithHttp2>(instance)
-}))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance) => {
-  expectAssignable<FastifyInstance>(instance)
-}))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: ServerWithHttp2) => {
-  expectAssignable<ServerWithHttp2>(instance)
-}))
-
-// With Type Provider
-type TestTypeProvider = { schema: 'test', validator: 'test', serializer: 'test' }
-const serverWithTypeProvider = fastify().withTypeProvider<TestTypeProvider>()
-type ServerWithTypeProvider = FastifyInstance<
-  Server,
-  IncomingMessage,
-  ServerResponse,
-  FastifyBaseLogger,
-  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))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsAsync))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithType))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithTypeAsync))
-// @ts-expect-error
-serverWithTypeProvider.register(testPluginWithTypeProvider)
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProvider, testOptions))
-// @ts-expect-error
-serverWithTypeProvider.register(testPluginWithTypeProviderAsync)
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderAsync, testOptions))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithType))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithTypeAsync))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance) => {
-  expectAssignable<FastifyInstance>(instance)
-}))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance: ServerWithTypeProvider) => {
-  expectAssignable<ServerWithTypeProvider>(instance)
-}))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance) => {
-  expectAssignable<FastifyInstance>(instance)
-}))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance: ServerWithTypeProvider) => {
-  expectAssignable<ServerWithTypeProvider>(instance)
-}))
-
-// With Type Provider and logger
-const customLogger = {
-  level: 'info',
-  info: () => { },
-  warn: () => { },
-  error: () => { },
-  fatal: () => { },
-  trace: () => { },
-  debug: () => { },
-  child: () => customLogger,
-  silent: () => { }
-}
-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
-) => { }
-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))
-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

@@ -1,254 +0,0 @@
-import { Buffer } from 'node:buffer'
-import { expectAssignable, expectError, expectType } from 'tsd'
-import fastify, { FastifyContextConfig, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
-import { FastifyInstance } from '../../types/instance'
-import { FastifyBaseLogger } from '../../types/logger'
-import { ResolveReplyTypeWithRouteGeneric } from '../../types/reply'
-import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
-import { ContextConfigDefault, RawReplyDefaultExpression, RawServerDefault } from '../../types/utils'
-
-type DefaultSerializationFunction = (payload: { [key: string]: unknown }) => string
-type DefaultFastifyReplyWithCode<Code extends number> = FastifyReply<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, ResolveReplyTypeWithRouteGeneric<RouteGenericInterface['Reply'], Code, FastifySchema, FastifyTypeProviderDefault>>
-
-const getHandler: RouteHandlerMethod = function (_request, reply) {
-  expectType<RawReplyDefaultExpression>(reply.raw)
-  expectType<FastifyBaseLogger>(reply.log)
-  expectType<FastifyRequest<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression>>(reply.request)
-  expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.code)
-  expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.status)
-  expectType<(...args: [payload?: unknown]) => FastifyReply>(reply.code(100 as number).send)
-  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<((...args: [payload?: unknown]) => FastifyReply)>(reply.send)
-  expectAssignable<(key: string, value: any) => FastifyReply>(reply.header)
-  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<(url: string, statusCode?: number) => FastifyReply>(reply.redirect)
-  expectType<() => FastifyReply>(reply.hijack)
-  expectType<() => void>(reply.callNotFound)
-  expectType<(contentType: string) => FastifyReply>(reply.type)
-  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) => 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<((input: { [key: string]: unknown }, httpStatus: string) => unknown)>(reply.serializeInput)
-  expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(reply.routeOptions.config)
-  expectType<string>(reply.getDecorator<string>('foo'))
-}
-
-interface ReplyPayload {
-  Reply: {
-    test: boolean;
-  };
-}
-
-interface ReplyArrayPayload {
-  Reply: string[]
-}
-
-interface ReplyUnion {
-  Reply: {
-    success: boolean;
-  } | {
-    error: string;
-  }
-}
-
-interface ReplyHttpCodes {
-  Reply: {
-    '1xx': number,
-    200: 'abc',
-    201: boolean,
-    300: { foo: string },
-  }
-}
-
-interface InvalidReplyHttpCodes {
-  Reply: {
-    '1xx': number,
-    200: string,
-    999: boolean,
-  }
-}
-
-interface ReplyVoid {
-  Reply: void;
-}
-
-interface ReplyUndefined {
-  Reply: undefined;
-}
-
-// Issue #5534 scenario: 204 No Content should allow empty send(), 201 Created should require payload
-// Note: `204: undefined` gets converted to `unknown` via UndefinedToUnknown in type-provider.d.ts,
-// meaning send() is optional but send({}) is also allowed. Use `void` instead of `undefined`
-// if you want stricter "no payload allowed" semantics.
-interface ReplyHttpCodesWithNoContent {
-  Reply: {
-    201: { id: string };
-    204: undefined;
-  }
-}
-
-const typedHandler: RouteHandler<ReplyPayload> = async (request, reply) => {
-  // When Reply type is specified, send() requires a payload argument
-  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
-  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.code(100).send)
-}
-
-const server = fastify()
-server.get('/get', getHandler)
-server.get('/typed', typedHandler)
-server.get<ReplyPayload>('/get-generic-send', async function handler (request, reply) {
-  reply.send({ test: true })
-})
-// When Reply type is specified, send() requires a payload - calling without arguments should error
-expectError(server.get<ReplyPayload>('/get-generic-send-missing-payload', async function handler (request, reply) {
-  reply.send()
-}))
-server.get<ReplyPayload>('/get-generic-return', async function handler (request, reply) {
-  return { test: false }
-})
-expectError(server.get<ReplyPayload>('/get-generic-send-error', async function handler (request, reply) {
-  reply.send({ foo: 'bar' })
-}))
-expectError(server.get<ReplyPayload>('/get-generic-return-error', async function handler (request, reply) {
-  return { foo: 'bar' }
-}))
-server.get<ReplyUnion>('/get-generic-union-send', async function handler (request, reply) {
-  if (0 as number === 0) {
-    reply.send({ success: true })
-  } else {
-    reply.send({ error: 'error' })
-  }
-})
-server.get<ReplyUnion>('/get-generic-union-return', async function handler (request, reply) {
-  if (0 as number === 0) {
-    return { success: true }
-  } else {
-    return { error: 'error' }
-  }
-})
-expectError(server.get<ReplyUnion>('/get-generic-union-send-error-1', async function handler (request, reply) {
-  reply.send({ successes: true })
-}))
-expectError(server.get<ReplyUnion>('/get-generic-union-send-error-2', async function handler (request, reply) {
-  reply.send({ error: 500 })
-}))
-expectError(server.get<ReplyUnion>('/get-generic-union-return-error-1', async function handler (request, reply) {
-  return { successes: true }
-}))
-expectError(server.get<ReplyUnion>('/get-generic-union-return-error-2', async function handler (request, reply) {
-  return { error: 500 }
-}))
-server.get<ReplyHttpCodes>('/get-generic-http-codes-send', async function handler (request, reply) {
-  reply.code(200).send('abc')
-  reply.code(201).send(true)
-  reply.code(300).send({ foo: 'bar' })
-  reply.code(101).send(123)
-})
-expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-1', async function handler (request, reply) {
-  reply.code(200).send('def')
-}))
-expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-2', async function handler (request, reply) {
-  reply.code(201).send(0)
-}))
-expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-3', async function handler (request, reply) {
-  reply.code(300).send({ foo: 123 })
-}))
-expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-4', async function handler (request, reply) {
-  reply.code(100).send('asdasd')
-}))
-expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-5', async function handler (request, reply) {
-  reply.code(401).send({ foo: 123 })
-}))
-server.get<ReplyArrayPayload>('/get-generic-array-send', async function handler (request, reply) {
-  reply.code(200).send([''])
-})
-expectError(server.get<InvalidReplyHttpCodes>('get-invalid-http-codes-reply-error', async function handler (request, reply) {
-  reply.code(200).send('')
-}))
-server.get<InvalidReplyHttpCodes>('get-invalid-http-codes-reply-error', async function handler (request, reply) {
-  reply.code(200).send({
-    '1xx': 0,
-    200: '',
-    999: false
-  })
-})
-
-/* eslint-disable @typescript-eslint/no-unused-vars */
-const httpHeaderHandler: RouteHandlerMethod = function (_request, reply) {
-  // accept is a header provided by @types/node
-  reply.getHeader('accept')
-  /* eslint-disable @typescript-eslint/no-unused-expressions */
-  reply.getHeaders().accept
-  reply.hasHeader('accept')
-  reply.header('accept', 'test')
-  reply.headers({ accept: 'test' })
-  reply.removeHeader('accept')
-
-  // 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']
-  reply.hasHeader('x-fastify-test')
-  reply.header('x-fastify-test', 'test')
-  reply.headers({ 'x-fastify-test': 'test' })
-  reply.removeHeader('x-fastify-test')
-}
-
-// Test: send() without arguments is valid when no Reply type is specified (default unknown)
-server.get('/get-no-type-send-empty', async function handler (request, reply) {
-  reply.send()
-})
-
-// Test: send() without arguments is valid when Reply type is void
-server.get<ReplyVoid>('/get-void-send-empty', async function handler (request, reply) {
-  reply.send()
-})
-
-// Test: send() without arguments is valid when Reply type is undefined
-server.get<ReplyUndefined>('/get-undefined-send-empty', async function handler (request, reply) {
-  reply.send()
-})
-
-// Issue #5534 scenario: HTTP status codes with 204 No Content
-server.get<ReplyHttpCodesWithNoContent>('/get-http-codes-no-content', async function handler (request, reply) {
-  // 204 No Content - send() without payload is valid because Reply is undefined
-  reply.code(204).send()
-  // 201 Created - send() requires payload
-  reply.code(201).send({ id: '123' })
-})
-// 201 Created without payload should error
-expectError(server.get<ReplyHttpCodesWithNoContent>('/get-http-codes-201-missing-payload', async function handler (request, reply) {
-  reply.code(201).send()
-}))

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

@@ -1,188 +0,0 @@
-import { expectAssignable, expectError, expectType } from 'tsd'
-import fastify, {
-  ContextConfigDefault,
-  FastifyContextConfig,
-  FastifyLogFn,
-  FastifySchema,
-  FastifyTypeProviderDefault,
-  RawReplyDefaultExpression,
-  RawRequestDefaultExpression,
-  RawServerDefault,
-  RequestBodyDefault,
-  RequestGenericInterface,
-  RouteHandler,
-  RouteHandlerMethod,
-  SafePromiseLike
-} from '../../fastify'
-import { FastifyInstance } from '../../types/instance'
-import { FastifyBaseLogger } from '../../types/logger'
-import { FastifyReply } from '../../types/reply'
-import { FastifyRequest, RequestRouteOptions } from '../../types/request'
-import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
-import { RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from '../../types/utils'
-
-interface RequestBody {
-  content: string;
-}
-
-interface RequestQuerystring {
-  from: string;
-}
-
-interface RequestParams {
-  id: number;
-}
-
-interface RequestHeaders {
-  'x-foobar': string;
-}
-
-interface RequestData extends RequestGenericInterface {
-  Body: RequestBody;
-  Querystring: RequestQuerystring;
-  Params: RequestParams;
-  Headers: RequestHeaders;
-}
-
-type Handler = RouteHandler<RequestData>
-
-type CustomRequest = FastifyRequest<{
-  Body: RequestBody | undefined;
-  Querystring: RequestQuerystring;
-  Params: RequestParams;
-  Headers: RequestHeaders;
-}>
-
-type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
-type ExpectedGetValidationFunction = (input: { [key: string]: unknown }) => boolean
-
-interface CustomLoggerInterface extends FastifyBaseLogger {
-  foo: FastifyLogFn; // custom severity logger method
-}
-
-const getHandler: RouteHandler = function (request, _reply) {
-  expectType<string>(request.url)
-  expectType<string>(request.originalUrl)
-  expectType<string>(request.method)
-  expectType<Readonly<RequestRouteOptions>>(request.routeOptions)
-  expectType<boolean>(request.is404)
-  expectType<string>(request.hostname)
-  expectType<string>(request.host)
-  expectType<number | null>(request.port)
-  expectType<string>(request.ip)
-  expectType<string[] | undefined>(request.ips)
-  expectType<RawRequestDefaultExpression>(request.raw)
-  expectType<RequestBodyDefault>(request.body)
-  expectType<RequestParamsDefault>(request.params)
-  expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(request.routeOptions.config)
-  expectType<FastifySchema | undefined>(request.routeOptions.schema)
-  expectType<RouteHandlerMethod>(request.routeOptions.handler)
-  expectType<string | undefined>(request.routeOptions.url)
-  expectType<string | undefined>(request.routeOptions.version)
-
-  expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
-  request.headers = {}
-
-  expectType<RequestQuerystringDefault>(request.query)
-  expectType<string>(request.id)
-  expectType<FastifyBaseLogger>(request.log)
-  expectType<RawRequestDefaultExpression['socket']>(request.socket)
-  expectType<AbortSignal>(request.signal)
-  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)
-  expectType<string>(request.getDecorator<string>('foo'))
-  expectType<void>(request.setDecorator('foo', 'hello'))
-  expectType<void>(request.setDecorator<string>('foo', 'hello'))
-  expectError(request.setDecorator<string>('foo', true))
-}
-
-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<RequestQuerystring>(request.query)
-  expectType<string>(request.body.content)
-  expectType<string>(request.query.from)
-  expectType<number>(request.params.id)
-  expectType<string>(request.headers['x-foobar'])
-  expectType<FastifyInstance>(request.server)
-  expectType<FastifyContextConfig & FastifyRouteConfig>(request.routeOptions.config)
-}
-
-function putHandler (request: CustomRequest, reply: FastifyReply) {
-  expectType<RequestBody | undefined>(request.body)
-  expectType<RequestParams>(request.params)
-  expectType<RequestHeaders & RawRequestDefaultExpression['headers']>(request.headers)
-  expectType<RequestQuerystring>(request.query)
-  if (request.body === undefined) {
-    expectType<undefined>(request.body)
-  } else {
-    expectType<string>(request.body.content)
-  }
-  expectType<string>(request.query.from)
-  expectType<number>(request.params.id)
-  expectType<string>(request.headers['x-foobar'])
-  expectType<FastifyInstance>(request.server)
-  expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(request.routeOptions.config)
-}
-
-const server = fastify()
-server.get('/get', getHandler)
-server.post('/post', postHandler)
-server.put('/put', putHandler)
-
-const customLogger: CustomLoggerInterface = {
-  level: 'info',
-  silent: () => { },
-  info: () => { },
-  warn: () => { },
-  error: () => { },
-  fatal: () => { },
-  trace: () => { },
-  debug: () => { },
-  foo: () => { }, // custom severity logger method
-  child: () => customLogger
-}
-
-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)