jishushell 0.6.5 → 0.7.3

package/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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/node_modules/fastify/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)
+    }
   })
 }
 

package/node_modules/fastify/lib/reply.js

@@ -60,6 +60,7 @@ const {
 const decorators = require('./decorate')
 
 const toString = Object.prototype.toString
+const HTTP2_WRITE_CHUNK_SIZE = 64 * 1024
 
 function Reply (res, request, log) {
   this.raw = res
@@ -75,6 +76,7 @@ function Reply (res, request, log) {
   this.log = log
 }
 Reply.props = []
+Reply.instanceProperties = new Set(['raw', 'request', 'log'])
 
 Object.defineProperties(Reply.prototype, {
   [kRouteContext]: {
@@ -167,7 +169,7 @@ Reply.prototype.send = function (payload) {
       // node:stream/web
       typeof payload.getReader === 'function' ||
       // Response
-      toString.call(payload) === '[object Response]'
+      (typeof payload === 'object' && toString.call(payload) === '[object Response]')
     ) {
       onSendHook(this, payload)
       return this
@@ -593,7 +595,7 @@ function onSendEnd (reply, payload) {
   // since Response contain status code, headers and body,
   // we need to update the status, add the headers and use it's body as payload
   // before continuing
-  if (toString.call(payload) === '[object Response]') {
+  if (payload != null && typeof payload === 'object' && toString.call(payload) === '[object Response]') {
     // https://developer.mozilla.org/en-US/docs/Web/API/Response/status
     if (typeof payload.status === 'number') {
       reply.code(payload.status)
@@ -677,9 +679,52 @@ function onSendEnd (reply, payload) {
 
   safeWriteHead(reply, statusCode)
   // write payload first
-  res.write(payload)
-  // then send trailers
-  sendTrailer(payload, res, reply)
+  writePayload(payload, res, reply)
+}
+
+function isHttp2Reply (reply) {
+  return reply.request.raw?.httpVersionMajor === 2
+}
+
+function writePayload (payload, res, reply) {
+  if (!isHttp2Reply(reply) || Buffer.byteLength(payload) <= HTTP2_WRITE_CHUNK_SIZE) {
+    res.write(payload)
+    // then send trailers
+    sendTrailer(payload, res, reply)
+    return
+  }
+
+  writeHttp2Payload(payload, res, () => {
+    // then send trailers
+    sendTrailer(payload, res, reply)
+  })
+}
+
+function writeHttp2Payload (payload, res, done) {
+  const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload)
+  let offset = 0
+
+  function writeChunk () {
+    while (offset < buffer.length) {
+      /* c8 ignore next 3 - defensive guard for aborted responses */
+      if (res.destroyed || res.writableEnded) {
+        return
+      }
+
+      const end = Math.min(offset + HTTP2_WRITE_CHUNK_SIZE, buffer.length)
+      const shouldContinue = res.write(buffer.subarray(offset, end))
+      offset = end
+
+      if (shouldContinue === false) {
+        res.once('drain', writeChunk)
+        return
+      }
+    }
+
+    done()
+  }
+
+  writeChunk()
 }
 
 function logStreamError (logger, err, res) {
@@ -830,10 +875,12 @@ function sendTrailer (payload, res, reply) {
   const trailers = {}
   let handled = 0
   let skipped = true
+  let sent = false
   function send () {
     // add trailers when all handler handled
     /* istanbul ignore else */
-    if (handled === 0) {
+    if (handled === 0 && !sent) {
+      sent = true
       res.addTrailers(trailers)
       // we need to properly close the stream
       // after trailers sent
@@ -846,9 +893,10 @@ function sendTrailer (payload, res, reply) {
     skipped = false
     handled--
 
+    let cbAlreadyCalled = false
     function cb (err, value) {
-      // TODO: we may protect multiple callback calls
-      //       or mixing async-await with callback
+      if (cbAlreadyCalled) return
+      cbAlreadyCalled = true
       handled++
 
       // we can safely ignore error for trailer
@@ -914,6 +962,13 @@ function setupResponseListeners (reply) {
       }
     }
 
+    // Fix: release socket._meta so request/reply objects are not retained
+    // past the response on keep-alive connections.
+    const socket = reply.request.raw.socket
+    if (socket && socket._meta && socket._meta.request === reply.request) {
+      socket._meta = null
+    }
+
     if (ctx && ctx.onResponse !== null) {
       onResponseHookRunner(
         ctx.onResponse,

package/node_modules/fastify/lib/request.js

@@ -10,6 +10,7 @@ const {
   kSchemaController,
   kOptions,
   kRequestCacheValidateFns,
+  kRequestContentType,
   kRouteContext,
   kRequestOriginalUrl,
   kRequestSignal,
@@ -36,6 +37,7 @@ function Request (id, params, req, query, log, context) {
   this.body = undefined
 }
 Request.props = []
+Request.instanceProperties = new Set(['id', 'params', 'raw', 'query', 'log', 'body'])
 
 function getTrustProxyFn (tp) {
   if (typeof tp === 'function') {
@@ -117,8 +119,8 @@ function buildRequestWithTrustProxy (R, trustProxy) {
     },
     host: {
       get () {
-        const socketAddr = this.raw.socket?.remoteAddress
-        if (this.headers['x-forwarded-host'] && socketAddr !== null && proxyFn(socketAddr, 0)) {
+        const socket = this.raw.socket
+        if (this.headers['x-forwarded-host'] && socket != null && proxyFn(socket.remoteAddress, 0)) {
           return getLastEntryInMultiHeaderValue(this.headers['x-forwarded-host'])
         }
         /**
@@ -132,8 +134,8 @@ function buildRequestWithTrustProxy (R, trustProxy) {
     },
     protocol: {
       get () {
-        const socketAddr = this.raw.socket?.remoteAddress
-        if (this.headers['x-forwarded-proto'] && socketAddr !== null && proxyFn(socketAddr, 0)) {
+        const socket = this.raw.socket
+        if (this.headers['x-forwarded-proto'] && socket != null && proxyFn(socket.remoteAddress, 0)) {
           return getLastEntryInMultiHeaderValue(this.headers['x-forwarded-proto'])
         }
         if (this.socket) {
@@ -282,6 +284,14 @@ Object.defineProperties(Request.prototype, {
       this.additionalHeaders = headers
     }
   },
+  mediaType: {
+    get () {
+      if (!this[kRequestContentType] && this.headers['content-type'] !== undefined) {
+        this[kRequestContentType] = this[kRouteContext].contentTypeParser.getContentType(this.headers['content-type'])
+      }
+      return this[kRequestContentType]?.mediaType
+    }
+  },
   getValidationFunction: {
     value: function (httpPartOrSchema) {
       if (typeof httpPartOrSchema === 'string') {

package/node_modules/fastify/lib/route.js

@@ -24,6 +24,7 @@ const {
   FST_ERR_ROUTE_MISSING_HANDLER,
   FST_ERR_ROUTE_METHOD_NOT_SUPPORTED,
   FST_ERR_ROUTE_METHOD_INVALID,
+  FST_ERR_ROUTE_LOG_LEVEL_INVALID,
   FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED,
   FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT,
   FST_ERR_ROUTE_HANDLER_TIMEOUT_OPTION_NOT_INT,
@@ -68,6 +69,7 @@ const routerKeys = [
   'ignoreTrailingSlash',
   'maxParamLength',
   'onBadUrl',
+  'onMaxParamLength',
   'querystringParser',
   'useSemicolonDelimiter'
 ]
@@ -284,6 +286,7 @@ function buildRouting (options) {
       opts.routePath = path
       opts.prefix = prefix
       opts.logLevel = opts.logLevel || this[kLogLevel]
+      validateLogLevelOption(opts.logLevel, opts.method, opts.url, logger)
 
       if (this[kLogSerializers] || opts.logSerializers) {
         opts.logSerializers = Object.assign(Object.create(this[kLogSerializers]), opts.logSerializers)
@@ -365,7 +368,8 @@ function buildRouting (options) {
         // any route insertion error created by fastify can be safely ignore
         // because it only duplicate route for head
         if (!context[kRouteByFastify]) {
-          const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route`)
+          const methods = Array.isArray(opts.method) ? opts.method : [opts.method]
+          const isDuplicatedRoute = methods.some(method => error.message.includes(`Method '${method}' already declared for route`))
           if (isDuplicatedRoute) {
             throw new FST_ERR_DUPLICATED_ROUTE(opts.method, opts.url)
           }
@@ -476,12 +480,13 @@ function buildRouting (options) {
         res.setHeader('Connection', 'close')
       }
 
-      // TODO remove return503OnClosing after Node v18 goes EOL
-      /* istanbul ignore else */
+      // Load-shedding fast path during drain. server.close() and
+      // closeIdleConnections() only reap idle sockets; requests already
+      // pipelined or arriving on an active keep-alive connection still reach
+      // this point with closing === true. Short-circuiting with 503 avoids
+      // running the full handler chain (and any downstream calls) for work
+      // the load balancer should redirect elsewhere.
       if (return503OnClosing) {
-        // On Node v19 we cannot test this behavior as it won't be necessary
-        // anymore. It will close all the idle connections before they reach this
-        // stage.
         const headers = {
           'Content-Type': 'application/json',
           'Content-Length': '80'
@@ -635,6 +640,15 @@ function validateHandlerTimeoutOption (handlerTimeout) {
   }
 }
 
+function validateLogLevelOption (logLevel, method, path, logger) {
+  if (logLevel == null || logLevel === '') return
+  if (logger?.levels?.values == null) return
+
+  if (typeof logLevel !== 'string' || logger.levels.values[logLevel] === undefined) {
+    throw new FST_ERR_ROUTE_LOG_LEVEL_INVALID(method, path, logLevel)
+  }
+}
+
 function runPreParsing (err, request, reply) {
   if (reply.sent === true) return
   if (err != null) {

package/node_modules/fastify/lib/schema-controller.js

@@ -31,7 +31,7 @@ function buildSchemaController (parentSchemaCtrl, opts) {
     bucket: (opts && opts.bucket) || buildSchemas,
     compilersFactory,
     isCustomValidatorCompiler: typeof opts?.compilersFactory?.buildValidator === 'function',
-    isCustomSerializerCompiler: typeof opts?.compilersFactory?.buildValidator === 'function'
+    isCustomSerializerCompiler: typeof opts?.compilersFactory?.buildSerializer === 'function'
   }
 
   return new SchemaController(undefined, option)