fastify 5.8.5 → 5.10.0

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,8 +58,10 @@ 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
 
 function Reply (res, request, log) {
   this.raw = res
@@ -75,6 +77,7 @@ function Reply (res, request, log) {
   this.log = log
 }
 Reply.props = []
+Reply.instanceProperties = new Set(['raw', 'request', 'log'])
 
 Object.defineProperties(Reply.prototype, {
   [kRouteContext]: {
@@ -133,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
 }
 
@@ -157,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 (
@@ -167,7 +178,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
@@ -199,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') {
@@ -593,7 +603,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,19 +687,62 @@ 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 logStreamError (logger, err, res) {
-  if (err.code === 'ERR_STREAM_PREMATURE_CLOSE') {
-    if (!logger[kDisableRequestLogging]) {
-      logger.info({ res }, 'stream closed prematurely')
+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
     }
-  } else {
-    logger.warn({ err }, 'response terminated with an error with headers already sent')
+    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 (err, reply, res) {
+  reply.server[kLogController].streamError(err, reply.request, reply)
 }
 
 function sendWebStream (payload, res, reply) {
@@ -706,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)
     }
@@ -754,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 {
@@ -778,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 {
@@ -792,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()
@@ -830,10 +883,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 +901,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 +970,14 @@ 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.removeListener('timeout', socket._meta.onTimeout)
+      socket._meta = null
+    }
+
     if (ctx && ctx.onResponse !== null) {
       onResponseHookRunner(
         ctx.onResponse,
@@ -931,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

@@ -10,6 +10,7 @@ const {
   kSchemaController,
   kOptions,
   kRequestCacheValidateFns,
+  kRequestContentType,
   kRouteContext,
   kRequestOriginalUrl,
   kRequestSignal,
@@ -17,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,
@@ -36,6 +38,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 +120,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 +135,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) {
@@ -256,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
       }
@@ -282,6 +284,14 @@ Object.defineProperties(Request.prototype, {
       this.additionalHeaders = headers
     }
   },
+  mediaType: {
+    get () {
+      if (!this[kRequestContentType] && this.headers['content-type'] !== undefined) {
+        this[kRequestContentType] = ContentType.from(this.headers['content-type'])
+      }
+      return this[kRequestContentType]?.mediaType
+    }
+  },
   getValidationFunction: {
     value: function (httpPartOrSchema) {
       if (typeof httpPartOrSchema === 'string') {

package/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,
@@ -42,7 +43,6 @@ const {
   kReplySerializerDefault,
   kReplyIsError,
   kRequestPayloadStream,
-  kDisableRequestLogging,
   kSchemaErrorFormatter,
   kErrorHandler,
   kHasBeenDecorated,
@@ -51,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')
 
@@ -68,6 +69,7 @@ const routerKeys = [
   'ignoreTrailingSlash',
   'maxParamLength',
   'onBadUrl',
+  'onMaxParamLength',
   'querystringParser',
   'useSemicolonDelimiter'
 ]
@@ -81,8 +83,6 @@ function buildRouting (options) {
   let hasLogger
   let setupResponseListeners
   let throwIfAlreadyStarted
-  let disableRequestLogging
-  let disableRequestLoggingFn
   let ignoreTrailingSlash
   let ignoreDuplicateSlashes
   let return503OnClosing
@@ -105,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
@@ -284,6 +280,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 +362,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)
           }
@@ -459,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 */
@@ -476,19 +479,22 @@ 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'
         }
         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
       }
     }
@@ -513,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
@@ -553,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,
@@ -576,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 }
-    }
   }
 }
 
@@ -635,6 +632,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/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)

package/lib/schemas.js

@@ -10,6 +10,7 @@ const {
   FST_ERR_SCH_DUPLICATE,
   FST_ERR_SCH_CONTENT_MISSING_SCHEMA
 } = require('./errors')
+const ContentType = require('./content-type')
 
 const SCHEMAS_SOURCE = ['params', 'body', 'querystring', 'query', 'headers']
 
@@ -147,52 +148,58 @@ function getSchemaSerializer (context, statusCode, contentType) {
     return false
   }
   if (responseSchemaDef[statusCode]) {
-    if (responseSchemaDef[statusCode].constructor === Object && contentType) {
-      const mediaName = contentType.split(';', 1)[0]
-      if (responseSchemaDef[statusCode][mediaName]) {
-        return responseSchemaDef[statusCode][mediaName]
-      }
+    if (responseSchemaDef[statusCode].constructor === Object) {
+      const ct = new ContentType(contentType)
+      if (ct.isValid) {
+        if (responseSchemaDef[statusCode][ct.mediaType]) {
+          return responseSchemaDef[statusCode][ct.mediaType]
+        }
 
-      // fallback to match all media-type
-      if (responseSchemaDef[statusCode]['*/*']) {
-        return responseSchemaDef[statusCode]['*/*']
-      }
+        // fallback to match all media-type
+        if (responseSchemaDef[statusCode]['*/*']) {
+          return responseSchemaDef[statusCode]['*/*']
+        }
 
-      return false
+        return false
+      }
     }
     return responseSchemaDef[statusCode]
   }
   const fallbackStatusCode = (statusCode + '')[0] + 'xx'
   if (responseSchemaDef[fallbackStatusCode]) {
-    if (responseSchemaDef[fallbackStatusCode].constructor === Object && contentType) {
-      const mediaName = contentType.split(';', 1)[0]
-      if (responseSchemaDef[fallbackStatusCode][mediaName]) {
-        return responseSchemaDef[fallbackStatusCode][mediaName]
-      }
+    if (responseSchemaDef[fallbackStatusCode].constructor === Object) {
+      const ct = new ContentType(contentType)
+      if (ct.isValid) {
+        if (responseSchemaDef[fallbackStatusCode][ct.mediaType]) {
+          return responseSchemaDef[fallbackStatusCode][ct.mediaType]
+        }
 
-      // fallback to match all media-type
-      if (responseSchemaDef[fallbackStatusCode]['*/*']) {
-        return responseSchemaDef[fallbackStatusCode]['*/*']
-      }
+        // fallback to match all media-type
+        if (responseSchemaDef[fallbackStatusCode]['*/*']) {
+          return responseSchemaDef[fallbackStatusCode]['*/*']
+        }
 
-      return false
+        return false
+      }
     }
 
     return responseSchemaDef[fallbackStatusCode]
   }
   if (responseSchemaDef.default) {
-    if (responseSchemaDef.default.constructor === Object && contentType) {
-      const mediaName = contentType.split(';', 1)[0]
-      if (responseSchemaDef.default[mediaName]) {
-        return responseSchemaDef.default[mediaName]
-      }
+    if (responseSchemaDef.default.constructor === Object) {
+      const ct = new ContentType(contentType)
+      if (ct.isValid) {
+        if (responseSchemaDef.default[ct.mediaType]) {
+          return responseSchemaDef.default[ct.mediaType]
+        }
 
-      // fallback to match all media-type
-      if (responseSchemaDef.default['*/*']) {
-        return responseSchemaDef.default['*/*']
-      }
+        // fallback to match all media-type
+        if (responseSchemaDef.default['*/*']) {
+          return responseSchemaDef.default['*/*']
+        }
 
-      return false
+        return false
+      }
     }
 
     return responseSchemaDef.default