fastify 4.28.0 → 5.0.0-alpha.3

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, statusCode?: number): 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;
 }

package/test/types/type-provider.test-d.ts

@@ -4,7 +4,8 @@ import fastify, {
   FastifyRequest,
   FastifyReply,
   FastifyInstance,
-  FastifyError
+  FastifyError,
+  SafePromiseLike
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import { IncomingHttpHeaders } from 'http'
@@ -23,7 +24,10 @@ expectAssignable(server.get('/', (req) => expectType<unknown>(req.body)))
 // Remapping
 // -------------------------------------------------------------------
 
-interface NumberProvider extends FastifyTypeProvider { output: number } // remap all schemas to numbers
+interface NumberProvider extends FastifyTypeProvider {
+  validator: number
+  serializer: number
+} // remap all schemas to numbers
 
 expectAssignable(server.withTypeProvider<NumberProvider>().get(
   '/',
@@ -47,7 +51,7 @@ expectAssignable(server.withTypeProvider<NumberProvider>().get(
 // Override
 // -------------------------------------------------------------------
 
-interface OverriddenProvider extends FastifyTypeProvider { output: 'inferenced' }
+interface OverriddenProvider extends FastifyTypeProvider { validator: 'inferenced' }
 
 expectAssignable(server.withTypeProvider<OverriddenProvider>().get<{ Body: 'override' }>(
   '/',
@@ -69,7 +73,10 @@ expectAssignable(server.withTypeProvider<OverriddenProvider>().get<{ Body: 'over
 // TypeBox
 // -------------------------------------------------------------------
 
-interface TypeBoxProvider extends FastifyTypeProvider { output: this['input'] extends TSchema ? Static<this['input']> : unknown }
+interface TypeBoxProvider extends FastifyTypeProvider {
+  validator: this['schema'] extends TSchema ? Static<this['schema']> : unknown
+  serializer: this['schema'] extends TSchema ? Static<this['schema']> : unknown
+}
 
 expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
   '/',
@@ -103,7 +110,10 @@ expectAssignable<FastifyInstance>(server.withTypeProvider<TypeBoxProvider>())
 // JsonSchemaToTs
 // -------------------------------------------------------------------
 
-interface JsonSchemaToTsProvider extends FastifyTypeProvider { output: this['input'] extends JSONSchema ? FromSchema<this['input']> : unknown }
+interface JsonSchemaToTsProvider extends FastifyTypeProvider {
+  validator: this['schema'] extends JSONSchema ? FromSchema<this['schema']> : unknown
+  serializer: this['schema'] extends JSONSchema ? FromSchema<this['schema']> : unknown
+}
 
 // explicitly setting schema `as const`
 
@@ -907,7 +917,7 @@ expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get(
 // Reply Type Override
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -927,7 +937,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // Reply Type Override (Different Content-types)
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -955,7 +965,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // Reply Type Return Override
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -975,7 +985,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // Reply Type Return Override (Different Content-types)
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -1003,7 +1013,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // FastifyPlugin: Auxiliary
 // -------------------------------------------------------------------
 
-interface AuxiliaryPluginProvider extends FastifyTypeProvider { output: 'plugin-auxiliary' }
+interface AuxiliaryPluginProvider extends FastifyTypeProvider { validator: 'plugin-auxiliary' }
 
 // Auxiliary plugins may have varying server types per application. Recommendation would be to explicitly remap instance provider context within plugin if required.
 function plugin<T extends FastifyInstance> (instance: T) {
@@ -1032,7 +1042,7 @@ expectAssignable(server.withTypeProvider<AuxiliaryPluginProvider>().register(plu
 // Handlers: Inline
 // -------------------------------------------------------------------
 
-interface InlineHandlerProvider extends FastifyTypeProvider { output: 'handler-inline' }
+interface InlineHandlerProvider extends FastifyTypeProvider { validator: 'handler-inline' }
 
 // Inline handlers should infer for the request parameters (non-shared)
 expectAssignable(server.withTypeProvider<InlineHandlerProvider>().get(
@@ -1052,7 +1062,7 @@ expectAssignable(server.withTypeProvider<InlineHandlerProvider>().get(
 // Handlers: Auxiliary
 // -------------------------------------------------------------------
 
-interface AuxiliaryHandlerProvider extends FastifyTypeProvider { output: this['input'] }
+interface AuxiliaryHandlerProvider extends FastifyTypeProvider { validator: 'handler-auxiliary' }
 
 // Auxiliary handlers are likely shared for multiple routes and thus should infer as unknown due to potential varying parameters
 function auxiliaryHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction): void {
@@ -1069,3 +1079,40 @@ expectAssignable(server.withTypeProvider<AuxiliaryHandlerProvider>().get(
     expectType<'handler-auxiliary'>(req.body)
   }
 ))
+
+// -------------------------------------------------------------------
+// SafePromiseLike
+// -------------------------------------------------------------------
+const safePromiseLike = {
+  then: new Promise<string>(resolve => resolve('')).then,
+  __linterBrands: 'SafePromiseLike' as const
+}
+expectAssignable<SafePromiseLike<string>>(safePromiseLike)
+expectAssignable<PromiseLike<string>>(safePromiseLike)
+expectError<Promise<string>>(safePromiseLike)
+
+// -------------------------------------------------------------------
+// Separate Providers
+// -------------------------------------------------------------------
+
+interface SeparateProvider extends FastifyTypeProvider {
+  validator: string
+  serializer: Date
+}
+
+expectAssignable(server.withTypeProvider<SeparateProvider>().get(
+  '/',
+  {
+    schema: {
+      body: null,
+      response: {
+        200: { type: 'string' }
+      }
+    }
+  },
+  (req, res) => {
+    expectType<string>(req.body)
+
+    res.send(new Date())
+  }
+))

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

@@ -1,4 +1,4 @@
-import { expectAssignable, expectType } from 'tsd'
+import { expectAssignable } from 'tsd'
 import fastify, { FastifyInstance } from '../../fastify'
 
 async function hasSymbolDisposeWithUsing () {
@@ -12,3 +12,6 @@ async function hasSymbolDispose () {
   expectAssignable<FastifyInstance>(app)
   expectAssignable<FastifyInstance[typeof Symbol.asyncDispose]>(app.close)
 }
+
+hasSymbolDisposeWithUsing()
+hasSymbolDispose()

package/test/url-rewriting.test.js

@@ -119,8 +119,8 @@ test('Should rewrite url but keep originalUrl unchanged', t => {
     method: 'GET',
     url: '/',
     handler: (req, reply) => {
+      reply.send({ hello: 'world', hostname: req.hostname, port: req.port })
       t.equal(req.originalUrl, '/this-would-404-without-url-rewrite')
-      reply.send({ hello: 'world' })
     }
   })
 
@@ -132,7 +132,8 @@ test('Should rewrite url but keep originalUrl unchanged', t => {
       url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
     }, (err, response, body) => {
       t.error(err)
-      t.same(JSON.parse(body), { hello: 'world' })
+      const parsedBody = JSON.parse(body)
+      t.same(parsedBody, { hello: 'world', hostname: 'localhost', port: fastify.server.address().port })
       t.equal(response.statusCode, 200)
     })
   })

package/test/useSemicolonDelimiter.test.js

@@ -5,30 +5,27 @@ const test = t.test
 const Fastify = require('..')
 const sget = require('simple-get').concat
 
-test('use semicolon delimiter default true', t => {
+test('use semicolon delimiter default false', t => {
   t.plan(4)
 
   const fastify = Fastify({})
 
   t.teardown(fastify.close.bind(fastify))
 
-  fastify.get('/1234', (req, reply) => {
+  fastify.get('/1234;foo=bar', (req, reply) => {
     reply.send(req.query)
   })
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
 
-    console.log('http://localhost:' + fastify.server.address().port + '/1234;foo=bar')
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
     }, (err, response, body) => {
       t.error(err)
       t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), {
-        foo: 'bar'
-      })
+      t.same(JSON.parse(body), {})
     })
   })
 })

package/test/versioned-routes.test.js

@@ -454,7 +454,7 @@ test('test log stream', t => {
     t.teardown(() => { fastify.close() })
 
     http.get({
-      hostname: fastify.server.address().hostname,
+      host: fastify.server.address().hostname,
       port: fastify.server.address().port,
       path: '/',
       method: 'GET',

package/test/web-api.test.js

@@ -4,15 +4,9 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('../fastify')
 const fs = require('node:fs')
-const semver = require('semver')
 const { Readable } = require('node:stream')
 const { fetch: undiciFetch } = require('undici')
 
-if (semver.lt(process.versions.node, '18.0.0')) {
-  t.skip('Response or ReadableStream not available, skipping test')
-  process.exit(0)
-}
-
 test('should response with a ReadableStream', async (t) => {
   t.plan(2)
 

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

@@ -15,7 +15,7 @@ export type FastifyBodyParser<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > = ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, rawBody: RawBody, done: ContentTypeParserDoneFunction) => void)
 | ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, rawBody: RawBody) => Promise<any>)
 
@@ -27,7 +27,7 @@ export type FastifyContentTypeParser<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > = ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, payload: RawRequest) => Promise<any>)
 | ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, payload: RawRequest, done: ContentTypeParserDoneFunction) => void)
 
@@ -39,7 +39,7 @@ export interface AddContentTypeParser<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     contentType: string | string[] | RegExp,

package/types/context.d.ts

@@ -1,7 +1,6 @@
 import { FastifyRouteConfig } from './route'
 import { ContextConfigDefault } from './utils'
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface FastifyContextConfig {
 }
 

package/types/errors.d.ts

@@ -24,6 +24,7 @@ export type FastifyErrorCodes = Record<
 'FST_ERR_DEC_DEPENDENCY_INVALID_TYPE' |
 'FST_ERR_DEC_MISSING_DEPENDENCY' |
 'FST_ERR_DEC_AFTER_START' |
+'FST_ERR_DEC_REFERENCE_TYPE' |
 'FST_ERR_HOOK_INVALID_TYPE' |
 'FST_ERR_HOOK_INVALID_HANDLER' |
 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER' |

package/types/hooks.d.ts

@@ -724,7 +724,7 @@ export interface onReadyHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -737,7 +737,7 @@ export interface onReadyAsyncHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -752,7 +752,7 @@ export interface onListenHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -765,7 +765,7 @@ export interface onListenAsyncHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -779,7 +779,7 @@ export interface onCloseHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     instance: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -807,7 +807,7 @@ export interface preCloseHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,