fastify 5.8.4 → 5.9.0

package/test/decorator-instance-properties.test.js

@@ -0,0 +1,63 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('hasRequestDecorator returns true for built-in constructor-assigned request properties', t => {
+  t.plan(6)
+  const fastify = Fastify()
+  t.assert.equal(fastify.hasRequestDecorator('id'), true)
+  t.assert.equal(fastify.hasRequestDecorator('params'), true)
+  t.assert.equal(fastify.hasRequestDecorator('raw'), true)
+  t.assert.equal(fastify.hasRequestDecorator('query'), true)
+  t.assert.equal(fastify.hasRequestDecorator('log'), true)
+  t.assert.equal(fastify.hasRequestDecorator('body'), true)
+})
+
+test('hasReplyDecorator returns true for built-in constructor-assigned reply properties', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.assert.equal(fastify.hasReplyDecorator('raw'), true)
+  t.assert.equal(fastify.hasReplyDecorator('request'), true)
+  t.assert.equal(fastify.hasReplyDecorator('log'), true)
+})
+
+test('decorateRequest throws FST_ERR_DEC_ALREADY_PRESENT for built-in request properties', t => {
+  t.plan(4)
+  const fastify = Fastify()
+  for (const name of ['id', 'params', 'raw', 'body']) {
+    t.assert.throws(
+      () => fastify.decorateRequest(name, null),
+      (err) => err.code === 'FST_ERR_DEC_ALREADY_PRESENT'
+    )
+  }
+})
+
+test('decorateReply throws FST_ERR_DEC_ALREADY_PRESENT for built-in reply properties', t => {
+  t.plan(2)
+  const fastify = Fastify()
+  for (const name of ['raw', 'request']) {
+    t.assert.throws(
+      () => fastify.decorateReply(name, null),
+      (err) => err.code === 'FST_ERR_DEC_ALREADY_PRESENT'
+    )
+  }
+})
+
+test('hasRequestDecorator returns false for unknown properties', t => {
+  t.plan(1)
+  const fastify = Fastify()
+  t.assert.equal(fastify.hasRequestDecorator('nonExistent'), false)
+})
+
+test('decorateRequest still works for non-built-in names', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  fastify.decorateRequest('myExtra', null)
+  t.assert.equal(fastify.hasRequestDecorator('myExtra'), true)
+  fastify.get('/', async (req) => req.myExtra)
+  fastify.ready((err) => {
+    t.assert.ifError(err)
+    done()
+  })
+})

package/test/diagnostics-channel/async-error-handler.test.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const { test } = require('node:test')
+const diagnostics = require('node:diagnostics_channel')
+const Fastify = require('../..')
+const Request = require('../../lib/request')
+const Reply = require('../../lib/reply')
+
+test('diagnostics channel tracks async operations in async error handlers', async t => {
+  t.plan(17)
+  let callOrder = 0
+  let firstEncounteredMessage
+  let asyncStartFired = false
+  let asyncEndFired = false
+
+  const fastify = Fastify()
+
+  function subscribe (name, handler) {
+    const wrapped = (msg) => {
+      if (msg.request.server === fastify) handler(msg)
+    }
+    diagnostics.subscribe(name, wrapped)
+    t.after(() => diagnostics.unsubscribe(name, wrapped))
+  }
+
+  subscribe('tracing:fastify.request.handler:start', (msg) => {
+    t.assert.strictEqual(callOrder++, 0)
+    firstEncounteredMessage = msg
+    t.assert.ok(msg.request instanceof Request)
+    t.assert.ok(msg.reply instanceof Reply)
+  })
+
+  subscribe('tracing:fastify.request.handler:error', (msg) => {
+    t.assert.strictEqual(callOrder++, 1)
+    t.assert.ok(msg.error instanceof Error)
+    t.assert.strictEqual(msg.error.message, 'handler error')
+  })
+
+  subscribe('tracing:fastify.request.handler:end', (msg) => {
+    t.assert.strictEqual(callOrder++, 2)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    t.assert.strictEqual(msg.async, true)
+  })
+
+  subscribe('tracing:fastify.request.handler:asyncStart', (msg) => {
+    t.assert.strictEqual(callOrder++, 3)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    asyncStartFired = true
+  })
+
+  subscribe('tracing:fastify.request.handler:asyncEnd', (msg) => {
+    t.assert.strictEqual(callOrder++, 4)
+    t.assert.strictEqual(msg, firstEncounteredMessage)
+    asyncEndFired = true
+  })
+
+  fastify.setErrorHandler(async (error, request, reply) => {
+    await new Promise(resolve => setImmediate(resolve))
+    reply.status(503).send({ error: error.message })
+  })
+
+  fastify.get('/', () => {
+    throw new Error('handler error')
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 503)
+  t.assert.ok(asyncStartFired, 'asyncStart should fire for async error handler')
+  t.assert.ok(asyncEndFired, 'asyncEnd should fire for async error handler')
+})

package/test/hooks.test.js

@@ -12,6 +12,7 @@ const proxyquire = require('proxyquire')
 const { connect } = require('node:net')
 const { sleep } = require('./helper')
 const { waitForCb } = require('./toolkit.js')
+const { fetch } = require('undici')
 
 process.removeAllListeners('warning')
 
@@ -3277,6 +3278,28 @@ test('onTimeout should be triggered and socket _meta is set', async t => {
   }
 })
 
+test('socket._meta is cleared after response to prevent keep-alive leaks', async t => {
+  t.plan(3)
+  const fastify = Fastify({ connectionTimeout: 500 })
+  t.after(() => { fastify.close() })
+
+  fastify.addHook('onTimeout', function (req, res, done) { done() })
+
+  fastify.addHook('onResponse', function (req, reply, done) {
+    t.assert.strictEqual(req.raw.socket._meta, null, 'socket._meta must be null after response')
+    done()
+  })
+
+  fastify.get('/', async (req, reply) => {
+    return { hello: 'world' }
+  })
+
+  const address = await fastify.listen({ port: 0 })
+  const result = await fetch(address)
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+})
+
 test('registering invalid hooks should throw an error', async t => {
   t.plan(3)
 

package/test/http-methods/get.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
-const { Client } = require('undici')
+const { Client, fetch } = require('undici')
 const fastify = require('../../fastify')()
 
 const schema = {

package/test/http2/plain.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { test } = require('node:test')
+const http2 = require('node:http2')
 const Fastify = require('../..')
 const h2url = require('h2url')
 const msg = { hello: 'world' }
@@ -66,3 +67,137 @@ test('http2 plain test', async t => {
     t.assert.strictEqual(JSON.parse(res.body).port, parseInt(host.split(':')[1]))
   })
 })
+
+test('http2 large non-stream replies are sent completely', async t => {
+  const modes = ['buffer', 'string']
+
+  for (const mode of modes) {
+    await t.test(mode, async t => {
+      const fastify = Fastify({ http2: true })
+      const payload = mode === 'buffer'
+        ? Buffer.alloc((64 * 1024) + 1, 'a')
+        : 'a'.repeat((64 * 1024) + 1)
+      const contentLength = Buffer.byteLength(payload)
+
+      fastify.get('/large', async (req, reply) => {
+        reply.header('content-type', 'application/octet-stream')
+        reply.header('content-length', contentLength)
+
+        return payload
+      })
+
+      await fastify.listen({ port: 0, host: '127.0.0.1' })
+
+      const client = http2.connect(`http://127.0.0.1:${fastify.server.address().port}`)
+      t.after(() => {
+        client.close()
+        return fastify.close()
+      })
+
+      await new Promise((resolve, reject) => {
+        const large = client.request({
+          [http2.constants.HTTP2_HEADER_METHOD]: http2.constants.HTTP2_METHOD_GET,
+          [http2.constants.HTTP2_HEADER_PATH]: '/large'
+        })
+        const chunks = []
+
+        large.on('error', reject)
+        large.on('data', chunk => {
+          chunks.push(chunk)
+        })
+        large.on('end', () => {
+          t.assert.strictEqual(Buffer.concat(chunks).length, contentLength)
+          resolve()
+        })
+        large.end()
+      })
+    })
+  }
+})
+
+test('http2 large buffer replies can be cancelled without rejecting the next stream', async t => {
+  const fastify = Fastify({ http2: true })
+  const payload = Buffer.alloc(32 * 1024 * 1024, 'a')
+  let smallHit = false
+
+  fastify.get('/large', async (req, reply) => {
+    reply.header('content-type', 'application/octet-stream')
+    reply.header('content-length', payload.length)
+
+    return payload
+  })
+
+  fastify.get('/small', async () => {
+    smallHit = true
+    return 'ok'
+  })
+
+  await fastify.listen({ port: 0, host: '127.0.0.1' })
+
+  const client = http2.connect(`http://127.0.0.1:${fastify.server.address().port}`)
+  t.after(() => {
+    client.close()
+    return fastify.close()
+  })
+
+  await new Promise((resolve, reject) => {
+    let cancelTimer
+    let requestTimer
+    let timeout
+
+    function cleanup () {
+      clearTimeout(cancelTimer)
+      clearTimeout(requestTimer)
+      clearTimeout(timeout)
+    }
+
+    const large = client.request({
+      [http2.constants.HTTP2_HEADER_METHOD]: http2.constants.HTTP2_METHOD_GET,
+      [http2.constants.HTTP2_HEADER_PATH]: '/large'
+    })
+    let largeResponded = false
+
+    large.on('error', err => {
+      if (!largeResponded) {
+        cleanup()
+        reject(err)
+      }
+    })
+    large.on('response', () => {
+      largeResponded = true
+      large.pause()
+      cancelTimer = setTimeout(() => {
+        large.close(http2.constants.NGHTTP2_CANCEL)
+      }, 100)
+      requestTimer = setTimeout(() => {
+        const small = client.request({
+          [http2.constants.HTTP2_HEADER_METHOD]: http2.constants.HTTP2_METHOD_GET,
+          [http2.constants.HTTP2_HEADER_PATH]: '/small'
+        })
+        let body = ''
+
+        timeout = setTimeout(() => {
+          cleanup()
+          reject(new Error('timed out waiting for /small response'))
+        }, 3000)
+
+        small.setEncoding('utf8')
+        small.on('error', err => {
+          cleanup()
+          reject(err)
+        })
+        small.on('data', chunk => {
+          body += chunk
+        })
+        small.on('end', () => {
+          cleanup()
+          t.assert.strictEqual(body, 'ok')
+          t.assert.strictEqual(smallHit, true)
+          resolve()
+        })
+        small.end()
+      }, 200)
+    })
+    large.end()
+  })
+})

package/test/http2/secure-with-fallback.test.js

@@ -6,7 +6,7 @@ const h2url = require('h2url')
 const msg = { hello: 'world' }
 
 const { buildCertificate } = require('../build-certificate')
-const { Agent } = require('undici')
+const { Agent, fetch } = require('undici')
 test.before(buildCertificate)
 
 test('secure with fallback', async (t) => {

package/test/https/https.test.js

@@ -1,11 +1,10 @@
 'use strict'
 
 const { test } = require('node:test')
-const { request } = require('undici')
+const { request, Agent, fetch } = require('undici')
 const Fastify = require('../..')
 
 const { buildCertificate } = require('../build-certificate')
-const { Agent } = require('undici')
 test.before(buildCertificate)
 
 test('https', async (t) => {

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 88
+const expectedErrors = 91
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
@@ -630,6 +630,16 @@ test('FST_ERR_BAD_URL', t => {
   t.assert.ok(error instanceof Error)
 })
 
+test('FST_ERR_MAX_PARAM_LENGTH', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_MAX_PARAM_LENGTH()
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_MAX_PARAM_LENGTH')
+  t.assert.strictEqual(error.message, "'%s' is exceeding the max param length")
+  t.assert.strictEqual(error.statusCode, 414)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_ASYNC_CONSTRAINT', t => {
   t.plan(5)
   const error = new errors.FST_ERR_ASYNC_CONSTRAINT()
@@ -710,6 +720,16 @@ test('FST_ERR_ROUTE_METHOD_NOT_SUPPORTED', t => {
   t.assert.ok(error instanceof Error)
 })
 
+test('FST_ERR_ROUTE_LOG_LEVEL_INVALID', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_ROUTE_LOG_LEVEL_INVALID()
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_ROUTE_LOG_LEVEL_INVALID')
+  t.assert.strictEqual(error.message, "Log level for '%s:%s' route must be a valid logger level. Received: '%s'")
+  t.assert.strictEqual(error.statusCode, 500)
+  t.assert.ok(error instanceof TypeError)
+})
+
 test('FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED', t => {
   t.plan(5)
   const error = new errors.FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED()
@@ -810,6 +830,16 @@ test('FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER', t => {
   t.assert.ok(error instanceof TypeError)
 })
 
+test('FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED('my-dep', 'my-plugin')
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED')
+  t.assert.strictEqual(error.message, "The dependency 'my-dep' of plugin 'my-plugin' is not registered")
+  t.assert.strictEqual(error.statusCode, 500)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_PLUGIN_CALLBACK_NOT_FN', t => {
   t.plan(5)
   const error = new errors.FST_ERR_PLUGIN_CALLBACK_NOT_FN()

package/test/internals/plugin.test.js

@@ -149,7 +149,7 @@ test('checkDependencies should check if the given dependency is present in the i
 })
 
 test('checkDependencies should check if the given dependency is present in the instance (errored)', t => {
-  t.plan(1)
+  t.plan(3)
 
   fn[Symbol.for('plugin-meta')] = {
     name: 'test-plugin',
@@ -164,6 +164,8 @@ test('checkDependencies should check if the given dependency is present in the i
     t.assert.fail('should throw')
   } catch (err) {
     t.assert.strictEqual(err.message, "The dependency 'plugin' of plugin 'test-plugin' is not registered")
+    t.assert.strictEqual(err.code, 'FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED')
+    t.assert.strictEqual(err.name, 'FastifyError')
   }
 
   function fn () {}

package/test/internals/request.test.js

@@ -487,11 +487,13 @@ test('Request with undefined socket', t => {
   t.assert.ok(request.compileValidationSchema instanceof Function)
 })
 
-test('Request with trust proxy and undefined socket', t => {
-  t.plan(1)
+test('Request with trust proxy and undefined socket does not trust x-forwarded-host/proto', t => {
+  t.plan(2)
   const headers = {
+    host: 'hostname',
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
-    'x-forwarded-host': 'fastify.test'
+    'x-forwarded-host': 'fastify.test',
+    'x-forwarded-proto': 'https'
   }
   const req = {
     method: 'GET',
@@ -502,5 +504,27 @@ test('Request with trust proxy and undefined socket', t => {
 
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
+  t.assert.strictEqual(request.host, 'hostname')
+  t.assert.deepStrictEqual(request.protocol, undefined)
+})
+
+test('Request with trust proxy and null socket does not trust x-forwarded-host/proto', t => {
+  t.plan(2)
+  const headers = {
+    host: 'hostname',
+    'x-forwarded-for': '2.2.2.2, 1.1.1.1',
+    'x-forwarded-host': 'fastify.test',
+    'x-forwarded-proto': 'https'
+  }
+  const req = {
+    method: 'GET',
+    url: '/',
+    socket: null,
+    headers
+  }
+
+  const TpRequest = Request.buildRequest(Request, true)
+  const request = new TpRequest('id', 'params', req, 'query', 'log')
+  t.assert.strictEqual(request.host, 'hostname')
   t.assert.deepStrictEqual(request.protocol, undefined)
 })

package/test/internals/schema-controller-perf.test.js

@@ -1,6 +1,7 @@
 const { sep } = require('node:path')
 const { test } = require('node:test')
 const Fastify = require('../../fastify')
+const { kSchemaController } = require('../../lib/symbols')
 
 test('SchemaController are NOT loaded when the controllers are custom', async t => {
   const app = Fastify({
@@ -22,6 +23,38 @@ test('SchemaController are NOT loaded when the controllers are custom', async t
   t.assert.equal(stringifyModule, undefined, 'Stringify compiler is loaded')
 })
 
+test('isCustomSerializerCompiler flag is set correctly when only buildSerializer is provided', async t => {
+  const app = Fastify({
+    schemaController: {
+      compilersFactory: {
+        buildSerializer: () => () => { }
+      }
+    }
+  })
+
+  await app.ready()
+
+  const schemaController = app[kSchemaController]
+  t.assert.equal(schemaController.isCustomValidatorCompiler, false, 'isCustomValidatorCompiler should be false')
+  t.assert.equal(schemaController.isCustomSerializerCompiler, true, 'isCustomSerializerCompiler should be true')
+})
+
+test('isCustomValidatorCompiler flag is set correctly when only buildValidator is provided', async t => {
+  const app = Fastify({
+    schemaController: {
+      compilersFactory: {
+        buildValidator: () => () => { }
+      }
+    }
+  })
+
+  await app.ready()
+
+  const schemaController = app[kSchemaController]
+  t.assert.equal(schemaController.isCustomValidatorCompiler, true, 'isCustomValidatorCompiler should be true')
+  t.assert.equal(schemaController.isCustomSerializerCompiler, false, 'isCustomSerializerCompiler should be false')
+})
+
 test('SchemaController are loaded when the controllers are not custom', async t => {
   const app = Fastify()
   await app.ready()

package/test/logger/logging.test.js

@@ -16,7 +16,7 @@ t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost
   let localhostForURL
 
-  t.plan(14)
+  t.plan(15)
 
   t.before(async function () {
     [localhost, localhostForURL] = await helper.getLoopbackHost()
@@ -282,6 +282,23 @@ t.test('logging', { timeout: 60000 }, async (t) => {
     t.assert.strictEqual(stream.readableLength, 0)
   })
 
+  await t.test('should not log incoming request, outgoing response and route not found for 414 onMaxParamLength when disabled', async (t) => {
+    t.plan(1)
+    const stream = split(JSON.parse)
+    const fastify = Fastify({ disableRequestLogging: true, logger: { level: 'info', stream } })
+    t.after(() => fastify.close())
+
+    await fastify.ready()
+
+    await fastify.inject({
+      method: 'GET',
+      url: `/${'1234567890'.repeat(12)}`
+    })
+
+    // no more readable data
+    t.assert.strictEqual(stream.readableLength, 0)
+  })
+
   await t.test('should log incoming request and outgoing response based on disableRequestLogging function', async (t) => {
     const lines = [
       'incoming request',

package/test/logger/options.test.js

@@ -10,7 +10,7 @@ const Fastify = require('../../fastify')
 const { on } = stream
 
 t.test('logger options', { timeout: 60000 }, async (t) => {
-  t.plan(16)
+  t.plan(18)
 
   await t.test('logger can be silenced', (t) => {
     t.plan(17)
@@ -479,6 +479,43 @@ t.test('logger options', { timeout: 60000 }, async (t) => {
     }
   })
 
+  await t.test('Should throw when custom log level for a route is invalid', async (t) => {
+    t.plan(4)
+
+    const fastify = Fastify({
+      logger: true
+    })
+    t.after(() => fastify.close())
+
+    try {
+      fastify.get('/log', { logLevel: 'invalid' }, (req, reply) => {
+        reply.send({ hello: 'world' })
+      })
+      t.assert.fail('fastify.get should throw')
+    } catch (err) {
+      t.assert.ok(err)
+      t.assert.strictEqual(err.code, 'FST_ERR_ROUTE_LOG_LEVEL_INVALID')
+      t.assert.strictEqual(err.statusCode, 500)
+      t.assert.strictEqual(err.message, "Log level for 'GET:/log' route must be a valid logger level. Received: 'invalid'")
+    }
+  })
+
+  await t.test('Should allow null custom log level for a route', async (t) => {
+    t.plan(1)
+
+    const fastify = Fastify({
+      logger: true
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/log', { logLevel: null }, (req, reply) => {
+      reply.send({ hello: 'world' })
+    })
+
+    const response = await fastify.inject({ method: 'GET', url: '/log' })
+    t.assert.deepEqual(await response.json(), { hello: 'world' })
+  })
+
   await t.test('should pass when using unWritable props in the logger option', (t) => {
     t.plan(8)
     const fastify = Fastify({

package/test/reply-error.test.js

@@ -575,7 +575,7 @@ test('allow re-thrown error to default error handler when route handler is async
 })
 
 // Issue 2078 https://github.com/fastify/fastify/issues/2078
-// Supported error code list: http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+// Supported error code list: https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
 const invalidErrorCodes = [
   undefined,
   null,