fastify 5.6.1 → 5.6.2

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

@@ -21,8 +21,15 @@ const testPluginOptsAsync: FastifyPluginAsync<TestOptions> = async function (ins
   expectType<TestOptions>(opts)
 }
 
-const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
-const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
+const testPluginOptsWithType = (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginOptsWithTypeAsync = async (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions
+) => { }
 
 expectError(fastify().register(testPluginOpts, {})) // error because missing required options from generic declaration
 expectError(fastify().register(testPluginOptsAsync, {})) // error because missing required options from generic declaration
@@ -43,16 +50,27 @@ expectAssignable<FastifyInstance>(fastify().register(testPluginCallback, {}))
 const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
 expectAssignable<FastifyInstance>(fastify().register(testPluginAsync, {}))
 
-expectAssignable<FastifyInstance>(fastify().register(function (instance, opts): Promise<void> { return Promise.resolve() }))
+expectAssignable<FastifyInstance>(
+  fastify().register(function (instance, opts): Promise<void> { return Promise.resolve() })
+)
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, () => { }))
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, { logLevel: 'info', prefix: 'foobar' }))
 
 expectError(fastify().register(function (instance, opts, done) { }, { ...testOptions, logLevel: '' })) // must use a valid logLevel
 
 const httpsServer = fastify({ https: {} })
-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)
+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

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

@@ -9,7 +9,11 @@ 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 testPluginOptsWithType = (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
 const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
 
 interface TestOptions extends FastifyPluginOptions {
@@ -46,8 +50,15 @@ 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 testPluginWithHttp2WithType = (
+  instance: ServerWithHttp2,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginWithHttp2WithTypeAsync = async (
+  instance: ServerWithHttp2,
+  opts: FastifyPluginOptions
+) => { }
 const testOptions: TestOptions = {
   option1: 'a',
   option2: false
@@ -82,11 +93,32 @@ expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: Serv
 // With Type Provider
 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) { }
-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) => { }
+type ServerWithTypeProvider = FastifyInstance<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  FastifyLoggerInstance,
+  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))
@@ -129,34 +161,77 @@ const customLogger = {
 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) => { }
+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))
-// @ts-expect-error
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger))
-expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger, testOptions))
-// @ts-expect-error
-expectAssignable<ServerWithTypeProviderAndLogger>(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)
-}))
+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

@@ -20,7 +20,9 @@ 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<
+          (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)
@@ -35,14 +37,29 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   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,
+      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<
+          ((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'))

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

@@ -91,7 +91,9 @@ const getHandler: RouteHandler = function (request, _reply) {
   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 }, 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'))
@@ -99,14 +101,25 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectError(request.setDecorator<string>('foo', true))
 }
 
-const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, CustomLoggerInterface> = function (request, _reply) {
+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<RequestHeaders & RawRequestDefaultExpression['headers']>(
+    request.headers
+  )
   expectType<RequestQuerystring>(request.query)
   expectType<string>(request.body.content)
   expectType<string>(request.query.from)
@@ -154,15 +167,21 @@ const customLogger: CustomLoggerInterface = {
 const serverWithCustomLogger = fastify({ loggerInstance: customLogger })
 expectError<
 FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
-& Promise<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+& Promise<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
 >(serverWithCustomLogger)
 expectAssignable<
 FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
-& PromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+& PromiseLike<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
 >(serverWithCustomLogger)
 expectType<
 FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
-& SafePromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+& SafePromiseLike<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
 >(serverWithCustomLogger)
 
 serverWithCustomLogger.get('/get', getHandlerWithCustomLogger)

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

@@ -23,7 +23,16 @@ declare module '../../fastify' {
   }
 
   /* eslint-disable @typescript-eslint/no-unused-vars */
-  interface FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger, RequestType> {
+  interface FastifyRequest<
+    RouteGeneric,
+    RawServer,
+    RawRequest,
+    SchemaCompiler,
+    TypeProvider,
+    ContextConfig,
+    Logger,
+    RequestType
+  > {
     message: ContextConfig extends { includeMessage: true }
       ? string
       : null;

package/test/validation-error-handling.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('node:test')
+const { describe, test } = require('node:test')
 const Joi = require('joi')
 const Fastify = require('..')
 
@@ -831,3 +831,70 @@ test('plugin override', async (t) => {
   })
   t.assert.strictEqual(response5.statusCode, 400)
 })
+
+describe('sync and async must work in the same way', () => {
+  // Route with custom validator that throws
+  const throwingRouteValidator = {
+    schema: {
+      body: {
+        type: 'object',
+        properties: { name: { type: 'string' } }
+      }
+    },
+    validatorCompiler: () => {
+      return function (inputData) {
+        // This custom validator throws a sync error instead of returning `{ error }`
+        throw new Error('Custom validation failed')
+      }
+    },
+    handler (request, reply) { reply.send({ success: true }) }
+  }
+
+  test('async preValidation with custom validator should trigger error handler when validator throws', async (t) => {
+    t.plan(4)
+
+    const fastify = Fastify()
+    fastify.setErrorHandler((error, request, reply) => {
+      t.assert.ok(error instanceof Error, 'error should be an Error instance')
+      t.assert.strictEqual(error.message, 'Custom validation failed')
+      reply.status(500).send({ error: error.message })
+    })
+
+    // Add async preValidation hook
+    fastify.addHook('preValidation', async (request, reply) => {
+      await Promise.resolve('ok')
+    })
+    fastify.post('/async', throwingRouteValidator)
+
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/async',
+      payload: { name: 'test' }
+    })
+    t.assert.strictEqual(response.statusCode, 500)
+    t.assert.deepStrictEqual(response.json(), { error: 'Custom validation failed' })
+  })
+
+  test('sync preValidation with custom validator should trigger error handler when validator throws', async (t) => {
+    t.plan(4)
+
+    const fastify = Fastify()
+    fastify.setErrorHandler((error, request, reply) => {
+      t.assert.ok(error instanceof Error, 'error should be an Error instance')
+      t.assert.strictEqual(error.message, 'Custom validation failed')
+      reply.status(500).send({ error: error.message })
+    })
+
+    // Add sync preValidation hook
+    fastify.addHook('preValidation', (request, reply, next) => { next() })
+    fastify.post('/sync', throwingRouteValidator)
+
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/sync',
+      payload: { name: 'test' }
+    })
+    t.assert.strictEqual(response.statusCode, 500)
+    t.assert.deepStrictEqual(response.json(), { error: 'Custom validation failed' })
+  })
+})

package/test/wrap-thenable.test.js

@@ -2,7 +2,7 @@
 
 const { test } = require('node:test')
 const { kReplyHijacked } = require('../lib/symbols')
-const wrapThenable = require('../lib/wrapThenable')
+const wrapThenable = require('../lib/wrap-thenable')
 const Reply = require('../lib/reply')
 
 test('should resolve immediately when reply[kReplyHijacked] is true', async t => {

package/types/instance.d.ts

@@ -464,12 +464,12 @@ export interface FastifyInstance<
   /**
    * Fastify default error handler
    */
-  errorHandler: (error: FastifyError, request: FastifyRequest, reply: FastifyReply) => void;
+  errorHandler: <TError = unknown>(error: TError, request: FastifyRequest, reply: FastifyReply) => void;
 
   /**
    * Set a function that will be invoked whenever an exception is thrown during the request lifecycle.
    */
-  setErrorHandler<TError extends Error = FastifyError, RouteGeneric extends RouteGenericInterface = RouteGenericInterface, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(
+  setErrorHandler<TError = unknown, RouteGeneric extends RouteGenericInterface = RouteGenericInterface, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(
     handler: (this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>, error: TError, request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfigDefault, SchemaCompiler, TypeProvider>) => any | Promise<any>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;