fastify 5.0.0-alpha.2 → 5.0.0-alpha.4

package/test/schema-validation.test.js

@@ -105,6 +105,142 @@ test('Basic validation test', t => {
   })
 })
 
+test('Different schema per content type', t => {
+  t.plan(12)
+
+  const fastify = Fastify()
+  fastify.addContentTypeParser('application/octet-stream', {
+    parseAs: 'buffer'
+  }, async function (_, payload) {
+    return payload
+  })
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: schemaArtist
+          },
+          'application/octet-stream': {
+            schema: {} // Skip validation
+          },
+          'text/plain': {
+            schema: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: {
+      name: 'michelangelo',
+      work: 'sculptor, painter, architect and poet'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload).name, 'michelangelo')
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: { name: 'michelangelo' }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: "body must have required property 'work'" })
+    t.equal(res.statusCode, 400)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: Buffer.from('AAAAAAAA')
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Skip validation if no schema for content type', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: schemaArtist
+          }
+          // No schema for 'text/plain'
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Skip validation if no content type schemas', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          // No schemas
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
 test('External AJV instance', t => {
   t.plan(5)
 
@@ -829,7 +965,12 @@ test('Custom AJV settings - pt1', t => {
 
   fastify.post('/', {
     schema: {
-      body: { num: { type: 'integer' } }
+      body: {
+        type: 'object',
+        properties: {
+          num: { type: 'integer' }
+        }
+      }
     },
     handler: (req, reply) => {
       t.equal(req.body.num, 12)
@@ -862,7 +1003,12 @@ test('Custom AJV settings - pt2', t => {
 
   fastify.post('/', {
     schema: {
-      body: { num: { type: 'integer' } }
+      body: {
+        type: 'object',
+        properties: {
+          num: { type: 'integer' }
+        }
+      }
     },
     handler: (req, reply) => {
       t.fail('the handler is not called because the "12" is not coerced to number')
@@ -889,7 +1035,12 @@ test('Custom AJV settings on different parameters - pt1', t => {
 
   fastify.post('/api/:id', {
     schema: {
-      querystring: { id: { type: 'integer' } },
+      querystring: {
+        type: 'object',
+        properties: {
+          id: { type: 'integer' }
+        }
+      },
       body: {
         type: 'object',
         properties: {

package/test/skip-reply-send.test.js

@@ -19,7 +19,7 @@ const lifecycleHooks = [
   'onError'
 ]
 
-test('skip automatic reply.send() with reply.sent = true and a body', (t) => {
+test('skip automatic reply.send() with reply.hijack and a body', (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -33,7 +33,7 @@ test('skip automatic reply.send() with reply.sent = true and a body', (t) => {
   })
 
   app.get('/', (req, reply) => {
-    reply.sent = true
+    reply.hijack()
     reply.raw.end('hello world')
 
     return Promise.resolve('this will be skipped')
@@ -48,7 +48,7 @@ test('skip automatic reply.send() with reply.sent = true and a body', (t) => {
   })
 })
 
-test('skip automatic reply.send() with reply.sent = true and no body', (t) => {
+test('skip automatic reply.send() with reply.hijack and no body', (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -62,7 +62,7 @@ test('skip automatic reply.send() with reply.sent = true and no body', (t) => {
   })
 
   app.get('/', (req, reply) => {
-    reply.sent = true
+    reply.hijack()
     reply.raw.end('hello world')
 
     return Promise.resolve()
@@ -77,7 +77,7 @@ test('skip automatic reply.send() with reply.sent = true and no body', (t) => {
   })
 })
 
-test('skip automatic reply.send() with reply.sent = true and an error', (t) => {
+test('skip automatic reply.send() with reply.hijack and an error', (t) => {
   const stream = split(JSON.parse)
   const app = Fastify({
     logger: {
@@ -96,7 +96,7 @@ test('skip automatic reply.send() with reply.sent = true and an error', (t) => {
   })
 
   app.get('/', (req, reply) => {
-    reply.sent = true
+    reply.hijack()
     reply.raw.end('hello world')
 
     return Promise.reject(new Error('kaboom'))

package/test/stream-serializers.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const Reply = require('../lib/reply')
+
+test('should serialize reply when response stream is ended', t => {
+  t.plan(3)
+  const stream = require('node:stream')
+  const fastify = Fastify({
+    logger: {
+      serializers: {
+        res (reply) {
+          t.type(reply, Reply)
+          return reply
+        }
+      }
+    }
+  })
+
+  fastify.get('/error', function (req, reply) {
+    const reallyLongStream = new stream.Readable({
+      read: () => { }
+    })
+    reply.code(200).send(reallyLongStream)
+    reply.raw.end(Buffer.from('hello\n'))
+  })
+
+  fastify.inject({
+    url: '/error',
+    method: 'GET'
+  }, (err) => {
+    t.error(err)
+    fastify.close()
+  })
+})

package/test/throw.test.js

@@ -22,9 +22,9 @@ test('Fastify should throw on multiple assignment to the same route', t => {
 
   try {
     fastify.get('/', () => {})
-    t.fail('Should throw on duplicated route declaration')
+    t.fail('Should throw fastify duplicated route declaration')
   } catch (error) {
-    t.equal(error.message, "Method 'GET' already declared for route '/'")
+    t.equal(error.code, 'FST_ERR_DUPLICATED_ROUTE')
   }
 })
 
@@ -74,18 +74,6 @@ test('Fastify should throw for an invalid schema, printing the error route - bod
   })
 })
 
-test('Fastify should throw for an invalid shorthand option type', t => {
-  t.plan(3)
-  try {
-    Fastify({ jsonShorthand: 'hello' })
-    t.fail()
-  } catch (e) {
-    t.equal(e.code, 'FST_ERR_INIT_OPTS_INVALID')
-    t.match(e.message, /must be boolean/)
-    t.pass()
-  }
-})
-
 test('Should throw on unsupported method', t => {
   t.plan(1)
   const fastify = Fastify()

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

@@ -1,6 +1,6 @@
+import { FastifyErrorConstructor } from '@fastify/error'
 import { expectAssignable } from 'tsd'
 import { errorCodes } from '../../fastify'
-import { FastifyErrorConstructor } from '@fastify/error'
 
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_VALIDATION)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_NOT_FOUND)
@@ -10,7 +10,6 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCHEMA_CONTROLLER_B
 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_VERSION_CONSTRAINT_NOT_STR)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_VALIDATION)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_ALREADY_PRESENT)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_TYPE)

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

@@ -1,25 +1,26 @@
+import { ErrorObject as AjvErrorObject } from 'ajv'
+import * as http from 'http'
+import * as http2 from 'http2'
+import * as https from 'https'
+import { Socket } from 'net'
+import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
 import fastify, {
   ConnectionError,
+  FastifyBaseLogger,
+  FastifyError,
+  FastifyErrorCodes,
   FastifyInstance,
   FastifyPlugin,
   FastifyPluginAsync,
   FastifyPluginCallback,
+  InjectOptions,
+  LightMyRequestCallback,
   LightMyRequestChain,
   LightMyRequestResponse,
-  LightMyRequestCallback,
-  InjectOptions, FastifyBaseLogger,
   RawRequestDefaultExpression,
   RouteGenericInterface,
-  FastifyErrorCodes,
-  FastifyError,
   SafePromiseLike
 } from '../../fastify'
-import { ErrorObject as AjvErrorObject } from 'ajv'
-import * as http from 'http'
-import * as https from 'https'
-import * as http2 from 'http2'
-import { expectType, expectError, expectAssignable, expectNotAssignable } from 'tsd'
-import { Socket } from 'net'
 
 // FastifyInstance
 // http server
@@ -80,8 +81,8 @@ 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>(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({
@@ -139,52 +140,41 @@ 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({
-  versioning: {
-    storage: () => ({
-      get: () => 'foo',
-      set: () => { },
-      del: () => { },
-      empty: () => { }
-    }),
-    deriveVersion: () => 'foo'
-  }
-}))
 expectAssignable<FastifyInstance>(fastify({ constraints: {} }))
 expectAssignable<FastifyInstance>(fastify({
   constraints: {
     version: {
       name: 'version',
       storage: () => ({
-        get: () => () => {},
+        get: () => () => { },
         set: () => { },
         del: () => { },
         empty: () => { }
       }),
-      validate () {},
+      validate () { },
       deriveConstraint: () => 'foo'
     },
     host: {
       name: 'host',
       storage: () => ({
-        get: () => () => {},
+        get: () => () => { },
         set: () => { },
         del: () => { },
         empty: () => { }
       }),
-      validate () {},
+      validate () { },
       deriveConstraint: () => 'foo'
     },
     withObjectValue: {
       name: 'withObjectValue',
       storage: () => ({
-        get: () => () => {},
+        get: () => () => { },
         set: () => { },
         del: () => { },
         empty: () => { }
       }),
-      validate () {},
-      deriveConstraint: () => {}
+      validate () { },
+      deriveConstraint: () => { }
 
     }
   }
@@ -228,15 +218,14 @@ expectAssignable<FastifyInstance>(fastify({
     expectType<Socket>(socket)
   }
 }))
-expectAssignable<FastifyInstance>(fastify({ jsonShorthand: true }))
 
 // Thenable
 expectAssignable<PromiseLike<FastifyInstance>>(fastify({ return503OnClosing: true }))
 fastify().then(fastifyInstance => expectAssignable<FastifyInstance>(fastifyInstance))
 
-expectAssignable<FastifyPluginAsync>(async () => {})
-expectAssignable<FastifyPluginCallback>(() => {})
-expectAssignable<FastifyPlugin>(() => {})
+expectAssignable<FastifyPluginAsync>(async () => { })
+expectAssignable<FastifyPluginCallback>(() => { })
+expectAssignable<FastifyPlugin>(() => { })
 
 const ajvErrorObject: AjvErrorObject = {
   keyword: '',

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

@@ -273,83 +273,83 @@ server.route<RouteGenericInterface, CustomContextConfig>({
   url: '/',
   handler: () => { },
   onRequest: (request, reply, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preParsing: (request, reply, payload, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preValidation: (request, reply, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preHandler: (request, reply, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preSerialization: (request, reply, payload, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onSend: (request, reply, payload, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onResponse: (request, reply, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onTimeout: (request, reply, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onError: (request, reply, error, done) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   }
 })
 
 server.get<RouteGenericInterface, CustomContextConfig>('/', {
   onRequest: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preParsing: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preValidation: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preHandler: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preSerialization: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onSend: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onResponse: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onTimeout: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onError: async (request, reply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   }
 }, async (request, reply) => {
-  expectType<CustomContextConfigWithDefault>(request.context.config)
-  expectType<CustomContextConfigWithDefault>(reply.context.config)
+  expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+  expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
 })
 
 type CustomContextRequest = FastifyRequest<any, any, any, any, any, CustomContextConfig, any>
@@ -359,40 +359,40 @@ server.route<RouteGenericInterface, CustomContextConfig>({
   url: '/',
   handler: () => { },
   onRequest: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preParsing: async (request: CustomContextRequest, reply: CustomContextReply, payload: RequestPayload) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preValidation: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preHandler: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   preSerialization: async (request: CustomContextRequest, reply: CustomContextReply, payload: any) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onSend: async (request: CustomContextRequest, reply: CustomContextReply, payload: any) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onResponse: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onTimeout: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   },
   onError: async (request: CustomContextRequest, reply: CustomContextReply, error: FastifyError) => {
-    expectType<CustomContextConfigWithDefault>(request.context.config)
-    expectType<CustomContextConfigWithDefault>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.routeOptions.config)
+    expectType<CustomContextConfigWithDefault>(reply.routeOptions.config)
   }
 })
 

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

@@ -89,12 +89,12 @@ interface ReplyPayload {
 // typed sync error handler
 server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
   expectType<CustomError>(error)
-  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ReplyPayload>)>(reply.send)
+  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
 })
 // typed async error handler send
 server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
   expectType<CustomError>(error)
-  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ReplyPayload>)>(reply.send)
+  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
 })
 // typed async error handler return
 server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
@@ -250,7 +250,7 @@ expectType<FastifyInstance>(fastify().get<RouteGenericInterface, { contextKey: s
   errorHandler: (error, request, reply) => {
     expectAssignable<FastifyError>(error)
     expectAssignable<FastifyRequest>(request)
-    expectAssignable<{ contextKey: string }>(request.routeConfig)
+    expectAssignable<{ contextKey: string }>(request.routeOptions.config)
     expectAssignable<FastifyReply>(reply)
     expectAssignable<void>(server.errorHandler(error, request, reply))
   }