fastify 5.10.0 → 5.11.1

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/http-methods/custom-http-methods.test.js

@@ -112,3 +112,64 @@ test('addHttpMethod rejects fake http method', t => {
   const fastify = Fastify()
   t.assert.throws(() => { fastify.addHttpMethod('FOOO') }, /Provided method is invalid!/)
 })
+
+test('addHttpMethod warns when overriding an existing method', (t, done) => {
+  const fastify = Fastify()
+  const onWarning = warning => {
+    t.assert.strictEqual(warning.name, 'FastifyDeprecation')
+    t.assert.strictEqual(warning.code, 'FSTDEP025')
+    done()
+  }
+  process.once('warning', onWarning)
+
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', onWarning)
+  })
+
+  fastify.addHttpMethod('GET', { hasBody: true })
+})
+
+test('addHttpMethod does not warn when overriding an existing method explicitly', t => {
+  const doNotWarn = () => {
+    t.assert.fail('should not warn')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.after(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+
+  fastify.addHttpMethod('POST', { overrideExisting: true })
+})
+
+test('addHttpMethod can change an existing method body behavior', async t => {
+  const fastify = Fastify()
+
+  fastify.addHttpMethod('GET', {
+    hasBody: true,
+    overrideExisting: true
+  })
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    exposeHeadRoute: false,
+    schema: {
+      body: {
+        type: 'object'
+      }
+    },
+    handler: async request => request.body
+  })
+
+  const response = await fastify.inject({
+    method: 'GET',
+    url: '/',
+    payload: { hello: 'world' }
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), { hello: 'world' })
+})

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/fastify.tst.ts

@@ -68,6 +68,17 @@ expect(fastify({ schemaController: {} })).type.toBe<
   FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
   SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
 >()
+
+expect(fastify({ http2: false })).type.toBe<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+
+expect(fastify({ https: {}, http2: false })).type.toBe<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+
 expect(
   fastify({
     schemaController: {

package/test/types/instance.tst.ts

@@ -215,6 +215,8 @@ function invalidSchemaErrorFormatter (err: Error) {
 server.setSchemaErrorFormatter(invalidSchemaErrorFormatter)
 
 expect(server.addHttpMethod('SEARCH', { hasBody: true })).type.toBe<FastifyInstance>()
+expect(server.addHttpMethod('GET', { overrideExisting: true })).type.toBe<FastifyInstance>()
+expect(server.addHttpMethod('POST', { hasBody: true, overrideExisting: true })).type.toBe<FastifyInstance>()
 
 // test listen opts objects
 const options: FastifyListenOptions = {}

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/test/validation-error-handling.test.js

@@ -218,6 +218,40 @@ test('should be able to attach validation to request', async (t) => {
   t.assert.strictEqual(response.statusCode, 400)
 })
 
+test('attached validationError exposes the same message sent by the default handler', async (t) => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.post('/attached', { schema, attachValidation: true }, function (req, reply) {
+    reply.code(400).send({
+      message: req.validationError.message,
+      code: req.validationError.code,
+      statusCode: req.validationError.statusCode,
+      validationContext: req.validationError.validationContext
+    })
+  })
+
+  fastify.post('/default', { schema }, echoBody)
+
+  const payload = { hello: 'michelangelo' }
+  const attached = await fastify.inject({ method: 'POST', payload, url: '/attached' })
+  const notAttached = await fastify.inject({ method: 'POST', payload, url: '/default' })
+
+  const attachedBody = attached.json()
+
+  t.assert.deepStrictEqual(attachedBody, {
+    message: "body must have required property 'name'",
+    code: 'FST_ERR_VALIDATION',
+    statusCode: 400,
+    validationContext: 'body'
+  })
+
+  t.assert.strictEqual(attachedBody.message, notAttached.json().message)
+  t.assert.strictEqual(attached.statusCode, 400)
+  t.assert.strictEqual(notAttached.statusCode, 400)
+})
+
 test('should respect when attachValidation is explicitly set to false', async (t) => {
   t.plan(2)
 

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
 

package/types/errors.d.ts

@@ -81,6 +81,8 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_HANDLER_TIMEOUT' |
   '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_LISTENING' |