fastify 5.3.3 → 5.5.0

package/test/stream.1.test.js

@@ -1,12 +1,11 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fs = require('node:fs')
 const Fastify = require('../fastify')
 
-test('should respond with a stream', (t, testDone) => {
-  t.plan(6)
+test('should respond with a stream', async t => {
+  t.plan(4)
   const fastify = Fastify()
 
   fastify.get('/', function (req, reply) {
@@ -14,26 +13,21 @@ test('should respond with a stream', (t, testDone) => {
     reply.code(200).send(stream)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
-
-    sget(`http://localhost:${fastify.server.address().port}`, function (err, response, data) {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.headers['content-type'], undefined)
-      t.assert.strictEqual(response.statusCode, 200)
-
-      fs.readFile(__filename, (err, expected) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(expected.toString(), data.toString())
-        testDone()
-      })
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.headers.get('content-type'), null)
+  t.assert.strictEqual(response.status, 200)
+
+  const data = await response.text()
+  const expected = await fs.promises.readFile(__filename, 'utf8')
+  t.assert.strictEqual(expected.toString(), data.toString())
 })
 
-test('should respond with a stream (error)', (t, testDone) => {
-  t.plan(3)
+test('should respond with a stream (error)', async t => {
+  t.plan(2)
   const fastify = Fastify()
 
   fastify.get('/error', function (req, reply) {
@@ -41,20 +35,16 @@ test('should respond with a stream (error)', (t, testDone) => {
     reply.code(200).send(stream)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
 
-    sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 500)
-      testDone()
-    })
-  })
+  const response = await fetch(`${fastifyServer}/error`)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 500)
 })
 
-test('should trigger the onSend hook', (t, testDone) => {
-  t.plan(4)
+test('should trigger the onSend hook', async (t) => {
+  t.plan(3)
   const fastify = Fastify()
 
   fastify.get('/', (req, reply) => {
@@ -67,19 +57,16 @@ test('should trigger the onSend hook', (t, testDone) => {
     done()
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     url: '/'
-  }, (err, res) => {
-    t.assert.ifError(err)
-    t.assert.strictEqual(res.headers['content-type'], 'application/javascript')
-    t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
-    fastify.close()
-    testDone()
   })
+  t.assert.strictEqual(res.headers['content-type'], 'application/javascript')
+  t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
+  return fastify.close()
 })
 
-test('should trigger the onSend hook only twice if pumping the stream fails, first with the stream, second with the serialized error', (t, testDone) => {
-  t.plan(5)
+test('should trigger the onSend hook only twice if pumping the stream fails, first with the stream, second with the serialized error', async t => {
+  t.plan(4)
   const fastify = Fastify()
 
   fastify.get('/', (req, reply) => {
@@ -98,14 +85,10 @@ test('should trigger the onSend hook only twice if pumping the stream fails, fir
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget(`http://localhost:${fastify.server.address().port}`, function (err, response) {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 500)
-      testDone()
-    })
-  })
+  const response = await fetch(fastifyServer)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 500)
 })

package/test/stream.4.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const errors = require('http-errors')
 const JSONStream = require('JSONStream')
 const Readable = require('node:stream').Readable
@@ -126,8 +125,8 @@ test('Destroying streams prematurely, log is disabled', (t, testDone) => {
   })
 })
 
-test('should respond with a stream1', (t, testDone) => {
-  t.plan(5)
+test('should respond with a stream1', async (t) => {
+  t.plan(4)
   const fastify = Fastify()
 
   fastify.get('/', function (req, reply) {
@@ -137,22 +136,19 @@ test('should respond with a stream1', (t, testDone) => {
     stream.end({ a: 42 })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
 
-    sget(`http://localhost:${fastify.server.address().port}`, function (err, response, body) {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.headers['content-type'], 'application/json')
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), [{ hello: 'world' }, { a: 42 }])
-      testDone()
-    })
-  })
+  const response = await fetch(fastifyServer)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.headers.get('content-type'), 'application/json')
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), [{ hello: 'world' }, { a: 42 }])
 })
 
-test('return a 404 if the stream emits a 404 error', (t, testDone) => {
-  t.plan(5)
+test('return a 404 if the stream emits a 404 error', async (t) => {
+  t.plan(4)
 
   const fastify = Fastify()
 
@@ -170,17 +166,11 @@ test('return a 404 if the stream emits a 404 error', (t, testDone) => {
     reply.send(reallyLongStream)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
-
-    const port = fastify.server.address().port
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
 
-    sget(`http://localhost:${port}`, function (err, response) {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
-      t.assert.strictEqual(response.statusCode, 404)
-      testDone()
-    })
-  })
+  const response = await fetch(fastifyServer)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.headers.get('content-type'), 'application/json; charset=utf-8')
+  t.assert.strictEqual(response.status, 404)
 })

package/test/stream.5.test.js

@@ -4,11 +4,10 @@ const { test } = require('node:test')
 const proxyquire = require('proxyquire')
 const fs = require('node:fs')
 const Readable = require('node:stream').Readable
-const sget = require('simple-get').concat
 const Fastify = require('..')
 
-test('should destroy stream when response is ended', (t, done) => {
-  t.plan(4)
+test('should destroy stream when response is ended', async (t) => {
+  t.plan(3)
   const stream = require('node:stream')
   const fastify = Fastify()
 
@@ -24,20 +23,16 @@ test('should destroy stream when response is ended', (t, done) => {
     reply.raw.end(Buffer.from('hello\n'))
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
 
-    sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
-  })
+  const response = await fetch(`${fastifyServer}/error`)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
 })
 
-test('should mark reply as sent before pumping the payload stream into response for async route handler', (t, done) => {
-  t.plan(3)
+test('should mark reply as sent before pumping the payload stream into response for async route handler', async (t) => {
+  t.plan(2)
   t.after(() => fastify.close())
 
   const handleRequest = proxyquire('../lib/handleRequest', {
@@ -63,14 +58,11 @@ test('should mark reply as sent before pumping the payload stream into response
     return reply.code(200).send(stream)
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     url: '/',
     method: 'GET'
-  }, (err, res) => {
-    t.assert.ifError(err)
-    t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
-    done()
   })
+  t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
 })
 
 test('reply.send handles aborted requests', (t, done) => {

package/test/trust-proxy.test.js

@@ -1,14 +1,10 @@
 'use strict'
 
 const { test, before } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('..')
 const helper = require('./helper')
-const { waitForCb } = require('./toolkit')
 
-const noop = () => {}
-
-const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) => {
+const fetchForwardedRequest = async (fastifyServer, forHeader, path, protoHeader) => {
   const headers = {
     'X-Forwarded-For': forHeader,
     'X-Forwarded-Host': 'example.com'
@@ -16,11 +12,10 @@ const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) =
   if (protoHeader) {
     headers['X-Forwarded-Proto'] = protoHeader
   }
-  sget({
-    method: 'GET',
-    headers,
-    url: 'http://localhost:' + app.server.address().port + path
-  }, testCaseDone || noop)
+
+  return fetch(fastifyServer + path, {
+    headers
+  })
 }
 
 const testRequestValues = (t, req, options) => {
@@ -52,8 +47,8 @@ before(async function () {
   [localhost] = await helper.getLoopbackHost()
 })
 
-test('trust proxy, not add properties to node req', (t, done) => {
-  t.plan(14)
+test('trust proxy, not add properties to node req', async t => {
+  t.plan(13)
   const app = fastify({
     trustProxy: true
   })
@@ -69,20 +64,14 @@ test('trust proxy, not add properties to node req', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    const completion = waitForCb({ steps: 2 })
-
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy', undefined, completion.stepIn)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined, completion.stepIn)
+  const fastifyServer = await app.listen({ port: 0 })
 
-    completion.patience.then(done)
-  })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxy', undefined)
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined)
 })
 
-test('trust proxy chain', (t, done) => {
-  t.plan(9)
+test('trust proxy chain', async t => {
+  t.plan(8)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
   })
@@ -93,14 +82,12 @@ test('trust proxy chain', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined)
 })
 
-test('trust proxy function', (t, done) => {
-  t.plan(9)
+test('trust proxy function', async t => {
+  t.plan(8)
   const app = fastify({
     trustProxy: (address) => address === localhost
   })
@@ -111,14 +98,12 @@ test('trust proxy function', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '1.1.1.1', '/trustproxyfunc', undefined)
 })
 
-test('trust proxy number', (t, done) => {
-  t.plan(10)
+test('trust proxy number', async t => {
+  t.plan(9)
   const app = fastify({
     trustProxy: 1
   })
@@ -129,14 +114,12 @@ test('trust proxy number', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined)
 })
 
-test('trust proxy IP addresses', (t, done) => {
-  t.plan(10)
+test('trust proxy IP addresses', async t => {
+  t.plan(9)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
   })
@@ -147,14 +130,12 @@ test('trust proxy IP addresses', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined, done)
-  })
+  const fastifyServer = await app.listen({ port: 0 })
+  await fetchForwardedRequest(fastifyServer, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined)
 })
 
-test('trust proxy protocol', (t, done) => {
-  t.plan(31)
+test('trust proxy protocol', async t => {
+  t.plan(30)
   const app = fastify({
     trustProxy: true
   })
@@ -173,16 +154,9 @@ test('trust proxy protocol', (t, done) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  app.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-
-    const completion = waitForCb({ steps: 3 })
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocol', 'lorem', completion.stepIn)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxynoprotocol', undefined, completion.stepIn)
+  const fastifyServer = await app.listen({ port: 0 })
 
-    // Allow for sgetForwardedRequest requests above to finish
-    setTimeout(() => sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', completion.stepIn))
-
-    completion.patience.then(done)
-  })
+  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')
 })

package/test/types/errors.test-d.ts

@@ -2,7 +2,6 @@ import { FastifyErrorConstructor } from '@fastify/error'
 import { expectAssignable } from 'tsd'
 import { errorCodes } from '../../fastify'
 
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_VALIDATION)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_NOT_FOUND)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_OPTIONS_NOT_OBJ)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_QSP_NOT_FN)
@@ -11,6 +10,9 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCHEMA_ERROR_FORMAT
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_VALIDATION)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LISTEN_OPTIONS_INVALID)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ERROR_HANDLER_NOT_FN)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ERROR_HANDLER_ALREADY_SET)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_ALREADY_PRESENT)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_TYPE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_EMPTY_TYPE)
@@ -20,11 +22,14 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_BODY_TOO_LARGE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_MEDIA_TYPE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_CONTENT_LENGTH)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_EMPTY_JSON_BODY)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INVALID_JSON_BODY)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_CTP_INSTANCE_ALREADY_STARTED)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_ALREADY_PRESENT)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_DEPENDENCY_INVALID_TYPE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_MISSING_DEPENDENCY)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_AFTER_START)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_REFERENCE_TYPE)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEC_UNDECLARED)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_TYPE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_HANDLER)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER)
@@ -33,7 +38,12 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_MISSING_MIDDLEWARE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HOOK_TIMEOUT)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_DESTINATION)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER_INSTANCE)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_INVALID_LOGGER_CONFIG)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_INVALID_PAYLOAD_TYPE)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_RESPONSE_BODY_CONSUMED)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_READABLE_STREAM_LOCKED)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_ALREADY_SENT)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REP_SENT_VALUE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SEND_INSIDE_ONERR)
@@ -57,6 +67,7 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FORCE_CLOSE_CONNECT
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DUPLICATED_ROUTE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_URL)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ASYNC_CONSTRAINT)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INVALID_URL)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_OPTIONS_NOT_OBJ)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_DUPLICATED_HANDLER)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_HANDLER_NOT_FN)
@@ -71,6 +82,7 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_REOPENED_SERVER)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INSTANCE_ALREADY_LISTENING)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_VERSION_MISMATCH)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE)
+expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_CALLBACK_NOT_FN)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_PLUGIN_NOT_VALID)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROOT_PLG_BOOTED)

package/test/types/fastify.test-d.ts

@@ -273,3 +273,6 @@ expectType<FastifyErrorCodes>(fastify.errorCodes)
 fastify({ allowUnsafeRegex: true })
 fastify({ allowUnsafeRegex: false })
 expectError(fastify({ allowUnsafeRegex: 'invalid' }))
+
+expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: true }))
+expectAssignable<FastifyInstance>(fastify({ allowErrorHandlerOverride: false }))

package/test/types/request.test-d.ts

@@ -78,6 +78,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifySchema | undefined>(request.routeOptions.schema)
   expectType<RouteHandlerMethod>(request.routeOptions.handler)
   expectType<string | undefined>(request.routeOptions.url)
+  expectType<string | undefined>(request.routeOptions.version)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
   request.headers = {}

package/test/types/type-provider.test-d.ts

@@ -1009,6 +1009,37 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply:
   }
 ))
 
+// -------------------------------------------------------------------
+// Reply Status Code (Different Status Codes)
+// -------------------------------------------------------------------
+
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
+  '/',
+  {
+    schema: {
+      response: {
+        200: {
+          content: {
+            'text/string': {
+              schema: { type: 'string' }
+            },
+            'application/json': {
+              schema: { type: 'object', properties: { msg: { type: 'string' } } }
+            }
+          }
+        },
+        500: { type: 'object', properties: { error: { type: 'string' } } }
+      } as const
+    }
+  },
+  async (_, res) => {
+    res.code(200)
+    res.code(500)
+    expectError(() => res.code(201))
+    expectError(() => res.code(400))
+  }
+))
+
 // -------------------------------------------------------------------
 // RouteGeneric Reply Type Return (Different Status Codes)
 // -------------------------------------------------------------------
@@ -1032,6 +1063,30 @@ expectAssignable(server.get<{
   }
 ))
 
+// -------------------------------------------------------------------
+// RouteGeneric Status Code (Different Status Codes)
+// -------------------------------------------------------------------
+
+expectAssignable(server.get<{
+  Reply: {
+    200: string | { msg: string }
+    400: number
+    '5xx': { error: string }
+  }
+}>(
+  '/',
+  async (_, res) => {
+    res.code(200)
+    res.code(400)
+    res.code(500)
+    res.code(502)
+    expectError(() => res.code(201))
+    expectError(() => res.code(300))
+    expectError(() => res.code(404))
+    return 'hello'
+  }
+))
+
 // -------------------------------------------------------------------
 // RouteGeneric Reply Type Return: Non Assignable (Different Status Codes)
 // -------------------------------------------------------------------