fastify 6.0.0-alpha.4 → 6.0.0-alpha.6

package/test/router-compile.test.js

@@ -0,0 +1,241 @@
+'use strict'
+
+const { test } = require('node:test')
+const FindMyWay = require('find-my-way')
+const Fastify = require('..')
+const { FST_ERR_INIT_OPTS_INVALID } = require('../lib/errors')
+
+const RouterPrototype = Object.getPrototypeOf(FindMyWay())
+
+function buildApp (opts) {
+  const fastify = Fastify(opts)
+
+  fastify.get('/', () => ({ route: 'root' }))
+  fastify.get('/users/:id', (req) => ({ route: 'user', id: req.params.id }))
+  fastify.post('/users', (req) => ({ route: 'create', body: req.body }))
+  fastify.get('/files/*', (req) => ({ route: 'files', path: req.params['*'] }))
+  fastify.get('/search', (req) => ({ route: 'search', query: req.query }))
+  fastify.get('/versioned', { constraints: { version: '1.2.0' } }, () => ({ route: 'v1' }))
+  fastify.get('/versioned', { constraints: { version: '2.0.0' } }, () => ({ route: 'v2' }))
+
+  return fastify
+}
+
+async function assertRoutes (t, fastify) {
+  let res = await fastify.inject('/')
+  t.assert.deepStrictEqual(res.json(), { route: 'root' })
+
+  res = await fastify.inject('/users/42')
+  t.assert.deepStrictEqual(res.json(), { route: 'user', id: '42' })
+
+  res = await fastify.inject('/users/caf%C3%A9')
+  t.assert.deepStrictEqual(res.json(), { route: 'user', id: 'café' })
+
+  res = await fastify.inject({ method: 'POST', url: '/users', payload: { name: 'foo' } })
+  t.assert.deepStrictEqual(res.json(), { route: 'create', body: { name: 'foo' } })
+
+  res = await fastify.inject('/files/a/b/c.txt')
+  t.assert.deepStrictEqual(res.json(), { route: 'files', path: 'a/b/c.txt' })
+
+  res = await fastify.inject('/search?q=fastify')
+  t.assert.deepStrictEqual(res.json(), { route: 'search', query: { q: 'fastify' } })
+
+  res = await fastify.inject({ url: '/versioned', headers: { 'accept-version': '2.x' } })
+  t.assert.deepStrictEqual(res.json(), { route: 'v2' })
+
+  res = await fastify.inject({ method: 'HEAD', url: '/users/42' })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.body, '')
+
+  res = await fastify.inject('/not-found')
+  t.assert.strictEqual(res.statusCode, 404)
+
+  res = await fastify.inject({ method: 'DELETE', url: '/users/42' })
+  t.assert.strictEqual(res.statusCode, 404)
+}
+
+test('routerOptions.compile defaults to false', async t => {
+  const compile = t.mock.method(RouterPrototype, 'compile')
+  const fastify = buildApp()
+  t.after(() => fastify.close())
+
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.compile, false)
+  await assertRoutes(t, fastify)
+  t.assert.strictEqual(compile.mock.callCount(), 0)
+})
+
+test('routerOptions.compile: true compiles the routes on ready', async t => {
+  const compile = t.mock.method(RouterPrototype, 'compile')
+  const fastify = buildApp({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  t.assert.strictEqual(fastify.initialConfig.routerOptions.compile, true)
+  await fastify.ready()
+  // the main router and the 404 router
+  t.assert.strictEqual(compile.mock.callCount(), 2)
+  await assertRoutes(t, fastify)
+  t.assert.strictEqual(compile.mock.callCount(), 2)
+})
+
+test('routerOptions.compile: true works with real http requests', async t => {
+  const fastify = buildApp({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  const address = await fastify.listen({ port: 0 })
+
+  let res = await fetch(address + '/users/42')
+  t.assert.deepStrictEqual(await res.json(), { route: 'user', id: '42' })
+
+  res = await fetch(address + '/files/a/b')
+  t.assert.deepStrictEqual(await res.json(), { route: 'files', path: 'a/b' })
+
+  res = await fetch(address + '/nope')
+  t.assert.strictEqual(res.status, 404)
+})
+
+test('routerOptions.compile: true honors the other router options', async t => {
+  const fastify = Fastify({
+    routerOptions: {
+      compile: true,
+      ignoreTrailingSlash: true,
+      ignoreDuplicateSlashes: true,
+      caseSensitive: false,
+      maxParamLength: 5
+    }
+  })
+  t.after(() => fastify.close())
+
+  fastify.get('/foo/:id', (req) => ({ id: req.params.id }))
+
+  let res = await fastify.inject('/foo/abc/')
+  t.assert.deepStrictEqual(res.json(), { id: 'abc' })
+
+  res = await fastify.inject('//FOO//abc')
+  t.assert.deepStrictEqual(res.json(), { id: 'abc' })
+
+  res = await fastify.inject('/foo/toolongparam')
+  t.assert.strictEqual(res.statusCode, 414)
+})
+
+test('routerOptions.compile: true supports rewriteUrl', async t => {
+  const fastify = Fastify({
+    routerOptions: { compile: true },
+    rewriteUrl: (req) => req.url === '/old' ? '/new' : req.url
+  })
+  t.after(() => fastify.close())
+
+  fastify.get('/new', () => ({ route: 'new' }))
+
+  const res = await fastify.inject('/old')
+  t.assert.deepStrictEqual(res.json(), { route: 'new' })
+})
+
+test('routerOptions.compile: true supports asynchronous constraints', async t => {
+  const fastify = Fastify({
+    routerOptions: {
+      compile: true,
+      constraints: {
+        secret: {
+          name: 'secret',
+          storage () {
+            const secrets = {}
+            return {
+              get: (secret) => secrets[secret] ?? null,
+              set: (secret, store) => { secrets[secret] = store }
+            }
+          },
+          deriveConstraint (req, ctx, done) {
+            setImmediate(() => done(null, req.headers['x-secret']))
+          },
+          validate () { return true }
+        }
+      }
+    }
+  })
+  t.after(() => fastify.close())
+
+  fastify.get('/', { constraints: { secret: 'alpha' } }, () => ({ secret: 'alpha' }))
+  fastify.get('/', { constraints: { secret: 'beta' } }, () => ({ secret: 'beta' }))
+
+  let res = await fastify.inject({ url: '/', headers: { 'x-secret': 'beta' } })
+  t.assert.deepStrictEqual(res.json(), { secret: 'beta' })
+
+  res = await fastify.inject({ url: '/', headers: { 'x-secret': 'gamma' } })
+  t.assert.strictEqual(res.statusCode, 404)
+})
+
+test('routerOptions.compile: true supports encapsulated 404 handlers', async t => {
+  const fastify = Fastify({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  fastify.register(async (instance) => {
+    instance.setNotFoundHandler((req, reply) => {
+      reply.code(404).send({ notFound: 'api' })
+    })
+    instance.get('/ok', () => ({ ok: true }))
+  }, { prefix: '/api' })
+
+  let res = await fastify.inject('/api/ok')
+  t.assert.deepStrictEqual(res.json(), { ok: true })
+
+  res = await fastify.inject('/api/missing')
+  t.assert.deepStrictEqual(res.json(), { notFound: 'api' })
+})
+
+test('routerOptions.compile: true compiles the 404 router', async t => {
+  const fastify = Fastify({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  fastify.setNotFoundHandler((req, reply) => {
+    reply.code(404).send({ notFound: 'root', method: req.method })
+  })
+
+  fastify.register(async (instance) => {
+    instance.setNotFoundHandler((req, reply) => {
+      reply.code(404).send({ notFound: 'api', method: req.method })
+    })
+
+    instance.register(async (instance) => {
+      instance.setNotFoundHandler((req, reply) => {
+        reply.code(404).send({ notFound: 'v1', method: req.method })
+      })
+    }, { prefix: '/v1' })
+  }, { prefix: '/api' })
+
+  for (const method of ['GET', 'POST', 'PUT', 'DELETE', 'PATCH']) {
+    let res = await fastify.inject({ method, url: '/missing' })
+    t.assert.deepStrictEqual(res.json(), { notFound: 'root', method })
+
+    res = await fastify.inject({ method, url: '/api/missing?x=1' })
+    t.assert.deepStrictEqual(res.json(), { notFound: 'api', method })
+
+    res = await fastify.inject({ method, url: '/api/v1/a/b/c' })
+    t.assert.deepStrictEqual(res.json(), { notFound: 'v1', method })
+  }
+
+  let res = await fastify.inject('/api')
+  t.assert.deepStrictEqual(res.json(), { notFound: 'api', method: 'GET' })
+
+  res = await fastify.inject('/api/v1/caf%C3%A9')
+  t.assert.deepStrictEqual(res.json(), { notFound: 'v1', method: 'GET' })
+})
+
+test('routerOptions.compile: true keeps findRoute and hasRoute working', async t => {
+  const fastify = Fastify({ routerOptions: { compile: true } })
+  t.after(() => fastify.close())
+
+  fastify.get('/users/:id', () => ({}))
+  await fastify.ready()
+
+  t.assert.ok(fastify.hasRoute({ method: 'GET', url: '/users/:id' }))
+  const route = fastify.findRoute({ method: 'GET', url: '/users/42' })
+  t.assert.deepStrictEqual({ ...route.params }, { id: '42' })
+  t.assert.strictEqual(fastify.findRoute({ method: 'GET', url: '/nope' }), null)
+})
+
+test('routerOptions.compile must be a boolean', t => {
+  t.assert.throws(
+    () => Fastify({ routerOptions: { compile: 'yes' } }),
+    FST_ERR_INIT_OPTS_INVALID
+  )
+})

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-serialization.test.js

@@ -243,7 +243,7 @@ test('Different content types', (t, testDone) => {
         reply.send({ details: 'validation error' })
         break
       default:
-        // to test if schema not found
+        // to test failing closed on an undeclared content-type
         reply.header('Content-Type', 'application/vnd.v3+json')
         reply.code(200)
         reply.send([{ type: 'student', grade: 6 }, { type: 'student', grade: 9 }])
@@ -320,8 +320,8 @@ test('Different content types', (t, testDone) => {
   })
   fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
     t.assert.ifError(err)
-    t.assert.strictEqual(res.payload, JSON.stringify([{ type: 'student', grade: 6 }, { type: 'student', grade: 9 }]))
-    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.payload, '{}')
     completion.stepIn()
   })
   fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v2+json' } }, (err, res) => {
@@ -332,8 +332,8 @@ test('Different content types', (t, testDone) => {
   })
   fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v3+json' } }, (err, res) => {
     t.assert.ifError(err)
-    t.assert.strictEqual(res.payload, JSON.stringify({ firstName: 'New', lastName: 'Hoo', country: 'eg', city: 'node' }))
-    t.assert.strictEqual(res.statusCode, 300)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.payload, '{}')
     completion.stepIn()
   })
   fastify.inject({ method: 'GET', url: '/', headers: { Accept: 'application/vnd.v4+json' } }, (err, res) => {
@@ -386,8 +386,8 @@ test('Different content types', (t, testDone) => {
   })
   fastify.inject({ method: 'GET', url: '/test', headers: { Accept: 'application/vnd.v1+json' } }, (err, res) => {
     t.assert.ifError(err)
-    t.assert.strictEqual(res.payload, JSON.stringify({ created: true }))
-    t.assert.strictEqual(res.statusCode, 201)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.payload, '{}')
     completion.stepIn()
   })
 
@@ -1310,3 +1310,116 @@ test('response schema is applied when Content-Type has trailing semicolon only',
     testDone()
   })
 })
+
+test('fails closed when the response content-type is not declared in the content map', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  name: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/hal+json')
+    reply.send({ name: 'alice', password: 'SHOULD_NOT_LEAK' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(
+      JSON.parse(res.payload).code,
+      'FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN'
+    )
+    testDone()
+  })
+})
+
+test('response content-type matching */* still serialises when no exact content-type is declared', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          content: {
+            '*/*': {
+              schema: {
+                type: 'object',
+                required: ['name'],
+                additionalProperties: false,
+                properties: {
+                  name: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.header('Content-Type', 'application/hal+json')
+    reply.send({ name: 'alice', password: 'SHOULD_BE_STRIPPED' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { name: 'alice' })
+    testDone()
+  })
+})
+
+test('error responses fall back to the default error serializer when the content map does not declare the error content type', (t, testDone) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  // The content map does not declare `application/json` and has no `*/*`
+  // catch-all, so the error handler must fall back to the default serializer
+  // instead of failing closed.
+  fastify.get('/', {
+    schema: {
+      response: {
+        default: {
+          content: {
+            'application/problem+json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  title: { type: 'string' }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    throw new Error('boom')
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
+      statusCode: 500,
+      error: 'Internal Server Error',
+      message: 'boom'
+    })
+    testDone()
+  })
+})

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>()