fastify 5.2.2 → 5.3.0

package/test/decorator.test.js

@@ -925,9 +925,9 @@ test('Request/reply decorators should be able to access the server instance', as
   server.decorateRequest('assert', rootAssert)
   server.decorateReply('assert', rootAssert)
 
-  server.get('/root-assert', async (req, rep) => {
+  server.get('/root-assert', async (req, res) => {
     req.assert()
-    rep.assert()
+    res.assert()
     return 'done'
   })
 
@@ -936,9 +936,9 @@ test('Request/reply decorators should be able to access the server instance', as
     instance.decorateReply('assert', nestedAssert)
     instance.decorate('foo', 'bar')
 
-    instance.get('/nested-assert', async (req, rep) => {
+    instance.get('/nested-assert', async (req, res) => {
       req.assert()
-      rep.assert()
+      res.assert()
       return 'done'
     })
   })
@@ -1260,3 +1260,173 @@ test('chain of decorators on Reply', async (t) => {
     t.equal(response.body, 'tata')
   }
 })
+
+test('getDecorator should return the decorator', t => {
+  t.plan(12)
+  const fastify = Fastify()
+
+  fastify.decorate('root', 'from_root')
+  fastify.decorateRequest('root', 'from_root_request')
+  fastify.decorateReply('root', 'from_root_reply')
+
+  t.equal(fastify.getDecorator('root'), 'from_root')
+  fastify.get('/', async (req, res) => {
+    t.equal(req.getDecorator('root'), 'from_root_request')
+    t.equal(res.getDecorator('root'), 'from_root_reply')
+
+    res.send()
+  })
+
+  fastify.register((child) => {
+    child.decorate('child', 'from_child')
+
+    t.equal(child.getDecorator('child'), 'from_child')
+    t.equal(child.getDecorator('root'), 'from_root')
+
+    child.get('/child', async (req, res) => {
+      t.equal(req.getDecorator('root'), 'from_root_request')
+      t.equal(res.getDecorator('root'), 'from_root_reply')
+
+      res.send()
+    })
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+
+    fastify.inject({ url: '/child' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+  })
+})
+
+test('getDecorator should return function decorators with expected binded context', t => {
+  t.plan(12)
+  const fastify = Fastify()
+
+  fastify.decorate('a', function () {
+    return this
+  })
+  fastify.decorateRequest('b', function () {
+    return this
+  })
+  fastify.decorateReply('c', function () {
+    return this
+  })
+
+  fastify.register((child) => {
+    child.decorate('a', function () {
+      return this
+    })
+
+    t.same(child.getDecorator('a')(), child)
+    child.get('/child', async (req, res) => {
+      t.same(req.getDecorator('b')(), req)
+      t.same(res.getDecorator('c')(), res)
+
+      res.send()
+    })
+  })
+
+  t.same(fastify.getDecorator('a')(), fastify)
+  fastify.get('/', async (req, res) => {
+    t.same(req.getDecorator('b')(), req)
+    t.same(res.getDecorator('c')(), res)
+
+    res.send()
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+
+    fastify.inject({ url: '/child' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+
+    t.pass()
+  })
+})
+
+test('getDecorator should only return decorators existing in the scope', t => {
+  t.plan(9)
+
+  function assertsThrowOnUndeclaredDecorator (notDecorated, instanceType) {
+    try {
+      notDecorated.getDecorator('foo')
+      t.fail()
+    } catch (e) {
+      t.same(e.code, 'FST_ERR_DEC_UNDECLARED')
+      t.same(e.message, `No decorator 'foo' has been declared on ${instanceType}.`)
+    }
+  }
+
+  const fastify = Fastify()
+  fastify.register(child => {
+    child.decorate('foo', true)
+    child.decorateRequest('foo', true)
+    child.decorateReply('foo', true)
+  })
+
+  fastify.get('/', async (req, res) => {
+    assertsThrowOnUndeclaredDecorator(req, 'request')
+    assertsThrowOnUndeclaredDecorator(res, 'reply')
+
+    return { hello: 'world' }
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+
+    assertsThrowOnUndeclaredDecorator(fastify, 'instance')
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+  })
+})
+
+test('Request.setDecorator should update an existing decorator', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.decorateRequest('session', null)
+  fastify.decorateRequest('utility', null)
+  fastify.addHook('onRequest', async (req, reply) => {
+    req.setDecorator('session', { user: 'Jean' })
+    req.setDecorator('utility', function () {
+      return this
+    })
+    try {
+      req.setDecorator('foo', { user: 'Jean' })
+      t.fail()
+    } catch (e) {
+      t.same(e.code, 'FST_ERR_DEC_UNDECLARED')
+      t.same(e.message, "No decorator 'foo' has been declared on request.")
+    }
+  })
+
+  fastify.get('/', async (req, res) => {
+    t.strictSame(req.getDecorator('session'), { user: 'Jean' })
+    t.same(req.getDecorator('utility')(), req)
+
+    res.send()
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+  })
+})

package/test/fastify-instance.test.js

@@ -7,9 +7,12 @@ const os = require('node:os')
 const {
   kOptions,
   kErrorHandler,
-  kChildLoggerFactory
+  kChildLoggerFactory,
+  kState
 } = require('../lib/symbols')
 
+const isIPv6Missing = !Object.values(os.networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
+
 test('root fastify instance is an object', t => {
   t.plan(1)
   t.assert.strictEqual(typeof Fastify(), 'object')
@@ -279,7 +282,7 @@ test('fastify instance should contains listeningOrigin property (unix socket)',
   await fastify.close()
 })
 
-test('fastify instance should contains listeningOrigin property (IPv6)', async t => {
+test('fastify instance should contains listeningOrigin property (IPv6)', { skip: isIPv6Missing }, async t => {
   t.plan(1)
   const port = 3000
   const host = '::1'
@@ -288,3 +291,10 @@ test('fastify instance should contains listeningOrigin property (IPv6)', async t
   t.assert.deepStrictEqual(fastify.listeningOrigin, `http://[::1]:${port}`)
   await fastify.close()
 })
+
+test('fastify instance should ensure ready promise cleanup on ready', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  await fastify.ready()
+  t.assert.strictEqual(fastify[kState].readyPromise, null)
+})

package/test/hooks.on-listen.test.js

@@ -6,6 +6,9 @@ const fp = require('fastify-plugin')
 const split = require('split2')
 const helper = require('./helper')
 const { kState } = require('../lib/symbols')
+const { networkInterfaces } = require('node:os')
+
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
 
 let localhost
 before(async function () {
@@ -405,7 +408,7 @@ test('localhost onListen encapsulation should be called in order and should log
   })
 })
 
-test('non-localhost onListen should be called in order', t => {
+test('non-localhost onListen should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(2)
 
   const fastify = Fastify()
@@ -428,7 +431,7 @@ test('non-localhost onListen should be called in order', t => {
   })
 })
 
-test('non-localhost async onListen should be called in order', async t => {
+test('non-localhost async onListen should be called in order', { skip: isIPv6Missing }, async t => {
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -448,7 +451,7 @@ test('non-localhost async onListen should be called in order', async t => {
   })
 })
 
-test('non-localhost sync onListen should log errors as warnings and continue', t => {
+test('non-localhost sync onListen should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -488,7 +491,7 @@ test('non-localhost sync onListen should log errors as warnings and continue', t
   })
 })
 
-test('non-localhost async onListen should log errors as warnings and continue', async t => {
+test('non-localhost async onListen should log errors as warnings and continue', { skip: isIPv6Missing }, async t => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -529,7 +532,7 @@ test('non-localhost async onListen should log errors as warnings and continue',
   })
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin', t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
   t.plan(3)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -562,7 +565,7 @@ test('non-localhost Register onListen hook after a plugin inside a plugin', t =>
   })
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -608,7 +611,7 @@ test('non-localhost Register onListen hook after a plugin inside a plugin should
   })
 })
 
-test('non-localhost onListen encapsulation should be called in order', t => {
+test('non-localhost onListen encapsulation should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(6)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -640,7 +643,7 @@ test('non-localhost onListen encapsulation should be called in order', t => {
   })
 })
 
-test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', t => {
+test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(7)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -874,7 +877,7 @@ test('onListen localhost with callback encapsulation should be called in order',
   })
 })
 
-test('onListen non-localhost should work in order with callback in sync', t => {
+test('onListen non-localhost should work in order with callback in sync', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -896,7 +899,7 @@ test('onListen non-localhost should work in order with callback in sync', t => {
   })
 })
 
-test('onListen non-localhost should work in order with callback in async', t => {
+test('onListen non-localhost should work in order with callback in async', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -916,7 +919,7 @@ test('onListen non-localhost should work in order with callback in async', t =>
   })
 })
 
-test('onListen non-localhost sync with callback should log errors as warnings and continue', t => {
+test('onListen non-localhost sync with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -960,7 +963,7 @@ test('onListen non-localhost sync with callback should log errors as warnings an
   })
 })
 
-test('onListen non-localhost async with callback should log errors as warnings and continue', t => {
+test('onListen non-localhost async with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -1002,7 +1005,7 @@ test('onListen non-localhost async with callback should log errors as warnings a
   })
 })
 
-test('Register onListen hook non-localhost with callback after a plugin inside a plugin', t => {
+test('Register onListen hook non-localhost with callback after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
   t.plan(5)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -1035,7 +1038,7 @@ test('Register onListen hook non-localhost with callback after a plugin inside a
   })
 })
 
-test('onListen non-localhost with callback encapsulation should be called in order', t => {
+test('onListen non-localhost with callback encapsulation should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(8)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 84
+const expectedErrors = 85
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
@@ -21,6 +21,7 @@ test(`should expose ${expectedErrors} errors`, t => {
 
 test('ensure name and codes of Errors are identical', t => {
   t.plan(expectedErrors)
+
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -249,6 +250,16 @@ test('FST_ERR_DEC_REFERENCE_TYPE', t => {
   t.assert.ok(error instanceof Error)
 })
 
+test('FST_ERR_DEC_UNDECLARED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_DEC_UNDECLARED('myDecorator', 'request')
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_DEC_UNDECLARED')
+  t.assert.strictEqual(error.message, "No decorator 'myDecorator' has been declared on request.")
+  t.assert.strictEqual(error.statusCode, 500)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_HOOK_INVALID_TYPE', t => {
   t.plan(5)
   const error = new errors.FST_ERR_HOOK_INVALID_TYPE()
@@ -881,6 +892,7 @@ test('FST_ERR_ERROR_HANDLER_NOT_FN', t => {
 
 test('Ensure that all errors are in Errors.md TOC', t => {
   t.plan(expectedErrors)
+
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -918,6 +930,7 @@ test('Ensure that all errors are in Errors.md documented', t => {
 
 test('Ensure that non-existing errors are not in Errors.md documented', t => {
   t.plan(expectedErrors)
+
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = /<a id="[0-9a-zA-Z_]+">([0-9a-zA-Z_]+)<\/a>/g

package/test/listen.2.test.js

@@ -3,6 +3,9 @@
 const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
+const { networkInterfaces } = require('node:os')
+
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
 
 let localhostForURL
 
@@ -59,7 +62,7 @@ test('double listen errors callback with (err, address)', (t, done) => {
   })
 })
 
-test('nonlocalhost double listen errors callback with (err, address)', (t, done) => {
+test('nonlocalhost double listen errors callback with (err, address)', { skip: isIPv6Missing }, (t, done) => {
   t.plan(4)
   const fastify = Fastify()
   t.after(() => fastify.close())

package/test/server.test.js

@@ -2,6 +2,8 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
+const sget = require('simple-get').concat
+const undici = require('undici')
 
 test('listen should accept null port', async t => {
   const fastify = Fastify()
@@ -11,3 +13,176 @@ test('listen should accept null port', async t => {
     fastify.listen({ port: null })
   )
 })
+
+test('listen should accept undefined port', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({ port: undefined })
+  )
+})
+
+test('listen should accept stringified number port', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({ port: '1234' })
+  )
+})
+
+test('listen should accept log text resolution function', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({
+      host: '127.0.0.1',
+      port: '1234',
+      listenTextResolver: (address) => {
+        t.assert.strictEqual(address, 'http://127.0.0.1:1234')
+        return 'hardcoded text'
+      }
+    })
+  )
+})
+
+test('listen should reject string port', async (t) => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  try {
+    await fastify.listen({ port: 'hello-world' })
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'ERR_SOCKET_BAD_PORT')
+  }
+
+  try {
+    await fastify.listen({ port: '1234hello' })
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'ERR_SOCKET_BAD_PORT')
+  }
+})
+
+test('Test for hostname and port', (t, end) => {
+  const app = Fastify()
+  t.after(() => app.close())
+  app.get('/host', (req, res) => {
+    const host = 'localhost:8000'
+    t.assert.strictEqual(req.host, host)
+    t.assert.strictEqual(req.hostname, req.host.split(':')[0])
+    t.assert.strictEqual(req.port, Number(req.host.split(':')[1]))
+    res.send('ok')
+  })
+
+  app.listen({ port: 8000 }, () => {
+    sget('http://localhost:8000/host', () => { end() })
+  })
+})
+
+test('abort signal', async t => {
+  await t.test('listen should not start server', (t, end) => {
+    t.plan(2)
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      end()
+    }
+    const controller = new AbortController()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    fastify.listen({ port: 1234, signal: controller.signal }, (err) => {
+      t.assert.ifError(err)
+    })
+    controller.abort()
+    t.assert.strictEqual(fastify.server.listening, false)
+  })
+
+  await t.test('listen should not start server if already aborted', (t, end) => {
+    t.plan(2)
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      end()
+    }
+
+    const controller = new AbortController()
+    controller.abort()
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    fastify.listen({ port: 1234, signal: controller.signal }, (err) => {
+      t.assert.ifError(err)
+    })
+    t.assert.strictEqual(fastify.server.listening, false)
+  })
+
+  await t.test('listen should throw if received invalid signal', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    try {
+      fastify.listen({ port: 1234, signal: {} }, (err) => {
+        t.assert.ifError(err)
+      })
+      t.assert.fail('should throw')
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_LISTEN_OPTIONS_INVALID')
+      t.assert.strictEqual(e.message, 'Invalid listen options: \'Invalid options.signal\'')
+    }
+  })
+})
+
+test('#5180 - preClose should be called before closing secondary server', async (t) => {
+  t.plan(2)
+  const fastify = Fastify({ forceCloseConnections: true })
+  let flag = false
+  t.after(() => fastify.close())
+
+  fastify.addHook('preClose', () => {
+    flag = true
+  })
+
+  fastify.get('/', async (req, reply) => {
+    // request will be pending for 1 second to simulate a slow request
+    await new Promise((resolve) => { setTimeout(resolve, 1000) })
+    return { hello: 'world' }
+  })
+
+  fastify.listen({ port: 0 }, (err) => {
+    t.assert.ifError(err)
+    const addresses = fastify.addresses()
+    const mainServerAddress = fastify.server.address()
+    let secondaryAddress
+    for (const addr of addresses) {
+      if (addr.family !== mainServerAddress.family) {
+        secondaryAddress = addr
+        secondaryAddress.address = secondaryAddress.family === 'IPv6'
+          ? `[${secondaryAddress.address}]`
+          : secondaryAddress.address
+        break
+      }
+    }
+
+    if (!secondaryAddress) {
+      t.assert.ok(true, 'Secondary address not found')
+      return
+    }
+
+    undici.request(`http://${secondaryAddress.address}:${secondaryAddress.port}/`)
+      .then(
+        () => { t.assert.fail('Request should not succeed') },
+        () => {
+          t.assert.ok(flag)
+        }
+      )
+
+    // Close the server while the slow request is pending
+    setTimeout(fastify.close, 250)
+  })
+
+  // Wait 1000ms to ensure that the test is finished and async operations are
+  // completed
+  await new Promise((resolve) => { setTimeout(resolve, 1000) })
+})

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

@@ -522,6 +522,9 @@ expectError(server.decorateReply('typedTestReplyMethod', async function (x) {
   return 'foo'
 }))
 
+const foo = server.getDecorator<string>('foo')
+expectType<string>(foo)
+
 const versionConstraintStrategy = {
   name: 'version',
   storage: () => ({

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

@@ -45,6 +45,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectAssignable<((input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpStatus?: string) => unknown)>(reply.serializeInput)
   expectAssignable<((input: { [key: string]: unknown }, httpStatus: string) => unknown)>(reply.serializeInput)
   expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(reply.routeOptions.config)
+  expectType<string>(reply.getDecorator<string>('foo'))
 }
 
 interface ReplyPayload {

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

@@ -92,6 +92,10 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectAssignable<(schema: { [key: string]: unknown }) => ExpectedGetValidationFunction>(request.getValidationFunction)
   expectAssignable<(input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
   expectAssignable<(input: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
+  expectType<string>(request.getDecorator<string>('foo'))
+  expectType<void>(request.setDecorator('foo', 'hello'))
+  expectType<void>(request.setDecorator<string>('foo', 'hello'))
+  expectError(request.setDecorator<string>('foo', true))
 }
 
 const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, CustomLoggerInterface> = function (request, _reply) {

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

@@ -1009,6 +1009,46 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply:
   }
 ))
 
+// -------------------------------------------------------------------
+// RouteGeneric Reply Type Return (Different Status Codes)
+// -------------------------------------------------------------------
+
+expectAssignable(server.get<{
+  Reply: {
+    200: string | { msg: string }
+    400: number
+    '5xx': { error: string }
+  }
+}>(
+  '/',
+  async (_, res) => {
+    const option = 1 as 1 | 2 | 3 | 4
+    switch (option) {
+      case 1: return 'hello'
+      case 2: return { msg: 'hello' }
+      case 3: return 400
+      case 4: return { error: 'error' }
+    }
+  }
+))
+
+// -------------------------------------------------------------------
+// RouteGeneric Reply Type Return: Non Assignable (Different Status Codes)
+// -------------------------------------------------------------------
+
+expectError(server.get<{
+  Reply: {
+    200: string | { msg: string }
+    400: number
+    '5xx': { error: string }
+  }
+}>(
+  '/',
+  async (_, res) => {
+    return true
+  }
+))
+
 // -------------------------------------------------------------------
 // FastifyPlugin: Auxiliary
 // -------------------------------------------------------------------