fastify 5.8.4 → 5.9.0

package/test/schema-validation.test.js

@@ -6,6 +6,7 @@ const Fastify = require('..')
 const AJV = require('ajv')
 const Schema = require('fluent-json-schema')
 const { waitForCb } = require('./toolkit')
+const { kRequestContentType } = require('../lib/symbols')
 
 const customSchemaCompilers = {
   body: new AJV({
@@ -1374,6 +1375,7 @@ test('Schema validation when no content type is provided', async t => {
     },
     preValidation: async (request) => {
       request.headers['content-type'] = undefined
+      request[kRequestContentType] = undefined
     }
   }, async () => 'ok')
 
@@ -1460,6 +1462,27 @@ test('Schema validation will not be bypass by different content type', async t =
   t.assert.strictEqual(found.status, 400)
   t.assert.strictEqual((await found.json()).code, 'FST_ERR_VALIDATION')
 
+  let injected = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': ' application/json'
+    },
+    payload: JSON.stringify({ invalid: 'string' })
+  })
+  t.assert.strictEqual(injected.statusCode, 400)
+  t.assert.strictEqual(injected.json().code, 'FST_ERR_VALIDATION')
+
+  injected = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': ' application/json'
+    },
+    payload: JSON.stringify({ foo: 'string' })
+  })
+  t.assert.strictEqual(injected.statusCode, 200)
+
   found = await fetch(address, {
     method: 'POST',
     url: '/',
@@ -1570,3 +1593,25 @@ test('Schema validation will not be bypass by different content type', async t =
   t.assert.strictEqual(found.status, 415)
   t.assert.strictEqual((await found.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
 })
+test('coercion of empty string to null with nullable types', async t => {
+  const assert = require('node:assert')
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      querystring: {
+        type: 'object',
+        properties: {
+          param: { type: ['integer', 'null'] }
+        }
+      }
+    }
+  }, async (req, reply) => {
+    return { param: req.query.param }
+  })
+
+  const res = await fastify.inject({
+    method: 'GET',
+    url: '/?param='
+  })
+  assert.strictEqual(JSON.parse(res.payload).param, null)
+})

package/test/scripts/validate-ecosystem-links.test.js

@@ -127,7 +127,6 @@ Some description [inline link](https://github.com/a/b).
 describe('checkGitHubRepo', () => {
   let originalDispatcher
   let mockAgent
-  let originalFetch
   let originalSetTimeout
 
   beforeEach(() => {
@@ -136,12 +135,10 @@ describe('checkGitHubRepo', () => {
     mockAgent = new MockAgent()
     mockAgent.disableNetConnect()
     setGlobalDispatcher(mockAgent)
-    originalFetch = global.fetch
     originalSetTimeout = global.setTimeout
   })
 
   afterEach(async () => {
-    global.fetch = originalFetch
     global.setTimeout = originalSetTimeout
     setGlobalDispatcher(originalDispatcher)
     await mockAgent.close()
@@ -180,16 +177,9 @@ describe('checkGitHubRepo', () => {
 
   it('returns invalid status for malformed owner or repository names', async () => {
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
-    let called = false
-
-    global.fetch = async () => {
-      called = true
-      return { status: 200 }
-    }
 
     const result = await checkGitHubRepo('owner/evil', 'repo', 1)
 
-    assert.strictEqual(called, false)
     assert.strictEqual(result.exists, false)
     assert.strictEqual(result.status, 'invalid')
     assert.strictEqual(result.error, 'Invalid GitHub repository identifier')
@@ -199,17 +189,17 @@ describe('checkGitHubRepo', () => {
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
     let attempts = 0
 
-    global.setTimeout = (fn) => {
-      fn()
-      return 0
-    }
+    global.setTimeout = (fn) => { fn(); return 0 }
 
-    global.fetch = async () => {
-      attempts++
-      return {
-        status: attempts === 1 ? 403 : 200
-      }
-    }
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD'
+    }).reply(() => { attempts++; return { statusCode: 403 } })
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD'
+    }).reply(() => { attempts++; return { statusCode: 200 } })
 
     const result = await checkGitHubRepo('owner', 'repo', 1)
 
@@ -221,23 +211,25 @@ describe('checkGitHubRepo', () => {
   it('adds authorization header when GITHUB_TOKEN is set', async () => {
     process.env.GITHUB_TOKEN = 'my-token'
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
-    let authorization
 
-    global.fetch = async (url, options) => {
-      authorization = options.headers.Authorization
-      return {
-        status: 200
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD',
+      headers: {
+        authorization: 'token my-token'
       }
-    }
+    }).reply(200)
 
     const result = await checkGitHubRepo('owner', 'repo')
 
-    assert.strictEqual(authorization, 'token my-token')
     assert.strictEqual(result.exists, true)
+    assert.strictEqual(result.status, 200)
   })
 
   it('handles network errors', async () => {
     const { checkGitHubRepo } = loadValidateEcosystemLinksModule()
+
     const mockPool = mockAgent.get('https://api.github.com')
     mockPool.intercept({
       path: '/repos/owner/repo',
@@ -254,37 +246,41 @@ describe('checkGitHubRepo', () => {
 
 describe('validateAllLinks', () => {
   let originalReadFileSync
-  let originalFetch
   let originalSetTimeout
   let originalConsoleLog
   let originalStdoutWrite
+  let mockAgent
+  let originalDispatcher
 
   beforeEach(() => {
     originalReadFileSync = fs.readFileSync
-    originalFetch = global.fetch
     originalSetTimeout = global.setTimeout
     originalConsoleLog = console.log
     originalStdoutWrite = process.stdout.write
+    originalDispatcher = getGlobalDispatcher()
+
+    mockAgent = new MockAgent()
+    mockAgent.disableNetConnect()
+    setGlobalDispatcher(mockAgent)
 
     console.log = () => {}
     process.stdout.write = () => true
 
-    global.setTimeout = (fn) => {
-      fn()
-      return 0
-    }
+    global.setTimeout = (fn) => { fn(); return 0 }
   })
 
-  afterEach(() => {
+  afterEach(async () => {
     fs.readFileSync = originalReadFileSync
-    global.fetch = originalFetch
     global.setTimeout = originalSetTimeout
     console.log = originalConsoleLog
     process.stdout.write = originalStdoutWrite
+    setGlobalDispatcher(originalDispatcher)
+    await mockAgent.close()
   })
 
   it('validates links, deduplicates repositories and groups inaccessible links', async () => {
     const { validateAllLinks } = loadValidateEcosystemLinksModule()
+    let requests = 0
 
     fs.readFileSync = () => `
 - [repo one](https://github.com/owner/repo)
@@ -292,21 +288,15 @@ describe('validateAllLinks', () => {
 - [repo two](https://github.com/another/project)
 `
 
-    let requests = 0
-    global.fetch = async (url) => {
-      requests++
-      const pathname = new URL(url).pathname
-
-      if (pathname === '/repos/owner/repo') {
-        return { status: 404 }
-      }
-
-      if (pathname === '/repos/another/project') {
-        return { status: 200 }
-      }
-
-      throw new Error(`Unexpected url: ${url}`)
-    }
+    const mockPool = mockAgent.get('https://api.github.com')
+    mockPool.intercept({
+      path: '/repos/owner/repo',
+      method: 'HEAD'
+    }).reply(() => { requests++; return { statusCode: 404 } })
+    mockPool.intercept({
+      path: '/repos/another/project',
+      method: 'HEAD'
+    }).reply(() => { requests++; return { statusCode: 200 } })
 
     const result = await validateAllLinks()
 
@@ -324,15 +314,8 @@ describe('validateAllLinks', () => {
 
     fs.readFileSync = () => '# Ecosystem\nNo links here.'
 
-    let requests = 0
-    global.fetch = async () => {
-      requests++
-      return { status: 200 }
-    }
-
     const result = await validateAllLinks()
 
-    assert.strictEqual(requests, 0)
     assert.strictEqual(result.notFound.length, 0)
     assert.strictEqual(result.found.length, 0)
   })

package/test/throw.test.js

@@ -28,6 +28,20 @@ test('Fastify should throw on multiple assignment to the same route', (t) => {
   }
 })
 
+test('Fastify should throw on multiple assignment to the same route with array method', (t) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.route({ method: ['GET', 'POST'], url: '/', handler: () => {} })
+
+  try {
+    fastify.route({ method: ['GET', 'POST'], url: '/', handler: () => {} })
+    t.assert.fail('Should throw fastify duplicated route declaration')
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'FST_ERR_DUPLICATED_ROUTE')
+  }
+})
+
 test('Fastify should throw for an invalid schema, printing the error route - headers', async (t) => {
   t.plan(1)
 

package/test/trust-proxy.test.js

@@ -3,6 +3,8 @@
 const { test, before } = require('node:test')
 const fastify = require('..')
 const helper = require('./helper')
+const Request = require('../lib/request')
+const buildRequest = Request.buildRequest
 
 const fetchForwardedRequest = async (fastifyServer, forHeader, path, protoHeader) => {
   const headers = {
@@ -219,3 +221,75 @@ test('trust proxy reads forwarded headers from trusted connections', async t =>
     }
   })
 })
+
+test('trust proxy with number and undefined socket remoteAddress', t => {
+  t.plan(3)
+
+  // Test case for issue #6606: trustProxy: 1 with undefined/null socket.remoteAddress
+  // This simulates IISNode on Windows where socket.remoteAddress may be undefined
+  const headers = {
+    'x-forwarded-for': '2.2.2.2, 1.1.1.1',
+    'x-forwarded-host': 'fastify.test',
+    'x-forwarded-proto': 'https'
+  }
+  // socket must exist but remoteAddress can be undefined
+  // This is what happens in IISNode with enableXFF="true"
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: { remoteAddress: undefined },
+    headers
+  }
+
+  const TpRequest = buildRequest(Request, 1)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  // Even with undefined socket.remoteAddress, req.ip should be populated from X-Forwarded-For
+  t.assert.ok(request.ip, 'ip is defined')
+  // With trustProxy: 1, we trust 1 hop from socket. Since socket.remoteAddress is undefined,
+  // the hop count check should skip it and we get 1.1.1.1 (the first trusted address from X-Forwarded-For)
+  t.assert.strictEqual(request.ip, '1.1.1.1', 'gets ip from x-forwarded-for')
+  // The host should also work correctly
+  t.assert.strictEqual(request.host, 'fastify.test', 'gets host from x-forwarded-host')
+})
+
+test('trust proxy with number and null socket remoteAddress', t => {
+  t.plan(2)
+
+  // Test case for trustProxy: 1 with null socket.remoteAddress
+  const headers = {
+    'x-forwarded-for': '2.2.2.2, 1.1.1.1',
+    'x-forwarded-host': 'fastify.test'
+  }
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: { remoteAddress: null },
+    headers
+  }
+
+  const TpRequest = buildRequest(Request, 1)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  t.assert.ok(request.ip, 'ip is defined')
+  t.assert.strictEqual(request.ip, '1.1.1.1', 'gets ip from x-forwarded-for')
+})
+
+test('trust proxy does not trust x-forwarded-host/proto when socket is null', t => {
+  t.plan(2)
+
+  const headers = {
+    host: 'real.test',
+    'x-forwarded-host': 'spoofed.test',
+    'x-forwarded-proto': 'https'
+  }
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: null,
+    headers
+  }
+
+  const TpRequest = buildRequest(Request, true)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  t.assert.strictEqual(request.host, 'real.test', 'falls back to host header')
+  t.assert.strictEqual(request.protocol, undefined, 'does not trust x-forwarded-proto')
+})

package/test/types/content-type-parser.tst.ts

@@ -0,0 +1,70 @@
+import { IncomingMessage } from 'node:http'
+import { expect } from 'tstyche'
+import fastify, { FastifyBodyParser } from '../../fastify.js'
+import { FastifyRequest } from '../../types/request.js'
+
+expect(fastify().addContentTypeParser('contentType', function (request, payload, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  done(null)
+})).type.toBe<void>()
+
+// Body limit options
+
+expect(fastify().addContentTypeParser('contentType', { bodyLimit: 99 }, function (request, payload, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  done(null)
+})).type.toBe<void>()
+
+// Array for contentType
+
+expect(fastify().addContentTypeParser(['contentType'], function (request, payload, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  done(null)
+})).type.toBe<void>()
+
+// Body Parser - the generic after addContentTypeParser enforces the type of the `body` parameter as well as the value of the `parseAs` property
+
+expect(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, function (request, body, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<string>()
+  done(null)
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, function (request, body, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<Buffer>()
+  done(null)
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser('contentType', async function (request: FastifyRequest, payload: IncomingMessage) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  return null
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, async function (request: FastifyRequest, body: string) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<string>()
+  return null
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, async function (request: FastifyRequest, body: Buffer) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<Buffer>()
+  return null
+})).type.toBe<void>()
+
+expect(fastify().getDefaultJsonParser('error', 'ignore')).type.toBe<FastifyBodyParser<string>>()
+expect(fastify().getDefaultJsonParser).type.not.toBeCallableWith('error', 'skip')
+expect(fastify().getDefaultJsonParser).type.not.toBeCallableWith('nothing', 'ignore')
+
+expect(fastify().removeAllContentTypeParsers()).type.toBe<void>()
+expect(fastify().removeAllContentTypeParsers).type.not.toBeCallableWith('contentType')
+
+expect(fastify().removeContentTypeParser('contentType')).type.toBe<void>()
+expect(fastify().removeContentTypeParser(/contentType+.*/)).type.toBe<void>()
+expect(fastify().removeContentTypeParser(['contentType', /contentType+.*/])).type.toBe<void>()
+expect(fastify().removeContentTypeParser).type.not.toBeCallableWith({})

package/test/types/{decorate-request-reply.test-d.ts → decorate-request-reply.tst.ts}

@@ -1,5 +1,5 @@
-import fastify from '../../fastify'
-import { expectType } from 'tsd'
+import { expect } from 'tstyche'
+import fastify from '../../fastify.js'
 
 type TestType = void
 
@@ -13,6 +13,6 @@ declare module '../../fastify' {
 }
 
 fastify().get('/', (req, res) => {
-  expectType<TestType>(req.testProp)
-  expectType<TestType>(res.testProp)
+  expect(req.testProp).type.toBe<TestType>()
+  expect(res.testProp).type.toBe<TestType>()
 })

package/test/types/{dummy-plugin.ts → dummy-plugin.mts}

@@ -1,4 +1,4 @@
-import { FastifyPluginAsync } from '../../fastify'
+import { FastifyPluginAsync } from '../../fastify.js'
 
 export interface DummyPluginOptions {
   foo?: number

package/test/types/errors.tst.ts

@@ -0,0 +1,91 @@
+import { FastifyErrorConstructor } from '@fastify/error'
+import { expect } from 'tstyche'
+import { errorCodes } from '../../fastify.js'
+
+expect(errorCodes.FST_ERR_NOT_FOUND).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_OPTIONS_NOT_OBJ).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_QSP_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_VALIDATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LISTEN_OPTIONS_INVALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ERROR_HANDLER_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ERROR_HANDLER_ALREADY_SET).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_ALREADY_PRESENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_EMPTY_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_PARSE_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_BODY_TOO_LARGE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_MEDIA_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_CONTENT_LENGTH).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_EMPTY_JSON_BODY).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_JSON_BODY).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INSTANCE_ALREADY_STARTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_ALREADY_PRESENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_DEPENDENCY_INVALID_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_MISSING_DEPENDENCY).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_AFTER_START).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_REFERENCE_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_UNDECLARED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_INVALID_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_INVALID_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_NOT_SUPPORTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_MISSING_MIDDLEWARE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_TIMEOUT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_DESTINATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_LOGGER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_LOGGER_INSTANCE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_LOGGER_CONFIG).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_INVALID_PAYLOAD_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_RESPONSE_BODY_CONSUMED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_READABLE_STREAM_LOCKED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_ALREADY_SENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_SENT_VALUE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SEND_INSIDE_ONERR).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SEND_UNDEFINED_ERR).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_STATUS_CODE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_TRAILER_NAME).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_TRAILER_VALUE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_FAILED_ERROR_SERIALIZATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_MISSING_SERIALIZATION_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REQ_INVALID_VALIDATION_INVOCATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_MISSING_ID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_ALREADY_PRESENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_CONTENT_MISSING_SCHEMA).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_DUPLICATE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_VALIDATION_BUILD).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_SERIALIZATION_BUILD).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_INIT_OPTS_INVALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DUPLICATED_ROUTE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_URL).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ASYNC_CONSTRAINT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_INVALID_URL).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_OPTIONS_NOT_OBJ).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_DUPLICATED_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_HANDLER_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_MISSING_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_METHOD_INVALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_METHOD_NOT_SUPPORTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+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_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>()
+expect(errorCodes.FST_ERR_PLUGIN_VERSION_MISMATCH).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_CALLBACK_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_NOT_VALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROOT_PLG_BOOTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PARENT_PLUGIN_BOOTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_TIMEOUT).type.toBeAssignableTo<FastifyErrorConstructor>()