fastify 5.10.0 → 5.11.0

package/lib/route.js

@@ -179,7 +179,7 @@ function buildRouting (options) {
 
   function findRoute (options) {
     const route = router.find(
-      options.method,
+      options.method?.toUpperCase() ?? '',
       options.url || '',
       options.constraints
     )

package/lib/schemas.js

@@ -149,7 +149,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   }
   if (responseSchemaDef[statusCode]) {
     if (responseSchemaDef[statusCode].constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef[statusCode][ct.mediaType]) {
           return responseSchemaDef[statusCode][ct.mediaType]
@@ -168,7 +168,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   const fallbackStatusCode = (statusCode + '')[0] + 'xx'
   if (responseSchemaDef[fallbackStatusCode]) {
     if (responseSchemaDef[fallbackStatusCode].constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef[fallbackStatusCode][ct.mediaType]) {
           return responseSchemaDef[fallbackStatusCode][ct.mediaType]
@@ -187,7 +187,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   }
   if (responseSchemaDef.default) {
     if (responseSchemaDef.default.constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef.default[ct.mediaType]) {
           return responseSchemaDef.default[ct.mediaType]

package/lib/validation.js

@@ -138,7 +138,7 @@ function validateParam (validatorFunction, request, paramName) {
   function answer (ret) {
     if (ret === false) return validatorFunction.errors
     if (ret && ret.error) return ret.error
-    if (ret && ret.value) request[paramName] = ret.value
+    if (ret && typeof ret === 'object' && 'value' in ret) request[paramName] = ret.value
     return false
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "5.10.0",
+  "version": "5.11.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -191,7 +191,7 @@
     "joi": "^18.0.1",
     "json-schema-to-ts": "^3.0.1",
     "JSONStream": "^1.3.5",
-    "markdownlint-cli2": "^0.22.0",
+    "markdownlint-cli2": "^0.23.0",
     "neostandard": "^0.12.0",
     "node-forge": "^1.3.1",
     "proxyquire": "^2.1.3",

package/test/content-type.test.js

@@ -161,12 +161,11 @@ describe('ContentType class', () => {
     t.assert.equal(found.mediaType, 'application/json')
     t.assert.equal(found.type, 'application')
     t.assert.equal(found.subtype, 'json')
-    t.assert.equal(found.parameters.size, 3)
+    t.assert.equal(found.parameters.size, 2)
 
     const expected = [
       ['charset', 'utf-8'],
-      ['foo', 'BaR'],
-      ['baz', 'invalid quoted string']
+      ['foo', 'BaR']
     ]
     t.assert.deepStrictEqual(
       Array.from(found.parameters.entries()),
@@ -175,9 +174,37 @@ describe('ContentType class', () => {
 
     t.assert.equal(
       found.toString(),
-      'application/json; charset="utf-8"; foo="BaR"; baz="invalid quoted string"'
+      'application/json; charset="utf-8"; foo="BaR"'
     )
   })
+
+  test('preserves a semicolon inside a quoted parameter value', (t) => {
+    // RFC 9110 §5.6.6: ';' is a literal qdtext octet inside a quoted-string
+    // and does not terminate the parameter value.
+    const found = new ContentType('application/json; name="foo;bar"; charset=utf-8')
+    t.assert.equal(found.isValid, true)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.parameters.get('name'), 'foo;bar')
+    t.assert.equal(found.parameters.get('charset'), 'utf-8')
+  })
+
+  test('does not leak a fake parameter out of a quoted value', (t) => {
+    // A `key=value;` sequence inside a quoted-string is opaque content of the
+    // enclosing value, not a subsequent parameter.
+    const found = new ContentType('application/json; name="a=b;charset=fake"; boundary=xyz')
+    t.assert.equal(found.isValid, true)
+    t.assert.equal(found.parameters.get('name'), 'a=b;charset=fake')
+    t.assert.equal(found.parameters.get('boundary'), 'xyz')
+    t.assert.equal(found.parameters.has('charset'), false)
+  })
+
+  test('unescapes a quoted-pair inside a quoted-string', (t) => {
+    // RFC 9110 §5.6.4: a quoted-pair MUST be handled as if replaced by
+    // the octet following the backslash.
+    const found = new ContentType('application/json; name="he said \\"hi\\""')
+    t.assert.equal(found.isValid, true)
+    t.assert.equal(found.parameters.get('name'), 'he said "hi"')
+  })
 })
 
 describe('ContentType class cache', () => {

package/test/find-route.test.js

@@ -66,6 +66,22 @@ test('findRoute should return null when when url is not passed', t => {
   }), null)
 })
 
+test('findRoute should return null when method is not passed', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  t.assert.strictEqual(fastify.findRoute({
+    url: '/artists/:artistId'
+  }), null)
+})
+
 test('findRoute should return null when route cannot be found due to a different path', t => {
   t.plan(1)
   const fastify = Fastify()
@@ -103,6 +119,25 @@ test('findRoute should return the route when found', t => {
   t.assert.strictEqual(route.params.artistId, ':artistId')
 })
 
+test('findRoute should find a route even if method is not uppercased', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/artists/:artistId', {
+    schema: {
+      params: { artistId: { type: 'integer' } }
+    },
+    handler: (req, reply) => reply.send(typeof req.params.artistId)
+  })
+
+  const route = fastify.findRoute({
+    method: 'get',
+    url: '/artists/:artistId'
+  })
+  t.assert.notStrictEqual(route, null)
+  t.assert.strictEqual(route.params.artistId, ':artistId')
+})
+
 test('findRoute should work correctly when used within plugins', (t, done) => {
   t.plan(1)
   const fastify = Fastify()

package/test/fix-6411.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('custom validatorCompiler returning falsy values should update request param', async (t) => {
+  const fastify = Fastify()
+
+  fastify.setValidatorCompiler(() => {
+    return (data) => {
+      if (typeof data === 'object' && data !== null && 'coerceTo' in data) {
+        return { value: data.coerceTo }
+      }
+      return true
+    }
+  })
+
+  fastify.post('/test', { schema: { body: { type: 'object' } } }, (request, reply) => {
+    reply.send({ body: request.body })
+  })
+
+  // value: 0 (falsy)
+  {
+    const res = await fastify.inject({
+      method: 'POST',
+      url: '/test',
+      payload: { coerceTo: 0 }
+    })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(JSON.parse(res.payload).body, 0, 'should update body to 0')
+  }
+
+  // value: "" (falsy)
+  {
+    const res = await fastify.inject({
+      method: 'POST',
+      url: '/test',
+      payload: { coerceTo: '' }
+    })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(JSON.parse(res.payload).body, '', 'should update body to empty string')
+  }
+
+  // value: false (falsy)
+  {
+    const res = await fastify.inject({
+      method: 'POST',
+      url: '/test',
+      payload: { coerceTo: false }
+    })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(JSON.parse(res.payload).body, false, 'should update body to false')
+  }
+
+  // value: null (falsy)
+  {
+    const res = await fastify.inject({
+      method: 'POST',
+      url: '/test',
+      payload: { coerceTo: null }
+    })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(JSON.parse(res.payload).body, null, 'should update body to null')
+  }
+})

package/test/internals/all.test.js

@@ -9,7 +9,8 @@ test('fastify.all should add all the methods to the same url', async t => {
   const requirePayload = [
     'POST',
     'PUT',
-    'PATCH'
+    'PATCH',
+    'QUERY'
   ]
 
   const supportedMethods = fastify.supportedMethods

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 92
+const expectedErrors = 94
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
@@ -770,6 +770,26 @@ test('FST_ERR_ROUTE_REWRITE_NOT_STR', t => {
   t.assert.ok(error instanceof TypeError)
 })
 
+test('FST_ERR_ROUTE_MISSING_CONTENT_TYPE', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_ROUTE_MISSING_CONTENT_TYPE()
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_ROUTE_MISSING_CONTENT_TYPE')
+  t.assert.strictEqual(error.message, "Method '%s' must provide a 'Content-Type' header.")
+  t.assert.strictEqual(error.statusCode, 400)
+  t.assert.ok(error instanceof Error)
+})
+
+test('FST_ERR_ROUTE_MISSING_CONTENT', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_ROUTE_MISSING_CONTENT()
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_ROUTE_MISSING_CONTENT')
+  t.assert.strictEqual(error.message, "Method '%s' must provide a request body.")
+  t.assert.strictEqual(error.statusCode, 400)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_REOPENED_CLOSE_SERVER', t => {
   t.plan(5)
   const error = new errors.FST_ERR_REOPENED_CLOSE_SERVER()

package/test/internals/reply.test.js

@@ -1949,3 +1949,25 @@ test('Uint8Array view of ArrayBuffer returns correct byteLength', (t, done) => {
     })
   })
 })
+
+test('reply.send should not treat charset= inside a quoted parameter value as an already-declared charset', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.get('/', function (req, reply) {
+    // A quoted parameter value that happens to contain the substring
+    // `charset=` is opaque content of that value, not a real charset
+    // parameter, so reply.send must still append `; charset=utf-8`.
+    reply.header('content-type', 'application/json; name="a=b;charset=fake"')
+    reply.send({ hello: 'world' })
+  })
+
+  const res = await fastify.inject({ method: 'GET', url: '/' })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(
+    res.headers['content-type'],
+    'application/json; name="a=b;charset=fake"; charset=utf-8'
+  )
+})

package/test/reply-error.test.js

@@ -813,3 +813,38 @@ test('pipe stream inside error handler should not cause error', (t, testDone) =>
     testDone()
   })
 })
+
+test('should catch error when setting invalid header on async preSerializeation hook', async (t) => {
+  t.plan(2)
+
+  const app = Fastify()
+  app.addHook('preSerialization', async (_, reply) => {
+    reply.header('X-Invalid', '\n')
+  })
+  app.addHook('onError', function (request, reply, err, done) {
+    // onError will run twice, since it execute preSerialization hook twice
+    // requires to fallback to root error handler
+    t.assert.ok(err)
+    done()
+  })
+  app.get('/', async () => ({ ok: true }))
+  await app.inject({ method: 'GET', path: '/' })
+})
+
+test('should catch error when setting invalid header on async onSend hook', async (t) => {
+  t.plan(2)
+
+  const app = Fastify()
+  app.addHook('onSend', async (_, reply, payload) => {
+    reply.header('X-Invalid', '\n')
+    return payload
+  })
+  app.addHook('onError', function (request, reply, err, done) {
+    // onError will run twice, since it execute onSend hook twice
+    // requires to fallback to root error handler
+    t.assert.ok(err)
+    done()
+  })
+  app.get('/', async () => ({ ok: true }))
+  await app.inject({ method: 'GET', path: '/' })
+})

package/test/rfc-10008.test.js

@@ -0,0 +1,147 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const Fastify = require('..')
+
+describe('RFC 10008', () => {
+  test('support adding QUERY method though fastify.route', async (t) => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.route({
+      method: 'QUERY',
+      url: '/query',
+      handler: function (request, reply) {
+        reply.send(request.body)
+      }
+    })
+    await fastify.ready()
+
+    const res = await fastify.inject({
+      method: 'QUERY',
+      url: '/query',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ hello: 'world' })
+    })
+
+    t.assert.equal(res.statusCode, 200)
+    t.assert.equal(res.json().hello, 'world')
+  })
+
+  test('support adding QUERY method though fastify.query', async (t) => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.query('/query', function (request, reply) {
+      reply.send(request.body)
+    })
+    await fastify.ready()
+
+    const res = await fastify.inject({
+      method: 'QUERY',
+      url: '/query',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ hello: 'world' })
+    })
+
+    t.assert.equal(res.statusCode, 200)
+    t.assert.equal(res.json().hello, 'world')
+  })
+
+  /**
+   * https://datatracker.ietf.org/doc/html/rfc10008#section-2.1
+   */
+
+  test('should return 400 if Content-Type header is missing for QUERY method', async (t) => {
+    // If a request lacks media type information, it is
+    // incorrect by definition and needs to fail with a
+    // 4xx status code such as 400 (Client Error).
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.query('/query', function (request, reply) {
+      reply.send(request.body)
+    })
+    await fastify.ready()
+
+    const res = await fastify.inject({
+      method: 'QUERY',
+      url: '/query',
+      body: JSON.stringify({ hello: 'world' })
+    })
+
+    t.assert.equal(res.statusCode, 400)
+    t.assert.equal(res.json().code, 'FST_ERR_ROUTE_MISSING_CONTENT_TYPE')
+  })
+
+  test('should return 400 if invalid 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").
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.query('/query', function (request, reply) {
+      reply.send(request.body)
+    })
+    await fastify.ready()
+
+    const res = await fastify.inject({
+      method: 'QUERY',
+      url: '/query',
+      headers: { 'Content-Type': 'application/json' },
+      body: 'it is not a valid json'
+    })
+
+    t.assert.equal(res.statusCode, 400)
+    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").
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.query('/query', function (request, reply) {
+      reply.send(request.body)
+    })
+    await fastify.ready()
+
+    const res = await fastify.inject({
+      method: 'QUERY',
+      url: '/query',
+      headers: { 'Content-Type': 'application/json' }
+    })
+
+    t.assert.equal(res.statusCode, 400)
+    t.assert.equal(res.json().code, 'FST_ERR_ROUTE_MISSING_CONTENT')
+  })
+
+  test('should return 415 if unsupported media type is provided for QUERY method', async (t) => {
+    // If a media type is specified but is not supported by the
+    // resource, a 415 (Unsupported Media Type) is appropriate.
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.query('/query', function (request, reply) {
+      reply.send(request.body)
+    })
+    await fastify.ready()
+
+    const res = await fastify.inject({
+      method: 'QUERY',
+      url: '/query',
+      headers: { 'Content-Type': 'application/ld+json' },
+      body: JSON.stringify({ hello: 'world' })
+    })
+
+    t.assert.equal(res.statusCode, 415)
+    t.assert.equal(res.json().code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
+  })
+})

package/test/route-shorthand.test.js

@@ -21,8 +21,13 @@ describe('route-shorthand', () => {
 
       const instance = new Client(`http://localhost:${fastify.server.address().port}`)
 
-      const response = await instance.request({ path: '/', method })
-      t.assert.strictEqual(response.statusCode, 200)
+      if (method === 'QUERY') {
+        const response = await instance.request({ path: '/', method, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ hello: 'world' }) })
+        t.assert.strictEqual(response.statusCode, 200)
+      } else {
+        const response = await instance.request({ path: '/', method })
+        t.assert.strictEqual(response.statusCode, 200)
+      }
     })
   }
 
@@ -41,8 +46,13 @@ describe('route-shorthand', () => {
       currentMethod = method
       const instance = new Client(`http://localhost:${fastify.server.address().port}`)
 
-      const response = await instance.request({ path: '/', method })
-      t.assert.strictEqual(response.statusCode, 200)
+      if (method === 'QUERY') {
+        const response = await instance.request({ path: '/', method, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ hello: 'world' }) })
+        t.assert.strictEqual(response.statusCode, 200)
+      } else {
+        const response = await instance.request({ path: '/', method })
+        t.assert.strictEqual(response.statusCode, 200)
+      }
     }
   })
 })

package/test/schema-serialization.test.js

@@ -2,6 +2,7 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
+const ContentType = require('../lib/content-type')
 const { waitForCb } = require('./toolkit')
 
 const echoBody = (req, reply) => { reply.send(req.body) }
@@ -62,6 +63,38 @@ test('custom serializer options', (t, testDone) => {
   })
 })
 
+test('reuse parsed content type when selecting response serializer', async t => {
+  const fastify = Fastify()
+  const contentType = 'application/x-fastify-cache-test+json; version=1'
+
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/x-fastify-cache-test+json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  hello: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (request, reply) {
+    reply.type(contentType).send({ hello: 'world', ignored: true })
+  })
+
+  const response = await fastify.inject('/')
+  const normalizedContentType = response.headers['content-type']
+
+  t.assert.deepStrictEqual(response.json(), { hello: 'world' })
+  t.assert.ok(ContentType.cache.get(normalizedContentType))
+})
+
 test('Different content types', (t, testDone) => {
   t.plan(46)
 

package/test/types/errors.tst.ts

@@ -77,6 +77,8 @@ expect(errorCodes.FST_ERR_ROUTE_METHOD_NOT_SUPPORTED).type.toBeAssignableTo<Fast
 expect(errorCodes.FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED).type.toBeAssignableTo<FastifyErrorConstructor>()
 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_LISTENING).type.toBeAssignableTo<FastifyErrorConstructor>()

package/test/types/route.tst.ts

@@ -1,5 +1,5 @@
-import * as http from 'node:http'
 import { FastifyError } from '@fastify/error'
+import * as http from 'node:http'
 import { expect } from 'tstyche'
 import fastify, { FastifyInstance, FastifyReply, FastifyRequest, RouteHandlerMethod } from '../../fastify.js'
 import { RequestPayload } from '../../types/hooks.js'
@@ -75,10 +75,10 @@ fastify().get(
 )
 
 type LowerCaseHTTPMethods = 'delete' | 'get' | 'head' | 'patch' | 'post' | 'put' |
-  'options' | 'propfind' | 'proppatch' | 'mkcol' | 'copy' | 'move' | 'lock' |
+  'options' | 'query' | 'propfind' | 'proppatch' | 'mkcol' | 'copy' | 'move' | 'lock' |
   'unlock' | 'trace' | 'search' | 'mkcalendar' | 'report'
 
-  ;['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS', 'PROPFIND',
+  ;['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS', 'QUERY', 'PROPFIND',
   'PROPPATCH', 'MKCOL', 'COPY', 'MOVE', 'LOCK', 'UNLOCK', 'TRACE', 'SEARCH', 'MKCALENDAR', 'REPORT'
 ].forEach(method => {
   // route method

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

@@ -16,8 +16,15 @@ export type FastifyBodyParser<
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
   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>)
+> = ((
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>,
+  rawBody: RawBody,
+  done: ContentTypeParserDoneFunction
+) => void)
+| ((
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>,
+  rawBody: RawBody
+) => Promise<any>)
 
 /**
  * Content Type Parser method that operates on request content
@@ -28,8 +35,15 @@ export type FastifyContentTypeParser<
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
   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)
+> = ((
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>,
+  payload: RawRequest
+) => Promise<any>)
+| ((
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>,
+  payload: RawRequest,
+  done: ContentTypeParserDoneFunction
+) => void)
 
 /**
  * Natively, Fastify only supports 'application/json' and 'text/plain' content types. The default charset is utf-8. If you need to support different content types, you can use the addContentTypeParser API. The default JSON and/or plain text parser can be changed.
@@ -48,7 +62,10 @@ export interface AddContentTypeParser<
     },
     parser: FastifyContentTypeParser<RawServer, RawRequest, RouteGeneric, SchemaCompiler, TypeProvider>
   ): void;
-  (contentType: string | string[] | RegExp, parser: FastifyContentTypeParser<RawServer, RawRequest, RouteGeneric, SchemaCompiler, TypeProvider>): void;
+  (
+    contentType: string | string[] | RegExp,
+    parser: FastifyContentTypeParser<RawServer, RawRequest, RouteGeneric, SchemaCompiler, TypeProvider>
+  ): void;
   <parseAs extends string | Buffer>(
     contentType: string | string[] | RegExp,
     opts: {
@@ -68,7 +85,10 @@ export type ProtoAction = 'error' | 'remove' | 'ignore'
 
 export type ConstructorAction = 'error' | 'remove' | 'ignore'
 
-export type getDefaultJsonParser = (onProtoPoisoning: ProtoAction, onConstructorPoisoning: ConstructorAction) => FastifyBodyParser<string>
+export type getDefaultJsonParser = (
+  onProtoPoisoning: ProtoAction,
+  onConstructorPoisoning: ConstructorAction
+) => FastifyBodyParser<string>
 
 export type removeContentTypeParser = (contentType: string | RegExp | (string | RegExp)[]) => void