fastify 5.3.3 → 5.5.0

package/test/url-rewriting.test.js

@@ -2,10 +2,9 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
-test('Should rewrite url', (t, done) => {
-  t.plan(5)
+test('Should rewrite url', async t => {
+  t.plan(4)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -22,24 +21,19 @@ test('Should rewrite url', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
 })
 
-test('Should not rewrite if the url is the same', (t, done) => {
-  t.plan(4)
+test('Should not rewrite if the url is the same', async t => {
+  t.plan(3)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -56,22 +50,18 @@ test('Should not rewrite if the url is the same', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 404)
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 404)
 })
 
-test('Should throw an error', (t, done) => {
-  t.plan(5)
+test('Should throw an error', async t => {
+  t.plan(2)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -88,23 +78,20 @@ test('Should throw an error', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.strictEqual(err.code, 'ECONNRESET')
-      t.assert.strictEqual(response, undefined)
-      t.assert.strictEqual(body, undefined)
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => fastify.close())
+
+  try {
+    await fetch(`${fastifyServer}/this-would-404-without-url-rewrite`)
+    t.assert.fail('Expected fetch to throw an error')
+  } catch (err) {
+    t.assert.ok(err instanceof Error)
+  }
 })
 
-test('Should rewrite url but keep originalUrl unchanged', (t, done) => {
-  t.plan(7)
+test('Should rewrite url but keep originalUrl unchanged', async t => {
+  t.plan(6)
   const fastify = Fastify({
     rewriteUrl (req) {
       t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
@@ -122,18 +109,14 @@ test('Should rewrite url but keep originalUrl unchanged', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      const parsedBody = JSON.parse(body)
-      t.assert.deepStrictEqual(parsedBody, { hello: 'world', hostname: 'localhost', port: fastify.server.address().port })
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
-  })
+  await fastify.listen({ port: 0 })
+  const port = fastify.server.address().port
+
+  t.after(() => fastify.close())
+
+  const result = await fetch(`http://localhost:${port}/this-would-404-without-url-rewrite`)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world', hostname: 'localhost', port })
 })

package/test/use-semicolon-delimiter.test.js

@@ -2,10 +2,9 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
-test('use semicolon delimiter default false', (t, done) => {
-  t.plan(4)
+test('use semicolon delimiter default false', async (t) => {
+  t.plan(2)
 
   const fastify = Fastify()
 
@@ -13,23 +12,19 @@ test('use semicolon delimiter default false', (t, done) => {
     reply.send(req.query)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), {})
-      fastify.close()
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar', {
+    method: 'GET'
   })
+  t.assert.strictEqual(result.status, 200)
+  const body = await result.json()
+  t.assert.deepStrictEqual(body, {})
 })
 
-test('use semicolon delimiter set to true', (t, done) => {
-  t.plan(4)
+test('use semicolon delimiter set to true', async (t) => {
+  t.plan(3)
   const fastify = Fastify({
     useSemicolonDelimiter: true
   })
@@ -38,26 +33,19 @@ test('use semicolon delimiter set to true', (t, done) => {
     reply.send(req.query)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), {
-        foo: 'bar'
-      })
-      fastify.close()
-      done()
-    })
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {
+    foo: 'bar'
   })
 })
 
-test('use semicolon delimiter set to false', (t, done) => {
-  t.plan(4)
+test('use semicolon delimiter set to false', async (t) => {
+  t.plan(3)
 
   const fastify = Fastify({
     useSemicolonDelimiter: false
@@ -67,24 +55,17 @@ test('use semicolon delimiter set to false', (t, done) => {
     reply.send(req.query)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), {})
-      fastify.close()
-      done()
-    })
-  })
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {})
 })
 
-test('use semicolon delimiter set to false return 404', (t, done) => {
-  t.plan(3)
+test('use semicolon delimiter set to false return 404', async (t) => {
+  t.plan(2)
 
   const fastify = Fastify({
     useSemicolonDelimiter: false
@@ -94,17 +75,94 @@ test('use semicolon delimiter set to false return 404', (t, done) => {
     reply.send(req.query)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 404)
+})
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 404)
-      fastify.close()
-      done()
-    })
+test('use routerOptions semicolon delimiter default false', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/1234;foo=bar', (req, reply) => {
+    reply.send(req.query)
   })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {})
+})
+
+test('use routerOptions semicolon delimiter set to true', async t => {
+  t.plan(3)
+  const fastify = Fastify({
+    routerOptions: {
+      useSemicolonDelimiter: true
+    }
+  })
+
+  fastify.get('/1234', async (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {
+    foo: 'bar'
+  })
+})
+
+test('use routerOptions semicolon delimiter set to false', async t => {
+  t.plan(3)
+
+  const fastify = Fastify({
+    routerOptions: {
+      useSemicolonDelimiter: false
+    }
+  })
+
+  fastify.get('/1234;foo=bar', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), {})
+})
+
+test('use routerOptions semicolon delimiter set to false return 404', async t => {
+  t.plan(2)
+
+  const fastify = Fastify({
+    routerOptions: {
+      useSemicolonDelimiter: false
+    }
+  })
+
+  fastify.get('/1234', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer + '/1234;foo=bar')
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 404)
 })

package/test/versioned-routes.test.js

@@ -3,7 +3,6 @@
 const { test, before } = require('node:test')
 const helper = require('./helper')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 const http = require('node:http')
 const split = require('split2')
 const append = require('vary').append
@@ -233,8 +232,8 @@ test('Versioned route but not version header should return a 404', (t, done) =>
   })
 })
 
-test('Should register a versioned route (server)', (t, done) => {
-  t.plan(6)
+test('Should register a versioned route (server)', async t => {
+  t.plan(5)
   const fastify = Fastify()
 
   fastify.route({
@@ -246,34 +245,27 @@ test('Should register a versioned route (server)', (t, 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({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'Accept-Version': '1.x'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-
-      sget({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port,
-        headers: {
-          'Accept-Version': '2.x'
-        }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 404)
-        done()
-      })
-    })
+  const result1 = await fetch(fastifyServer, {
+    headers: {
+      'Accept-Version': '1.x'
+    }
+  })
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  const body1 = await result1.json()
+  t.assert.deepStrictEqual(body1, { hello: 'world' })
+
+  const result2 = await fetch(fastifyServer, {
+    headers: {
+      'Accept-Version': '2.x'
+    }
   })
+
+  t.assert.ok(!result2.ok)
+  t.assert.strictEqual(result2.status, 404)
 })
 
 test('Shorthand route declaration', (t, done) => {
@@ -402,8 +394,8 @@ test('Bad accept version (inject)', (t, done) => {
   })
 })
 
-test('Bad accept version (server)', (t, done) => {
-  t.plan(5)
+test('Bad accept version (server)', async t => {
+  t.plan(4)
   const fastify = Fastify()
 
   fastify.route({
@@ -415,33 +407,24 @@ test('Bad accept version (server)', (t, 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({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'Accept-Version': 'a.b.c'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 404)
-
-      sget({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port,
-        headers: {
-          'Accept-Version': 12
-        }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 404)
-        done()
-      })
-    })
+  const result1 = await fetch(fastifyServer, {
+    headers: {
+      'Accept-Version': 'a.b.c'
+    }
+  })
+  t.assert.ok(!result1.ok)
+  t.assert.strictEqual(result1.status, 404)
+
+  const result2 = await fetch(fastifyServer, {
+    headers: {
+      'Accept-Version': '12'
+    }
   })
+  t.assert.ok(!result2.ok)
+  t.assert.strictEqual(result2.status, 404)
 })
 
 test('test log stream', (t, done) => {

package/types/errors.d.ts

@@ -9,6 +9,9 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ' |
   'FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR' |
   'FST_ERR_VALIDATION' |
+  'FST_ERR_LISTEN_OPTIONS_INVALID' |
+  'FST_ERR_ERROR_HANDLER_NOT_FN' |
+  'FST_ERR_ERROR_HANDLER_ALREADY_SET' |
   'FST_ERR_CTP_ALREADY_PRESENT' |
   'FST_ERR_CTP_INVALID_TYPE' |
   'FST_ERR_CTP_EMPTY_TYPE' |
@@ -18,12 +21,14 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_CTP_INVALID_MEDIA_TYPE' |
   'FST_ERR_CTP_INVALID_CONTENT_LENGTH' |
   'FST_ERR_CTP_EMPTY_JSON_BODY' |
+  'FST_ERR_CTP_INVALID_JSON_BODY' |
   'FST_ERR_CTP_INSTANCE_ALREADY_STARTED' |
   'FST_ERR_DEC_ALREADY_PRESENT' |
   'FST_ERR_DEC_DEPENDENCY_INVALID_TYPE' |
   'FST_ERR_DEC_MISSING_DEPENDENCY' |
   'FST_ERR_DEC_AFTER_START' |
   'FST_ERR_DEC_REFERENCE_TYPE' |
+  'FST_ERR_DEC_UNDECLARED' |
   'FST_ERR_HOOK_INVALID_TYPE' |
   'FST_ERR_HOOK_INVALID_HANDLER' |
   'FST_ERR_HOOK_INVALID_ASYNC_HANDLER' |
@@ -32,7 +37,12 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_HOOK_TIMEOUT' |
   'FST_ERR_LOG_INVALID_DESTINATION' |
   'FST_ERR_LOG_INVALID_LOGGER' |
+  'FST_ERR_LOG_INVALID_LOGGER_INSTANCE' |
+  'FST_ERR_LOG_INVALID_LOGGER_CONFIG' |
+  'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED' |
   'FST_ERR_REP_INVALID_PAYLOAD_TYPE' |
+  'FST_ERR_REP_RESPONSE_BODY_CONSUMED' |
+  'FST_ERR_REP_READABLE_STREAM_LOCKED' |
   'FST_ERR_REP_ALREADY_SENT' |
   'FST_ERR_REP_SENT_VALUE' |
   'FST_ERR_SEND_INSIDE_ONERR' |
@@ -56,7 +66,6 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_DUPLICATED_ROUTE' |
   'FST_ERR_BAD_URL' |
   'FST_ERR_ASYNC_CONSTRAINT' |
-  'FST_ERR_DEFAULT_ROUTE_INVALID_TYPE' |
   'FST_ERR_INVALID_URL' |
   'FST_ERR_ROUTE_OPTIONS_NOT_OBJ' |
   'FST_ERR_ROUTE_DUPLICATED_HANDLER' |
@@ -72,6 +81,7 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_INSTANCE_ALREADY_LISTENING' |
   'FST_ERR_PLUGIN_VERSION_MISMATCH' |
   'FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE' |
+  'FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER' |
   'FST_ERR_PLUGIN_CALLBACK_NOT_FN' |
   'FST_ERR_PLUGIN_NOT_VALID' |
   'FST_ERR_ROOT_PLG_BOOTED' |

package/types/hooks.d.ts

@@ -498,7 +498,7 @@ export type onTimeoutMetaHookHandler<
 /**
  * This hook is useful if you need to do some custom error logging or add some specific header in case of error.
  * It is not intended for changing the error, and calling reply.send will throw an exception.
- * This hook will be executed only after the customErrorHandler has been executed, and only if the customErrorHandler sends an error back to the user (Note that the default customErrorHandler always sends the error back to the user).
+ * This hook will be executed before the customErrorHandler.
  * Notice: unlike the other hooks, pass an error to the done function is not supported.
  */
 export interface onErrorHookHandler<

package/types/instance.d.ts

@@ -466,7 +466,7 @@ export interface FastifyInstance<
   errorHandler: (error: FastifyError, request: FastifyRequest, reply: FastifyReply) => void;
 
   /**
-   * Set a function that will be called whenever an error happens
+   * Set a function that will be invoked whenever an exception is thrown during the request lifecycle.
    */
   setErrorHandler<TError extends Error = FastifyError, RouteGeneric extends RouteGenericInterface = RouteGenericInterface, SchemaCompiler extends FastifySchema = FastifySchema, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(
     handler: (this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>, error: TError, request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfigDefault, SchemaCompiler, TypeProvider>) => any | Promise<any>

package/types/reply.d.ts

@@ -46,8 +46,8 @@ export interface FastifyReply<
   log: FastifyBaseLogger;
   request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>;
   server: FastifyInstance;
-  code<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
-  status<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
+  code<Code extends keyof SchemaCompiler['response'] extends never ? ReplyKeysToCodes<keyof RouteGeneric['Reply']> : keyof SchemaCompiler['response'] extends ReplyKeysToCodes<keyof RouteGeneric['Reply']> ? keyof SchemaCompiler['response'] : ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
+  status<Code extends keyof SchemaCompiler['response'] extends never ? ReplyKeysToCodes<keyof RouteGeneric['Reply']> : keyof SchemaCompiler['response'] extends ReplyKeysToCodes<keyof RouteGeneric['Reply']> ? keyof SchemaCompiler['response'] : ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
   statusCode: number;
   sent: boolean;
   send(payload?: ReplyType): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;

package/types/request.d.ts

@@ -32,6 +32,7 @@ export interface RequestRouteOptions<ContextConfig = ContextConfigDefault, Schem
   config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;
   schema?: SchemaCompiler; // it is empty for 404 requests
   handler: RouteHandlerMethod;
+  version?: string;
 }
 
 /**

package/.taprc

@@ -1,7 +0,0 @@
-# vim: set filetype=yaml :
-node-arg:
-  - '--allow-natives-syntax'
-
-include:
-  - 'test/**/*.test.js'
-  - 'test/**/*.test.mjs'