fastify 5.8.5 → 5.9.0

package/fastify.d.ts

@@ -6,7 +6,7 @@ import { Socket } from 'node:net'
 import { BuildCompilerFromPool, ValidatorFactory } from '@fastify/ajv-compiler'
 import { FastifyError } from '@fastify/error'
 import { Options as FJSOptions, SerializerFactory } from '@fastify/fast-json-stringify-compiler'
-import { Config as FindMyWayConfig, ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { ConstraintStrategy, Config as FindMyWayConfig, HTTPVersion } from 'find-my-way'
 import { InjectOptions, CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, Response as LightMyRequestResponse } from 'light-my-request'
 
 import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, FastifyContentTypeParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction } from './types/content-type-parser'
@@ -28,7 +28,7 @@ import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './type
 import { FastifyReply } from './types/reply'
 import { FastifyRequest, RequestGenericInterface } from './types/request'
 import { RouteGenericInterface, RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
-import { FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
+import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
 import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/server-factory'
 import { FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike } from './types/type-provider'
 import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './types/utils'
@@ -90,7 +90,7 @@ declare namespace fastify {
 
   type TrustProxyFunction = (address: string, hop: number) => boolean
 
-  export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'querystringParser'> & {
+  export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'onMaxParamLength' | 'querystringParser'> & {
     defaultRoute?: (
       req: RawRequestDefaultExpression<RawServer>,
       res: RawReplyDefaultExpression<RawServer>
@@ -100,6 +100,11 @@ declare namespace fastify {
       req: RawRequestDefaultExpression<RawServer>,
       res: RawReplyDefaultExpression<RawServer>
     ) => void,
+    onMaxParamLength?: (
+      path: string,
+      req: RawRequestDefaultExpression<RawServer>,
+      res: RawReplyDefaultExpression<RawServer>
+    ) => void,
     querystringParser?: (str: string) => { [key: string]: unknown }
   }
 

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.8.5'
+const VERSION = '5.9.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -63,6 +63,7 @@ const { defaultInitOptions } = getSecuredInitialConfig
 const {
   FST_ERR_ASYNC_CONSTRAINT,
   FST_ERR_BAD_URL,
+  FST_ERR_MAX_PARAM_LENGTH,
   FST_ERR_OPTIONS_NOT_OBJ,
   FST_ERR_QSP_NOT_FN,
   FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN,
@@ -92,7 +93,7 @@ function fastify (serverOptions) {
     disableRequestLogging,
     hasLogger,
     initialConfig
-  } = processOptions(serverOptions, defaultRoute, onBadUrl)
+  } = processOptions(serverOptions, defaultRoute, onBadUrl, onMaxParamLength)
 
   // Default router
   const router = buildRouting(options.routerOptions)
@@ -381,8 +382,7 @@ function fastify (serverOptions) {
       hookRunnerApplication('preClose', fastify[kAvvioBoot], fastify, function () {
         if (fastify[kState].listening) {
           /* istanbul ignore next: Cannot test this without Node.js core support */
-          if (forceCloseConnections === 'idle') {
-            // Not needed in Node 19
+          if (forceCloseConnections === 'idle' && options.serverFactory) {
             instance.server.closeIdleConnections()
             /* istanbul ignore next: Cannot test this without Node.js core support */
           } else if (serverHasCloseAllConnections && forceCloseConnections) {
@@ -423,8 +423,8 @@ function fastify (serverOptions) {
     })
   })
 
-  // Create bad URL context
-  const onBadUrlContext = new Context({
+  // Create route event (bad URL, max param length, etc) context
+  const routeEventContext = new Context({
     server: fastify,
     config: {}
   })
@@ -637,10 +637,10 @@ function fastify (serverOptions) {
 
   function onBadUrl (path, req, res) {
     if (options.frameworkErrors) {
-      const id = getGenReqId(onBadUrlContext.server, req)
-      const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
+      const id = getGenReqId(routeEventContext.server, req)
+      const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
 
-      const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+      const request = new Request(id, null, req, null, childLogger, routeEventContext)
       const reply = new Reply(res, request, childLogger)
 
       const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
@@ -663,15 +663,43 @@ function fastify (serverOptions) {
     res.end(body)
   }
 
+  function onMaxParamLength (path, req, res) {
+    if (options.frameworkErrors) {
+      const id = getGenReqId(routeEventContext.server, req)
+      const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
+
+      const request = new Request(id, null, req, null, childLogger, routeEventContext)
+      const reply = new Reply(res, request, childLogger)
+
+      const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
+      if (resolvedDisableRequestLogging === false) {
+        childLogger.info({ req: request }, 'incoming request')
+      }
+
+      return options.frameworkErrors(new FST_ERR_MAX_PARAM_LENGTH(path), request, reply)
+    }
+    const body = JSON.stringify({
+      error: 'Bad Request',
+      code: 'FST_ERR_MAX_PARAM_LENGTH',
+      message: `'${path}' is exceeding the max param length`,
+      statusCode: 414
+    })
+    res.writeHead(414, {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body)
+    })
+    res.end(body)
+  }
+
   function buildAsyncConstraintCallback (isAsync, req, res) {
     if (isAsync === false) return undefined
     return function onAsyncConstraintError (err) {
       if (err) {
         if (options.frameworkErrors) {
-          const id = getGenReqId(onBadUrlContext.server, req)
-          const childLogger = createChildLogger(onBadUrlContext, options.logger, req, id)
+          const id = getGenReqId(routeEventContext.server, req)
+          const childLogger = createChildLogger(routeEventContext, options.logger, req, id)
 
-          const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
+          const request = new Request(id, null, req, null, childLogger, routeEventContext)
           const reply = new Reply(res, request, childLogger)
 
           const resolvedDisableRequestLogging = typeof disableRequestLogging === 'function' ? disableRequestLogging(req) : disableRequestLogging
@@ -748,7 +776,7 @@ function fastify (serverOptions) {
     if (!options.allowErrorHandlerOverride && this[kErrorHandlerAlreadySet]) {
       throw new FST_ERR_ERROR_HANDLER_ALREADY_SET()
     } else if (this[kErrorHandlerAlreadySet]) {
-      FSTWRN004("To disable this behavior, set 'allowErrorHandlerOverride' to false or ignore this message. For more information, visit: https://fastify.dev/docs/latest/Reference/Server/#allowerrorhandleroverride")
+      FSTWRN004()
     }
 
     this[kErrorHandlerAlreadySet] = true
@@ -821,7 +849,7 @@ function fastify (serverOptions) {
   }
 }
 
-function processOptions (options, defaultRoute, onBadUrl) {
+function processOptions (options, defaultRoute, onBadUrl, onMaxParamLength) {
   // Options validations
   if (options && typeof options !== 'object') {
     throw new FST_ERR_OPTIONS_NOT_OBJ()
@@ -890,6 +918,7 @@ function processOptions (options, defaultRoute, onBadUrl) {
   options.routerOptions = buildRouterOptions(options, {
     defaultRoute,
     onBadUrl,
+    onMaxParamLength,
     ignoreTrailingSlash: defaultInitOptions.ignoreTrailingSlash,
     ignoreDuplicateSlashes: defaultInitOptions.ignoreDuplicateSlashes,
     maxParamLength: defaultInitOptions.maxParamLength,

package/lib/content-type-parser.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { AsyncResource } = require('node:async_hooks')
-const { FifoMap: Fifo } = require('toad-cache')
+const { FifoMap: Fifo, LruMap: Lru } = require('toad-cache')
 const { parse: secureJsonParse } = require('secure-json-parse')
 const ContentType = require('./content-type')
 const {
@@ -39,6 +39,15 @@ function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning)
   this.parserList = ['application/json', 'text/plain']
   this.parserRegExpList = []
   this.cache = new Fifo(100)
+  this.ctCache = new Lru(100)
+}
+
+ContentTypeParser.prototype.getContentType = function (raw) {
+  let ct = this.ctCache.get(raw)
+  if (ct !== undefined) return ct
+  ct = new ContentType(raw)
+  this.ctCache.set(raw, ct)
+  return ct
 }
 
 ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
@@ -118,6 +127,8 @@ ContentTypeParser.prototype.existingParser = function (contentType) {
 
 ContentTypeParser.prototype.getParser = function (contentType) {
   if (typeof contentType === 'string') {
+    const cached = this.cache.get(contentType)
+    if (cached !== undefined) return cached
     contentType = new ContentType(contentType)
   }
   const ct = contentType.toString()
@@ -158,6 +169,7 @@ ContentTypeParser.prototype.removeAll = function () {
   this.parserRegExpList = []
   this.parserList = []
   this.cache = new Fifo(100)
+  this.ctCache = new Lru(100)
 }
 
 ContentTypeParser.prototype.remove = function (contentType) {

package/lib/decorate.js

@@ -47,7 +47,7 @@ function getInstanceDecorator (name) {
 
 function decorateConstructor (konstructor, name, fn, dependencies) {
   const instance = konstructor.prototype
-  if (Object.hasOwn(instance, name) || hasKey(konstructor, name)) {
+  if (Object.hasOwn(instance, name) || hasKey(konstructor, name) || hasInstanceProperty(konstructor, name)) {
     throw new FST_ERR_DEC_ALREADY_PRESENT(name)
   }
 
@@ -87,19 +87,27 @@ function checkExistence (instance, name) {
 }
 
 function hasKey (fn, name) {
-  if (fn.props) {
-    return fn.props.find(({ key }) => key === name)
+  return fn.props ? fn.props.some(p => p.key === name) : false
+}
+
+function hasInstanceProperty (konstructor, name) {
+  let k = konstructor
+  while (k) {
+    if (k.instanceProperties && k.instanceProperties.has(name)) return true
+    k = k.parent
   }
   return false
 }
 
 function checkRequestExistence (name) {
   if (name && hasKey(this[kRequest], name)) return true
+  if (name && hasInstanceProperty(this[kRequest], name)) return true
   return checkExistence(this[kRequest].prototype, name)
 }
 
 function checkReplyExistence (name) {
   if (name && hasKey(this[kReply], name)) return true
+  if (name && hasInstanceProperty(this[kReply], name)) return true
   return checkExistence(this[kReply].prototype, name)
 }
 

package/lib/error-handler.js

@@ -8,7 +8,8 @@ const {
   kReplyNextErrorHandler,
   kReplyIsRunningOnErrorHook,
   kRouteContext,
-  kDisableRequestLogging
+  kDisableRequestLogging,
+  kDiagnosticsStore
 } = require('./symbols.js')
 
 const {
@@ -19,7 +20,6 @@ const {
 const { getSchemaSerializer } = require('./schemas')
 
 const serializeError = require('./error-serializer')
-
 const rootErrorHandler = {
   func: defaultErrorHandler,
   toJSON () {
@@ -69,7 +69,8 @@ function handleError (reply, error, cb) {
     const result = func(error, reply.request, reply)
     if (result !== undefined) {
       if (result !== null && typeof result.then === 'function') {
-        wrapThenable(result, reply)
+        const store = reply[kDiagnosticsStore] || null
+        wrapThenable(result, reply, store)
       } else {
         reply.send(result)
       }

package/lib/error-serializer.js

@@ -40,93 +40,93 @@ const asInteger = serializer.asInteger.bind(serializer)
     const JSON_STR_NULL = 'null'
   
     
-  
-    // #
-    function anonymous0 (input) {
-      const obj = (input && typeof input.toJSON === 'function')
+      // #
+      function anonymous0 (input) {
+        const obj = (input && typeof input.toJSON === 'function')
     ? input.toJSON()
     : input
   
-      if (obj === null) return JSON_STR_EMPTY_OBJECT
+        if (obj === null) return JSON_STR_EMPTY_OBJECT
+        let json = ''
 
-      let value
-let json = JSON_STR_BEGIN_OBJECT
-let addComma = false
+        json += JSON_STR_BEGIN_OBJECT
+let addComma_0 = false
 
-      value = obj["statusCode"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"statusCode\":"
-        json += asNumber(value)
-      }
+          const value_statusCode_1 = obj["statusCode"]
+          if (value_statusCode_1 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"statusCode\":"
+            json += asNumber(value_statusCode_1)
+          }
 
-      value = obj["code"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"code\":"
-        
-        if (typeof value !== 'string') {
-          if (value === null) {
+          const value_code_2 = obj["code"]
+          if (value_code_2 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"code\":"
+            
+        if (typeof value_code_2 !== 'string') {
+          if (value_code_2 === null) {
             json += JSON_STR_EMPTY_STRING
-          } else if (value instanceof Date) {
-            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
-          } else if (value instanceof RegExp) {
-            json += asString(value.source)
+          } else if (value_code_2 instanceof Date) {
+            json += JSON_STR_QUOTE + value_code_2.toISOString() + JSON_STR_QUOTE
+          } else if (value_code_2 instanceof RegExp) {
+            json += asString(value_code_2.source)
           } else {
-            json += asString(value.toString())
+            json += asString(value_code_2.toString())
           }
         } else {
-          json += asString(value)
+          json += asString(value_code_2)
         }
         
-      }
+          }
 
-      value = obj["error"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"error\":"
-        
-        if (typeof value !== 'string') {
-          if (value === null) {
+          const value_error_3 = obj["error"]
+          if (value_error_3 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"error\":"
+            
+        if (typeof value_error_3 !== 'string') {
+          if (value_error_3 === null) {
             json += JSON_STR_EMPTY_STRING
-          } else if (value instanceof Date) {
-            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
-          } else if (value instanceof RegExp) {
-            json += asString(value.source)
+          } else if (value_error_3 instanceof Date) {
+            json += JSON_STR_QUOTE + value_error_3.toISOString() + JSON_STR_QUOTE
+          } else if (value_error_3 instanceof RegExp) {
+            json += asString(value_error_3.source)
           } else {
-            json += asString(value.toString())
+            json += asString(value_error_3.toString())
           }
         } else {
-          json += asString(value)
+          json += asString(value_error_3)
         }
         
-      }
+          }
 
-      value = obj["message"]
-      if (value !== undefined) {
-        !addComma && (addComma = true) || (json += JSON_STR_COMMA)
-        json += "\"message\":"
-        
-        if (typeof value !== 'string') {
-          if (value === null) {
+          const value_message_4 = obj["message"]
+          if (value_message_4 !== undefined) {
+            !addComma_0 && (addComma_0 = true) || (json += JSON_STR_COMMA)
+            json += "\"message\":"
+            
+        if (typeof value_message_4 !== 'string') {
+          if (value_message_4 === null) {
             json += JSON_STR_EMPTY_STRING
-          } else if (value instanceof Date) {
-            json += JSON_STR_QUOTE + value.toISOString() + JSON_STR_QUOTE
-          } else if (value instanceof RegExp) {
-            json += asString(value.source)
+          } else if (value_message_4 instanceof Date) {
+            json += JSON_STR_QUOTE + value_message_4.toISOString() + JSON_STR_QUOTE
+          } else if (value_message_4 instanceof RegExp) {
+            json += asString(value_message_4.source)
           } else {
-            json += asString(value.toString())
+            json += asString(value_message_4.toString())
           }
         } else {
-          json += asString(value)
+          json += asString(value_message_4)
         }
         
-      }
+          }
 
-    return json + JSON_STR_END_OBJECT
-  
-    }
+    json += JSON_STR_END_OBJECT
   
+        return json
+      }
+    
     const main = anonymous0
     return main
     

package/lib/errors.js

@@ -364,6 +364,12 @@ const codes = {
     400,
     URIError
   ),
+  FST_ERR_MAX_PARAM_LENGTH: createError(
+    'FST_ERR_MAX_PARAM_LENGTH',
+    "'%s' is exceeding the max param length",
+    414,
+    URIError
+  ),
   FST_ERR_ASYNC_CONSTRAINT: createError(
     'FST_ERR_ASYNC_CONSTRAINT',
     'Unexpected error from async constraint',
@@ -408,6 +414,12 @@ const codes = {
     '%s method is not supported.',
     500
   ),
+  FST_ERR_ROUTE_LOG_LEVEL_INVALID: createError(
+    'FST_ERR_ROUTE_LOG_LEVEL_INVALID',
+    "Log level for '%s:%s' route must be a valid logger level. Received: '%s'",
+    500,
+    TypeError
+  ),
   FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED: createError(
     'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED',
     'Body validation schema for %s:%s route is not supported!',
@@ -470,7 +482,10 @@ const codes = {
     500,
     TypeError
   ),
-
+  FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED: createError(
+    'FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED',
+    "The dependency '%s' of plugin '%s' is not registered"
+  ),
   /**
    *  Avvio Errors
    */

package/lib/four-oh-four.js

@@ -32,8 +32,12 @@ function fourOhFour (options) {
   const { logger, disableRequestLogging } = options
 
   // 404 router, used for handling encapsulated 404 handlers
-  const router = FindMyWay({ onBadUrl: createOnBadUrl(), defaultRoute: fourOhFourFallBack })
-  let _onBadUrlHandler = null
+  const router = FindMyWay({
+    onBadUrl: createRouteEventHandler(),
+    onMaxParamLength: createRouteEventHandler(),
+    defaultRoute: fourOhFourFallBack
+  })
+  let _routeEventHandler = null
 
   return { router, setNotFoundHandler, setContext, arrange404 }
 
@@ -43,6 +47,7 @@ function fourOhFour (options) {
     instance[kCanSetNotFoundHandler] = true
     // we need to bind instance for the context
     router.onBadUrl = router.onBadUrl.bind(instance)
+    router.onMaxParamLength = router.onMaxParamLength.bind(instance)
     router.defaultRoute = router.defaultRoute.bind(instance)
   }
 
@@ -60,15 +65,15 @@ function fourOhFour (options) {
     })
   }
 
-  function createOnBadUrl () {
-    return function onBadUrl (path, req, res) {
+  function createRouteEventHandler () {
+    return function onRouteEvent (path, req, res) {
       const fourOhFourContext = this[kFourOhFourLevelInstance][kFourOhFourContext]
       const id = getGenReqId(fourOhFourContext.server, req)
       const childLogger = createChildLogger(fourOhFourContext, logger, req, id)
       const request = new Request(id, null, req, null, childLogger, fourOhFourContext)
       const reply = new Reply(res, request, childLogger)
 
-      _onBadUrlHandler(request, reply)
+      _routeEventHandler(request, reply)
     }
   }
 
@@ -121,12 +126,12 @@ function fourOhFour (options) {
     if (handler) {
       this[kFourOhFourLevelInstance][kCanSetNotFoundHandler] = false
       handler = handler.bind(this)
-      // update onBadUrl handler
-      _onBadUrlHandler = handler
+      // update route event handler
+      _routeEventHandler = handler
     } else {
       handler = basic404
-      // update onBadUrl handler
-      _onBadUrlHandler = basic404
+      // update route event handler
+      _routeEventHandler = basic404
     }
 
     this.after((notHandledErr, done) => {

package/lib/handle-request.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const diagnostics = require('node:diagnostics_channel')
-const ContentType = require('./content-type')
 const wrapThenable = require('./wrap-thenable')
 const { validate: validateSchema } = require('./validation')
 const { preValidationHookRunner, preHandlerHookRunner } = require('./hooks')
@@ -11,7 +10,9 @@ const {
   kReplyIsError,
   kRouteContext,
   kFourOhFourContext,
-  kSupportedHTTPMethods
+  kSupportedHTTPMethods,
+  kRequestContentType,
+  kDiagnosticsStore
 } = require('./symbols')
 
 const channels = diagnostics.tracingChannel('fastify.request.handler')
@@ -51,13 +52,17 @@ function handleRequest (err, request, reply) {
       return
     }
 
-    const contentType = new ContentType(ctHeader)
-    if (contentType.isValid === false) {
+    // Conditional assignment to avoid creating a new ContentType instance
+    // It can be assigned when accessing the .mediaType in hooks
+    if (!request[kRequestContentType]) {
+      request[kRequestContentType] = request[kRouteContext].contentTypeParser.getContentType(ctHeader)
+    }
+    if (request[kRequestContentType].isValid === false) {
       reply[kReplyIsError] = true
       reply.status(415).send(new FST_ERR_CTP_INVALID_MEDIA_TYPE())
       return
     }
-    request[kRouteContext].contentTypeParser.run(contentType.toString(), handler, request, reply)
+    request[kRouteContext].contentTypeParser.run(request[kRequestContentType].toString(), handler, request, reply)
     return
   }
 
@@ -142,6 +147,7 @@ function preHandlerCallback (err, request, reply) {
         method: context.config.method
       }
     }
+    reply[kDiagnosticsStore] = store
     channels.start.runStores(store, preHandlerCallbackInner, undefined, err, request, reply, store)
   }
 }

package/lib/plugin-override.js

@@ -82,7 +82,8 @@ function buildRoutePrefix (instancePrefix, pluginPrefix) {
   if (instancePrefix.endsWith('/') && pluginPrefix[0] === '/') {
     // Remove the extra '/' to avoid: '/first//second'
     pluginPrefix = pluginPrefix.slice(1)
-  } else if (pluginPrefix[0] !== '/') {
+  } else if (pluginPrefix[0] !== '/' && !instancePrefix.endsWith('/')) {
+    // Add the missing '/' to avoid: '/firstsecond'
     pluginPrefix = '/' + pluginPrefix
   }
 

package/lib/plugin-utils.js

@@ -10,7 +10,8 @@ const { exist, existReply, existRequest } = require('./decorate.js')
 const {
   FST_ERR_PLUGIN_VERSION_MISMATCH,
   FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE,
-  FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER
+  FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER,
+  FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED
 } = require('./errors.js')
 
 const rcRegex = /-(?:rc|pre|alpha).+$/u
@@ -70,10 +71,9 @@ function checkDependencies (fn) {
   assert(Array.isArray(dependencies), 'The dependencies should be an array of strings')
 
   dependencies.forEach(dependency => {
-    assert(
-      this[kRegisteredPlugins].indexOf(dependency) > -1,
-      `The dependency '${dependency}' of plugin '${meta.name}' is not registered`
-    )
+    if (!this[kRegisteredPlugins].includes(dependency)) {
+      throw new FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED(dependency, meta.name)
+    }
   })
 }