fastify 4.19.2 → 4.21.0

package/lib/logger.js

@@ -107,27 +107,64 @@ function createLogger (options) {
  * 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) {
+function validateLogger (logger, strict) {
   const methods = ['info', 'error', 'debug', 'fatal', 'warn', 'trace', 'child']
-  const missingMethods = methods.filter(method => !logger[method] || typeof logger[method] !== 'function')
+  const missingMethods = logger
+    ? methods.filter(method => !logger[method] || typeof logger[method] !== 'function')
+    : methods
 
   if (!missingMethods.length) {
     return true
-  } else if (missingMethods.length === methods.length) {
+  } 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)
+
+  // Optimisation: 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)
+}
+
 module.exports = {
   createLogger,
+  createChildLogger,
+  defaultChildLoggerFactory,
   serializers,
   now
 }

package/lib/reply.js

@@ -23,7 +23,7 @@ const {
   kOptions,
   kRouteContext
 } = require('./symbols.js')
-const { hookRunner, hookIterator, onSendHookRunner } = require('./hooks')
+const { onSendHookRunner, onResponseHookRunner, onPreHandlerHookRunner } = require('./hooks')
 
 const internals = require('./handleRequest')[Symbol.for('internals')]
 const loggerUtils = require('./logger')
@@ -97,7 +97,7 @@ Object.defineProperties(Reply.prototype, {
 
       // We throw only if sent was overwritten from Fastify
       if (this.sent && this[kReplyHijacked]) {
-        throw new FST_ERR_REP_ALREADY_SENT()
+        throw new FST_ERR_REP_ALREADY_SENT(this.request.url, this.request.method)
       }
 
       this[kReplyHijacked] = true
@@ -124,7 +124,7 @@ Reply.prototype.send = function (payload) {
   }
 
   if (this.sent) {
-    this.log.warn({ err: new FST_ERR_REP_ALREADY_SENT() }, 'Reply already sent')
+    this.log.warn({ err: new FST_ERR_REP_ALREADY_SENT(this.request.url, this.request.method) })
     return this
   }
 
@@ -539,6 +539,18 @@ function wrapOnSendEnd (err, request, reply, payload) {
   }
 }
 
+function safeWriteHead (reply, statusCode) {
+  const res = reply.raw
+  try {
+    res.writeHead(statusCode, reply[kReplyHeaders])
+  } catch (err) {
+    if (err.code === 'ERR_HTTP_HEADERS_SENT') {
+      reply.log.warn(`Reply was already sent, did you forget to "return reply" in the "${reply.request.raw.url}" (${reply.request.raw.method}) route?`)
+    }
+    throw err
+  }
+}
+
 function onSendEnd (reply, payload) {
   const res = reply.raw
   const req = reply.request
@@ -569,7 +581,7 @@ function onSendEnd (reply, payload) {
       reply[kReplyHeaders]['content-length'] = '0'
     }
 
-    res.writeHead(statusCode, reply[kReplyHeaders])
+    safeWriteHead(reply, statusCode)
     sendTrailer(payload, res, reply)
     return
   }
@@ -594,7 +606,7 @@ function onSendEnd (reply, payload) {
     }
   }
 
-  res.writeHead(statusCode, reply[kReplyHeaders])
+  safeWriteHead(reply, statusCode)
   // write payload first
   res.write(payload)
   // then send trailers
@@ -755,9 +767,8 @@ function setupResponseListeners (reply) {
     const ctx = reply[kRouteContext]
 
     if (ctx && ctx.onResponse !== null) {
-      hookRunner(
+      onResponseHookRunner(
         ctx.onResponse,
-        onResponseIterator,
         reply.request,
         reply,
         onResponseCallback
@@ -771,10 +782,6 @@ function setupResponseListeners (reply) {
   reply.raw.on('error', onResFinished)
 }
 
-function onResponseIterator (fn, request, reply, next) {
-  return fn(request, reply, next)
-}
-
 function onResponseCallback (err, request, reply) {
   if (reply.log[kDisableRequestLogging]) {
     return
@@ -839,9 +846,8 @@ function notFound (reply) {
 
   // preHandler hook
   if (reply[kRouteContext].preHandler !== null) {
-    hookRunner(
+    onPreHandlerHookRunner(
       reply[kRouteContext].preHandler,
-      hookIterator,
       reply.request,
       reply,
       internals.preHandlerCallback

package/lib/reqIdGenFactory.js

@@ -1,14 +1,26 @@
 'use strict'
 
-module.exports = function (requestIdHeader, optGenReqId) {
+/**
+ * @callback GenerateRequestId
+ * @param {Object} req
+ * @returns {string}
+ */
+
+/**
+ * @param {string} [requestIdHeader]
+ * @param {GenerateRequestId} [optGenReqId]
+ * @returns {GenerateRequestId}
+ */
+function reqIdGenFactory (requestIdHeader, optGenReqId) {
   // 2,147,483,647 (2^31 − 1) stands for max SMI value (an internal optimization of V8).
   // With this upper bound, if you'll be generating 1k ids/sec, you're going to hit it in ~25 days.
   // This is very likely to happen in real-world applications, hence the limit is enforced.
   // Growing beyond this value will make the id generation slower and cause a deopt.
   // In the worst cases, it will become a float, losing accuracy.
   const maxInt = 2147483647
+
   let nextReqId = 0
-  function defaultGenReqId (req) {
+  function defaultGenReqId (_req) {
     nextReqId = (nextReqId + 1) & maxInt
     return `req-${nextReqId.toString(36)}`
   }
@@ -16,7 +28,6 @@ module.exports = function (requestIdHeader, optGenReqId) {
   const genReqId = optGenReqId || defaultGenReqId
 
   if (requestIdHeader) {
-    // requestIdHeader = typeof requestIdHeader === 'string' ? requestIdHeader : 'request-id'
     return function (req) {
       return req.headers[requestIdHeader] || genReqId(req)
     }
@@ -24,3 +35,7 @@ module.exports = function (requestIdHeader, optGenReqId) {
 
   return genReqId
 }
+
+module.exports = {
+  reqIdGenFactory
+}

package/lib/route.js

@@ -3,7 +3,7 @@
 const FindMyWay = require('find-my-way')
 const Context = require('./context')
 const handleRequest = require('./handleRequest')
-const { hookRunner, hookIterator, onRequestAbortHookRunner, lifecycleHooks } = require('./hooks')
+const { onRequestAbortHookRunner, lifecycleHooks, preParsingHookRunner, onTimeoutHookRunner, onRequestHookRunner } = require('./hooks')
 const { supportedMethods } = require('./httpMethods')
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
@@ -20,7 +20,6 @@ const {
   FST_ERR_DEFAULT_ROUTE_INVALID_TYPE,
   FST_ERR_DUPLICATED_ROUTE,
   FST_ERR_INVALID_URL,
-  FST_ERR_SEND_UNDEFINED_ERR,
   FST_ERR_HOOK_INVALID_HANDLER,
   FST_ERR_ROUTE_OPTIONS_NOT_OBJ,
   FST_ERR_ROUTE_DUPLICATED_HANDLER,
@@ -51,13 +50,13 @@ const {
   kRouteContext
 } = require('./symbols.js')
 const { buildErrorHandler } = require('./error-handler')
+const { createChildLogger } = require('./logger')
 
 function buildRouting (options) {
   const router = FindMyWay(options.config)
 
   let avvio
   let fourOhFour
-  let requestIdLogLabel
   let logger
   let hasLogger
   let setupResponseListeners
@@ -74,6 +73,10 @@ function buildRouting (options) {
   let closing = false
 
   return {
+    /**
+     * @param {import('../fastify').FastifyServerOptions} options
+     * @param {*} fastifyArgs
+     */
     setup (options, fastifyArgs) {
       avvio = fastifyArgs.avvio
       fourOhFour = fastifyArgs.fourOhFour
@@ -84,7 +87,6 @@ function buildRouting (options) {
       validateHTTPVersion = fastifyArgs.validateHTTPVersion
 
       globalExposeHeadRoutes = options.exposeHeadRoutes
-      requestIdLogLabel = options.requestIdLogLabel
       genReqId = options.genReqId
       disableRequestLogging = options.disableRequestLogging
       ignoreTrailingSlash = options.ignoreTrailingSlash
@@ -168,7 +170,10 @@ function buildRouting (options) {
     ) !== null
   }
 
-  // Route management
+  /**
+   * Route management
+   * @param {{ options: import('../fastify').RouteOptions, isFastify: boolean }}
+   */
   function route ({ options, isFastify }) {
     // Since we are mutating/assigning only top level props, it is fine to have a shallow copy using the spread operator
     const opts = { ...options }
@@ -282,6 +287,7 @@ function buildRouting (options) {
         handler: opts.handler.bind(this),
         config,
         errorHandler: opts.errorHandler,
+        childLoggerFactory: opts.childLoggerFactory,
         bodyLimit: opts.bodyLimit,
         logLevel: opts.logLevel,
         logSerializers: opts.logSerializers,
@@ -399,10 +405,6 @@ function buildRouting (options) {
   function routeHandler (req, res, params, context, query) {
     const id = genReqId(req)
 
-    const loggerBinding = {
-      [requestIdLogLabel]: id
-    }
-
     const loggerOpts = {
       level: context.logLevel
     }
@@ -410,7 +412,7 @@ function buildRouting (options) {
     if (context.logSerializers) {
       loggerOpts.serializers = context.logSerializers
     }
-    const childLogger = logger.child(loggerBinding, loggerOpts)
+    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.
@@ -477,9 +479,8 @@ function buildRouting (options) {
     }
 
     if (context.onRequest !== null) {
-      hookRunner(
+      onRequestHookRunner(
         context.onRequest,
-        hookIterator,
         request,
         reply,
         runPreParsing
@@ -494,7 +495,6 @@ function buildRouting (options) {
         if (req.aborted) {
           onRequestAbortHookRunner(
             context.onRequestAbort,
-            hookIterator,
             request,
             handleOnRequestAbortHooksErrors.bind(null, reply)
           )
@@ -519,9 +519,8 @@ function handleOnRequestAbortHooksErrors (reply, err) {
 
 function handleTimeout () {
   const { context, request, reply } = this._meta
-  hookRunner(
+  onTimeoutHookRunner(
     context.onTimeout,
-    hookIterator,
     request,
     reply,
     noop
@@ -570,52 +569,6 @@ function runPreParsing (err, request, reply) {
   }
 }
 
-function preParsingHookRunner (functions, request, reply, cb) {
-  let i = 0
-
-  function next (err, stream) {
-    if (reply.sent) {
-      return
-    }
-
-    if (typeof stream !== 'undefined') {
-      request[kRequestPayloadStream] = stream
-    }
-
-    if (err || i === functions.length) {
-      cb(err, request, reply)
-      return
-    }
-
-    const fn = functions[i++]
-    let result
-    try {
-      result = fn(request, reply, request[kRequestPayloadStream], next)
-    } catch (error) {
-      next(error)
-      return
-    }
-
-    if (result && typeof result.then === 'function') {
-      result.then(handleResolve, handleReject)
-    }
-  }
-
-  function handleResolve (stream) {
-    next(null, stream)
-  }
-
-  function handleReject (err) {
-    if (!err) {
-      err = new FST_ERR_SEND_UNDEFINED_ERR()
-    }
-
-    next(err)
-  }
-
-  next(null, request[kRequestPayloadStream])
-}
-
 /**
  * Used within the route handler as a `net.Socket.close` event handler.
  * The purpose is to remove a socket from the tracked sockets collection when

package/lib/schema-controller.js

@@ -50,6 +50,8 @@ class SchemaController {
       this.schemaBucket = this.opts.bucket(parent.getSchemas())
       this.validatorCompiler = parent.getValidatorCompiler()
       this.serializerCompiler = parent.getSerializerCompiler()
+      this.isCustomValidatorCompiler = parent.isCustomValidatorCompiler
+      this.isCustomSerializerCompiler = parent.isCustomSerializerCompiler
       this.parent = parent
     } else {
       this.schemaBucket = this.opts.bucket()

package/lib/server.js

@@ -9,7 +9,8 @@ const { kState, kOptions, kServerBindings } = require('./symbols')
 const {
   FST_ERR_HTTP2_INVALID_VERSION,
   FST_ERR_REOPENED_CLOSE_SERVER,
-  FST_ERR_REOPENED_SERVER
+  FST_ERR_REOPENED_SERVER,
+  FST_ERR_LISTEN_OPTIONS_INVALID
 } = require('./errors')
 
 module.exports.createServer = createServer
@@ -22,8 +23,6 @@ function defaultResolveServerListeningText (address) {
 function createServer (options, httpHandler) {
   const server = getServerInstance(options, httpHandler)
 
-  return { server, listen }
-
   // `this` is the Fastify object
   function listen (listenOptions, ...args) {
     let cb = args.slice(-1).pop()
@@ -48,6 +47,20 @@ function createServer (options, httpHandler) {
     } else {
       listenOptions.cb = cb
     }
+    if (listenOptions.signal) {
+      if (typeof listenOptions.signal.on !== 'function' && typeof listenOptions.signal.addEventListener !== 'function') {
+        throw new FST_ERR_LISTEN_OPTIONS_INVALID('Invalid options.signal')
+      }
+
+      if (listenOptions.signal.aborted) {
+        this.close()
+      } else {
+        const onAborted = () => {
+          this.close()
+        }
+        listenOptions.signal.addEventListener('abort', onAborted, { once: true })
+      }
+    }
 
     // If we have a path specified, don't default host to 'localhost' so we don't end up listening
     // on both path and host
@@ -99,6 +112,8 @@ function createServer (options, httpHandler) {
 
     this.ready(listenCallback.call(this, server, listenOptions))
   }
+
+  return { server, listen }
 }
 
 function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, onListen) {
@@ -138,17 +153,16 @@ function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, o
                 // pace through the `onClose` hook.
                 // It also allows them to handle possible connections already
                 // attached to them if any.
+                /* c8 ignore next 20 */
                 this.onClose((instance, done) => {
                   if (instance[kState].listening) {
                     // No new TCP connections are accepted
                     // We swallow any error from the secondary
                     // server
                     secondaryServer.close(() => done())
-                    /* istanbul ignore next: Cannot test this without Node.js core support */
                     if (serverOpts.forceCloseConnections === 'idle') {
                       // Not needed in Node 19
                       secondaryServer.closeIdleConnections()
-                    /* istanbul ignore next: Cannot test this without Node.js core support */
                     } else if (typeof secondaryServer.closeAllConnections === 'function' && serverOpts.forceCloseConnections) {
                       secondaryServer.closeAllConnections()
                     }
@@ -216,9 +230,10 @@ function listenCallback (server, listenOptions) {
     }
 
     server.once('error', wrap)
-    server.listen(listenOptions, wrap)
-
-    this[kState].listening = true
+    if (!this[kState].closing) {
+      server.listen(listenOptions, wrap)
+      this[kState].listening = true
+    }
   }
 }
 

package/lib/symbols.js

@@ -55,6 +55,7 @@ const keys = {
   // This symbol is only meant to be used for fastify tests and should not be used for any other purpose
   kTestInternals: Symbol('fastify.testInternals'),
   kErrorHandler: Symbol('fastify.errorHandler'),
+  kChildLoggerFactory: Symbol('fastify.childLoggerFactory'),
   kHasBeenDecorated: Symbol('fastify.hasBeenDecorated'),
   kKeepAliveConnections: Symbol('fastify.keepAliveConnections'),
   kRouteByFastify: Symbol('fastify.routeByFastify')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.19.2",
+  "version": "4.21.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -10,23 +10,22 @@
     "benchmark": "npx concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"npx autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
     "benchmark:parser": "npx concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"npx 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": "cross-env NODE_OPTIONS=no-network-family-autoselection npm run unit -- --cov --coverage-report=html",
-    "coverage:ci": "npm run unit -- --cov --coverage-report=html --no-browser --no-check-coverage",
-    "coverage:ci-check-coverage": "nyc check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
-    "license-checker": "license-checker --production --onlyAllow=\"MIT;ISC;BSD-3-Clause;BSD-2-Clause\"",
+    "coverage": "npm run unit -- --coverage-report=html",
+    "coverage:ci": "c8 --reporter=lcov tap --coverage-report=html --no-browser --no-check-coverage",
+    "coverage:ci-check-coverage": "c8 check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
     "lint": "npm run lint:standard && npm run lint:typescript && npm run lint:markdown",
     "lint:fix": "standard --fix",
     "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
     "prepublishOnly": "cross-env PREPUBLISH=true tap --no-check-coverage test/build/**.test.js && npm run test:validator:integrity",
-    "test": "npm run lint && cross-env NODE_OPTIONS=no-network-family-autoselection npm run unit && npm run test:typescript",
+    "test": "npm run lint && npm run unit && npm run test:typescript",
     "test:ci": "npm run unit -- --cov --coverage-report=lcovonly && 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 && tsd",
     "test:watch": "npm run unit -- -w --no-coverage-report -R terse",
-    "unit": "tap",
+    "unit": "c8 tap",
     "unit:junit": "tap-mocha-reporter xunit < out.tap > test/junit-testresults.xml",
     "unit:report": "tap --cov --coverage-report=html --coverage-report=cobertura | tee out.tap"
   },
@@ -134,7 +133,7 @@
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.28.9",
+    "@sinclair/typebox": "^0.29.1",
     "@sinonjs/fake-timers": "^11.0.0",
     "@types/node": "^20.1.0",
     "@typescript-eslint/eslint-plugin": "^5.59.2",
@@ -145,6 +144,7 @@
     "ajv-i18n": "^4.2.0",
     "ajv-merge-patch": "^5.0.1",
     "branch-comparer": "^1.1.0",
+    "c8": "^8.0.0",
     "cross-env": "^7.0.3",
     "eslint": "^8.39.0",
     "eslint-config-standard": "^17.0.0",
@@ -161,10 +161,8 @@
     "joi": "^17.9.2",
     "json-schema-to-ts": "^2.9.1",
     "JSONStream": "^1.3.5",
-    "license-checker": "^25.0.1",
     "markdownlint-cli2": "^0.8.1",
     "proxyquire": "^2.1.3",
-    "pump": "^3.0.0",
     "self-cert": "^2.0.0",
     "send": "^0.18.0",
     "simple-get": "^4.0.1",

package/test/500s.test.js

@@ -9,6 +9,7 @@ test('default 500', t => {
   t.plan(4)
 
   const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
@@ -33,6 +34,7 @@ test('custom 500', t => {
   t.plan(6)
 
   const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
@@ -62,6 +64,7 @@ test('encapsulated 500', t => {
   t.plan(10)
 
   const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
@@ -113,6 +116,7 @@ test('custom 500 with hooks', t => {
   t.plan(7)
 
   const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
@@ -166,3 +170,21 @@ test('cannot set errorHandler after binding', t => {
     }
   })
 })
+
+test('cannot set childLoggerFactory after binding', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+
+    try {
+      fastify.setChildLoggerFactory(() => { })
+      t.fail()
+    } catch (e) {
+      t.pass()
+    }
+  })
+})

package/test/async-await.test.js

@@ -124,7 +124,7 @@ test('ignore the result of the promise if reply.send is called beforehand (objec
 })
 
 test('server logs an error if reply.send is called and a value is returned via async/await', t => {
-  const lines = ['incoming request', 'request completed', 'Reply already sent']
+  const lines = ['incoming request', 'request completed', 'Reply was already sent, did you forget to "return reply" in "/" (GET)?']
   t.plan(lines.length + 2)
 
   const splitStream = split(JSON.parse)