fastify 4.28.0 → 5.0.0-alpha.3

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)
   }
 }
 

package/lib/reply.js

@@ -55,7 +55,7 @@ const {
   FST_ERR_MISSING_SERIALIZATION_FN,
   FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN
 } = require('./errors')
-const { FSTDEP010, FSTDEP013, FSTDEP019, FSTDEP020, FSTDEP021 } = require('./warnings')
+const { FSTDEP010, FSTDEP013, FSTDEP019, FSTDEP021 } = require('./warnings')
 
 const toString = Object.prototype.toString
 
@@ -137,6 +137,11 @@ Object.defineProperties(Reply.prototype, {
   }
 })
 
+Reply.prototype.writeEarlyHints = function (hints, callback) {
+  this.raw.writeEarlyHints(hints, callback)
+  return this
+}
+
 Reply.prototype.hijack = function () {
   this[kReplyHijacked] = true
   return this
@@ -477,13 +482,6 @@ Reply.prototype.callNotFound = function () {
   return this
 }
 
-// TODO: should be removed in fastify@5
-Reply.prototype.getResponseTime = function () {
-  FSTDEP020()
-
-  return this.elapsedTime
-}
-
 // Make reply a thenable, so it could be used with async/await.
 // See
 // - https://github.com/fastify/fastify/issues/1864 for the discussions
@@ -910,9 +908,8 @@ function buildReply (R) {
     this[kReplyEndTime] = undefined
     this.log = log
 
-    // eslint-disable-next-line no-var
     var prop
-    // eslint-disable-next-line no-var
+
     for (var i = 0; i < props.length; i++) {
       prop = props[i]
       this[prop.key] = prop.value

package/lib/request.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const proxyAddr = require('proxy-addr')
-const semver = require('semver')
 const {
   FSTDEP005,
   FSTDEP012,
@@ -49,8 +48,8 @@ function getTrustProxyFn (tp) {
     return tp
   }
   if (tp === true) {
-    // Support plain true/false
-    return function () { return true }
+    // Support trusting everything
+    return null
   }
   if (typeof tp === 'number') {
     // Support trusting hop count
@@ -115,7 +114,8 @@ function buildRequestWithTrustProxy (R, trustProxy) {
   Object.defineProperties(_Request.prototype, {
     ip: {
       get () {
-        return proxyAddr(this.raw, proxyFn)
+        const addrs = proxyAddr.all(this.raw, proxyFn)
+        return addrs[addrs.length - 1]
       }
     },
     ips: {
@@ -123,7 +123,7 @@ function buildRequestWithTrustProxy (R, trustProxy) {
         return proxyAddr.all(this.raw, proxyFn)
       }
     },
-    hostname: {
+    host: {
       get () {
         if (this.ip !== undefined && this.headers['x-forwarded-host']) {
           return getLastEntryInMultiHeaderValue(this.headers['x-forwarded-host'])
@@ -238,10 +238,7 @@ Object.defineProperties(Request.prototype, {
   },
   connection: {
     get () {
-      /* istanbul ignore next */
-      if (semver.gte(process.versions.node, '13.0.0')) {
-        FSTDEP005()
-      }
+      FSTDEP005()
       return this.raw.connection
     }
   },
@@ -257,11 +254,32 @@ Object.defineProperties(Request.prototype, {
       }
     }
   },
-  hostname: {
+  host: {
     get () {
       return this.raw.headers.host || this.raw.headers[':authority']
     }
   },
+  hostname: {
+    get () {
+      return (this.host).split(':')[0]
+    }
+  },
+  port: {
+    get () {
+      // first try taking port from host
+      const portFromHost = parseInt((this.host).split(':').slice(-1)[0])
+      if (!isNaN(portFromHost)) {
+        return portFromHost
+      }
+      // now fall back to port from host/:authority header
+      const portFromHeader = parseInt((this.headers.host || this.headers[':authority']).split(':').slice(-1)[0])
+      if (!isNaN(portFromHeader)) {
+        return portFromHeader
+      }
+      // fall back to null
+      return null
+    }
+  },
   protocol: {
     get () {
       if (this.socket) {
@@ -299,13 +317,13 @@ Object.defineProperties(Request.prototype, {
       }
 
       const validatorCompiler = this[kRouteContext].validatorCompiler ||
-      this.server[kSchemaController].validatorCompiler ||
-     (
-       // We compile the schemas if no custom validatorCompiler is provided
-       // nor set
-       this.server[kSchemaController].setupValidator(this.server[kOptions]) ||
-       this.server[kSchemaController].validatorCompiler
-     )
+        this.server[kSchemaController].validatorCompiler ||
+        (
+          // We compile the schemas if no custom validatorCompiler is provided
+          // nor set
+          this.server[kSchemaController].setupValidator(this.server[kOptions]) ||
+          this.server[kSchemaController].validatorCompiler
+        )
 
       const validateFn = validatorCompiler({
         schema,
@@ -342,8 +360,8 @@ Object.defineProperties(Request.prototype, {
 
       // We cannot compile if the schema is missed
       if (validate == null && (schema == null ||
-          typeof schema !== 'object' ||
-          Array.isArray(schema))
+        typeof schema !== 'object' ||
+        Array.isArray(schema))
       ) {
         throw new FST_ERR_REQ_INVALID_VALIDATION_INVOCATION(httpPart)
       }

package/lib/route.js

@@ -9,8 +9,7 @@ const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
 const {
   FSTDEP007,
-  FSTDEP008,
-  FSTDEP014
+  FSTDEP008
 } = require('./warnings')
 
 const {
@@ -21,7 +20,6 @@ const {
 const {
   FST_ERR_SCH_VALIDATION_BUILD,
   FST_ERR_SCH_SERIALIZATION_BUILD,
-  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE,
   FST_ERR_DUPLICATED_ROUTE,
   FST_ERR_INVALID_URL,
   FST_ERR_HOOK_INVALID_HANDLER,
@@ -72,7 +70,6 @@ function buildRouting (options) {
   let ignoreDuplicateSlashes
   let return503OnClosing
   let globalExposeHeadRoutes
-  let validateHTTPVersion
   let keepAliveConnections
 
   let closing = false
@@ -89,7 +86,6 @@ function buildRouting (options) {
       hasLogger = fastifyArgs.hasLogger
       setupResponseListeners = fastifyArgs.setupResponseListeners
       throwIfAlreadyStarted = fastifyArgs.throwIfAlreadyStarted
-      validateHTTPVersion = fastifyArgs.validateHTTPVersion
 
       globalExposeHeadRoutes = options.exposeHeadRoutes
       disableRequestLogging = options.disableRequestLogging
@@ -102,18 +98,6 @@ function buildRouting (options) {
     route, // configure a route in the fastify instance
     hasRoute,
     prepareRoute,
-    getDefaultRoute: function () {
-      FSTDEP014()
-      return router.defaultRoute
-    },
-    setDefaultRoute: function (defaultRoute) {
-      FSTDEP014()
-      if (typeof defaultRoute !== 'function') {
-        throw new FST_ERR_DEFAULT_ROUTE_INVALID_TYPE()
-      }
-
-      router.defaultRoute = defaultRoute
-    },
     routeHandler,
     closeRoutes: () => { closing = true },
     printRoutes: router.prettyPrint.bind(router),
@@ -169,10 +153,11 @@ function buildRouting (options) {
 
   function hasRoute ({ options }) {
     const normalizedMethod = options.method?.toUpperCase() ?? ''
-    return findRoute({
-      ...options,
-      method: normalizedMethod
-    }) !== null
+    return router.hasRoute(
+      normalizedMethod,
+      options.url || '',
+      options.constraints
+    )
   }
 
   function findRoute (options) {
@@ -460,19 +445,6 @@ function buildRouting (options) {
     const childLogger = createChildLogger(context, logger, req, id, loggerOpts)
     childLogger[kDisableRequestLogging] = disableRequestLogging
 
-    // TODO: The check here should be removed once https://github.com/nodejs/node/issues/43115 resolve in core.
-    if (!validateHTTPVersion(req.httpVersion)) {
-      childLogger.info({ res: { statusCode: 505 } }, 'request aborted - invalid HTTP version')
-      const message = '{"error":"HTTP Version Not Supported","message":"HTTP Version Not Supported","statusCode":505}'
-      const headers = {
-        'Content-Type': 'application/json',
-        'Content-Length': message.length
-      }
-      res.writeHead(505, headers)
-      res.end(message)
-      return
-    }
-
     if (closing === true) {
       /* istanbul ignore next mac, windows */
       if (req.httpVersionMajor !== 2) {