fastify 5.9.0 → 5.11.0

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/stream.4.test.js

@@ -6,7 +6,7 @@ const JSONStream = require('JSONStream')
 const Readable = require('node:stream').Readable
 const split = require('split2')
 const Fastify = require('..')
-const { kDisableRequestLogging } = require('../lib/symbols.js')
+const { kLogController } = require('../lib/symbols.js')
 
 test('Destroying streams prematurely should call abort method', (t, testDone) => {
   t.plan(7)
@@ -87,7 +87,7 @@ test('Destroying streams prematurely, log is disabled', (t, testDone) => {
   const http = require('node:http')
 
   fastify.get('/', function (request, reply) {
-    reply.log[kDisableRequestLogging] = true
+    reply.server[kLogController].disableRequestLogging = true
 
     let sent = false
     const reallyLongStream = new stream.Readable({

package/test/trust-proxy.test.js

@@ -6,10 +6,10 @@ const helper = require('./helper')
 const Request = require('../lib/request')
 const buildRequest = Request.buildRequest
 
-const fetchForwardedRequest = async (fastifyServer, forHeader, path, protoHeader) => {
+const fetchForwardedRequest = async (fastifyServer, forHeader, path, protoHeader, hostHeader = 'fastify.test') => {
   const headers = {
     'X-Forwarded-For': forHeader,
-    'X-Forwarded-Host': 'fastify.test'
+    'X-Forwarded-Host': hostHeader
   }
   if (protoHeader) {
     headers['X-Forwarded-Proto'] = protoHeader
@@ -28,8 +28,10 @@ const testRequestValues = (t, req, options) => {
   if (options.host) {
     t.assert.ok(req.host, 'host is defined')
     t.assert.strictEqual(req.host, options.host, 'gets host from x-forwarded-host')
-    t.assert.ok(req.hostname)
-    t.assert.strictEqual(req.hostname, options.host, 'gets hostname from x-forwarded-host')
+  }
+  if (options.hostname) {
+    t.assert.ok(req.hostname, 'hostname is defined')
+    t.assert.strictEqual(req.hostname, options.hostname, 'gets hostname from x-forwarded-host')
   }
   if (options.ips) {
     t.assert.deepStrictEqual(req.ips, options.ips, 'gets ips from x-forwarded-for')
@@ -38,9 +40,8 @@ const testRequestValues = (t, req, options) => {
     t.assert.ok(req.protocol, 'protocol is defined')
     t.assert.strictEqual(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
   }
-  if (options.port) {
-    t.assert.ok(req.port, 'port is defined')
-    t.assert.strictEqual(req.port, options.port, 'port is taken from x-forwarded-for or host')
+  if ('port' in options) {
+    t.assert.strictEqual(req.port, options.port, 'port is parsed from x-forwarded-host')
   }
 }
 
@@ -50,117 +51,135 @@ before(async function () {
 })
 
 test('trust proxy, not add properties to node req', async t => {
-  t.plan(13)
+  t.plan(11)
   const app = fastify({
     trustProxy: true
   })
   t.after(() => app.close())
 
   app.get('/trustproxy', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'], port: app.server.address().port })
+    // x-forwarded-host carries no port, so req.port is null
+    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'], port: null })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   const fastifyServer = await app.listen({ port: 0 })
 
-  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxy', undefined)
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxy', undefined, 'fastify.test:1234')
   await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined)
 })
 
 test('trust proxy chain', async t => {
-  t.plan(8)
+  t.plan(7)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
   })
   t.after(() => app.close())
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   const fastifyServer = await app.listen({ port: 0 })
-  await fetchForwardedRequest(fastifyServer, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined)
+  await fetchForwardedRequest(fastifyServer, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined, 'fastify.test:1234')
 })
 
 test('trust proxy function', async t => {
-  t.plan(8)
+  t.plan(7)
   const app = fastify({
     trustProxy: (address) => address === localhost
   })
   t.after(() => app.close())
 
   app.get('/trustproxyfunc', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   const fastifyServer = await app.listen({ port: 0 })
-  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined)
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined, 'fastify.test:1234')
 })
 
 test('trust proxy number', async t => {
-  t.plan(9)
+  t.plan(8)
   const app = fastify({
     trustProxy: 1
   })
   t.after(() => app.close())
 
   app.get('/trustproxynumber', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   const fastifyServer = await app.listen({ port: 0 })
-  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined)
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, 'fastify.test:1234')
 })
 
 test('trust proxy IP addresses', async t => {
-  t.plan(9)
+  t.plan(8)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
   })
   t.after(() => app.close())
 
   app.get('/trustproxyipaddrs', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   const fastifyServer = await app.listen({ port: 0 })
-  await fetchForwardedRequest(fastifyServer, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined)
+  await fetchForwardedRequest(fastifyServer, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined, 'fastify.test:1234')
 })
 
 test('trust proxy protocol', async t => {
-  t.plan(30)
+  t.plan(27)
   const app = fastify({
     trustProxy: true
   })
   t.after(() => app.close())
 
   app.get('/trustproxyprotocol', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem', host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem', host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
   app.get('/trustproxynoprotocol', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http', host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http', host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
   app.get('/trustproxyprotocols', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor', host: 'fastify.test', port: app.server.address().port })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor', host: 'fastify.test:1234', hostname: 'fastify.test', port: 1234 })
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   const fastifyServer = await app.listen({ port: 0 })
 
-  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocol', 'lorem')
-  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxynoprotocol', undefined)
-  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor')
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocol', 'lorem', 'fastify.test:1234')
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxynoprotocol', undefined, 'fastify.test:1234')
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', 'fastify.test:1234')
+})
+
+test('trust proxy port is null when x-forwarded-host has no port', async t => {
+  t.plan(5)
+  const app = fastify({
+    trustProxy: true
+  })
+  t.after(() => app.close())
+
+  app.get('/trustproxynoport', function (req, reply) {
+    // req.port is derived from req.host; a forwarded host without a port yields null
+    testRequestValues(t, req, { host: 'fastify.test', hostname: 'fastify.test', port: null })
+    reply.code(200).send({ host: req.host, port: req.port })
+  })
+
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxynoport', undefined)
 })
 
 test('trust proxy ignores forwarded headers from untrusted connections', async t => {

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
 

package/types/errors.d.ts

@@ -40,6 +40,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_LOG_INVALID_LOGGER_INSTANCE' |
   'FST_ERR_LOG_INVALID_LOGGER_CONFIG' |
   'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED' |
+  'FST_ERR_LOG_INVALID_LOG_CONTROLLER' |
   'FST_ERR_REP_INVALID_PAYLOAD_TYPE' |
   'FST_ERR_REP_RESPONSE_BODY_CONSUMED' |
   'FST_ERR_REP_READABLE_STREAM_LOCKED' |
@@ -80,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' |