fastify 4.18.0 → 4.19.1

package/lib/schema-controller.js

@@ -100,28 +100,28 @@ class SchemaController {
   /**
    * This method will be called when a validator must be setup.
    * Do not setup the compiler more than once
-   * @param {object} serverOptions: the fastify server option
+   * @param {object} serverOptions the fastify server options
    */
-  setupValidator (serverOption) {
+  setupValidator (serverOptions) {
     const isReady = this.validatorCompiler !== undefined && !this.addedSchemas
     if (isReady) {
       return
     }
-    this.validatorCompiler = this.getValidatorBuilder()(this.schemaBucket.getSchemas(), serverOption.ajv)
+    this.validatorCompiler = this.getValidatorBuilder()(this.schemaBucket.getSchemas(), serverOptions.ajv)
   }
 
   /**
    * This method will be called when a serializer must be setup.
    * Do not setup the compiler more than once
-   * @param {object} serverOptions: the fastify server option
+   * @param {object} serverOptions the fastify server options
    */
-  setupSerializer (serverOption) {
+  setupSerializer (serverOptions) {
     const isReady = this.serializerCompiler !== undefined && !this.addedSchemas
     if (isReady) {
       return
     }
 
-    this.serializerCompiler = this.getSerializerBuilder()(this.schemaBucket.getSchemas(), serverOption.serializerOpts)
+    this.serializerCompiler = this.getSerializerBuilder()(this.schemaBucket.getSchemas(), serverOptions.serializerOpts)
   }
 }
 

package/lib/schemas.js

@@ -147,8 +147,8 @@ function getSchemaAnyway (schema, jsonShorthand) {
  *
  * @param {object} context the request context
  * @param {number} statusCode the http status code
- * @param {string} contentType the reply content type
- * @returns {function|boolean} the right JSON Schema function to serialize
+ * @param {string} [contentType] the reply content type
+ * @returns {function|false} the right JSON Schema function to serialize
  * the reply or false if it is not set
  */
 function getSchemaSerializer (context, statusCode, contentType) {

package/lib/server.js

@@ -61,7 +61,6 @@ function createServer (options, httpHandler) {
     if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false) {
       listenOptions.host = host
     }
-
     if (host === 'localhost') {
       listenOptions.cb = (err, address) => {
         if (err) {
@@ -115,41 +114,68 @@ function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, o
       return
     }
 
+    const isMainServerListening = mainServer.listening && serverOpts.serverFactory
+
     let binding = 0
     let binded = 0
-    const primaryAddress = mainServer.address()
-    for (const adr of addresses) {
-      if (adr.address !== primaryAddress.address) {
-        binding++
-        const secondaryOpts = Object.assign({}, listenOptions, {
-          host: adr.address,
-          port: primaryAddress.port,
-          cb: (_ignoreErr) => {
-            binded++
-
-            /* istanbul ignore next: the else won't be taken unless listening fails */
-            if (!_ignoreErr) {
-              this[kServerBindings].push(secondaryServer)
+    if (!isMainServerListening) {
+      const primaryAddress = mainServer.address()
+      for (const adr of addresses) {
+        if (adr.address !== primaryAddress.address) {
+          binding++
+          const secondaryOpts = Object.assign({}, listenOptions, {
+            host: adr.address,
+            port: primaryAddress.port,
+            cb: (_ignoreErr) => {
+              binded++
+
+              /* istanbul ignore next: the else won't be taken unless listening fails */
+              if (!_ignoreErr) {
+                this[kServerBindings].push(secondaryServer)
+                // Due to the nature of the feature is not possible to know
+                // ahead of time the number of bindings that will be made.
+                // For instance, each binding is hooked to be closed at their own
+                // pace through the `onClose` hook.
+                // It also allows them to handle possible connections already
+                // attached to them if any.
+                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()
+                    }
+                  } else {
+                    done()
+                  }
+                })
+              }
+
+              if (binded === binding) {
+                // regardless of the error, we are done
+                onListen()
+              }
             }
+          })
 
-            if (binded === binding) {
-              // regardless of the error, we are done
-              onListen()
-            }
-          }
-        })
-
-        const secondaryServer = getServerInstance(serverOpts, httpHandler)
-        const closeSecondary = () => { secondaryServer.close(() => {}) }
-        secondaryServer.on('upgrade', mainServer.emit.bind(mainServer, 'upgrade'))
-        mainServer.on('unref', closeSecondary)
-        mainServer.on('close', closeSecondary)
-        mainServer.on('error', closeSecondary)
-        this[kState].listening = false
-        listenCallback.call(this, secondaryServer, secondaryOpts)()
+          const secondaryServer = getServerInstance(serverOpts, httpHandler)
+          const closeSecondary = () => { secondaryServer.close(() => { }) }
+          secondaryServer.on('upgrade', mainServer.emit.bind(mainServer, 'upgrade'))
+          mainServer.on('unref', closeSecondary)
+          mainServer.on('close', closeSecondary)
+          mainServer.on('error', closeSecondary)
+          this[kState].listening = false
+          listenCallback.call(this, secondaryServer, secondaryOpts)()
+        }
       }
     }
-
     // no extra bindings are necessary
     if (binding === 0) {
       onListen()

package/lib/symbols.js

@@ -30,6 +30,7 @@ const keys = {
   kRequestPayloadStream: Symbol('fastify.RequestPayloadStream'),
   kRequestAcceptVersion: Symbol('fastify.RequestAcceptVersion'),
   kRequestCacheValidateFns: Symbol('fastify.request.cache.validateFns'),
+  kRequestOriginalUrl: Symbol('fastify.request.originalUrl'),
   // 404
   kFourOhFour: Symbol('fastify.404'),
   kCanSetNotFoundHandler: Symbol('fastify.canSetNotFoundHandler'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.18.0",
+  "version": "4.19.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -10,7 +10,7 @@
     "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": "NODE_OPTIONS=no-network-family-autoselection npm run unit -- --cov --coverage-report=html",
+    "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\"",
@@ -19,8 +19,8 @@
     "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "prepublishOnly": "PREPUBLISH=true tap --no-check-coverage test/build/**.test.js && npm run test:validator:integrity",
-    "test": "npm run lint && NODE_OPTIONS=no-network-family-autoselection npm run unit && npm run test:typescript",
+    "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: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",
@@ -135,7 +135,7 @@
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
     "@sinclair/typebox": "^0.28.9",
-    "@sinonjs/fake-timers": "^10.0.2",
+    "@sinonjs/fake-timers": "^11.0.0",
     "@types/node": "^20.1.0",
     "@typescript-eslint/eslint-plugin": "^5.59.2",
     "@typescript-eslint/parser": "^5.59.2",
@@ -145,11 +145,12 @@
     "ajv-i18n": "^4.2.0",
     "ajv-merge-patch": "^5.0.1",
     "branch-comparer": "^1.1.0",
+    "cross-env": "^7.0.3",
     "eslint": "^8.39.0",
     "eslint-config-standard": "^17.0.0",
     "eslint-import-resolver-node": "^0.3.7",
     "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-n": "^15.7.0",
+    "eslint-plugin-n": "^16.0.1",
     "eslint-plugin-promise": "^6.1.1",
     "fast-json-body": "^1.1.0",
     "fastify-plugin": "^4.5.0",
@@ -161,7 +162,7 @@
     "json-schema-to-ts": "^2.9.1",
     "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
-    "markdownlint-cli2": "^0.7.1",
+    "markdownlint-cli2": "^0.8.1",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "self-cert": "^2.0.0",
@@ -181,10 +182,10 @@
     "@fastify/ajv-compiler": "^3.5.0",
     "@fastify/error": "^3.2.0",
     "@fastify/fast-json-stringify-compiler": "^4.3.0",
-    "fast-json-stringify": "^5.7.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.2.1",
     "fast-content-type-parse": "^1.0.0",
+    "fast-json-stringify": "^5.7.0",
     "find-my-way": "^7.6.0",
     "light-my-request": "^5.9.1",
     "pino": "^8.12.0",

package/test/buffer.test.js

@@ -0,0 +1,51 @@
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+
+test('Buffer test', async t => {
+  const fastify = Fastify()
+  fastify.addContentTypeParser('application/json', { parseAs: 'buffer' }, fastify.getDefaultJsonParser('error', 'ignore'))
+
+  fastify.delete('/', async (request) => {
+    return request.body
+  })
+
+  test('should return 200 if the body is not empty', async t => {
+    t.plan(3)
+
+    const response = await fastify.inject({
+      method: 'DELETE',
+      url: '/',
+      payload: Buffer.from('{"hello":"world"}'),
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    t.error(response.error)
+    t.equal(response.statusCode, 200)
+    t.same(response.payload.toString(), '{"hello":"world"}')
+  })
+
+  test('should return 400 if the body is empty', async t => {
+    t.plan(3)
+
+    const response = await fastify.inject({
+      method: 'DELETE',
+      url: '/',
+      payload: Buffer.alloc(0),
+      headers: {
+        'content-type': 'application/json'
+      }
+    })
+
+    t.error(response.error)
+    t.equal(response.statusCode, 400)
+    t.same(JSON.parse(response.payload.toString()), {
+      error: 'Bad Request',
+      code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
+      message: 'Body cannot be empty when content-type is set to \'application/json\'',
+      statusCode: 400
+    })
+  })
+})

package/test/close-pipelining.test.js

@@ -87,13 +87,16 @@ test('Should close the socket abruptly - pipelining - return503OnClosing: false,
   })
 
   const responses = await Promise.allSettled([
+    instance.request({ path: '/', method: 'GET' }),
     instance.request({ path: '/', method: 'GET' }),
     instance.request({ path: '/', method: 'GET' }),
     instance.request({ path: '/', method: 'GET' })
   ])
+
   t.equal(responses[0].status, 'fulfilled')
-  t.equal(responses[1].status, 'rejected')
+  t.equal(responses[1].status, 'fulfilled')
   t.equal(responses[2].status, 'rejected')
+  t.equal(responses[3].status, 'rejected')
 
   await instance.close()
 })

package/test/close.test.js

@@ -2,8 +2,7 @@
 
 const net = require('net')
 const http = require('http')
-const t = require('tap')
-const test = t.test
+const { test } = require('tap')
 const Fastify = require('..')
 const { Client } = require('undici')
 const semver = require('semver')
@@ -205,7 +204,7 @@ test('Should return error while closing (callback) - injection', t => {
 })
 
 const isV19plus = semver.gte(process.version, '19.0.0')
-t.test('Current opened connection should continue to work after closing and return "connection: close" header - return503OnClosing: false, skip Node >= v19.x', { skip: isV19plus }, t => {
+test('Current opened connection should continue to work after closing and return "connection: close" header - return503OnClosing: false, skip Node >= v19.x', { skip: isV19plus }, t => {
   const fastify = Fastify({
     return503OnClosing: false,
     forceCloseConnections: false
@@ -243,7 +242,7 @@ t.test('Current opened connection should continue to work after closing and retu
   })
 })
 
-t.test('Current opened connection should NOT continue to work after closing and return "connection: close" header - return503OnClosing: false, skip Node < v19.x', { skip: !isV19plus }, t => {
+test('Current opened connection should NOT continue to work after closing and return "connection: close" header - return503OnClosing: false, skip Node < v19.x', { skip: !isV19plus }, t => {
   t.plan(4)
   const fastify = Fastify({
     return503OnClosing: false,
@@ -282,7 +281,7 @@ t.test('Current opened connection should NOT continue to work after closing and
   })
 })
 
-t.test('Current opened connection should not accept new incoming connections', t => {
+test('Current opened connection should not accept new incoming connections', t => {
   t.plan(3)
   const fastify = Fastify({ forceCloseConnections: false })
   fastify.get('/', (req, reply) => {
@@ -304,7 +303,7 @@ t.test('Current opened connection should not accept new incoming connections', t
   })
 })
 
-t.test('rejected incoming connections should be logged', t => {
+test('rejected incoming connections should be logged', t => {
   t.plan(2)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -449,6 +448,149 @@ test('shutsdown while keep-alive connections are active (non-async, idle, native
   })
 })
 
+test('triggers on-close hook in the right order with multiple bindings', async t => {
+  const expectedOrder = [1, 2, 3]
+  const order = []
+  const fastify = Fastify()
+
+  t.plan(1)
+
+  // Follows LIFO
+  fastify.addHook('onClose', () => {
+    order.push(2)
+  })
+
+  fastify.addHook('onClose', () => {
+    order.push(1)
+  })
+
+  await fastify.listen({ port: 0 })
+
+  await new Promise((resolve, reject) => {
+    setTimeout(() => {
+      fastify.close(err => {
+        order.push(3)
+        t.match(order, expectedOrder)
+
+        if (err) t.error(err)
+        else resolve()
+      })
+    }, 2000)
+  })
+})
+
+test('triggers on-close hook in the right order with multiple bindings (forceCloseConnections - idle)', { skip: noSupport }, async t => {
+  const expectedPayload = { hello: 'world' }
+  const timeoutTime = 2 * 60 * 1000
+  const expectedOrder = [1, 2]
+  const order = []
+  const fastify = Fastify({ forceCloseConnections: 'idle' })
+
+  fastify.server.setTimeout(timeoutTime)
+  fastify.server.keepAliveTimeout = timeoutTime
+
+  fastify.get('/', async (req, reply) => {
+    await new Promise((resolve) => {
+      setTimeout(resolve, 1000)
+    })
+
+    return expectedPayload
+  })
+
+  fastify.addHook('onClose', () => {
+    order.push(1)
+  })
+
+  await fastify.listen({ port: 0 })
+  const addresses = fastify.addresses()
+  const testPlan = (addresses.length * 2) + 1
+
+  t.plan(testPlan)
+
+  for (const addr of addresses) {
+    const { family, address, port } = addr
+    const host = family === 'IPv6' ? `[${address}]` : address
+    const client = new Client(`http://${host}:${port}`, {
+      keepAliveTimeout: 1 * 60 * 1000
+    })
+
+    client.request({ path: '/', method: 'GET' })
+      .then((res) => res.body.json(), err => t.error(err))
+      .then(json => {
+        t.match(json, expectedPayload, 'should payload match')
+        t.notOk(client.closed, 'should client not be closed')
+      }, err => t.error(err))
+  }
+
+  await new Promise((resolve, reject) => {
+    setTimeout(() => {
+      fastify.close(err => {
+        order.push(2)
+        t.match(order, expectedOrder)
+
+        if (err) t.error(err)
+        else resolve()
+      })
+    }, 2000)
+  })
+})
+
+test('triggers on-close hook in the right order with multiple bindings (forceCloseConnections - true)', { skip: noSupport }, async t => {
+  const expectedPayload = { hello: 'world' }
+  const timeoutTime = 2 * 60 * 1000
+  const expectedOrder = [1, 2]
+  const order = []
+  const fastify = Fastify({ forceCloseConnections: true })
+
+  fastify.server.setTimeout(timeoutTime)
+  fastify.server.keepAliveTimeout = timeoutTime
+
+  fastify.get('/', async (req, reply) => {
+    await new Promise((resolve) => {
+      setTimeout(resolve, 1000)
+    })
+
+    return expectedPayload
+  })
+
+  fastify.addHook('onClose', () => {
+    order.push(1)
+  })
+
+  await fastify.listen({ port: 0 })
+  const addresses = fastify.addresses()
+  const testPlan = (addresses.length * 2) + 1
+
+  t.plan(testPlan)
+
+  for (const addr of addresses) {
+    const { family, address, port } = addr
+    const host = family === 'IPv6' ? `[${address}]` : address
+    const client = new Client(`http://${host}:${port}`, {
+      keepAliveTimeout: 1 * 60 * 1000
+    })
+
+    client.request({ path: '/', method: 'GET' })
+      .then((res) => res.body.json(), err => t.error(err))
+      .then(json => {
+        t.match(json, expectedPayload, 'should payload match')
+        t.notOk(client.closed, 'should client not be closed')
+      }, err => t.error(err))
+  }
+
+  await new Promise((resolve, reject) => {
+    setTimeout(() => {
+      fastify.close(err => {
+        order.push(2)
+        t.match(order, expectedOrder)
+
+        if (err) t.error(err)
+        else resolve()
+      })
+    }, 2000)
+  })
+})
+
 test('shutsdown while keep-alive connections are active (non-async, custom)', t => {
   t.plan(5)
 

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

@@ -11,10 +11,10 @@ const dns = require('dns').promises
 test('Should support a custom http server', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
 
-  t.plan(localAddresses.length + 3)
+  t.plan((localAddresses.length - 1) + 3)
 
   const serverFactory = (handler, opts) => {
-    t.ok(opts.serverFactory, 'it is called twice for every HOST interface')
+    t.ok(opts.serverFactory, 'it is called once for localhost')
 
     const server = http.createServer((req, res) => {
       req.custom = true
@@ -71,3 +71,14 @@ test('Should not allow forceCloseConnection=idle if the server does not support
     "Cannot set forceCloseConnections to 'idle' as your HTTP server does not support closeIdleConnections method"
   )
 })
+
+test('Should accept user defined serverFactory and ignore secondary server creation', async t => {
+  const server = http.createServer(() => {})
+  t.teardown(() => new Promise(resolve => server.close(resolve)))
+  const app = await Fastify({
+    serverFactory: () => server
+  })
+  t.resolves(async () => {
+    await app.listen({ port: 0 })
+  })
+})

package/test/genReqId.test.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { Readable } = require('stream')
 const { test } = require('tap')
 const Fastify = require('..')
 
@@ -30,3 +31,44 @@ test('Should accept a custom genReqId function', t => {
     })
   })
 })
+
+test('Custom genReqId function gets raw request as argument', t => {
+  t.plan(9)
+
+  const REQUEST_ID = 'REQ-1234'
+
+  const fastify = Fastify({
+    genReqId: function (req) {
+      t.notOk('id' in req)
+      t.notOk('raw' in req)
+      t.ok(req instanceof Readable)
+      // http.IncomingMessage does have `rawHeaders` property, but FastifyRequest does not
+      const index = req.rawHeaders.indexOf('x-request-id')
+      const xReqId = req.rawHeaders[index + 1]
+      t.equal(xReqId, REQUEST_ID)
+      t.equal(req.headers['x-request-id'], REQUEST_ID)
+      return xReqId
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    t.equal(req.id, REQUEST_ID)
+    reply.send({ id: req.id })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.error(err)
+    fastify.inject({
+      method: 'GET',
+      headers: {
+        'x-request-id': REQUEST_ID
+      },
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, res) => {
+      t.error(err)
+      const payload = JSON.parse(res.payload)
+      t.equal(payload.id, REQUEST_ID)
+      fastify.close()
+    })
+  })
+})

package/test/header-overflow.test.js

@@ -0,0 +1,65 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const sget = require('simple-get').concat
+
+const maxHeaderSize = 1024
+
+test('Should return 431 if request header fields are too large', t => {
+  t.plan(3)
+
+  const fastify = Fastify({ http: { maxHeaderSize } })
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (_req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: {
+        'Large-Header': 'a'.repeat(maxHeaderSize)
+      }
+    }, (err, res) => {
+      t.error(err)
+      t.equal(res.statusCode, 431)
+    })
+  })
+
+  t.teardown(() => fastify.close())
+})
+
+test('Should return 431 if URI is too long', t => {
+  t.plan(3)
+
+  const fastify = Fastify({ http: { maxHeaderSize } })
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (_req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+
+    sget({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port + `/${'a'.repeat(maxHeaderSize)}`
+    }, (err, res) => {
+      t.error(err)
+      t.equal(res.statusCode, 431)
+    })
+  })
+
+  t.teardown(() => fastify.close())
+})

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

@@ -13,10 +13,10 @@ t.before(buildCertificate)
 test('Should support a custom https server', async t => {
   const localAddresses = await dns.lookup('localhost', { all: true })
 
-  t.plan(localAddresses.length + 3)
+  t.plan((localAddresses.length - 1) + 3)
 
   const serverFactory = (handler, opts) => {
-    t.ok(opts.serverFactory, 'it is called twice for every HOST interface')
+    t.ok(opts.serverFactory, 'it is called once for localhost')
 
     const options = {
       key: global.context.key,