fastify 6.0.0-alpha.3 → 6.0.0-alpha.5

package/test/internals/request.test.js

@@ -402,6 +402,56 @@ test('Request with trust proxy - handles multiple entries in x-forwarded-host/pr
   t.assert.strictEqual(request.protocol, 'https')
 })
 
+test('Request with trust proxy - host getter reads the merged headers once', t => {
+  t.plan(2)
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: { remoteAddress: 'ip' },
+    headers: { host: 'fastify.test' }
+  }
+
+  const TpRequest = Request.buildRequest(Request, true)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  // the headers getter may allocate a new object once request.headers was
+  // assigned in a hook, so the host getter must read it once per access
+  const additional = { 'user-assigned': 'yes' }
+  let reads = 0
+  Object.defineProperty(request, 'headers', {
+    get () {
+      reads++
+      return Object.assign({}, req.headers, additional)
+    }
+  })
+  t.assert.strictEqual(request.host, 'fastify.test')
+  t.assert.strictEqual(reads, 1)
+})
+
+test('Request with trust proxy - protocol getter reads the merged headers once', t => {
+  t.plan(2)
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: { remoteAddress: 'ip' },
+    headers: { 'x-forwarded-proto': 'https' }
+  }
+
+  const TpRequest = Request.buildRequest(Request, true)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  // the headers getter may allocate a new object once request.headers was
+  // assigned in a hook, so the protocol getter must read it once per access
+  const additional = { 'user-assigned': 'yes' }
+  let reads = 0
+  Object.defineProperty(request, 'headers', {
+    get () {
+      reads++
+      return Object.assign({}, req.headers, additional)
+    }
+  })
+  t.assert.strictEqual(request.protocol, 'https')
+  t.assert.strictEqual(reads, 1)
+})
+
 test('Request with trust proxy - plain', t => {
   t.plan(1)
   const headers = {

package/test/internals/validation.test.js

@@ -10,6 +10,72 @@ const { normalizeSchema } = require('../../lib/schemas')
 const symbols = require('../../lib/validation').symbols
 const { kSchemaVisited } = require('../../lib/symbols')
 
+for (const [part, symbol] of [
+  ['params', symbols.paramsSchema],
+  ['body', symbols.bodySchema],
+  ['query', symbols.querystringSchema],
+  ['headers', symbols.headersSchema]
+]) {
+  for (const async of [false, true]) {
+    test(`validate reads only the validated ${part} once (${async ? 'async' : 'sync'})`, async t => {
+      const request = {}
+      const value = { hello: 'world' }
+      let reads = 0
+      let calls = 0
+
+      for (const name of ['params', 'body', 'query', 'headers']) {
+        Object.defineProperty(request, name, {
+          get () {
+            t.assert.strictEqual(name, part, 'unvalidated request parts must not be read')
+            reads++
+            return value
+          }
+        })
+      }
+
+      const context = {
+        [symbol]: data => {
+          calls++
+          t.assert.strictEqual(data, value)
+          return async ? Promise.resolve(data) : true
+        }
+      }
+
+      t.assert.strictEqual(await validation.validate(context, request), false)
+      t.assert.strictEqual(reads, 1)
+      t.assert.strictEqual(calls, 1)
+    })
+  }
+}
+
+test('validate skips a body without a matching content-type schema', t => {
+  const context = { [symbols.bodySchema]: { 'application/json': () => true } }
+  const request = {
+    mediaType: 'text/plain',
+    get body () {
+      t.assert.fail('an unvalidated body must not be read')
+    }
+  }
+
+  t.assert.strictEqual(validation.validate(context, request), false)
+})
+
+test('validate passes null for an undefined request part and preserves other values', t => {
+  for (const value of [undefined, null, false, 0, '']) {
+    let calls = 0
+    const context = {
+      [symbols.bodySchema]: data => {
+        calls++
+        t.assert.strictEqual(data, value === undefined ? null : value)
+        return true
+      }
+    }
+
+    t.assert.strictEqual(validation.validate(context, { body: value }), false)
+    t.assert.strictEqual(calls, 1)
+  }
+})
+
 test('Symbols', t => {
   t.plan(5)
   t.assert.strictEqual(typeof symbols.responseSchema, 'symbol')

package/test/reply-media-type.test.js

@@ -129,3 +129,60 @@ test('reply.mediaType should reflect the last type set', async (t) => {
   const body = response.body
   t.assert.strictEqual(body, 'mediaType = text/plain')
 })
+
+test('reply.mediaType should match the content-type set via raw.setHeader', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.raw.setHeader('content-type', 'application/json; charset=utf-8')
+    t.assert.strictEqual(reply.mediaType, 'application/json')
+    reply.send({ mediaType: reply.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('reply.mediaType should match case-insensitive content-type set via raw.setHeader', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.raw.setHeader('Content-Type', 'text/html; charset=utf-8')
+    t.assert.strictEqual(reply.mediaType, 'text/html')
+    reply.send(reply.mediaType)
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  t.assert.strictEqual(response.body, 'text/html')
+})
+
+test('reply.mediaType should prioritize reply.type over raw.setHeader', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.raw.setHeader('content-type', 'application/xml')
+    reply.type('application/json')
+    t.assert.strictEqual(reply.mediaType, 'application/json')
+    reply.send({ mediaType: reply.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})

package/test/rfc-10008.test.js

@@ -99,12 +99,9 @@ describe('RFC 10008', () => {
     t.assert.equal(res.json().code, 'FST_ERR_CTP_INVALID_JSON_BODY')
   })
 
-  test('should return 400 if no content is provided for QUERY method', async (t) => {
-    // If a media type is specified but is inconsistent
-    // with the actual request content, a 400 (Bad Request)
-    // can be returned. That is, a server is not allowed to
-    // infer a media type from the request content and then
-    // override a missing or "erroneous" value (i.e., "content sniffing").
+  test('should return 200 if body is empty but media type allows it for QUERY method', async (t) => {
+    // If a media type is set and allows the body to be empty,
+    // the server must allow it.
     t.plan(2)
 
     const fastify = Fastify()
@@ -116,11 +113,11 @@ describe('RFC 10008', () => {
     const res = await fastify.inject({
       method: 'QUERY',
       url: '/query',
-      headers: { 'Content-Type': 'application/json' }
+      headers: { 'Content-Type': 'text/plain' }
     })
 
-    t.assert.equal(res.statusCode, 400)
-    t.assert.equal(res.json().code, 'FST_ERR_ROUTE_MISSING_CONTENT')
+    t.assert.equal(res.statusCode, 200)
+    t.assert.equal(res.body, '')
   })
 
   test('should return 415 if unsupported media type is provided for QUERY method', async (t) => {

package/test/schema-feature.test.js

@@ -459,7 +459,7 @@ test('Should emit a warning for every route with undefined schema', (t, testDone
     t.assert.ifError(error)
     t.assert.strictEqual(res.statusCode, 200)
     // fastify.inject run in series
-    // last callback recieve all warnings at once
+    // last callback receive all warnings at once
     // GET /undefinedParams/123
     t.assert.deepStrictEqual(spyData.calls[0], { arguments: ['params', 'GET', '/undefinedParams/:id'], result: true })
     t.assert.deepStrictEqual(spyData.calls[1], { arguments: ['params', 'HEAD', '/undefinedParams/:id'], result: true })

package/test/schema-validation.test.js

@@ -8,7 +8,7 @@ const Schema = require('fluent-json-schema')
 const { waitForCb } = require('./helper')
 const { kRequestContentType } = require('../lib/symbols')
 const { spyWarning } = require('process-warning')
-const { FSTSEC002 } = require('../lib/warnings')
+const { FSTSEC002, FSTSEC003 } = require('../lib/warnings')
 
 const customSchemaCompilers = {
   body: new AJV({
@@ -1921,6 +1921,52 @@ test('inline and local $ref header schemas do not emit FSTSEC002', async t => {
   t.assert.strictEqual(spyData.callCount(), 0)
 })
 
+test('header schema with a $ref inside propertyNames emits FSTSEC003 (case-normalization does not reach it)', async t => {
+  const spyData = spyWarning(FSTSEC003)
+  t.after(spyData.restore)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { $ref: '#/definitions/denied' },
+        definitions: {
+          denied: { not: { enum: ['X-Debug-Override'] } }
+        }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  t.assert.strictEqual(spyData.callCount(), 1)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['POST', '/', '#/definitions/denied'])
+})
+
+test('header schema detects a $ref inside propertyNames nested in an array', async t => {
+  const spyData = spyWarning(FSTSEC003)
+  t.after(spyData.restore)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { not: { anyOf: [{ $ref: '#/definitions/denied' }] } },
+        definitions: {
+          denied: { enum: ['X-Debug-Override'] }
+        }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  t.assert.strictEqual(spyData.callCount(), 1)
+  t.assert.deepStrictEqual(spyData.calls[0].arguments, ['POST', '/', '#/definitions/denied'])
+})
+
 test('header schema normalization traverses dependent schema keywords', async t => {
   const fastify = Fastify({
     ajv: { customOptions: { strictSchema: false } }
@@ -1993,3 +2039,207 @@ test('header schema detects an external $ref nested in an array', async t => {
     'http://example.com/nested-admin-headers#'
   ])
 })
+
+test('header schema propertyNames: not-enum deny-list is lowercased', async t => {
+  const fastify = Fastify()
+
+  // A `propertyNames` subschema validates each header name itself, so strings in
+  // its `enum` are header names. They must be lowercased the same way as
+  // `required` entries, otherwise a deny-list written in the usual header case
+  // never matches the lowercased request object.
+  fastify.get('/', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { not: { enum: ['X-Debug-Override'] } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  const blocked = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { 'X-Debug-Override': '1' }
+  })
+  t.assert.strictEqual(blocked.statusCode, 400)
+  t.assert.strictEqual(blocked.json().code, 'FST_ERR_VALIDATION')
+
+  const ok = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { 'X-Other': '1' }
+  })
+  t.assert.strictEqual(ok.statusCode, 200)
+})
+
+test('header schema propertyNames: non-string enum items are left untouched', async t => {
+  const fastify = Fastify({
+    ajv: { customOptions: { strictSchema: false } }
+  })
+
+  fastify.get('/', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { not: { enum: ['X-Debug-Override', 42, null] } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  const blocked = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { 'X-Debug-Override': '1' }
+  })
+  t.assert.strictEqual(blocked.statusCode, 400)
+
+  const ok = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { 'X-Other': '1' }
+  })
+  t.assert.strictEqual(ok.statusCode, 200)
+})
+
+test('header schema propertyNames: not-const deny-list is lowercased', async t => {
+  const fastify = Fastify()
+
+  fastify.get('/', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { not: { const: 'X-Debug-Override' } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  const blocked = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { 'X-Debug-Override': '1' }
+  })
+  t.assert.strictEqual(blocked.statusCode, 400)
+  t.assert.strictEqual(blocked.json().code, 'FST_ERR_VALIDATION')
+})
+
+test('header schema propertyNames: enum/const are lowercased inside combinators', async t => {
+  const fastify = Fastify()
+
+  // The header-name `enum`/`const` can be nested under combinators inside
+  // `propertyNames`; the lowercasing context must propagate through them.
+  fastify.get('/anyOf', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { not: { anyOf: [{ enum: ['X-Debug-Override'] }] } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  fastify.get('/oneOf', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { not: { oneOf: [{ const: 'X-Debug-Override' }] } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  for (const url of ['/anyOf', '/oneOf']) {
+    const blocked = await fastify.inject({
+      method: 'GET',
+      url,
+      headers: { 'X-Debug-Override': '1' }
+    })
+    t.assert.strictEqual(blocked.statusCode, 400, `${url} should block the header`)
+    t.assert.strictEqual(blocked.json().code, 'FST_ERR_VALIDATION')
+  }
+})
+
+test('header schema propertyNames: lowercase-equivalent schema behaves identically', async t => {
+  const fastify = Fastify()
+
+  fastify.get('/', {
+    schema: {
+      headers: {
+        type: 'object',
+        propertyNames: { not: { enum: ['x-debug-override'] } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  const blocked = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { 'X-Debug-Override': '1' }
+  })
+  t.assert.strictEqual(blocked.statusCode, 400)
+  t.assert.strictEqual(blocked.json().code, 'FST_ERR_VALIDATION')
+})
+
+test('header schema propertyNames: enum/const values in header value schemas are not lowercased', async t => {
+  const fastify = Fastify()
+
+  // `enum`/`const` inside a property value subschema hold header *values*, not
+  // names, and must be preserved with their original case.
+  fastify.get('/enum', {
+    schema: {
+      headers: {
+        type: 'object',
+        properties: { 'X-Mode': { type: 'string', enum: ['MIXED', 'lowercase'] } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  fastify.get('/const', {
+    schema: {
+      headers: {
+        type: 'object',
+        properties: { 'X-Mode': { type: 'string', const: 'MIXED' } }
+      }
+    }
+  }, async () => ({ ok: true }))
+
+  await fastify.ready()
+
+  const enumMixed = await fastify.inject({
+    method: 'GET',
+    url: '/enum',
+    headers: { 'X-Mode': 'MIXED' }
+  })
+  t.assert.strictEqual(enumMixed.statusCode, 200)
+
+  const constMixed = await fastify.inject({
+    method: 'GET',
+    url: '/const',
+    headers: { 'X-Mode': 'MIXED' }
+  })
+  t.assert.strictEqual(constMixed.statusCode, 200)
+})
+
+test('header schema propertyNames lowercasing does not mutate the input schema', async t => {
+  const headers = {
+    type: 'object',
+    propertyNames: { not: { enum: ['X-Debug-Override'], const: 'X-Other' } }
+  }
+  const schema = { headers }
+  const schemaBefore = JSON.stringify(schema)
+  const headersBefore = JSON.stringify(headers)
+
+  const fastify = Fastify()
+  fastify.get('/', { schema }, async () => ({ ok: true }))
+  await fastify.ready()
+
+  t.assert.strictEqual(JSON.stringify(schema), schemaBefore)
+  t.assert.strictEqual(JSON.stringify(headers), headersBefore)
+})

package/test/types/errors.tst.ts

@@ -79,7 +79,6 @@ expect(errorCodes.FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED).type.toBeA
 expect(errorCodes.FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT).type.toBeAssignableTo<FastifyErrorConstructor>()
 expect(errorCodes.FST_ERR_ROUTE_REWRITE_NOT_STR).type.toBeAssignableTo<FastifyErrorConstructor>()
 expect(errorCodes.FST_ERR_ROUTE_MISSING_CONTENT_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
-expect(errorCodes.FST_ERR_ROUTE_MISSING_CONTENT).type.toBeAssignableTo<FastifyErrorConstructor>()
 expect(errorCodes.FST_ERR_REOPENED_CLOSE_SERVER).type.toBeAssignableTo<FastifyErrorConstructor>()
 expect(errorCodes.FST_ERR_REOPENED_SERVER).type.toBeAssignableTo<FastifyErrorConstructor>()
 expect(errorCodes.FST_ERR_INSTANCE_ALREADY_STARTED).type.toBeAssignableTo<FastifyErrorConstructor>()

package/test/types/fastify.tst.ts

@@ -3,6 +3,7 @@ import * as http from 'node:http'
 import * as http2 from 'node:http2'
 import * as https from 'node:https'
 import { Socket } from 'node:net'
+import pino from 'pino'
 import { expect } from 'tstyche'
 import fastify, {
   ConnectionError,
@@ -180,6 +181,10 @@ const customLogger = {
   debug: () => { },
   child: () => customLogger
 }
+const pinoLogger = pino()
+const pinoLoggerServer: FastifyInstance = fastify({ loggerInstance: pinoLogger })
+
+expect(pinoLoggerServer).type.toBeAssignableTo<FastifyInstance>()
 expect(fastify({ logger: customLogger })).type.toBeAssignableTo<
   FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
 >()

package/test/types/route.tst.ts

@@ -58,6 +58,15 @@ const asyncPreHandler = async (request: FastifyRequest) => {
 
 fastify().get('/', { preHandler: asyncPreHandler }, async () => 'this is an example')
 
+fastify().route({
+  method: 'GET',
+  url: '/',
+  onRequest: async function () {
+    expect(this).type.toBe<FastifyInstance>()
+  },
+  handler: async () => 'ok'
+})
+
 fastify().get(
   '/',
   { config: { foo: 'bar', bar: 100, includeMessage: true } },
@@ -495,6 +504,12 @@ expect(fastify().hasRoute({
   method: 'GET'
 })).type.toBe<boolean>()
 
+fastify().hasRoute({
+  url: '/',
+  // @ts-expect-error  Type 'string[]' is not assignable to type 'HTTPMethods'.
+  method: ['GET', 'POST']
+})
+
 expect(fastify().hasRoute({
   url: '/',
   method: 'GET',
@@ -539,6 +554,12 @@ expect(
   })
 ).type.toBe<Omit<FindMyWayFindResult<RawServerDefault>, 'store'>>()
 
+fastify().findRoute({
+  url: '/',
+  // @ts-expect-error  Type 'string[]' is not assignable to type 'HTTPMethods'.
+  method: ['GET', 'POST']
+})
+
 // we should not expose store
 expect(fastify().findRoute({
   url: '/',

package/types/errors.d.ts

@@ -83,7 +83,6 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_ROUTE_HANDLER_TIMEOUT_OPTION_NOT_INT' |
   'FST_ERR_ROUTE_REWRITE_NOT_STR' |
   'FST_ERR_ROUTE_MISSING_CONTENT_TYPE' |
-  'FST_ERR_ROUTE_MISSING_CONTENT' |
   'FST_ERR_REOPENED_CLOSE_SERVER' |
   'FST_ERR_REOPENED_SERVER' |
   'FST_ERR_INSTANCE_ALREADY_STARTED' |

package/types/instance.d.ts

@@ -215,13 +215,13 @@ export interface FastifyInstance<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault,
     SchemaCompiler extends FastifySchema = FastifySchema
-  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): boolean;
+  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'url' | 'constraints'> & { method: HTTPMethods }): boolean;
 
   findRoute<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault,
     SchemaCompiler extends FastifySchema = FastifySchema
-  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): Omit<FindMyWayFindResult<RawServer>, 'store'>;
+  >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'url' | 'constraints'> & { method: HTTPMethods }): Omit<FindMyWayFindResult<RawServer>, 'store'>;
 
   // addHook: overloads
 
@@ -579,7 +579,7 @@ export interface FastifyInstance<
    * which allows for modifying or adding child logger bindings and logger options, or
    * returning a completely custom child logger implementation.
    */
-  childLoggerFactory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  childLoggerFactory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, FastifyBaseLogger, TypeProvider>;
 
   /**
    * Hook function that is called when creating a child logger instance for each request
@@ -598,7 +598,7 @@ export interface FastifyInstance<
    * }
    * ```
    */
-  setChildLoggerFactory(factory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger,
+  setChildLoggerFactory(factory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, FastifyBaseLogger,
     TypeProvider>): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
   /**

package/types/route.d.ts

@@ -46,7 +46,8 @@ export interface RouteConstraint {
 /**
  * Route shorthand options for the various shorthand methods
  */
-type RouteShorthandHook<T extends (...args: any) => any> = (...args: Parameters<T>) => void | Promise<unknown>
+type RouteShorthandHook<T extends (this: any, ...args: any) => any> =
+  (this: ThisParameterType<T>, ...args: Parameters<T>) => void | Promise<unknown>
 
 export interface RouteShorthandOptions<
   RawServer extends RawServerBase = RawServerDefault,
@@ -78,7 +79,7 @@ export interface RouteShorthandOptions<
     reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, NoInfer<SchemaCompiler>,
       TypeProvider>
   ) => void;
-  childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, FastifyBaseLogger, TypeProvider>;
   schemaErrorFormatter?: SchemaErrorFormatter;
 
   // hooks