fastify 4.20.0 → 4.22.0

package/docs/Reference/TypeScript.md

@@ -788,7 +788,7 @@ There are a couple supported import methods with the Fastify type system.
 Many type definitions share the same generic parameters; they are all
 documented, in detail, within this section.
 
-Most definitions depend on `@node/types` modules `http`, `https`, and `http2`
+Most definitions depend on `@types/node` modules `http`, `https`, and `http2`
 
 ##### RawServer
 Underlying Node.js server type

package/docs/Reference/Validation-and-Serialization.md

@@ -397,7 +397,7 @@ configuration](https://github.com/fastify/ajv-compiler#ajv-configuration) is:
 {
   coerceTypes: 'array', // change data type of data to match type keyword
   useDefaults: true, // replace missing properties and items with the values from corresponding default keyword
-  removeAdditional: true, // remove additional properties
+  removeAdditional: true, // remove additional properties if additionalProperties is set to false, see: https://ajv.js.org/guide/modifying-data.html#removing-additional-properties
   uriResolver: require('fast-uri'),
   addUsedSchema: false,
   // Explicitly set allErrors to `false`.

package/fastify.d.ts

@@ -20,15 +20,15 @@ import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './type
 import { FastifyReply } from './types/reply'
 import { FastifyRequest, RequestGenericInterface } from './types/request'
 import { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface } from './types/route'
-import { FastifySchema, FastifySchemaCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
+import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
 import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/serverFactory'
 import { FastifyTypeProvider, FastifyTypeProviderDefault } from './types/type-provider'
 import { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
 
 declare module '@fastify/error' {
   interface FastifyError {
-    validation?: fastify.ValidationResult[];
     validationContext?: SchemaErrorDataVar;
+    validation?: FastifySchemaValidationError[];
   }
 }
 
@@ -162,13 +162,10 @@ declare namespace fastify {
     clientErrorHandler?: (error: ConnectionError, socket: Socket) => void,
   }
 
-  export interface ValidationResult {
-    keyword: string;
-    instancePath: string;
-    schemaPath: string;
-    params: Record<string, string | string[]>;
-    message?: string;
-  }
+  /**
+   * @deprecated use {@link FastifySchemaValidationError}
+   */
+  export type ValidationResult = FastifySchemaValidationError;
 
   /* Export additional types */
   export type {
@@ -241,4 +238,4 @@ declare function fastify<
 
 // CJS export
 // const fastify = require('fastify')
-export = fastify
+export = fastify

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.20.0'
+const VERSION = '4.22.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -241,7 +241,7 @@ function fastify (options) {
     [kReply]: Reply.buildReply(Reply),
     [kRequest]: Request.buildRequest(Request, options.trustProxy),
     [kFourOhFour]: fourOhFour,
-    [pluginUtils.registeredPlugins]: [],
+    [pluginUtils.kRegisteredPlugins]: [],
     [kPluginNameChain]: ['fastify'],
     [kAvvioBoot]: null,
     // routing method
@@ -312,7 +312,7 @@ function fastify (options) {
     close: null,
     printPlugins: null,
     hasPlugin: function (name) {
-      return this[kPluginNameChain].includes(name)
+      return this[pluginUtils.kRegisteredPlugins].includes(name) || this[kPluginNameChain].includes(name)
     },
     // http server
     listen,

package/lib/contentTypeParser.js

@@ -226,8 +226,11 @@ function rawBody (request, reply, options, parser, done) {
 
   function onData (chunk) {
     receivedLength += chunk.length
-
-    if ((payload.receivedEncodedLength || receivedLength) > limit) {
+    const { receivedEncodedLength = 0 } = payload
+    // The resulting body length must not exceed bodyLimit (see "zip bomb").
+    // The case when encoded length is larger than received length is rather theoretical,
+    // unless the stream returned by preParsing hook is broken and reports wrong value.
+    if (receivedLength > limit || receivedEncodedLength > limit) {
       payload.removeListener('data', onData)
       payload.removeListener('end', onEnd)
       payload.removeListener('error', onEnd)

package/lib/error-serializer.js

@@ -16,41 +16,43 @@
 ) {
 
     
-    function anonymous0 (input) {
-      // #
   
+    // #
+    function anonymous0 (input) {
       const obj = (input && typeof input.toJSON === 'function')
     ? input.toJSON()
     : input
   
-      let json = '{'
-      let addComma = false
+      
+    let addComma = false
+    let json = '{'
+  
+        if (obj["statusCode"] !== undefined) {
+          !addComma && (addComma = true) || (json += ',')
+          json += "\"statusCode\":"
+          json += serializer.asNumber(obj["statusCode"])
+        }
+        
+        if (obj["code"] !== undefined) {
+          !addComma && (addComma = true) || (json += ',')
+          json += "\"code\":"
+          json += serializer.asString(obj["code"])
+        }
+        
+        if (obj["error"] !== undefined) {
+          !addComma && (addComma = true) || (json += ',')
+          json += "\"error\":"
+          json += serializer.asString(obj["error"])
+        }
+        
+        if (obj["message"] !== undefined) {
+          !addComma && (addComma = true) || (json += ',')
+          json += "\"message\":"
+          json += serializer.asString(obj["message"])
+        }
+        
+  return json + '}'
   
-      if (obj["statusCode"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
-        json += "\"statusCode\":"
-      json += serializer.asNumber(obj["statusCode"])
-      }
-    
-      if (obj["code"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
-        json += "\"code\":"
-      json += serializer.asString(obj["code"])
-      }
-    
-      if (obj["error"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
-        json += "\"error\":"
-      json += serializer.asString(obj["error"])
-      }
-    
-      if (obj["message"] !== undefined) {
-        !addComma && (addComma = true) || (json += ',')
-        json += "\"message\":"
-      json += serializer.asString(obj["message"])
-      }
-    
-      return json + '}'
     }
   
     const main = anonymous0

package/lib/errors.js

@@ -214,7 +214,7 @@ const codes = {
   ),
   FST_ERR_REP_ALREADY_SENT: createError(
     'FST_ERR_REP_ALREADY_SENT',
-    'Reply was already sent.'
+    'Reply was already sent, did you forget to "return reply" in "%s" (%s)?'
   ),
   FST_ERR_REP_SENT_VALUE: createError(
     'FST_ERR_REP_SENT_VALUE',

package/lib/pluginOverride.js

@@ -27,9 +27,10 @@ const pluginUtils = require('./pluginUtils')
 module.exports = function override (old, fn, opts) {
   const shouldSkipOverride = pluginUtils.registerPlugin.call(old, fn)
 
+  const fnName = pluginUtils.getPluginName(fn) || pluginUtils.getFuncPreview(fn)
   if (shouldSkipOverride) {
     // after every plugin registration we will enter a new name
-    old[kPluginNameChain].push(pluginUtils.getDisplayName(fn))
+    old[kPluginNameChain].push(fnName)
     return old
   }
 
@@ -48,8 +49,14 @@ module.exports = function override (old, fn, opts) {
   instance[kSchemaController] = SchemaController.buildSchemaController(old[kSchemaController])
   instance.getSchema = instance[kSchemaController].getSchema.bind(instance[kSchemaController])
   instance.getSchemas = instance[kSchemaController].getSchemas.bind(instance[kSchemaController])
-  instance[pluginUtils.registeredPlugins] = Object.create(instance[pluginUtils.registeredPlugins])
-  instance[kPluginNameChain] = [pluginUtils.getPluginName(fn) || pluginUtils.getFuncPreview(fn)]
+
+  // Track the registered and loaded plugins since the root instance.
+  // It does not track the current encapsulated plugin.
+  instance[pluginUtils.kRegisteredPlugins] = Object.create(instance[pluginUtils.kRegisteredPlugins])
+
+  // Track the plugin chain since the root instance.
+  // When an non-encapsulated plugin is added, the chain will be updated.
+  instance[kPluginNameChain] = [fnName]
 
   if (instance[kLogSerializers] || opts.logSerializers) {
     instance[kLogSerializers] = Object.assign(Object.create(instance[kLogSerializers]), opts.logSerializers)

package/lib/pluginUtils.js

@@ -2,7 +2,7 @@
 
 const semver = require('semver')
 const assert = require('assert')
-const registeredPlugins = Symbol.for('registered-plugin')
+const kRegisteredPlugins = Symbol.for('registered-plugin')
 const {
   kTestInternals
 } = require('./symbols.js')
@@ -25,12 +25,15 @@ function getPluginName (func) {
   // let's see if this is a file, and in that case use that
   // this is common for plugins
   const cache = require.cache
-  const keys = Object.keys(cache)
-
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i]
-    if (cache[key].exports === func) {
-      return key
+  // cache is undefined inside SEA
+  if (cache) {
+    const keys = Object.keys(cache)
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      if (cache[key].exports === func) {
+        return key
+      }
     }
   }
 
@@ -65,7 +68,7 @@ function checkDependencies (fn) {
 
   dependencies.forEach(dependency => {
     assert(
-      this[registeredPlugins].indexOf(dependency) > -1,
+      this[kRegisteredPlugins].indexOf(dependency) > -1,
       `The dependency '${dependency}' of plugin '${meta.name}' is not registered`
     )
   })
@@ -128,7 +131,7 @@ function registerPluginName (fn) {
 
   const name = meta.name
   if (!name) return
-  this[registeredPlugins].push(name)
+  this[kRegisteredPlugins].push(name)
 }
 
 function registerPlugin (fn) {
@@ -142,7 +145,7 @@ function registerPlugin (fn) {
 module.exports = {
   getPluginName,
   getFuncPreview,
-  registeredPlugins,
+  kRegisteredPlugins,
   getDisplayName,
   registerPlugin
 }

package/lib/reply.js

@@ -97,7 +97,7 @@ Object.defineProperties(Reply.prototype, {
 
       // We throw only if sent was overwritten from Fastify
       if (this.sent && this[kReplyHijacked]) {
-        throw new FST_ERR_REP_ALREADY_SENT()
+        throw new FST_ERR_REP_ALREADY_SENT(this.request.url, this.request.method)
       }
 
       this[kReplyHijacked] = true
@@ -124,7 +124,7 @@ Reply.prototype.send = function (payload) {
   }
 
   if (this.sent) {
-    this.log.warn({ err: new FST_ERR_REP_ALREADY_SENT() }, 'Reply already sent')
+    this.log.warn({ err: new FST_ERR_REP_ALREADY_SENT(this.request.url, this.request.method) })
     return this
   }
 
@@ -539,6 +539,18 @@ function wrapOnSendEnd (err, request, reply, payload) {
   }
 }
 
+function safeWriteHead (reply, statusCode) {
+  const res = reply.raw
+  try {
+    res.writeHead(statusCode, reply[kReplyHeaders])
+  } catch (err) {
+    if (err.code === 'ERR_HTTP_HEADERS_SENT') {
+      reply.log.warn(`Reply was already sent, did you forget to "return reply" in the "${reply.request.raw.url}" (${reply.request.raw.method}) route?`)
+    }
+    throw err
+  }
+}
+
 function onSendEnd (reply, payload) {
   const res = reply.raw
   const req = reply.request
@@ -569,7 +581,7 @@ function onSendEnd (reply, payload) {
       reply[kReplyHeaders]['content-length'] = '0'
     }
 
-    res.writeHead(statusCode, reply[kReplyHeaders])
+    safeWriteHead(reply, statusCode)
     sendTrailer(payload, res, reply)
     return
   }
@@ -594,7 +606,7 @@ function onSendEnd (reply, payload) {
     }
   }
 
-  res.writeHead(statusCode, reply[kReplyHeaders])
+  safeWriteHead(reply, statusCode)
   // write payload first
   res.write(payload)
   // then send trailers

package/lib/wrapThenable.js

@@ -18,7 +18,10 @@ function wrapThenable (thenable, reply) {
     // the request may be terminated during the reply. in this situation,
     // it require an extra checking of request.aborted to see whether
     // the request is killed by client.
-    if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false)) {
+    // Most of the times aborted will be true when destroyed is true,
+    // however there is a race condition where the request is not
+    // aborted but only destroyed.
+    if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false && reply.request.raw.destroyed === false)) {
       // we use a try-catch internally to avoid adding a catch to another
       // promise, increase promise perf by 10%
       try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.20.0",
+  "version": "4.22.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -11,14 +11,14 @@
     "benchmark:parser": "npx concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"npx autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -m POST localhost:3000/\"",
     "build:validation": "node build/build-error-serializer.js && node build/build-validation.js",
     "coverage": "npm run unit -- --coverage-report=html",
-    "coverage:ci": "npm run unit -- --coverage-report=html --no-browser --no-check-coverage",
+    "coverage:ci": "c8 --reporter=lcov tap --coverage-report=html --no-browser --no-check-coverage",
     "coverage:ci-check-coverage": "c8 check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
-    "license-checker": "license-checker --production --onlyAllow=\"MIT;ISC;BSD-3-Clause;BSD-2-Clause\"",
     "lint": "npm run lint:standard && npm run lint:typescript && npm run lint:markdown",
-    "lint:fix": "standard --fix",
+    "lint:fix": "standard --fix && npm run lint:typescript:fix",
     "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
+    "lint:typescript:fix": "npm run lint:typescript -- --fix",
     "prepublishOnly": "cross-env PREPUBLISH=true tap --no-check-coverage test/build/**.test.js && npm run test:validator:integrity",
     "test": "npm run lint && npm run unit && npm run test:typescript",
     "test:ci": "npm run unit -- --cov --coverage-report=lcovonly && npm run test:typescript",
@@ -134,11 +134,11 @@
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.29.1",
+    "@sinclair/typebox": "^0.31.1",
     "@sinonjs/fake-timers": "^11.0.0",
     "@types/node": "^20.1.0",
-    "@typescript-eslint/eslint-plugin": "^5.59.2",
-    "@typescript-eslint/parser": "^5.59.2",
+    "@typescript-eslint/eslint-plugin": "^6.3.0",
+    "@typescript-eslint/parser": "^6.3.0",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
     "ajv-formats": "^2.1.1",
@@ -162,10 +162,8 @@
     "joi": "^17.9.2",
     "json-schema-to-ts": "^2.9.1",
     "JSONStream": "^1.3.5",
-    "license-checker": "^25.0.1",
     "markdownlint-cli2": "^0.8.1",
     "proxyquire": "^2.1.3",
-    "pump": "^3.0.0",
     "self-cert": "^2.0.0",
     "send": "^0.18.0",
     "simple-get": "^4.0.1",

package/test/async-await.test.js

@@ -124,7 +124,7 @@ test('ignore the result of the promise if reply.send is called beforehand (objec
 })
 
 test('server logs an error if reply.send is called and a value is returned via async/await', t => {
-  const lines = ['incoming request', 'request completed', 'Reply already sent']
+  const lines = ['incoming request', 'request completed', 'Reply was already sent, did you forget to "return reply" in "/" (GET)?']
   t.plan(lines.length + 2)
 
   const splitStream = split(JSON.parse)

package/test/bodyLimit.test.js

@@ -2,6 +2,7 @@
 
 const Fastify = require('..')
 const sget = require('simple-get').concat
+const zlib = require('zlib')
 const t = require('tap')
 const test = t.test
 
@@ -45,6 +46,74 @@ test('bodyLimit', t => {
   })
 })
 
+test('bodyLimit is applied to decoded content', t => {
+  t.plan(9)
+
+  const body = { x: 'x'.repeat(30000) }
+  const json = JSON.stringify(body)
+  const encoded = zlib.gzipSync(json)
+
+  const fastify = Fastify()
+
+  fastify.addHook('preParsing', async (req, reply, payload) => {
+    t.equal(req.headers['content-length'], `${encoded.length}`)
+    const unzip = zlib.createGunzip()
+    Object.defineProperty(unzip, 'receivedEncodedLength', {
+      get () {
+        return unzip.bytesWritten
+      }
+    })
+    payload.pipe(unzip)
+    return unzip
+  })
+
+  fastify.post('/body-limit-40k', {
+    bodyLimit: 40000,
+    onError: async (req, res, err) => {
+      t.fail('should not be called')
+    }
+  }, (request, reply) => {
+    reply.send({ x: request.body.x })
+  })
+
+  fastify.post('/body-limit-20k', {
+    bodyLimit: 20000,
+    onError: async (req, res, err) => {
+      t.equal(err.code, 'FST_ERR_CTP_BODY_TOO_LARGE')
+      t.equal(err.statusCode, 413)
+    }
+  }, (request, reply) => {
+    reply.send({ x: 'handler should not be called' })
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/body-limit-40k',
+    headers: {
+      'content-encoding': 'gzip',
+      'content-type': 'application/json'
+    },
+    payload: encoded
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.same(res.json(), body)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/body-limit-20k',
+    headers: {
+      'content-encoding': 'gzip',
+      'content-type': 'application/json'
+    },
+    payload: encoded
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 413)
+  })
+})
+
 test('default request.routeOptions.bodyLimit should be 1048576', t => {
   t.plan(4)
   const fastify = Fastify()

package/test/custom-http-server.test.js

@@ -10,8 +10,9 @@ const dns = require('dns').promises
 
 test('Should support a custom http server', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
+  const minPlan = localAddresses.length - 1 || 1
 
-  t.plan((localAddresses.length - 1) + 3)
+  t.plan(minPlan + 3)
 
   const serverFactory = (handler, opts) => {
     t.ok(opts.serverFactory, 'it is called once for localhost')

package/test/https/custom-https-server.test.js

@@ -12,8 +12,9 @@ t.before(buildCertificate)
 
 test('Should support a custom https server', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
+  const minPlan = localAddresses.length - 1 || 1
 
-  t.plan((localAddresses.length - 1) + 3)
+  t.plan(minPlan + 3)
 
   const serverFactory = (handler, opts) => {
     t.ok(opts.serverFactory, 'it is called once for localhost')

package/test/internals/errors.test.js

@@ -339,10 +339,10 @@ test('FST_ERR_REP_INVALID_PAYLOAD_TYPE', t => {
 
 test('FST_ERR_REP_ALREADY_SENT', t => {
   t.plan(5)
-  const error = new errors.FST_ERR_REP_ALREADY_SENT()
+  const error = new errors.FST_ERR_REP_ALREADY_SENT('/hello', 'GET')
   t.equal(error.name, 'FastifyError')
   t.equal(error.code, 'FST_ERR_REP_ALREADY_SENT')
-  t.equal(error.message, 'Reply was already sent.')
+  t.equal(error.message, 'Reply was already sent, did you forget to "return reply" in "/hello" (GET)?')
   t.equal(error.statusCode, 500)
   t.ok(error instanceof Error)
 })

package/test/internals/plugin.test.js

@@ -29,6 +29,21 @@ test('getPluginName should return plugin name if the file is cached', t => {
   t.equal(pluginName, expectedPluginName)
 })
 
+test('getPluginName should not throw when require.cache is undefined', t => {
+  t.plan(1)
+  function example () {
+    console.log('is just an example')
+  }
+  const cache = require.cache
+  require.cache = undefined
+  t.teardown(() => {
+    require.cache = cache
+  })
+  const pluginName = pluginUtilsPublic.getPluginName(example)
+
+  t.equal(pluginName, 'example')
+})
+
 test("getMeta should return the object stored with the 'plugin-meta' symbol", t => {
   t.plan(1)
 
@@ -122,7 +137,7 @@ test('checkDependencies should check if the given dependency is present in the i
   }
 
   function context () {}
-  context[pluginUtilsPublic.registeredPlugins] = ['plugin']
+  context[pluginUtilsPublic.kRegisteredPlugins] = ['plugin']
 
   try {
     pluginUtils.checkDependencies.call(context, fn)
@@ -143,7 +158,7 @@ test('checkDependencies should check if the given dependency is present in the i
   }
 
   function context () {}
-  context[pluginUtilsPublic.registeredPlugins] = []
+  context[pluginUtilsPublic.kRegisteredPlugins] = []
 
   try {
     pluginUtils.checkDependencies.call(context, fn)

package/test/internals/reply.test.js

@@ -1508,7 +1508,7 @@ test('should throw error when passing falsy value to reply.sent', t => {
 })
 
 test('should throw error when attempting to set reply.sent more than once', t => {
-  t.plan(4)
+  t.plan(3)
   const fastify = Fastify()
 
   fastify.get('/', function (req, reply) {
@@ -1518,7 +1518,6 @@ test('should throw error when attempting to set reply.sent more than once', t =>
       t.fail('must throw')
     } catch (err) {
       t.equal(err.code, 'FST_ERR_REP_ALREADY_SENT')
-      t.equal(err.message, 'Reply was already sent.')
     }
     reply.raw.end()
   })
@@ -2088,3 +2087,35 @@ test('invalid response headers and custom error handler', async t => {
 
   await fastify.close()
 })
+
+test('reply.send will intercept ERR_HTTP_HEADERS_SENT and log an error message', t => {
+  t.plan(2)
+
+  const response = new Writable()
+  Object.assign(response, {
+    setHeader: () => {},
+    hasHeader: () => false,
+    getHeader: () => undefined,
+    writeHead: () => {
+      const err = new Error('kaboom')
+      err.code = 'ERR_HTTP_HEADERS_SENT'
+      throw err
+    },
+    write: () => {},
+    headersSent: true
+  })
+
+  const log = {
+    warn: (msg) => {
+      t.equal(msg, 'Reply was already sent, did you forget to "return reply" in the "/hello" (GET) route?')
+    }
+  }
+
+  const reply = new Reply(response, { [kRouteContext]: { onSend: null }, raw: { url: '/hello', method: 'GET' } }, log)
+
+  try {
+    reply.send('')
+  } catch (err) {
+    t.equal(err.code, 'ERR_HTTP_HEADERS_SENT')
+  }
+})

package/test/plugin.test.js

@@ -1247,3 +1247,29 @@ test('hasPlugin returns true when using no encapsulation', async t => {
 
   await fastify.ready()
 })
+
+test('hasPlugin returns true when using encapsulation', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  const pluginCallback = function (server, options, done) {
+    done()
+  }
+  const pluginName = 'awesome-plugin'
+  const plugin = fp(pluginCallback, { name: pluginName })
+
+  fastify.register(plugin)
+
+  fastify.register(async (server) => {
+    t.ok(server.hasPlugin(pluginName))
+  })
+
+  fastify.register(async function foo (server) {
+    server.register(async function bar (server) {
+      t.ok(server.hasPlugin(pluginName))
+    })
+  })
+
+  await fastify.ready()
+})

package/test/serial/logger.0.test.js

@@ -519,7 +519,12 @@ t.test('test log stream', (t) => {
   })
 
   t.test('reply.send logs an error if called twice in a row', async (t) => {
-    const lines = ['incoming request', 'request completed', 'Reply already sent', 'Reply already sent']
+    const lines = [
+      'incoming request',
+      'request completed',
+      'Reply was already sent, did you forget to "return reply" in "/" (GET)?',
+      'Reply was already sent, did you forget to "return reply" in "/" (GET)?'
+    ]
     t.plan(lines.length + 1)
 
     const stream = split(JSON.parse)