fastify 5.0.0 → 5.2.0

package/lib/{logger.js → logger-factory.js}

@@ -1,88 +1,90 @@
 'use strict'
 
-/**
- * Code imported from `pino-http`
- * Repo: https://github.com/pinojs/pino-http
- * License: MIT (https://raw.githubusercontent.com/pinojs/pino-http/master/LICENSE)
- */
-
-const nullLogger = require('abstract-logging')
-const pino = require('pino')
-const { serializersSym } = pino.symbols
 const {
-  FST_ERR_LOG_INVALID_DESTINATION,
-  FST_ERR_LOG_INVALID_LOGGER,
-  FST_ERR_LOG_INVALID_LOGGER_INSTANCE,
+  FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED,
   FST_ERR_LOG_INVALID_LOGGER_CONFIG,
-  FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED
+  FST_ERR_LOG_INVALID_LOGGER_INSTANCE,
+  FST_ERR_LOG_INVALID_LOGGER
 } = require('./errors')
 
-function createPinoLogger (opts) {
-  if (opts.stream && opts.file) {
-    throw new FST_ERR_LOG_INVALID_DESTINATION()
-  } else if (opts.file) {
-    // we do not have stream
-    opts.stream = pino.destination(opts.file)
-    delete opts.file
+/**
+ * Utility for creating a child logger with the appropriate bindings, logger factory
+ * and validation.
+ * @param {object} context
+ * @param {import('../fastify').FastifyBaseLogger} logger
+ * @param {import('../fastify').RawRequestDefaultExpression<any>} req
+ * @param {string} reqId
+ * @param {import('../types/logger.js').ChildLoggerOptions?} loggerOpts
+ *
+ * @returns {object} New logger instance, inheriting all parent bindings,
+ * with child bindings added.
+ */
+function createChildLogger (context, logger, req, reqId, loggerOpts) {
+  const loggerBindings = {
+    [context.requestIdLogLabel]: reqId
   }
+  const child = context.childLoggerFactory.call(context.server, logger, loggerBindings, loggerOpts || {}, req)
 
-  const prevLogger = opts.logger
-  const prevGenReqId = opts.genReqId
-  let logger = null
-
-  if (prevLogger) {
-    opts.logger = undefined
-    opts.genReqId = undefined
-    // we need to tap into pino internals because in v5 it supports
-    // adding serializers in child loggers
-    if (prevLogger[serializersSym]) {
-      opts.serializers = Object.assign({}, opts.serializers, prevLogger[serializersSym])
-    }
-    logger = prevLogger.child({}, opts)
-    opts.logger = prevLogger
-    opts.genReqId = prevGenReqId
-  } else {
-    logger = pino(opts, opts.stream)
+  // Optimization: bypass validation if the factory is our own default factory
+  if (context.childLoggerFactory !== defaultChildLoggerFactory) {
+    validateLogger(child, true) // throw if the child is not a valid logger
   }
 
-  return logger
+  return child
 }
 
-const serializers = {
-  req: function asReqValue (req) {
-    return {
-      method: req.method,
-      url: req.url,
-      version: req.headers && req.headers['accept-version'],
-      host: req.host,
-      remoteAddress: req.ip,
-      remotePort: req.socket ? req.socket.remotePort : undefined
-    }
-  },
-  err: pino.stdSerializers.err,
-  res: function asResValue (reply) {
-    return {
-      statusCode: reply.statusCode
-    }
-  }
+/** Default factory to create child logger instance
+ *
+ * @param {import('../fastify.js').FastifyBaseLogger} logger
+ * @param {import('../types/logger.js').Bindings} bindings
+ * @param {import('../types/logger.js').ChildLoggerOptions} opts
+ *
+ * @returns {import('../types/logger.js').FastifyBaseLogger}
+ */
+function defaultChildLoggerFactory (logger, bindings, opts) {
+  return logger.child(bindings, opts)
 }
 
-function now () {
-  const ts = process.hrtime()
-  return (ts[0] * 1e3) + (ts[1] / 1e6)
+/**
+ * Determines if a provided logger object meets the requirements
+ * of a Fastify compatible logger.
+ *
+ * @param {object} logger Object to validate.
+ * @param {boolean?} strict `true` if the object must be a logger (always throw if any methods missing)
+ *
+ * @returns {boolean} `true` when the logger meets the requirements.
+ *
+ * @throws {FST_ERR_LOG_INVALID_LOGGER} When the logger object is
+ * missing required methods.
+ */
+function validateLogger (logger, strict) {
+  const methods = ['info', 'error', 'debug', 'fatal', 'warn', 'trace', 'child']
+  const missingMethods = logger
+    ? methods.filter(method => !logger[method] || typeof logger[method] !== 'function')
+    : methods
+
+  if (!missingMethods.length) {
+    return true
+  } else if ((missingMethods.length === methods.length) && !strict) {
+    return false
+  } else {
+    throw FST_ERR_LOG_INVALID_LOGGER(missingMethods.join(','))
+  }
 }
 
 function createLogger (options) {
-  // if no logger is provided, then create a default logger
+  if (options.logger && options.loggerInstance) {
+    throw new FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED()
+  }
+
   if (!options.loggerInstance && !options.logger) {
+    const nullLogger = require('abstract-logging')
     const logger = nullLogger
     logger.child = () => logger
     return { logger, hasLogger: false }
   }
 
-  if (options.logger && options.loggerInstance) {
-    throw new FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED()
-  }
+  const { createPinoLogger, serializers } = require('./logger-pino.js')
 
   // check if the logger instance has all required properties
   if (validateLogger(options.loggerInstance)) {
@@ -120,69 +122,15 @@ function createLogger (options) {
   return { logger, hasLogger: true }
 }
 
-/**
- * Determines if a provided logger object meets the requirements
- * of a Fastify compatible logger.
- *
- * @param {object} logger Object to validate.
- * @param {boolean?} strict `true` if the object must be a logger (always throw if any methods missing)
- *
- * @returns {boolean} `true` when the logger meets the requirements.
- *
- * @throws {FST_ERR_LOG_INVALID_LOGGER} When the logger object is
- * missing required methods.
- */
-function validateLogger (logger, strict) {
-  const methods = ['info', 'error', 'debug', 'fatal', 'warn', 'trace', 'child']
-  const missingMethods = logger
-    ? methods.filter(method => !logger[method] || typeof logger[method] !== 'function')
-    : methods
-
-  if (!missingMethods.length) {
-    return true
-  } else if ((missingMethods.length === methods.length) && !strict) {
-    return false
-  } else {
-    throw FST_ERR_LOG_INVALID_LOGGER(missingMethods.join(','))
-  }
-}
-
-/**
- * Utility for creating a child logger with the appropriate bindings, logger factory
- * and validation.
- * @param {object} context
- * @param {import('../fastify').FastifyBaseLogger} logger
- * @param {import('../fastify').RawRequestDefaultExpression<any>} req
- * @param {string} reqId
- * @param {import('../types/logger.js').ChildLoggerOptions?} loggerOpts
- */
-function createChildLogger (context, logger, req, reqId, loggerOpts) {
-  const loggerBindings = {
-    [context.requestIdLogLabel]: reqId
-  }
-  const child = context.childLoggerFactory.call(context.server, logger, loggerBindings, loggerOpts || {}, req)
-
-  // Optimization: bypass validation if the factory is our own default factory
-  if (context.childLoggerFactory !== defaultChildLoggerFactory) {
-    validateLogger(child, true) // throw if the child is not a valid logger
-  }
-
-  return child
-}
-
-/**
- * @param {import('../fastify.js').FastifyBaseLogger} logger
- * @param {import('../types/logger.js').Bindings} bindings
- * @param {import('../types/logger.js').ChildLoggerOptions} opts
- */
-function defaultChildLoggerFactory (logger, bindings, opts) {
-  return logger.child(bindings, opts)
+function now () {
+  const ts = process.hrtime()
+  return (ts[0] * 1e3) + (ts[1] / 1e6)
 }
 
 module.exports = {
-  createLogger,
   createChildLogger,
   defaultChildLoggerFactory,
-  serializers,
-  now
+  createLogger,
+  validateLogger,
+  now,
 }

package/lib/logger-pino.js

@@ -0,0 +1,68 @@
+'use strict'
+
+/**
+ * Code imported from `pino-http`
+ * Repo: https://github.com/pinojs/pino-http
+ * License: MIT (https://raw.githubusercontent.com/pinojs/pino-http/master/LICENSE)
+ */
+
+const pino = require('pino')
+const { serializersSym } = pino.symbols
+const {
+  FST_ERR_LOG_INVALID_DESTINATION,
+} = require('./errors')
+
+function createPinoLogger (opts) {
+  if (opts.stream && opts.file) {
+    throw new FST_ERR_LOG_INVALID_DESTINATION()
+  } else if (opts.file) {
+    // we do not have stream
+    opts.stream = pino.destination(opts.file)
+    delete opts.file
+  }
+
+  const prevLogger = opts.logger
+  const prevGenReqId = opts.genReqId
+  let logger = null
+
+  if (prevLogger) {
+    opts.logger = undefined
+    opts.genReqId = undefined
+    // we need to tap into pino internals because in v5 it supports
+    // adding serializers in child loggers
+    if (prevLogger[serializersSym]) {
+      opts.serializers = Object.assign({}, opts.serializers, prevLogger[serializersSym])
+    }
+    logger = prevLogger.child({}, opts)
+    opts.logger = prevLogger
+    opts.genReqId = prevGenReqId
+  } else {
+    logger = pino(opts, opts.stream)
+  }
+
+  return logger
+}
+
+const serializers = {
+  req: function asReqValue (req) {
+    return {
+      method: req.method,
+      url: req.url,
+      version: req.headers && req.headers['accept-version'],
+      host: req.host,
+      remoteAddress: req.ip,
+      remotePort: req.socket ? req.socket.remotePort : undefined
+    }
+  },
+  err: pino.stdSerializers.err,
+  res: function asResValue (reply) {
+    return {
+      statusCode: reply.statusCode
+    }
+  }
+}
+
+module.exports = {
+  serializers,
+  createPinoLogger,
+}

package/lib/pluginOverride.js

@@ -66,7 +66,7 @@ module.exports = function override (old, fn, opts) {
     instance[kFourOhFour].arrange404(instance)
   }
 
-  for (const hook of instance[kHooks].onRegister) hook.call(this, instance, opts)
+  for (const hook of instance[kHooks].onRegister) hook.call(old, instance, opts)
 
   return instance
 }

package/lib/pluginUtils.js

@@ -48,7 +48,7 @@ function getPluginName (func) {
 
 function getFuncPreview (func) {
   // takes the first two lines of the function if nothing else works
-  return func.toString().split('\n').slice(0, 2).map(s => s.trim()).join(' -- ')
+  return func.toString().split('\n', 2).map(s => s.trim()).join(' -- ')
 }
 
 function getDisplayName (fn) {
@@ -110,7 +110,7 @@ function checkVersion (fn) {
 
   const requiredVersion = meta.fastify
 
-  const fastifyRc = /-(rc|pre|alpha).+$/.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

package/lib/reply.js

@@ -32,7 +32,7 @@ const {
 } = require('./hooks')
 
 const internals = require('./handleRequest')[Symbol.for('internals')]
-const loggerUtils = require('./logger')
+const loggerUtils = require('./logger-factory')
 const now = loggerUtils.now
 const { handleError } = require('./error-handler')
 const { getSchemaSerializer } = require('./schemas')
@@ -263,8 +263,7 @@ Reply.prototype.header = function (key, value = '') {
 
 Reply.prototype.headers = function (headers) {
   const keys = Object.keys(headers)
-  /* eslint-disable no-var */
-  for (var i = 0; i !== keys.length; ++i) {
+  for (let i = 0; i !== keys.length; ++i) {
     const key = keys[i]
     this.header(key, headers[key])
   }
@@ -868,9 +867,9 @@ function buildReply (R) {
     this[kReplyEndTime] = undefined
     this.log = log
 
-    var prop
+    let prop
 
-    for (var i = 0; i < props.length; i++) {
+    for (let i = 0; i < props.length; i++) {
       prop = props[i]
       this[prop.key] = prop.value
     }

package/lib/request.js

@@ -73,10 +73,8 @@ function buildRegularRequest (R) {
     this.log = log
     this.body = undefined
 
-    // eslint-disable-next-line no-var
-    var prop
-    // eslint-disable-next-line no-var
-    for (var i = 0; i < props.length; i++) {
+    let prop
+    for (let i = 0; i < props.length; i++) {
       prop = props[i]
       this[prop.key] = prop.value
     }
@@ -119,7 +117,11 @@ function buildRequestWithTrustProxy (R, trustProxy) {
         if (this.ip !== undefined && this.headers['x-forwarded-host']) {
           return getLastEntryInMultiHeaderValue(this.headers['x-forwarded-host'])
         }
-        return this.headers.host || this.headers[':authority']
+        // the last fallback is used to support the following cases:
+        // 1. support http.requireHostHeader === false
+        // 2. support HTTP/1.0 without Host Header
+        // 3. support headers schema which may remove the Host Header
+        return this.headers.host ?? this.headers[':authority'] ?? ''
       }
     },
     protocol: {
@@ -211,23 +213,28 @@ Object.defineProperties(Request.prototype, {
   },
   host: {
     get () {
-      return this.raw.headers.host || this.raw.headers[':authority']
+      // the last fallback is used to support the following cases:
+      // 1. support http.requireHostHeader === false
+      // 2. support HTTP/1.0 without Host Header
+      // 3. support headers schema which may remove the Host Header
+      return this.raw.headers.host ?? this.raw.headers[':authority'] ?? ''
     }
   },
   hostname: {
     get () {
-      return (this.host).split(':')[0]
+      return this.host.split(':', 1)[0]
     }
   },
   port: {
     get () {
       // first try taking port from host
-      const portFromHost = parseInt((this.host).split(':').slice(-1)[0])
+      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])
+      const host = (this.headers.host ?? this.headers[':authority'] ?? '')
+      const portFromHeader = parseInt(host.split(':').slice(-1)[0])
       if (!isNaN(portFromHeader)) {
         return portFromHeader
       }

package/lib/route.js

@@ -49,7 +49,7 @@ const {
   kRouteContext
 } = require('./symbols.js')
 const { buildErrorHandler } = require('./error-handler')
-const { createChildLogger } = require('./logger')
+const { createChildLogger } = require('./logger-factory.js')
 const { getGenReqId } = require('./reqIdGenFactory.js')
 
 function buildRouting (options) {
@@ -181,45 +181,46 @@ function buildRouting (options) {
    * @param {{ options: import('../fastify').RouteOptions, isFastify: boolean }}
    */
   function route ({ options, isFastify }) {
+    throwIfAlreadyStarted('Cannot add route!')
+
     // Since we are mutating/assigning only top level props, it is fine to have a shallow copy using the spread operator
     const opts = { ...options }
 
-    const { exposeHeadRoute } = opts
-    const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
-    const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
+    const path = opts.url || opts.path || ''
 
-    const isGetRoute = opts.method === 'GET' ||
-      (Array.isArray(opts.method) && opts.method.includes('GET'))
-    const isHeadRoute = opts.method === 'HEAD' ||
-      (Array.isArray(opts.method) && opts.method.includes('HEAD'))
+    if (!opts.handler) {
+      throw new FST_ERR_ROUTE_MISSING_HANDLER(opts.method, path)
+    }
 
-    // we need to clone a set of initial options for HEAD route
-    const headOpts = shouldExposeHead && isGetRoute ? { ...options } : null
+    if (opts.errorHandler !== undefined && typeof opts.errorHandler !== 'function') {
+      throw new FST_ERR_ROUTE_HANDLER_NOT_FN(opts.method, path)
+    }
 
-    throwIfAlreadyStarted('Cannot add route!')
+    validateBodyLimitOption(opts.bodyLimit)
 
-    const path = opts.url || opts.path || ''
+    const shouldExposeHead = opts.exposeHeadRoute ?? globalExposeHeadRoutes
+
+    let isGetRoute = false
+    let isHeadRoute = false
 
     if (Array.isArray(opts.method)) {
-      // eslint-disable-next-line no-var
-      for (var i = 0; i < opts.method.length; ++i) {
+      for (let i = 0; i < opts.method.length; ++i) {
         opts.method[i] = normalizeAndValidateMethod.call(this, opts.method[i])
         validateSchemaBodyOption.call(this, opts.method[i], path, opts.schema)
+
+        isGetRoute = opts.method.includes('GET')
+        isHeadRoute = opts.method.includes('HEAD')
       }
     } else {
       opts.method = normalizeAndValidateMethod.call(this, opts.method)
       validateSchemaBodyOption.call(this, opts.method, path, opts.schema)
-    }
 
-    if (!opts.handler) {
-      throw new FST_ERR_ROUTE_MISSING_HANDLER(opts.method, path)
+      isGetRoute = opts.method === 'GET'
+      isHeadRoute = opts.method === 'HEAD'
     }
 
-    if (opts.errorHandler !== undefined && typeof opts.errorHandler !== 'function') {
-      throw new FST_ERR_ROUTE_HANDLER_NOT_FN(opts.method, path)
-    }
-
-    validateBodyLimitOption(opts.bodyLimit)
+    // we need to clone a set of initial options for HEAD route
+    const headOpts = shouldExposeHead && isGetRoute ? { ...options } : null
 
     const prefix = this[kRoutePrefix]
 

package/lib/validation.js

@@ -7,7 +7,7 @@ const {
   kSchemaBody: bodySchema,
   kSchemaResponse: responseSchema
 } = require('./symbols')
-const scChecker = /^[1-5]{1}[0-9]{2}$|^[1-5]xx$|^default$/
+const scChecker = /^[1-5](?:\d{2}|xx)$|^default$/
 
 const {
   FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX
@@ -24,7 +24,7 @@ function compileSchemasForSerialization (context, compile) {
     .reduce(function (acc, statusCode) {
       const schema = context.schema.response[statusCode]
       statusCode = statusCode.toLowerCase()
-      if (!scChecker.exec(statusCode)) {
+      if (!scChecker.test(statusCode)) {
         throw new FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX()
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "5.0.0",
+  "version": "5.2.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -10,24 +10,22 @@
     "benchmark": "concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
     "benchmark:parser": "concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -m POST localhost:3000/\"",
     "build:validation": "node build/build-error-serializer.js && node build/build-validation.js",
-    "coverage": "npm run unit -- --coverage-report=html",
-    "coverage:ci": "tap --coverage-report=html --coverage-report=lcov --allow-incomplete-coverage",
-    "coverage:ci-check-coverage": "tap replay",
+    "coverage": "c8 --reporter html borp --reporter=./test/test-reporter.mjs --coverage --check-coverage --lines 100 ",
+    "coverage:ci-check-coverage": "borp --reporter=./test/test-reporter.mjs --coverage --check-coverage --lines 100",
     "lint": "npm run lint:eslint",
     "lint:fix": "eslint --fix",
     "lint:markdown": "markdownlint-cli2",
     "lint:eslint": "eslint",
-    "prepublishOnly": "cross-env PREPUBLISH=true tap --allow-incomplete-coverage test/build/**.test.js && npm run test:validator:integrity",
+    "prepublishOnly": "cross-env PREPUBLISH=true borp --reporter=./test/test-reporter.mjs && npm run test:validator:integrity",
     "test": "npm run lint && npm run unit && npm run test:typescript",
-    "test:ci": "npm run unit -- --coverage-report=lcovonly && npm run test:typescript",
+    "test:ci": "npm run unit && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
     "test:validator:integrity": "npm run build:validation && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/error-serializer.js && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/configValidator.js",
-    "test:typescript": "tsc test/types/import.ts --noEmit && tsd",
+    "test:typescript": "tsc test/types/import.ts --target es2022 --moduleResolution node16 --module node16 --noEmit && tsd",
     "test:watch": "npm run unit -- --watch --coverage-report=none --reporter=terse",
-    "unit": "tap",
-    "unit:junit": "tap-mocha-reporter xunit < out.tap > test/junit-testresults.xml",
-    "unit:report": "tap --coverage-report=html --coverage-report=cobertura | tee out.tap",
-    "citgm": "tap --jobs=1 --timeout=120"
+    "unit": "borp --reporter=./test/test-reporter.mjs --coverage --check-coverage",
+    "unit:report": "c8 --reporter html borp --reporter=./test/test-reporter.mjs",
+    "citgm": "borp --reporter=./test/test-reporter.mjs --coverage --check-coverage --concurrency=1"
   },
   "repository": {
     "type": "git",
@@ -163,12 +161,13 @@
     "ajv-i18n": "^4.2.0",
     "ajv-merge-patch": "^5.0.1",
     "autocannon": "^7.15.0",
+    "borp": "^0.18.0",
     "branch-comparer": "^1.1.0",
     "concurrently": "^8.2.2",
     "cross-env": "^7.0.3",
     "eslint": "^9.0.0",
     "fast-json-body": "^1.1.0",
-    "fastify-plugin": "^4.5.1",
+    "fastify-plugin": "^5.0.0",
     "fluent-json-schema": "^5.0.0",
     "h2url": "^0.2.0",
     "http-errors": "^2.0.0",
@@ -179,12 +178,11 @@
     "neostandard": "^0.11.3",
     "node-forge": "^1.3.1",
     "proxyquire": "^2.1.3",
-    "send": "^0.18.0",
     "simple-get": "^4.0.1",
     "split2": "^4.2.0",
     "tap": "^21.0.0",
     "tsd": "^0.31.0",
-    "typescript": "^5.4.5",
+    "typescript": "~5.4.5",
     "undici": "^6.13.0",
     "vary": "^1.1.2",
     "yup": "^1.4.0"
@@ -202,7 +200,7 @@
     "process-warning": "^4.0.0",
     "proxy-addr": "^2.0.7",
     "rfdc": "^1.3.1",
-    "secure-json-parse": "^2.7.0",
+    "secure-json-parse": "^3.0.1",
     "semver": "^7.6.0",
     "toad-cache": "^3.7.0"
   },