fastify 5.8.5 → 5.10.0

package/test/types/using.tst.ts

@@ -0,0 +1,14 @@
+import { expect, test } from 'tstyche'
+import fastify, { FastifyInstance } from '../../fastify.js'
+
+test("has 'Symbol.dispose' when declared with 'using'", async () => {
+  await using app = fastify()
+  expect(app).type.toBeAssignableTo<FastifyInstance>()
+  expect(app[Symbol.asyncDispose]).type.toBe<() => Promise<undefined>>()
+})
+
+test("has 'Symbol.dispose'", async () => {
+  await using app = fastify()
+  expect(app).type.toBeAssignableTo<FastifyInstance>()
+  expect(app[Symbol.asyncDispose]).type.toBe<() => Promise<undefined>>()
+})

package/types/errors.d.ts

@@ -40,6 +40,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_LOG_INVALID_LOGGER_INSTANCE' |
   'FST_ERR_LOG_INVALID_LOGGER_CONFIG' |
   'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED' |
+  'FST_ERR_LOG_INVALID_LOG_CONTROLLER' |
   'FST_ERR_REP_INVALID_PAYLOAD_TYPE' |
   'FST_ERR_REP_RESPONSE_BODY_CONSUMED' |
   'FST_ERR_REP_READABLE_STREAM_LOCKED' |
@@ -65,6 +66,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE' |
   'FST_ERR_DUPLICATED_ROUTE' |
   'FST_ERR_BAD_URL' |
+  'FST_ERR_MAX_PARAM_LENGTH' |
   'FST_ERR_ASYNC_CONSTRAINT' |
   'FST_ERR_INVALID_URL' |
   'FST_ERR_ROUTE_OPTIONS_NOT_OBJ' |
@@ -73,6 +75,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_ROUTE_MISSING_HANDLER' |
   'FST_ERR_ROUTE_METHOD_INVALID' |
   'FST_ERR_ROUTE_METHOD_NOT_SUPPORTED' |
+  'FST_ERR_ROUTE_LOG_LEVEL_INVALID' |
   'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED' |
   'FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT' |
   'FST_ERR_HANDLER_TIMEOUT' |
@@ -84,6 +87,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_PLUGIN_VERSION_MISMATCH' |
   'FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE' |
   'FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER' |
+  'FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED' |
   'FST_ERR_PLUGIN_CALLBACK_NOT_FN' |
   'FST_ERR_PLUGIN_NOT_VALID' |
   'FST_ERR_ROOT_PLG_BOOTED' |

package/types/instance.d.ts

@@ -595,12 +595,14 @@ export interface FastifyInstance<
     https?: boolean | Readonly<{ allowHTTP1: boolean }>,
     ignoreTrailingSlash?: boolean,
     ignoreDuplicateSlashes?: boolean,
+    /** @deprecated Use the `logController` option with `disableRequestLogging` or `isLogDisabled` override instead. Will be removed in `fastify@6`. */
     disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean),
     maxParamLength?: number,
     onProtoPoisoning?: ProtoAction,
     onConstructorPoisoning?: ConstructorAction,
     pluginTimeout?: number,
     requestIdHeader?: string | false,
+    /** @deprecated Use the `logController` option with `requestIdLogLabel` instead. Will be removed in `fastify@6`. */
     requestIdLogLabel?: string,
     http2SessionTimeout?: number,
     useSemicolonDelimiter?: boolean,

package/types/logger.d.ts

@@ -82,6 +82,28 @@ export interface FastifyLoggerOptions<
   stream?: FastifyLoggerStreamDestination;
 }
 
+export interface LogControllerOptions {
+  disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean)
+  requestIdLogLabel?: string
+}
+
+export declare class LogController {
+  disableRequestLogging: boolean | ((req: FastifyRequest) => boolean)
+  requestIdLogLabel: string
+
+  constructor (options?: LogControllerOptions)
+
+  isLogDisabled (request: FastifyRequest): boolean
+  incomingRequest (request: FastifyRequest, reply: FastifyReply, metadata?: Record<string, unknown>): void
+  requestCompleted (error: Error | null, request: FastifyRequest, reply: FastifyReply, metadata?: Record<string, unknown>): void
+  defaultErrorLog (error: Error, request: FastifyRequest, reply: FastifyReply, metadata?: Record<string, unknown>): void
+  streamError (error: Error, request: FastifyRequest, reply: FastifyReply, metadata?: Record<string, unknown>): void
+  routeNotFound (request: FastifyRequest, reply: FastifyReply, metadata?: Record<string, unknown>): void
+  writeHeadError (error: Error, request: FastifyRequest, reply: FastifyReply, metadata?: Record<string, unknown>): void
+  serializerError (error: Error, request: FastifyRequest, reply: FastifyReply, metadata: { statusCode: number }): void
+  serviceUnavailable (logger: FastifyBaseLogger, server: FastifyInstance): void
+}
+
 export interface FastifyChildLoggerFactory<
   RawServer extends RawServerBase = RawServerDefault,
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,

package/types/request.d.ts

@@ -71,22 +71,43 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
    * @deprecated Use `raw` property
    */
   readonly req: RawRequest & RouteGeneric['Headers']; // this enables the developer to extend the existing http(s|2) headers list
+  /**
+   * Derived from request socket metadata or forwarding headers.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly ip: string;
+  /**
+   * Derived from forwarding headers when trustProxy is enabled.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly ips?: string[];
+  /**
+   * Derived from Host/:authority/X-Forwarded-Host request metadata.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly host: string;
+  /**
+   * Parsed from request host metadata.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly port: number | null;
   readonly hostname: string;
   readonly url: string;
   readonly originalUrl: string;
+  /**
+   * Derived from socket state or forwarding headers.
+   * Treat as untrusted input and validate before security-sensitive use.
+   */
   readonly protocol: 'http' | 'https';
   readonly method: string;
   readonly routeOptions: Readonly<RequestRouteOptions<ContextConfig, SchemaCompiler>>
   readonly is404: boolean;
   readonly socket: RawRequest['socket'];
   readonly signal: AbortSignal;
+  readonly mediaType: string | undefined;
 
-  getValidationFunction(httpPart: HTTPRequestPart): ValidationFunction
-  getValidationFunction(schema: { [key: string]: any }): ValidationFunction
+  getValidationFunction(httpPart: HTTPRequestPart): ValidationFunction | undefined
+  getValidationFunction(schema: { [key: string]: any }): ValidationFunction | undefined
   compileValidationSchema(schema: { [key: string]: any }, httpPart?: HTTPRequestPart): ValidationFunction
   validateInput(input: any, schema: { [key: string]: any }, httpPart?: HTTPRequestPart): boolean
   validateInput(input: any, httpPart?: HTTPRequestPart): boolean

package/test/types/content-type-parser.test-d.ts

@@ -1,72 +0,0 @@
-import fastify, { FastifyBodyParser } from '../../fastify'
-import { expectError, expectType } from 'tsd'
-import { IncomingMessage } from 'node:http'
-import { FastifyRequest } from '../../types/request'
-
-expectType<void>(fastify().addContentTypeParser('contentType', function (request, payload, done) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  done(null)
-}))
-
-// Body limit options
-
-expectType<void>(fastify().addContentTypeParser('contentType', { bodyLimit: 99 }, function (request, payload, done) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  done(null)
-}))
-
-// Array for contentType
-
-expectType<void>(fastify().addContentTypeParser(['contentType'], function (request, payload, done) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  done(null)
-}))
-
-// Body Parser - the generic after addContentTypeParser enforces the type of the `body` parameter as well as the value of the `parseAs` property
-
-expectType<void>(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, function (request, body, done) {
-  expectType<FastifyRequest>(request)
-  expectType<string>(body)
-  done(null)
-}))
-
-expectType<void>(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, function (request, body, done) {
-  expectType<FastifyRequest>(request)
-  expectType<Buffer>(body)
-  done(null)
-}))
-
-expectType<void>(fastify().addContentTypeParser('contentType', async function (request: FastifyRequest, payload: IncomingMessage) {
-  expectType<FastifyRequest>(request)
-  expectType<IncomingMessage>(payload)
-  return null
-}))
-
-expectType<void>(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, async function (request: FastifyRequest, body: string) {
-  expectType<FastifyRequest>(request)
-  expectType<string>(body)
-  return null
-}))
-
-expectType<void>(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, async function (request: FastifyRequest, body: Buffer) {
-  expectType<FastifyRequest>(request)
-  expectType<Buffer>(body)
-  return null
-}))
-
-expectType<FastifyBodyParser<string>>(fastify().getDefaultJsonParser('error', 'ignore'))
-
-expectError(fastify().getDefaultJsonParser('error', 'skip'))
-
-expectError(fastify().getDefaultJsonParser('nothing', 'ignore'))
-
-expectType<void>(fastify().removeAllContentTypeParsers())
-expectError(fastify().removeAllContentTypeParsers('contentType'))
-
-expectType<void>(fastify().removeContentTypeParser('contentType'))
-expectType<void>(fastify().removeContentTypeParser(/contentType+.*/))
-expectType<void>(fastify().removeContentTypeParser(['contentType', /contentType+.*/]))
-expectError(fastify().removeContentTypeParser({}))

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

@@ -1,90 +0,0 @@
-import { FastifyErrorConstructor } from '@fastify/error'
-import { expectAssignable } from 'tsd'
-import { errorCodes } from '../../fastify'
-
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_NOT_FOUND)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_OPTIONS_NOT_OBJ)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_QSP_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_VALIDATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LISTEN_OPTIONS_INVALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ERROR_HANDLER_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ERROR_HANDLER_ALREADY_SET)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_ALREADY_PRESENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_EMPTY_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_PARSE_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_BODY_TOO_LARGE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_MEDIA_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_CONTENT_LENGTH)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_EMPTY_JSON_BODY)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_JSON_BODY)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INSTANCE_ALREADY_STARTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_ALREADY_PRESENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_DEPENDENCY_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_MISSING_DEPENDENCY)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_AFTER_START)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_REFERENCE_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_UNDECLARED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_NOT_SUPPORTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_MISSING_MIDDLEWARE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_TIMEOUT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_DESTINATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER_INSTANCE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER_CONFIG)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_INVALID_PAYLOAD_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_RESPONSE_BODY_CONSUMED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_READABLE_STREAM_LOCKED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_ALREADY_SENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_SENT_VALUE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SEND_INSIDE_ONERR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SEND_UNDEFINED_ERR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_STATUS_CODE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_TRAILER_NAME)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_TRAILER_VALUE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FAILED_ERROR_SERIALIZATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_MISSING_SERIALIZATION_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REQ_INVALID_VALIDATION_INVOCATION)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_MISSING_ID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_ALREADY_PRESENT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_CONTENT_MISSING_SCHEMA)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_DUPLICATE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_VALIDATION_BUILD)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_SERIALIZATION_BUILD)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INIT_OPTS_INVALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE)
-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_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)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_MISSING_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_METHOD_INVALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_METHOD_NOT_SUPPORTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_REWRITE_NOT_STR)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REOPENED_CLOSE_SERVER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REOPENED_SERVER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INSTANCE_ALREADY_LISTENING)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_VERSION_MISMATCH)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_CALLBACK_NOT_FN)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_NOT_VALID)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROOT_PLG_BOOTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PARENT_PLUGIN_BOOTED)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_TIMEOUT)

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

@@ -1,352 +0,0 @@
-import Ajv, { ErrorObject as AjvErrorObject } from 'ajv'
-import * as http from 'node:http'
-import * as http2 from 'node:http2'
-import * as https from 'node:https'
-import { Socket } from 'node:net'
-import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
-import fastify, {
-  ConnectionError,
-  FastifyBaseLogger,
-  FastifyError,
-  FastifyErrorCodes,
-  FastifyInstance,
-  FastifyPlugin,
-  FastifyPluginAsync,
-  FastifyPluginCallback,
-  InjectOptions,
-  LightMyRequestCallback,
-  LightMyRequestChain,
-  LightMyRequestResponse,
-  RawRequestDefaultExpression,
-  RouteGenericInterface,
-  SafePromiseLike
-} from '../../fastify'
-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: {} }))
-// 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 }))
-// 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<LightMyRequestChain>(fastify({ http2: true, https: {} }).inject())
-expectType<
-  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
-  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
->(fastify({ schemaController: {} }))
-expectType<
-  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
-  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
->(
-  fastify({
-    schemaController: {
-      compilersFactory: {}
-    }
-  })
-)
-
-expectError(fastify<http2.Http2Server>({ http2: false })) // http2 option must be true
-expectError(fastify<http2.Http2SecureServer>({ http2: false })) // http2 option must be true
-expectError(
-  fastify({
-    schemaController: {
-      bucket: () => ({}) // cannot be empty
-    }
-  })
-)
-
-// light-my-request
-expectAssignable<InjectOptions>({ query: '' })
-fastify({ http2: true, https: {} }).inject().then((resp) => {
-  expectAssignable<LightMyRequestResponse>(resp)
-})
-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>(fastify({ ignoreTrailingSlash: true }))
-expectAssignable<FastifyInstance>(fastify({ ignoreDuplicateSlashes: true }))
-expectAssignable<FastifyInstance>(fastify({ connectionTimeout: 1000 }))
-expectAssignable<FastifyInstance>(fastify({ forceCloseConnections: true }))
-expectAssignable<FastifyInstance>(fastify({ keepAliveTimeout: 1000 }))
-expectAssignable<FastifyInstance>(fastify({ pluginTimeout: 1000 }))
-expectAssignable<FastifyInstance>(fastify({ bodyLimit: 100 }))
-expectAssignable<FastifyInstance>(fastify({ handlerTimeout: 5000 }))
-expectAssignable<FastifyInstance>(fastify({ maxParamLength: 100 }))
-expectAssignable<FastifyInstance>(fastify({ disableRequestLogging: true }))
-expectAssignable<FastifyInstance>(fastify({ disableRequestLogging: (req) => req.url?.includes('/health') ?? false }))
-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: { 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: {
-    level: 'info',
-    genReqId: () => 'request-id',
-    serializers: {
-      req: () => {
-        return {
-          method: 'GET',
-          url: '/',
-          version: '1.0.0',
-          host: 'localhost',
-          remoteAddress: '127.0.0.1',
-          remotePort: 3000
-        }
-      },
-      res: () => {
-        return {
-          statusCode: 200
-        }
-      },
-      err: () => {
-        return {
-          type: 'Error',
-          message: 'foo',
-          stack: ''
-        }
-      }
-    }
-  }
-}))
-const customLogger = {
-  level: 'info',
-  info: () => { },
-  warn: () => { },
-  error: () => { },
-  fatal: () => { },
-  trace: () => { },
-  debug: () => { },
-  child: () => 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' }))
-expectAssignable<FastifyInstance>(fastify({ requestIdHeader: false }))
-expectAssignable<FastifyInstance>(fastify({
-  genReqId: (req) => {
-    expectType<RawRequestDefaultExpression>(req)
-    return 'foo'
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({ trustProxy: true }))
-expectAssignable<FastifyInstance>(fastify({ querystringParser: () => ({ foo: 'bar' }) }))
-expectAssignable<FastifyInstance>(fastify({ querystringParser: () => ({ foo: { bar: 'fuzz' } }) }))
-expectAssignable<FastifyInstance>(fastify({ querystringParser: () => ({ foo: ['bar', 'fuzz'] }) }))
-expectAssignable<FastifyInstance>(fastify({ constraints: {} }))
-expectAssignable<FastifyInstance>(fastify({
-  constraints: {
-    version: {
-      name: 'version',
-      storage: () => ({
-        get: () => () => { },
-        set: () => { },
-        del: () => { },
-        empty: () => { }
-      }),
-      validate () { },
-      deriveConstraint: () => 'foo'
-    },
-    host: {
-      name: 'host',
-      storage: () => ({
-        get: () => () => { },
-        set: () => { },
-        del: () => { },
-        empty: () => { }
-      }),
-      validate () { },
-      deriveConstraint: () => 'foo'
-    },
-    withObjectValue: {
-      name: 'withObjectValue',
-      storage: () => ({
-        get: () => () => { },
-        set: () => { },
-        del: () => { },
-        empty: () => { }
-      }),
-      validate () { },
-      deriveConstraint: () => { }
-
-    }
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({ return503OnClosing: true }))
-expectAssignable<FastifyInstance>(fastify({
-  ajv: {
-    customOptions: {
-      removeAdditional: 'all'
-    },
-    plugins: [(ajv: Ajv): Ajv => ajv]
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({
-  ajv: {
-    plugins: [[(ajv: Ajv): Ajv => ajv, ['keyword1', 'keyword2']]]
-  }
-}))
-expectError(fastify({
-  ajv: {
-    customOptions: {
-      removeAdditional: 'all'
-    },
-    plugins: [
-      () => {
-        // error, plugins always return the Ajv instance fluently
-      }
-    ]
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({
-  ajv: {
-    onCreate: (ajvInstance) => {
-      expectType<Ajv>(ajvInstance)
-      return ajvInstance
-    }
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({ frameworkErrors: () => { } }))
-expectAssignable<FastifyInstance>(fastify({
-  rewriteUrl: function (req) {
-    this.log.debug('rewrite url')
-    return req.url === '/hi' ? '/hello' : req.url!
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({
-  schemaErrorFormatter: (errors, dataVar) => {
-    console.log(
-      errors[0].keyword.toLowerCase(),
-      errors[0].message?.toLowerCase(),
-      errors[0].params,
-      errors[0].instancePath.toLowerCase(),
-      errors[0].schemaPath.toLowerCase()
-    )
-    return new Error()
-  }
-}))
-expectAssignable<FastifyInstance>(fastify({
-  clientErrorHandler: (err, socket) => {
-    expectType<ConnectionError>(err)
-    expectType<Socket>(socket)
-  }
-}))
-
-expectAssignable<FastifyInstance>(fastify({
-  childLoggerFactory: function (
-    this: FastifyInstance,
-    logger: FastifyBaseLogger,
-    bindings: Bindings,
-    opts: ChildLoggerOptions,
-    req: RawRequestDefaultExpression
-  ) {
-    expectType<FastifyBaseLogger>(logger)
-    expectType<Bindings>(bindings)
-    expectType<ChildLoggerOptions>(opts)
-    expectType<RawRequestDefaultExpression>(req)
-    expectAssignable<FastifyInstance>(this)
-    return logger.child(bindings, opts)
-  }
-}))
-
-// Thenable
-expectAssignable<PromiseLike<FastifyInstance>>(fastify({ return503OnClosing: true }))
-fastify().then(fastifyInstance => expectAssignable<FastifyInstance>(fastifyInstance))
-
-expectAssignable<FastifyPluginAsync>(async () => { })
-expectAssignable<FastifyPluginCallback>(() => { })
-expectAssignable<FastifyPlugin>(() => { })
-
-const ajvErrorObject: AjvErrorObject = {
-  keyword: '',
-  instancePath: '',
-  schemaPath: '',
-  params: {},
-  message: ''
-}
-expectNotAssignable<AjvErrorObject>({
-  keyword: '',
-  instancePath: '',
-  schemaPath: '',
-  params: '',
-  message: ''
-})
-
-expectAssignable<FastifyError['validation']>([ajvErrorObject])
-expectAssignable<FastifyError['validationContext']>('body')
-expectAssignable<FastifyError['validationContext']>('headers')
-expectAssignable<FastifyError['validationContext']>('params')
-expectAssignable<FastifyError['validationContext']>('querystring')
-
-const routeGeneric: RouteGenericInterface = {}
-expectType<unknown>(routeGeneric.Body)
-expectType<unknown>(routeGeneric.Headers)
-expectType<unknown>(routeGeneric.Params)
-expectType<unknown>(routeGeneric.Querystring)
-expectType<unknown>(routeGeneric.Reply)
-
-// ErrorCodes
-expectType<FastifyErrorCodes>(fastify.errorCodes)
-
-fastify({ allowUnsafeRegex: true })
-fastify({ allowUnsafeRegex: false })
-expectError(fastify({ allowUnsafeRegex: 'invalid' }))
-
-expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: true }))
-expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: false }))