fastify 4.28.0 → 5.0.0-alpha.2

package/lib/contentTypeParser.js

@@ -2,7 +2,6 @@
 
 const { AsyncResource } = require('node:async_hooks')
 const { FifoMap: Fifo } = require('toad-cache')
-const { safeParse: safeParseContentType, defaultContentType } = require('fast-content-type-parse')
 const secureJson = require('secure-json-parse')
 const {
   kDefaultJsonParse,
@@ -27,6 +26,7 @@ const {
   FST_ERR_CTP_EMPTY_JSON_BODY,
   FST_ERR_CTP_INSTANCE_ALREADY_STARTED
 } = require('./errors')
+const { FSTSEC001 } = require('./warnings')
 
 function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning) {
   this[kDefaultJsonParse] = getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)
@@ -34,7 +34,7 @@ function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning)
   this.customParsers = new Map()
   this.customParsers.set('application/json', new Parser(true, false, bodyLimit, this[kDefaultJsonParse]))
   this.customParsers.set('text/plain', new Parser(true, false, bodyLimit, defaultPlainTextParser))
-  this.parserList = [new ParserListItem('application/json'), new ParserListItem('text/plain')]
+  this.parserList = ['application/json', 'text/plain']
   this.parserRegExpList = []
   this.cache = new Fifo(100)
 }
@@ -42,9 +42,16 @@ function ContentTypeParser (bodyLimit, onProtoPoisoning, onConstructorPoisoning)
 ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
   const contentTypeIsString = typeof contentType === 'string'
 
-  if (!contentTypeIsString && !(contentType instanceof RegExp)) throw new FST_ERR_CTP_INVALID_TYPE()
-  if (contentTypeIsString && contentType.length === 0) throw new FST_ERR_CTP_EMPTY_TYPE()
-  if (typeof parserFn !== 'function') throw new FST_ERR_CTP_INVALID_HANDLER()
+  if (contentTypeIsString) {
+    contentType = contentType.trim().toLowerCase()
+    if (contentType.length === 0) throw new FST_ERR_CTP_EMPTY_TYPE()
+  } else if (!(contentType instanceof RegExp)) {
+    throw new FST_ERR_CTP_INVALID_TYPE()
+  }
+
+  if (typeof parserFn !== 'function') {
+    throw new FST_ERR_CTP_INVALID_HANDLER()
+  }
 
   if (this.existingParser(contentType)) {
     throw new FST_ERR_CTP_ALREADY_PRESENT(contentType)
@@ -63,21 +70,29 @@ ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
     parserFn
   )
 
-  if (contentTypeIsString && contentType === '*') {
+  if (contentType === '*') {
     this.customParsers.set('', parser)
   } else {
     if (contentTypeIsString) {
-      this.parserList.unshift(new ParserListItem(contentType))
+      this.parserList.unshift(contentType)
+      this.customParsers.set(contentType, parser)
     } else {
-      contentType.isEssence = contentType.source.indexOf(';') === -1
+      validateRegExp(contentType)
       this.parserRegExpList.unshift(contentType)
+      this.customParsers.set(contentType.toString(), parser)
     }
-    this.customParsers.set(contentType.toString(), parser)
   }
 }
 
 ContentTypeParser.prototype.hasParser = function (contentType) {
-  return this.customParsers.has(typeof contentType === 'string' ? contentType : contentType.toString())
+  if (typeof contentType === 'string') {
+    contentType = contentType.trim().toLowerCase()
+  } else {
+    if (!(contentType instanceof RegExp)) throw new FST_ERR_CTP_INVALID_TYPE()
+    contentType = contentType.toString()
+  }
+
+  return this.customParsers.has(contentType)
 }
 
 ContentTypeParser.prototype.existingParser = function (contentType) {
@@ -92,27 +107,20 @@ ContentTypeParser.prototype.existingParser = function (contentType) {
 }
 
 ContentTypeParser.prototype.getParser = function (contentType) {
-  if (this.hasParser(contentType)) {
-    return this.customParsers.get(contentType)
-  }
-
-  const parser = this.cache.get(contentType)
+  let parser = this.customParsers.get(contentType)
   if (parser !== undefined) return parser
 
-  const parsed = safeParseContentType(contentType)
-
-  // dummyContentType always the same object
-  // we can use === for the comparison and return early
-  if (parsed === defaultContentType) {
-    return this.customParsers.get('')
-  }
+  parser = this.cache.get(contentType)
+  if (parser !== undefined) return parser
 
   // eslint-disable-next-line no-var
   for (var i = 0; i !== this.parserList.length; ++i) {
     const parserListItem = this.parserList[i]
-    if (compareContentType(parsed, parserListItem)) {
-      const parser = this.customParsers.get(parserListItem.name)
-      // we set request content-type in cache to reduce parsing of MIME type
+    if (
+      contentType.slice(0, parserListItem.length) === parserListItem &&
+      (contentType.length === parserListItem.length || contentType.charCodeAt(parserListItem.length) === 59 /* `;` */ || contentType.charCodeAt(parserListItem.length) === 32 /* ` ` */)
+    ) {
+      parser = this.customParsers.get(parserListItem)
       this.cache.set(contentType, parser)
       return parser
     }
@@ -121,9 +129,8 @@ ContentTypeParser.prototype.getParser = function (contentType) {
   // eslint-disable-next-line no-var
   for (var j = 0; j !== this.parserRegExpList.length; ++j) {
     const parserRegExp = this.parserRegExpList[j]
-    if (compareRegExpContentType(contentType, parsed.type, parserRegExp)) {
-      const parser = this.customParsers.get(parserRegExp.toString())
-      // we set request content-type in cache to reduce parsing of MIME type
+    if (parserRegExp.test(contentType)) {
+      parser = this.customParsers.get(parserRegExp.toString())
       this.cache.set(contentType, parser)
       return parser
     }
@@ -140,13 +147,19 @@ ContentTypeParser.prototype.removeAll = function () {
 }
 
 ContentTypeParser.prototype.remove = function (contentType) {
-  if (!(typeof contentType === 'string' || contentType instanceof RegExp)) throw new FST_ERR_CTP_INVALID_TYPE()
+  let parsers
 
-  const removed = this.customParsers.delete(contentType.toString())
-
-  const parsers = typeof contentType === 'string' ? this.parserList : this.parserRegExpList
+  if (typeof contentType === 'string') {
+    contentType = contentType.trim().toLowerCase()
+    parsers = this.parserList
+  } else {
+    if (!(contentType instanceof RegExp)) throw new FST_ERR_CTP_INVALID_TYPE()
+    contentType = contentType.toString()
+    parsers = this.parserRegExpList
+  }
 
-  const idx = parsers.findIndex(ct => ct.toString() === contentType.toString())
+  const removed = this.customParsers.delete(contentType)
+  const idx = parsers.findIndex(ct => ct.toString() === contentType)
 
   if (idx > -1) {
     parsers.splice(idx, 1)
@@ -182,7 +195,7 @@ ContentTypeParser.prototype.run = function (contentType, handler, request, reply
   } else {
     const result = parser.fn(request, request[kRequestPayloadStream], done)
 
-    if (result && typeof result.then === 'function') {
+    if (typeof result?.then === 'function') {
       result.then(body => done(null, body), done)
     }
   }
@@ -205,9 +218,7 @@ ContentTypeParser.prototype.run = function (contentType, handler, request, reply
 function rawBody (request, reply, options, parser, done) {
   const asString = parser.asString
   const limit = options.limit === null ? parser.bodyLimit : options.limit
-  const contentLength = request.headers['content-length'] === undefined
-    ? NaN
-    : Number(request.headers['content-length'])
+  const contentLength = Number(request.headers['content-length'])
 
   if (contentLength > limit) {
     // We must close the connection as the client is going
@@ -373,60 +384,15 @@ function removeAllContentTypeParsers () {
   this[kContentTypeParser].removeAll()
 }
 
-function compareContentType (contentType, parserListItem) {
-  if (parserListItem.isEssence) {
-    // we do essence check
-    return contentType.type.indexOf(parserListItem) !== -1
-  } else {
-    // when the content-type includes parameters
-    // we do a full-text search
-    // reject essence content-type before checking parameters
-    if (contentType.type.indexOf(parserListItem.type) === -1) return false
-    for (const key of parserListItem.parameterKeys) {
-      // reject when missing parameters
-      if (!(key in contentType.parameters)) return false
-      // reject when parameters do not match
-      if (contentType.parameters[key] !== parserListItem.parameters[key]) return false
-    }
-    return true
-  }
-}
-
-function compareRegExpContentType (contentType, essenceMIMEType, regexp) {
-  if (regexp.isEssence) {
-    // we do essence check
-    return regexp.test(essenceMIMEType)
-  } else {
-    // when the content-type includes parameters
-    // we do a full-text match
-    return regexp.test(contentType)
+function validateRegExp (regexp) {
+  // RegExp should either start with ^ or include ;?
+  // It can ensure the user is properly detect the essence
+  // MIME types.
+  if (regexp.source[0] !== '^' && regexp.source.includes(';?') === false) {
+    FSTSEC001(regexp.source)
   }
 }
 
-function ParserListItem (contentType) {
-  this.name = contentType
-  // we pre-calculate all the needed information
-  // before content-type comparison
-  const parsed = safeParseContentType(contentType)
-  this.isEssence = contentType.indexOf(';') === -1
-  // we should not allow empty string for parser list item
-  // because it would become a match-all handler
-  if (this.isEssence === false && parsed.type === '') {
-    // handle semicolon or empty string
-    const tmp = contentType.split(';', 1)[0]
-    this.type = tmp === '' ? contentType : tmp
-  } else {
-    this.type = parsed.type
-  }
-  this.parameters = parsed.parameters
-  this.parameterKeys = Object.keys(parsed.parameters)
-}
-
-// used in ContentTypeParser.remove
-ParserListItem.prototype.toString = function () {
-  return this.name
-}
-
 module.exports = ContentTypeParser
 module.exports.helpers = {
   buildContentTypeParser,

package/lib/decorate.js

@@ -1,7 +1,5 @@
 'use strict'
 
-/* eslint no-prototype-builtins: 0 */
-
 const {
   kReply,
   kRequest,
@@ -13,11 +11,10 @@ const {
   FST_ERR_DEC_ALREADY_PRESENT,
   FST_ERR_DEC_MISSING_DEPENDENCY,
   FST_ERR_DEC_AFTER_START,
+  FST_ERR_DEC_REFERENCE_TYPE,
   FST_ERR_DEC_DEPENDENCY_INVALID_TYPE
 } = require('./errors')
 
-const { FSTDEP006 } = require('./warnings')
-
 function decorate (instance, name, fn, dependencies) {
   if (Object.prototype.hasOwnProperty.call(instance, name)) {
     throw new FST_ERR_DEC_ALREADY_PRESENT(name)
@@ -58,7 +55,7 @@ function decorateConstructor (konstructor, name, fn, dependencies) {
 
 function checkReferenceType (name, fn) {
   if (typeof fn === 'object' && fn && !(typeof fn.getter === 'function' || typeof fn.setter === 'function')) {
-    FSTDEP006(name)
+    throw new FST_ERR_DEC_REFERENCE_TYPE(name, typeof fn)
   }
 }
 
@@ -102,8 +99,7 @@ function checkDependencies (instance, name, deps) {
     throw new FST_ERR_DEC_DEPENDENCY_INVALID_TYPE(name)
   }
 
-  // eslint-disable-next-line no-var
-  for (var i = 0; i !== deps.length; ++i) {
+  for (let i = 0; i !== deps.length; ++i) {
     if (!checkExistence(instance, deps[i])) {
       throw new FST_ERR_DEC_MISSING_DEPENDENCY(deps[i])
     }

package/lib/error-serializer.js

@@ -1,5 +1,5 @@
 // This file is autogenerated by build/build-error-serializer.js, do not edit
-/* istanbul ignore file */
+/* c8 ignore start */
 
   'use strict'
 
@@ -117,3 +117,4 @@ let addComma = false
     return main
     
 }(validator, serializer)
+/* c8 ignore stop */

package/lib/errors.js

@@ -151,6 +151,10 @@ const codes = {
     'FST_ERR_DEC_AFTER_START',
     "The decorator '%s' has been added after start!"
   ),
+  FST_ERR_DEC_REFERENCE_TYPE: createError(
+    'FST_ERR_DEC_REFERENCE_TYPE',
+    "The decorator '%s' of type '%s' is a reference type. Use the { getter, setter } interface instead."
+  ),
 
   /**
    * hooks
@@ -209,6 +213,27 @@ const codes = {
     TypeError
   ),
 
+  FST_ERR_LOG_INVALID_LOGGER_INSTANCE: createError(
+    'FST_ERR_LOG_INVALID_LOGGER_INSTANCE',
+    'loggerInstance only accepts a logger instance.',
+    500,
+    TypeError
+  ),
+
+  FST_ERR_LOG_INVALID_LOGGER_CONFIG: createError(
+    'FST_ERR_LOG_INVALID_LOGGER_CONFIG',
+    'logger options only accepts a configuration object.',
+    500,
+    TypeError
+  ),
+
+  FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED: createError(
+    'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED',
+    'You cannot provide both logger and loggerInstance. Please provide only one.',
+    500,
+    TypeError
+  ),
+
   /**
    * reply
   */
@@ -339,12 +364,6 @@ const codes = {
     'Unexpected error from async constraint',
     500
   ),
-  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE: createError(
-    'FST_ERR_DEFAULT_ROUTE_INVALID_TYPE',
-    'The defaultRoute type should be a function',
-    500,
-    TypeError
-  ),
   FST_ERR_INVALID_URL: createError(
     'FST_ERR_INVALID_URL',
     "URL must be a string. Received '%s'",
@@ -429,6 +448,12 @@ const codes = {
     'FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE',
     "The decorator '%s'%s is not present in %s"
   ),
+  FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER: createError(
+    'FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER',
+    'The %s plugin being registered mixes async and callback styles. Async plugin should not mix async and callback style.',
+    500,
+    TypeError
+  ),
 
   /**
    *  Avvio Errors

package/lib/handleRequest.js

@@ -1,13 +1,18 @@
 'use strict'
 
+const { bodylessMethods, bodyMethods } = require('./httpMethods')
+const diagnostics = require('dc-polyfill')
 const { validate: validateSchema } = require('./validation')
 const { preValidationHookRunner, preHandlerHookRunner } = require('./hooks')
 const wrapThenable = require('./wrapThenable')
 const {
   kReplyIsError,
-  kRouteContext
+  kRouteContext,
+  kFourOhFourContext
 } = require('./symbols')
 
+const channels = diagnostics.tracingChannel('fastify.request.handler')
+
 function handleRequest (err, request, reply) {
   if (reply.sent === true) return
   if (err != null) {
@@ -20,45 +25,37 @@ function handleRequest (err, request, reply) {
   const headers = request.headers
   const context = request[kRouteContext]
 
-  if (method === 'GET' || method === 'HEAD') {
+  if (bodylessMethods.has(method)) {
     handler(request, reply)
     return
   }
 
-  const contentType = headers['content-type']
+  if (bodyMethods.has(method)) {
+    const contentType = headers['content-type']
+    const contentLength = headers['content-length']
+    const transferEncoding = headers['transfer-encoding']
 
-  if (method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'TRACE' || method === 'SEARCH' ||
-    method === 'PROPFIND' || method === 'PROPPATCH' || method === 'LOCK' || method === 'REPORT' || method === 'MKCALENDAR') {
     if (contentType === undefined) {
       if (
-        headers['transfer-encoding'] === undefined &&
-        (headers['content-length'] === '0' || headers['content-length'] === undefined)
-      ) { // Request has no body to parse
+        (contentLength === undefined || contentLength === '0') &&
+        transferEncoding === undefined
+      ) {
+        // Request has no body to parse
         handler(request, reply)
       } else {
         context.contentTypeParser.run('', handler, request, reply)
       }
     } else {
+      if (contentLength === undefined && transferEncoding === undefined && method === 'OPTIONS') {
+        // OPTIONS can have a Content-Type header without a body
+        handler(request, reply)
+        return
+      }
       context.contentTypeParser.run(contentType, handler, request, reply)
     }
     return
   }
 
-  if (method === 'OPTIONS' || method === 'DELETE') {
-    if (
-      contentType !== undefined &&
-      (
-        headers['transfer-encoding'] !== undefined ||
-        headers['content-length'] !== undefined
-      )
-    ) {
-      context.contentTypeParser.run(contentType, handler, request, reply)
-    } else {
-      handler(request, reply)
-    }
-    return
-  }
-
   // Return 404 instead of 405 see https://github.com/fastify/fastify/pull/862 for discussion
   handler(request, reply)
 }
@@ -126,28 +123,62 @@ function validationCompleted (request, reply, validationErr) {
 function preHandlerCallback (err, request, reply) {
   if (reply.sent) return
 
-  if (err != null) {
-    reply[kReplyIsError] = true
-    reply.send(err)
-    return
+  const context = request[kRouteContext]
+
+  if (!channels.hasSubscribers || context[kFourOhFourContext] === null) {
+    preHandlerCallbackInner(err, request, reply)
+  } else {
+    const store = {
+      request,
+      reply,
+      async: false,
+      route: {
+        url: context.config.url,
+        method: context.config.method
+      }
+    }
+    channels.start.runStores(store, preHandlerCallbackInner, undefined, err, request, reply, store)
   }
+}
 
-  let result
+function preHandlerCallbackInner (err, request, reply, store) {
+  const context = request[kRouteContext]
 
   try {
-    result = request[kRouteContext].handler(request, reply)
-  } catch (err) {
-    reply[kReplyIsError] = true
-    reply.send(err)
-    return
-  }
+    if (err != null) {
+      reply[kReplyIsError] = true
+      reply.send(err)
+      if (store) {
+        store.error = err
+        channels.error.publish(store)
+      }
+      return
+    }
 
-  if (result !== undefined) {
-    if (result !== null && typeof result.then === 'function') {
-      wrapThenable(result, reply)
-    } else {
-      reply.send(result)
+    let result
+
+    try {
+      result = context.handler(request, reply)
+    } catch (err) {
+      if (store) {
+        store.error = err
+        channels.error.publish(store)
+      }
+
+      reply[kReplyIsError] = true
+      reply.send(err)
+      return
+    }
+
+    if (result !== undefined) {
+      if (result !== null && typeof result.then === 'function') {
+        wrapThenable(result, reply, store)
+      } else {
+        reply.send(result)
+      }
     }
+  } finally {
+    if (store) channels.end.publish(store)
   }
 }
 

package/lib/httpMethods.js

@@ -1,24 +1,40 @@
 'use strict'
 
+const bodylessMethods = new Set([
+  // Standard
+  'GET',
+  'HEAD',
+  'TRACE',
+
+  // WebDAV
+  'UNLOCK'
+])
+
+const bodyMethods = new Set([
+  // Standard
+  'DELETE',
+  'OPTIONS',
+  'PATCH',
+  'PUT',
+  'POST',
+
+  // WebDAV
+  'COPY',
+  'LOCK',
+  'MOVE',
+  'MKCOL',
+  'PROPFIND',
+  'PROPPATCH',
+  'REPORT',
+  'SEARCH',
+  'MKCALENDAR'
+])
+
 module.exports = {
+  bodylessMethods,
+  bodyMethods,
   supportedMethods: [
-    'DELETE',
-    'GET',
-    'HEAD',
-    'PATCH',
-    'POST',
-    'PUT',
-    'OPTIONS',
-    'PROPFIND',
-    'PROPPATCH',
-    'MKCOL',
-    'COPY',
-    'MOVE',
-    'LOCK',
-    'UNLOCK',
-    'TRACE',
-    'SEARCH',
-    'REPORT',
-    'MKCALENDAR'
+    ...bodylessMethods,
+    ...bodyMethods
   ]
 }

package/lib/logger.js

@@ -11,7 +11,10 @@ const pino = require('pino')
 const { serializersSym } = pino.symbols
 const {
   FST_ERR_LOG_INVALID_DESTINATION,
-  FST_ERR_LOG_INVALID_LOGGER
+  FST_ERR_LOG_INVALID_LOGGER,
+  FST_ERR_LOG_INVALID_LOGGER_INSTANCE,
+  FST_ERR_LOG_INVALID_LOGGER_CONFIG,
+  FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED
 } = require('./errors')
 
 function createPinoLogger (opts) {
@@ -51,7 +54,7 @@ const serializers = {
       method: req.method,
       url: req.url,
       version: req.headers && req.headers['accept-version'],
-      hostname: req.hostname,
+      host: req.host,
       remoteAddress: req.ip,
       remotePort: req.socket ? req.socket.remotePort : undefined
     }
@@ -70,20 +73,35 @@ function now () {
 }
 
 function createLogger (options) {
-  if (!options.logger) {
+  // if no logger is provided, then create a default logger
+  if (!options.loggerInstance && !options.logger) {
     const logger = nullLogger
     logger.child = () => logger
     return { logger, hasLogger: false }
   }
 
-  if (validateLogger(options.logger)) {
+  if (options.logger && options.loggerInstance) {
+    throw new FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED()
+  }
+
+  // check if the logger instance has all required properties
+  if (validateLogger(options.loggerInstance)) {
     const logger = createPinoLogger({
-      logger: options.logger,
-      serializers: Object.assign({}, serializers, options.logger.serializers)
+      logger: options.loggerInstance,
+      serializers: Object.assign({}, serializers, options.loggerInstance.serializers)
     })
     return { logger, hasLogger: true }
   }
 
+  // if a logger instance is passed to logger, throw an exception
+  if (validateLogger(options.logger)) {
+    throw FST_ERR_LOG_INVALID_LOGGER_CONFIG()
+  }
+
+  if (options.loggerInstance) {
+    throw FST_ERR_LOG_INVALID_LOGGER_INSTANCE()
+  }
+
   const localLoggerOptions = {}
   if (Object.prototype.toString.call(options.logger) === '[object Object]') {
     Reflect.ownKeys(options.logger).forEach(prop => {

package/lib/pluginUtils.js

@@ -9,9 +9,9 @@ const {
 const { exist, existReply, existRequest } = require('./decorate')
 const {
   FST_ERR_PLUGIN_VERSION_MISMATCH,
-  FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE
+  FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE,
+  FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER
 } = require('./errors')
-const { FSTWRN002 } = require('./warnings.js')
 
 function getMeta (fn) {
   return fn[Symbol.for('plugin-meta')]
@@ -106,11 +106,11 @@ function _checkDecorators (that, instance, decorators, name) {
 
 function checkVersion (fn) {
   const meta = getMeta(fn)
-  if (!meta) return
+  if (meta == null || meta?.fastify == null) return
 
   const requiredVersion = meta.fastify
 
-  const fastifyRc = /-rc.+$/.test(this.version)
+  const fastifyRc = /-(rc|pre|alpha).+$/.test(this.version)
   if (fastifyRc === true && semver.gt(this.version, semver.coerce(requiredVersion)) === true) {
     // A Fastify release candidate phase is taking place. In order to reduce
     // the effort needed to test plugins with the RC, we allow plugins targeting
@@ -138,7 +138,7 @@ function registerPluginName (fn) {
 
 function checkPluginHealthiness (fn, pluginName) {
   if (fn.constructor.name === 'AsyncFunction' && fn.length === 3) {
-    FSTWRN002(pluginName || 'anonymous')
+    throw new FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER(pluginName)
   }
 }