fastify 4.19.1 → 4.20.0

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.1",
+  "version": "4.20.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -10,9 +10,9 @@
     "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",
+    "coverage": "npm run unit -- --coverage-report=html",
+    "coverage:ci": "npm run unit -- --coverage-report=html --no-browser --no-check-coverage",
+    "coverage:ci-check-coverage": "c8 check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
     "license-checker": "license-checker --production --onlyAllow=\"MIT;ISC;BSD-3-Clause;BSD-2-Clause\"",
     "lint": "npm run lint:standard && npm run lint:typescript && npm run lint:markdown",
     "lint:fix": "standard --fix",
@@ -20,13 +20,13 @@
     "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 +134,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 +145,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",

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/childLoggerFactory.test.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('..')
+
+test('Should accept a custom childLoggerFactory function', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.setChildLoggerFactory(function (logger, bindings, opts) {
+    t.ok(bindings.reqId)
+    t.ok(opts)
+    this.log.debug(bindings, 'created child logger')
+    return logger.child(bindings, opts)
+  })
+
+  fastify.get('/', (req, reply) => {
+    req.log.info('log message')
+    reply.send()
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    fastify.inject({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, res) => {
+      t.error(err)
+      fastify.close()
+    })
+  })
+})
+
+test('req.log should be the instance returned by the factory', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.setChildLoggerFactory(function (logger, bindings, opts) {
+    this.log.debug('using root logger')
+    return this.log
+  })
+
+  fastify.get('/', (req, reply) => {
+    t.equal(req.log, fastify.log)
+    req.log.info('log message')
+    reply.send()
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    fastify.inject({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, res) => {
+      t.error(err)
+      fastify.close()
+    })
+  })
+})
+
+test('should throw error if invalid logger is returned', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  fastify.setChildLoggerFactory(function () {
+    this.log.debug('returning an invalid logger, expect error')
+    return undefined
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.send()
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    t.throws(() => {
+      try {
+        fastify.inject({
+          method: 'GET',
+          url: 'http://localhost:' + fastify.server.address().port
+        }, (err) => {
+          t.fail('request should have failed but did not')
+          t.error(err)
+          fastify.close()
+        })
+      } finally {
+        fastify.close()
+      }
+    }, { code: 'FST_ERR_LOG_INVALID_LOGGER' })
+  })
+})

package/test/custom-http-server.test.js

@@ -82,3 +82,45 @@ test('Should accept user defined serverFactory and ignore secondary server creat
     await app.listen({ port: 0 })
   })
 })
+
+test('Should not call close on the server if it has not created it', async t => {
+  const server = http.createServer()
+
+  const serverFactory = (handler, opts) => {
+    server.on('request', handler)
+    return server
+  }
+
+  const fastify = Fastify({ serverFactory })
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  await fastify.ready()
+
+  await new Promise((resolve, reject) => {
+    server.listen(0)
+    server.on('listening', resolve)
+    server.on('error', reject)
+  })
+
+  const address = server.address()
+  t.equal(server.listening, true)
+  await fastify.close()
+
+  t.equal(server.listening, true)
+  t.same(server.address(), address)
+  t.same(fastify.addresses(), [address])
+
+  await new Promise((resolve, reject) => {
+    server.close((err) => {
+      if (err) {
+        return reject(err)
+      }
+      resolve()
+    })
+  })
+  t.equal(server.listening, false)
+  t.same(server.address(), null)
+})

package/test/encapsulated-child-logger-factory.test.js

@@ -0,0 +1,69 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('..')
+const fp = require('fastify-plugin')
+
+test('encapsulates an child logger factory', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(async function (fastify) {
+    fastify.setChildLoggerFactory(function pluginFactory (logger, bindings, opts) {
+      const child = logger.child(bindings, opts)
+      child.customLog = function (message) {
+        t.equal(message, 'custom')
+      }
+      return child
+    })
+    fastify.get('/encapsulated', async (req) => {
+      req.log.customLog('custom')
+    })
+  })
+
+  fastify.setChildLoggerFactory(function globalFactory (logger, bindings, opts) {
+    const child = logger.child(bindings, opts)
+    child.globalLog = function (message) {
+      t.equal(message, 'global')
+    }
+    return child
+  })
+  fastify.get('/not-encapsulated', async (req) => {
+    req.log.globalLog('global')
+  })
+
+  const res1 = await fastify.inject('/encapsulated')
+  t.equal(res1.statusCode, 200)
+
+  const res2 = await fastify.inject('/not-encapsulated')
+  t.equal(res2.statusCode, 200)
+})
+
+test('child logger factory set on root scope when using fastify-plugin', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(fp(async function (fastify) {
+    // Using fastify-plugin, the factory should be set on the root scope
+    fastify.setChildLoggerFactory(function pluginFactory (logger, bindings, opts) {
+      const child = logger.child(bindings, opts)
+      child.customLog = function (message) {
+        t.equal(message, 'custom')
+      }
+      return child
+    })
+    fastify.get('/not-encapsulated-1', async (req) => {
+      req.log.customLog('custom')
+    })
+  }))
+
+  fastify.get('/not-encapsulated-2', async (req) => {
+    req.log.customLog('custom')
+  })
+
+  const res1 = await fastify.inject('/not-encapsulated-1')
+  t.equal(res1.statusCode, 200)
+
+  const res2 = await fastify.inject('/not-encapsulated-2')
+  t.equal(res2.statusCode, 200)
+})

package/test/fastify-instance.test.js

@@ -7,7 +7,8 @@ const os = require('os')
 
 const {
   kOptions,
-  kErrorHandler
+  kErrorHandler,
+  kChildLoggerFactory
 } = require('../lib/symbols')
 
 test('root fastify instance is an object', t => {
@@ -100,6 +101,37 @@ test('errorHandler in plugin should be separate from the external one', async t
   t.same(fastify.errorHandler, fastify[kErrorHandler].func)
 })
 
+test('fastify instance should contain default childLoggerFactory', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.ok(fastify[kChildLoggerFactory] instanceof Function)
+  t.same(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
+  t.same(Object.getOwnPropertyDescriptor(fastify, 'childLoggerFactory').set, undefined)
+})
+
+test('childLoggerFactory in plugin should be separate from the external one', async t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    const inPluginLoggerFactory = function (logger, bindings, opts) {
+      return logger.child(bindings, opts)
+    }
+
+    instance.setChildLoggerFactory(inPluginLoggerFactory)
+
+    t.notSame(instance.childLoggerFactory, fastify.childLoggerFactory)
+    t.equal(instance.childLoggerFactory.name, 'inPluginLoggerFactory')
+
+    done()
+  })
+
+  await fastify.ready()
+
+  t.ok(fastify[kChildLoggerFactory] instanceof Function)
+  t.same(fastify.childLoggerFactory, fastify[kChildLoggerFactory])
+})
+
 test('fastify instance should contains listeningOrigin property (with port and host)', async t => {
   t.plan(1)
   const port = 3000
@@ -120,15 +152,6 @@ test('fastify instance should contains listeningOrigin property (with port and h
   await fastify.close()
 })
 
-test('fastify instance should contains listeningOrigin property (no options)', async t => {
-  t.plan(1)
-  const fastify = Fastify()
-  await fastify.listen()
-  const address = fastify.server.address()
-  t.same(fastify.listeningOrigin, `http://${address.address}:${address.port}`)
-  await fastify.close()
-})
-
 test('fastify instance should contains listeningOrigin property (unix socket)', { skip: os.platform() === 'win32' }, async t => {
   const fastify = Fastify()
   const path = `fastify.${Date.now()}.sock`
@@ -136,3 +159,13 @@ test('fastify instance should contains listeningOrigin property (unix socket)',
   t.same(fastify.listeningOrigin, path)
   await fastify.close()
 })
+
+test('fastify instance should contains listeningOrigin property (IPv6)', async t => {
+  t.plan(1)
+  const port = 3000
+  const host = '::1'
+  const fastify = Fastify()
+  await fastify.listen({ port, host })
+  t.same(fastify.listeningOrigin, `http://[::1]:${port}`)
+  await fastify.close()
+})

package/test/inject.test.js

@@ -458,14 +458,13 @@ test('should handle errors in builder-style injection correctly', async (t) => {
 })
 
 test('Should not throw on access to routeConfig frameworkErrors handler - FST_ERR_BAD_URL', t => {
-  t.plan(6)
+  t.plan(5)
 
   const fastify = Fastify({
     frameworkErrors: function (err, req, res) {
       t.ok(typeof req.id === 'string')
       t.ok(req.raw instanceof Readable)
       t.same(req.routerPath, undefined)
-      t.same(req.routeConfig, undefined)
       res.send(`${err.message} - ${err.code}`)
     }
   })