fastify 5.9.0 → 5.11.0

package/lib/log-controller.js

@@ -0,0 +1,169 @@
+'use strict'
+
+const { defaultInitOptions } = require('./initial-config-validation')
+
+/**
+ * Internal logger layer that wraps Fastify's log calls with
+ * request-lifecycle awareness (disable-check, level selection).
+ * Keeps the surface intentionally small so hot paths stay fast.
+ *
+ * Users can extend this class to customize internal log lines.
+ */
+class LogController {
+  /**
+   * @param {object} [options]
+   * @param {boolean | ((req: object) => boolean)} [options.disableRequestLogging=false]
+   *   When `true` (or a function returning `true`), per-request log lines
+   *   (incoming, completed, errors) are suppressed.
+   * @param {string} [options.requestIdLogLabel='reqId']
+   *   The label used for the request identifier when logging the request.
+   */
+  constructor (options) {
+    const opts = options || {}
+    this.disableRequestLogging = opts.disableRequestLogging || defaultInitOptions.disableRequestLogging
+    this.isDisableRequestLoggingFunction = typeof this.disableRequestLogging === 'function'
+    this.requestIdLogLabel = opts.requestIdLogLabel || defaultInitOptions.requestIdLogLabel
+  }
+
+  /**
+   * Checks whether request logging is disabled for the given request.
+   *
+   * @param {object} req  Raw or Fastify request object.
+   * @returns {boolean}   `true` when logging should be skipped.
+   */
+  isLogDisabled (req) {
+    return this.isDisableRequestLoggingFunction
+      ? this.disableRequestLogging(req)
+      : this.disableRequestLogging
+  }
+
+  /**
+   * Logs an incoming request at `info` level.
+   *
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  incomingRequest (request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    request.log.info({ req: request }, 'incoming request')
+  }
+
+  /**
+   * Logs the outcome of a completed request.
+   * Uses `error` level when an error is present, `info` otherwise.
+   *
+   * @param {Error | null} error  Error that occurred during the response, if any.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  requestCompleted (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    if (error) {
+      reply.log.error({ res: reply, err: error, responseTime: reply.elapsedTime }, 'request errored')
+    } else {
+      reply.log.info({ res: reply, responseTime: reply.elapsedTime }, 'request completed')
+    }
+  }
+
+  /**
+   * Logs an error handled by the default error handler.
+   * Uses `error` for 5xx status codes, `info` for 4xx.
+   *
+   * @param {Error} error         The error being handled.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object (must have `statusCode`).
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  defaultErrorLog (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    if (reply.statusCode >= 500) {
+      reply.log.error({ req: request, res: reply, err: error }, error?.message)
+    } else {
+      reply.log.info({ res: reply, err: error }, error?.message)
+    }
+  }
+
+  /**
+   * Logs stream-level errors that occur after headers have been sent.
+   * Premature closes are logged at `info`; other errors at `warn`.
+   *
+   * @param {Error} error         The stream error.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  streamError (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    if (error.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+      reply.log.info({ res: reply }, 'stream closed prematurely')
+    } else {
+      reply.log.warn({ err: error }, 'response terminated with an error with headers already sent')
+    }
+  }
+
+  /**
+   * Logs a "route not found" message at `info` level.
+   * Used by the default 404 handler.
+   *
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  routeNotFound (request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    const { url, method } = request.raw
+    request.log.info(`Route ${method}:${url} not found`)
+  }
+
+  /**
+   * Logs a warning when writeHead fails during error handling.
+   *
+   * @param {Error} error         The error thrown by writeHead.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} [metadata]   Extra contextual data (unused).
+   */
+  writeHeadError (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    reply.log.warn(
+      { req: request, res: reply, err: error },
+      error?.message
+    )
+  }
+
+  /**
+   * Logs an error when the serializer for a given status code fails.
+   *
+   * @param {Error} error         The serialization error.
+   * @param {object} request      Fastify request object.
+   * @param {object} reply        Fastify reply object.
+   * @param {object} metadata     Extra contextual data.
+   * @param {number} metadata.statusCode The status code that triggered the serializer.
+   */
+  serializerError (error, request, reply, metadata) {
+    if (this.isLogDisabled(request)) { return }
+
+    reply.log.error({ err: error, statusCode: metadata.statusCode }, 'The serializer for the given status code failed')
+  }
+
+  /**
+   * Logs a 503 Service Unavailable when the server is closing.
+   * Always emitted (not gated by `disableRequestLogging`).
+   *
+   * @param {import('../fastify').FastifyBaseLogger} logger
+   * @param {import('../fastify').FastifyInstance} server
+   */
+  serviceUnavailable (logger, server) {
+    logger.info({ res: { statusCode: 503 } }, 'request aborted - refusing to accept new requests as server is closing')
+  }
+}
+
+module.exports = { LogController }

package/lib/logger-factory.js

@@ -1,11 +1,18 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 const {
   FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED,
   FST_ERR_LOG_INVALID_LOGGER_CONFIG,
   FST_ERR_LOG_INVALID_LOGGER_INSTANCE,
-  FST_ERR_LOG_INVALID_LOGGER
+  FST_ERR_LOG_INVALID_LOGGER,
+  FST_ERR_LOG_INVALID_LOG_CONTROLLER
 } = require('./errors')
+const {
+  kLogController
+} = require('./symbols.js')
+const { LogController } = require('./log-controller.js')
 
 /**
  * Utility for creating a child logger with the appropriate bindings, logger factory
@@ -21,7 +28,7 @@ const {
  */
 function createChildLogger (context, logger, req, reqId, loggerOpts) {
   const loggerBindings = {
-    [context.requestIdLogLabel]: reqId
+    [context.server[kLogController].requestIdLogLabel]: reqId
   }
   const child = context.childLoggerFactory.call(context.server, logger, loggerBindings, loggerOpts || {}, req)
 
@@ -122,15 +129,29 @@ function createLogger (options) {
   return { logger, hasLogger: true }
 }
 
+function createLogController (options) {
+  const userController = options.logController
+  if (!userController) {
+    return new LogController(options)
+  }
+
+  if (userController instanceof LogController) {
+    return userController
+  }
+
+  throw new FST_ERR_LOG_INVALID_LOG_CONTROLLER(typeof userController)
+}
+
 function now () {
-  const ts = process.hrtime()
-  return (ts[0] * 1e3) + (ts[1] / 1e6)
+  return performance.now()
 }
 
 module.exports = {
   createChildLogger,
   defaultChildLoggerFactory,
+  createLogController,
   createLogger,
+  LogController,
   validateLogger,
   now
 }

package/lib/reply.js

@@ -16,7 +16,6 @@ const {
   kReplyHasStatusCode,
   kReplyIsRunningOnErrorHook,
   kReplyNextErrorHandler,
-  kDisableRequestLogging,
   kSchemaResponse,
   kReplyCacheSerializeFns,
   kSchemaController,
@@ -24,7 +23,8 @@ const {
   kRouteContext,
   kTimeoutTimer,
   kOnAbort,
-  kRequestSignal
+  kRequestSignal,
+  kLogController
 } = require('./symbols.js')
 const {
   onSendHookRunner,
@@ -58,6 +58,7 @@ const {
   FST_ERR_DEC_UNDECLARED
 } = require('./errors')
 const decorators = require('./decorate')
+const ContentType = require('./content-type.js')
 
 const toString = Object.prototype.toString
 const HTTP2_WRITE_CHUNK_SIZE = 64 * 1024
@@ -135,6 +136,14 @@ Reply.prototype.hijack = function () {
       this.request[kOnAbort] = null
     }
   }
+  // Clear socket._meta so hijacked replies (e.g. WebSocket upgrades) do not
+  // retain request/reply objects for the lifetime of the keep-alive socket
+  // when an onTimeout hook is registered.
+  const socket = this.request.raw.socket
+  if (socket?._meta?.request === this.request) {
+    socket.removeListener('timeout', socket._meta.onTimeout)
+    socket._meta = null
+  }
   return this
 }
 
@@ -159,8 +168,8 @@ Reply.prototype.send = function (payload) {
     return this
   }
 
-  const contentType = this.getHeader('content-type')
-  const hasContentType = contentType !== undefined
+  const contentType = ContentType.from(this.getHeader('content-type'))
+  const hasContentType = contentType.isEmpty === false
 
   if (payload !== null) {
     if (
@@ -201,18 +210,17 @@ Reply.prototype.send = function (payload) {
     payload = this[kReplySerializer](payload)
 
     // The indexOf below also matches custom json mimetypes such as 'application/hal+json' or 'application/ld+json'
-  } else if (!hasContentType || contentType.indexOf('json') !== -1) {
+  } else if (!hasContentType || contentType.mediaType.indexOf('json') !== -1) {
     if (!hasContentType) {
       this[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
-    } else if (contentType.indexOf('charset') === -1) {
+    } else if (contentType.parameters.has('charset') === false) {
+      // The lookup is case-insensitive because HTTP parameter names are
+      // case-insensitive (RFC 9110 section 5.6.6).
       // If user doesn't set charset, we will set charset to utf-8
-      const customContentType = contentType.trim()
-      if (customContentType.endsWith(';')) {
-        // custom content-type is ended with ';'
-        this[kReplyHeaders]['content-type'] = `${customContentType} charset=utf-8`
-      } else {
-        this[kReplyHeaders]['content-type'] = `${customContentType}; charset=utf-8`
-      }
+      const customContentType = contentType.toString()
+      // ContentType.toString already handle the trailing ;
+      // We can safely append the charset parameter to the end of the string
+      this[kReplyHeaders]['content-type'] = `${customContentType}; charset=utf-8`
     }
 
     if (typeof payload !== 'string') {
@@ -688,6 +696,12 @@ function isHttp2Reply (reply) {
 
 function writePayload (payload, res, reply) {
   if (!isHttp2Reply(reply) || Buffer.byteLength(payload) <= HTTP2_WRITE_CHUNK_SIZE) {
+    if (reply[kReplyTrailers] === null) {
+      // end(payload) corks the socket, so headers, payload and the
+      // finishing chunk are flushed with a single write
+      res.end(payload, null, null) // avoid ArgumentsAdaptorTrampoline from V8
+      return
+    }
     res.write(payload)
     // then send trailers
     sendTrailer(payload, res, reply)
@@ -727,14 +741,8 @@ function writeHttp2Payload (payload, res, done) {
   writeChunk()
 }
 
-function logStreamError (logger, err, res) {
-  if (err.code === 'ERR_STREAM_PREMATURE_CLOSE') {
-    if (!logger[kDisableRequestLogging]) {
-      logger.info({ res }, 'stream closed prematurely')
-    }
-  } else {
-    logger.warn({ err }, 'response terminated with an error with headers already sent')
-  }
+function logStreamError (err, reply, res) {
+  reply.server[kLogController].streamError(err, reply.request, reply)
 }
 
 function sendWebStream (payload, res, reply) {
@@ -751,7 +759,7 @@ function sendWebStream (payload, res, reply) {
     if (sourceOpen) {
       if (err != null && res.headersSent && !errorLogged) {
         errorLogged = true
-        logStreamError(reply.log, err, res)
+        logStreamError(err, reply, res)
       }
       reader.cancel().catch(noop)
     }
@@ -799,7 +807,7 @@ function sendWebStream (payload, res, reply) {
     if (res.headersSent || reply.request.raw.aborted === true) {
       if (!errorLogged) {
         errorLogged = true
-        logStreamError(reply.log, err, reply)
+        logStreamError(err, reply, reply)
       }
       res.destroy()
     } else {
@@ -823,7 +831,7 @@ function sendStream (payload, res, reply) {
       if (res.headersSent || reply.request.raw.aborted === true) {
         if (!errorLogged) {
           errorLogged = true
-          logStreamError(reply.log, err, reply)
+          logStreamError(err, reply, reply)
         }
         res.destroy()
       } else {
@@ -837,7 +845,7 @@ function sendStream (payload, res, reply) {
     if (sourceOpen) {
       if (err != null && res.headersSent && !errorLogged) {
         errorLogged = true
-        logStreamError(reply.log, err, res)
+        logStreamError(err, reply, res)
       }
       if (typeof payload.destroy === 'function') {
         payload.destroy()
@@ -966,6 +974,7 @@ function setupResponseListeners (reply) {
     // past the response on keep-alive connections.
     const socket = reply.request.raw.socket
     if (socket && socket._meta && socket._meta.request === reply.request) {
+      socket.removeListener('timeout', socket._meta.onTimeout)
       socket._meta = null
     }
 
@@ -986,25 +995,7 @@ function setupResponseListeners (reply) {
 }
 
 function onResponseCallback (err, request, reply) {
-  if (reply.log[kDisableRequestLogging]) {
-    return
-  }
-
-  const responseTime = reply.elapsedTime
-
-  if (err != null) {
-    reply.log.error({
-      res: reply,
-      err,
-      responseTime
-    }, 'request errored')
-    return
-  }
-
-  reply.log.info({
-    res: reply,
-    responseTime
-  }, 'request completed')
+  reply.server[kLogController].requestCompleted(err, request, reply)
 }
 
 function buildReply (R) {

package/lib/req-id-gen-factory.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { kGenReqId } = require('./symbols.js')
+
 /**
  * @callback GenerateRequestId
  * @param {Object} req
@@ -22,7 +24,8 @@ function reqIdGenFactory (requestIdHeader, optGenReqId) {
 }
 
 function getGenReqId (contextServer, req) {
-  return contextServer.genReqId(req)
+  // direct symbol access skips the `genReqId` getter indirection
+  return contextServer[kGenReqId](req)
 }
 
 function buildDefaultGenReqId () {

package/lib/request.js

@@ -18,6 +18,7 @@ const {
 } = require('./symbols')
 const { FST_ERR_REQ_INVALID_VALIDATION_INVOCATION, FST_ERR_DEC_UNDECLARED } = require('./errors')
 const decorators = require('./decorate')
+const ContentType = require('./content-type')
 
 const HTTP_PART_SYMBOL_MAP = {
   body: kSchemaBody,
@@ -258,8 +259,7 @@ Object.defineProperties(Request.prototype, {
   port: {
     get () {
       const portReg = /(?<port>:\d+)$/
-      const host = this.headers.host ?? this.headers[':authority'] ?? ''
-      const matches = portReg.exec(host)
+      const matches = portReg.exec(this.host)
       if (matches === null || matches[1] === undefined) {
         return null
       }
@@ -287,7 +287,7 @@ Object.defineProperties(Request.prototype, {
   mediaType: {
     get () {
       if (!this[kRequestContentType] && this.headers['content-type'] !== undefined) {
-        this[kRequestContentType] = this[kRouteContext].contentTypeParser.getContentType(this.headers['content-type'])
+        this[kRequestContentType] = ContentType.from(this.headers['content-type'])
       }
       return this[kRequestContentType]?.mediaType
     }

package/lib/route.js

@@ -43,7 +43,6 @@ const {
   kReplySerializerDefault,
   kReplyIsError,
   kRequestPayloadStream,
-  kDisableRequestLogging,
   kSchemaErrorFormatter,
   kErrorHandler,
   kHasBeenDecorated,
@@ -52,10 +51,11 @@ const {
   kRouteContext,
   kRequestSignal,
   kTimeoutTimer,
-  kOnAbort
+  kOnAbort,
+  kLogController
 } = require('./symbols.js')
 const { buildErrorHandler } = require('./error-handler')
-const { createChildLogger } = require('./logger-factory.js')
+const { createChildLogger, defaultChildLoggerFactory } = require('./logger-factory.js')
 const { getGenReqId } = require('./req-id-gen-factory.js')
 const { FSTDEP022 } = require('./warnings')
 
@@ -83,8 +83,6 @@ function buildRouting (options) {
   let hasLogger
   let setupResponseListeners
   let throwIfAlreadyStarted
-  let disableRequestLogging
-  let disableRequestLoggingFn
   let ignoreTrailingSlash
   let ignoreDuplicateSlashes
   let return503OnClosing
@@ -107,10 +105,6 @@ function buildRouting (options) {
       throwIfAlreadyStarted = fastifyArgs.throwIfAlreadyStarted
 
       globalExposeHeadRoutes = options.exposeHeadRoutes
-      disableRequestLogging = options.disableRequestLogging
-      if (typeof disableRequestLogging === 'function') {
-        disableRequestLoggingFn = options.disableRequestLogging
-      }
 
       ignoreTrailingSlash = options.routerOptions.ignoreTrailingSlash
       ignoreDuplicateSlashes = options.routerOptions.ignoreDuplicateSlashes
@@ -185,7 +179,7 @@ function buildRouting (options) {
 
   function findRoute (options) {
     const route = router.find(
-      options.method,
+      options.method?.toUpperCase() ?? '',
       options.url || '',
       options.constraints
     )
@@ -463,16 +457,21 @@ function buildRouting (options) {
   function routeHandler (req, res, params, context, query) {
     const id = getGenReqId(context.server, req)
 
-    const loggerOpts = {
-      level: context.logLevel
-    }
+    let childLogger
+    if (hasLogger === false && context.childLoggerFactory === defaultChildLoggerFactory) {
+      // the null logger children are the logger itself, so we can skip
+      // the child logger creation altogether
+      childLogger = logger
+    } else {
+      const loggerOpts = {
+        level: context.logLevel
+      }
 
-    if (context.logSerializers) {
-      loggerOpts.serializers = context.logSerializers
+      if (context.logSerializers) {
+        loggerOpts.serializers = context.logSerializers
+      }
+      childLogger = createChildLogger(context, logger, req, id, loggerOpts)
     }
-    const childLogger = createChildLogger(context, logger, req, id, loggerOpts)
-    // Set initial value; will be re-evaluated after FastifyRequest is constructed if it's a function
-    childLogger[kDisableRequestLogging] = disableRequestLoggingFn ? false : disableRequestLogging
 
     if (closing === true) {
       /* istanbul ignore next mac, windows */
@@ -493,7 +492,9 @@ function buildRouting (options) {
         }
         res.writeHead(503, headers)
         res.end('{"error":"Service Unavailable","message":"Service Unavailable","statusCode":503}')
-        childLogger.info({ res: { statusCode: 503 } }, 'request aborted - refusing to accept new requests as server is closing')
+
+        context.server[kLogController].serviceUnavailable(childLogger, context.server)
+
         return
       }
     }
@@ -518,16 +519,7 @@ function buildRouting (options) {
     const request = new context.Request(id, params, req, query, childLogger, context)
     const reply = new context.Reply(res, request, childLogger)
 
-    // Evaluate disableRequestLogging after FastifyRequest is constructed
-    // so the caller has access to decorations and customizations
-    const resolvedDisableRequestLogging = disableRequestLoggingFn
-      ? disableRequestLoggingFn(request)
-      : disableRequestLogging
-    childLogger[kDisableRequestLogging] = resolvedDisableRequestLogging
-
-    if (resolvedDisableRequestLogging === false) {
-      childLogger.info({ req: request }, 'incoming request')
-    }
+    context.server[kLogController].incomingRequest(request, reply)
 
     // Handler timeout setup — only when configured (zero overhead otherwise)
     const handlerTimeout = context.handlerTimeout
@@ -558,6 +550,13 @@ function buildRouting (options) {
       setupResponseListeners(reply)
     }
 
+    if (context.onTimeout !== null) {
+      if (!request.raw.socket._meta) {
+        request.raw.socket.on('timeout', handleTimeout)
+      }
+      request.raw.socket._meta = { context, request, reply, onTimeout: handleTimeout }
+    }
+
     if (context.onRequest !== null) {
       onRequestHookRunner(
         context.onRequest,
@@ -581,13 +580,6 @@ function buildRouting (options) {
         }
       })
     }
-
-    if (context.onTimeout !== null) {
-      if (!request.raw.socket._meta) {
-        request.raw.socket.on('timeout', handleTimeout)
-      }
-      request.raw.socket._meta = { context, request, reply }
-    }
   }
 }
 

package/lib/schemas.js

@@ -149,7 +149,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   }
   if (responseSchemaDef[statusCode]) {
     if (responseSchemaDef[statusCode].constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef[statusCode][ct.mediaType]) {
           return responseSchemaDef[statusCode][ct.mediaType]
@@ -168,7 +168,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   const fallbackStatusCode = (statusCode + '')[0] + 'xx'
   if (responseSchemaDef[fallbackStatusCode]) {
     if (responseSchemaDef[fallbackStatusCode].constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef[fallbackStatusCode][ct.mediaType]) {
           return responseSchemaDef[fallbackStatusCode][ct.mediaType]
@@ -187,7 +187,7 @@ function getSchemaSerializer (context, statusCode, contentType) {
   }
   if (responseSchemaDef.default) {
     if (responseSchemaDef.default.constructor === Object) {
-      const ct = new ContentType(contentType)
+      const ct = ContentType.from(contentType)
       if (ct.isValid) {
         if (responseSchemaDef.default[ct.mediaType]) {
           return responseSchemaDef.default[ct.mediaType]

package/lib/symbols.js

@@ -13,7 +13,6 @@ const keys = {
   kContentTypeParser: Symbol('fastify.contentTypeParser'),
   kState: Symbol('fastify.state'),
   kOptions: Symbol('fastify.options'),
-  kDisableRequestLogging: Symbol('fastify.disableRequestLogging'),
   kPluginNameChain: Symbol('fastify.pluginNameChain'),
   kRouteContext: Symbol('fastify.context'),
   kGenReqId: Symbol('fastify.genReqId'),
@@ -67,6 +66,7 @@ const keys = {
   kHasBeenDecorated: Symbol('fastify.hasBeenDecorated'),
   kKeepAliveConnections: Symbol('fastify.keepAliveConnections'),
   kRouteByFastify: Symbol('fastify.routeByFastify'),
+  kLogController: Symbol('fastify.logController'),
   kDiagnosticsStore: Symbol('fastify.diagnosticsStore')
 }
 

package/lib/validation.js

@@ -138,7 +138,7 @@ function validateParam (validatorFunction, request, paramName) {
   function answer (ret) {
     if (ret === false) return validatorFunction.errors
     if (ret && ret.error) return ret.error
-    if (ret && ret.value) request[paramName] = ret.value
+    if (ret && typeof ret === 'object' && 'value' in ret) request[paramName] = ret.value
     return false
   }
 }
@@ -146,6 +146,15 @@ function validateParam (validatorFunction, request, paramName) {
 function validate (context, request, execution) {
   const runExecution = execution === undefined
 
+  if (runExecution &&
+    context[paramsSchema] === undefined &&
+    context[bodySchema] === undefined &&
+    context[querystringSchema] === undefined &&
+    context[headersSchema] === undefined) {
+    // the route has no validation schemas
+    return false
+  }
+
   if (runExecution || !execution.skipParams) {
     const params = validateParam(context[paramsSchema], request, 'params')
     if (params) {