fastify 5.8.5 → 5.10.0

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 = 92
 
 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/logger.test.js

@@ -3,6 +3,7 @@
 const { test } = require('node:test')
 const Fastify = require('../..')
 const loggerUtils = require('../../lib/logger-factory')
+const { createLogController, LogController } = require('../../lib/logger-factory')
 const { serializers } = require('../../lib/logger-pino')
 
 test('time resolution', t => {
@@ -142,6 +143,327 @@ test('The logger should error if both stream and file destination are given', t
   }
 })
 
+test('LogController defaults', t => {
+  t.plan(3)
+  const dispatcher = new LogController()
+  t.assert.strictEqual(dispatcher.disableRequestLogging, false)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'reqId')
+  t.assert.strictEqual(dispatcher.isLogDisabled({}), false)
+})
+
+test('LogController with custom options', t => {
+  t.plan(2)
+  const dispatcher = new LogController({
+    disableRequestLogging: true,
+    requestIdLogLabel: 'traceId'
+  })
+  t.assert.strictEqual(dispatcher.disableRequestLogging, true)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'traceId')
+})
+
+test('LogController with function disableRequestLogging', t => {
+  t.plan(2)
+  const dispatcher = new LogController({
+    disableRequestLogging: (req) => req.skip === true
+  })
+  t.assert.strictEqual(dispatcher.isLogDisabled({ skip: true }), true)
+  t.assert.strictEqual(dispatcher.isLogDisabled({ skip: false }), false)
+})
+
+test('requestCompleted should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') },
+    info: () => { t.assert.fail('info should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.requestCompleted(new Error('test'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('requestCompleted should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') },
+    info: () => { t.assert.fail('info should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.requestCompleted(new Error('test'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('requestCompleted should log error when err is present', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('test')
+  const log = {
+    error: (data, msg) => {
+      t.assert.strictEqual(msg, 'request errored')
+    }
+  }
+  const request = {}
+  const reply = { request, log, elapsedTime: 42 }
+  logController.requestCompleted(err, request, reply)
+})
+
+test('requestCompleted should log info when no error', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const log = {
+    info: (data, msg) => {
+      t.assert.strictEqual(msg, 'request completed')
+    }
+  }
+  const request = {}
+  const reply = { request, log, elapsedTime: 42 }
+  logController.requestCompleted(null, request, reply)
+})
+
+test('defaultErrorLog should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    info: () => { t.assert.fail('info should not be called') },
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 404 }
+  logController.defaultErrorLog(new Error('not found'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('defaultErrorLog should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    info: () => { t.assert.fail('info should not be called') },
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 404 }
+  logController.defaultErrorLog(new Error('not found'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('defaultErrorLog should log info for 4xx errors', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('not found')
+  const log = {
+    info: (data, msg) => {
+      t.assert.strictEqual(msg, 'not found')
+    }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 404 }
+  logController.defaultErrorLog(err, request, reply)
+})
+
+test('defaultErrorLog should log error for 5xx errors', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('internal error')
+  const log = {
+    error: (data, msg) => {
+      t.assert.strictEqual(msg, 'internal error')
+    }
+  }
+  const request = {}
+  const reply = { request, log, statusCode: 500 }
+  logController.defaultErrorLog(err, request, reply)
+})
+
+test('writeHeadError should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    warn: () => { t.assert.fail('warn should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.writeHeadError(new Error('write head failed'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('writeHeadError should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    warn: () => { t.assert.fail('warn should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.writeHeadError(new Error('write head failed'), request, reply)
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('writeHeadError should log warn with error message', t => {
+  t.plan(2)
+  const logController = new LogController({ disableRequestLogging: false })
+  const error = new Error('write head failed')
+  const request = {}
+  const reply = {
+    request,
+    log: {
+      warn: (data, msg) => {
+        t.assert.strictEqual(msg, 'write head failed')
+        t.assert.strictEqual(data.err, error)
+      }
+    }
+  }
+  logController.writeHeadError(error, request, reply)
+})
+
+test('serializerError should not log when logging is disabled (boolean)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.serializerError(new Error('serializer failed'), request, reply, { statusCode: 500 })
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('serializerError should not log when logging is disabled (function)', t => {
+  t.plan(1)
+  const logController = new LogController({ disableRequestLogging: () => true })
+  const log = {
+    error: () => { t.assert.fail('error should not be called') }
+  }
+  const request = {}
+  const reply = { request, log }
+  logController.serializerError(new Error('serializer failed'), request, reply, { statusCode: 500 })
+  t.assert.ok(true, 'logger was not called')
+})
+
+test('serializerError should log error with status code', t => {
+  t.plan(2)
+  const logController = new LogController({ disableRequestLogging: false })
+  const err = new Error('serializer failed')
+  const request = {}
+  const reply = {
+    request,
+    log: {
+      error: (data, msg) => {
+        t.assert.strictEqual(msg, 'The serializer for the given status code failed')
+        t.assert.strictEqual(data.statusCode, 500)
+      }
+    }
+  }
+  logController.serializerError(err, request, reply, { statusCode: 500 })
+})
+
+test('createLogController should use LogController instance directly', t => {
+  t.plan(2)
+  const custom = new LogController({ disableRequestLogging: true, requestIdLogLabel: 'traceId' })
+  const dispatcher = createLogController({ logController: custom })
+  t.assert.strictEqual(dispatcher, custom)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'traceId')
+})
+
+test('createLogController should create default when no instance provided', t => {
+  t.plan(2)
+  const dispatcher = createLogController({ disableRequestLogging: false, requestIdLogLabel: 'reqId' })
+  t.assert.ok(dispatcher instanceof LogController)
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'reqId')
+})
+
+test('createLogController should throw on invalid type', t => {
+  t.plan(1)
+  t.assert.throws(() => {
+    createLogController({ disableRequestLogging: false, logController: 'bad' })
+  }, { code: 'FST_ERR_LOG_INVALID_LOG_CONTROLLER' })
+})
+
+test('createLogController should throw when plain object is provided', t => {
+  t.plan(1)
+  t.assert.throws(() => {
+    createLogController({ disableRequestLogging: false, logController: { incomingRequest: () => { } } })
+  }, { code: 'FST_ERR_LOG_INVALID_LOG_CONTROLLER' })
+})
+
+test('createLogController should accept null', t => {
+  t.plan(1)
+  const logController = createLogController({ disableRequestLogging: false, logController: null })
+  t.assert.ok(logController)
+})
+
+test('LogController subclass should work', t => {
+  t.plan(2)
+
+  class MyDispatcher extends LogController {
+    constructor () {
+      super({ requestIdLogLabel: 'traceId' })
+    }
+
+    incomingRequest (request, reply, metadata) {
+      t.assert.ok(true, 'custom incomingRequest called')
+    }
+  }
+
+  const dispatcher = new MyDispatcher()
+  t.assert.strictEqual(dispatcher.requestIdLogLabel, 'traceId')
+  dispatcher.incomingRequest({})
+})
+
+test('LogController subclass keeps defaults for non-overridden methods', t => {
+  t.plan(1)
+
+  class MyDispatcher extends LogController {
+    incomingRequest () { }
+  }
+
+  const dispatcher = new MyDispatcher()
+  const log = {
+    info: (data, msg) => {
+      t.assert.strictEqual(msg, 'request completed')
+    }
+  }
+  const request = {}
+  const reply = { request, log, elapsedTime: 42 }
+  dispatcher.requestCompleted(null, request, reply)
+})
+
+test('serviceUnavailable should log with logger and receive server', t => {
+  t.plan(2)
+  const dispatcher = new LogController()
+  const fakeLogger = {
+    info: (data, msg) => {
+      t.assert.deepStrictEqual(data, { res: { statusCode: 503 } })
+      t.assert.strictEqual(msg, 'request aborted - refusing to accept new requests as server is closing')
+    }
+  }
+  const fakeServer = { name: 'test-server' }
+  dispatcher.serviceUnavailable(fakeLogger, fakeServer)
+})
+
+test('serviceUnavailable subclass can use server', t => {
+  t.plan(1)
+
+  const fakeServer = { name: 'test-server' }
+
+  class MyDispatcher extends LogController {
+    serviceUnavailable (logger, server) {
+      t.assert.strictEqual(server, fakeServer)
+    }
+  }
+
+  const dispatcher = new MyDispatcher()
+  dispatcher.serviceUnavailable({}, fakeServer)
+})
+
+test('LogController is exported from fastify', t => {
+  t.plan(2)
+  t.assert.ok(Fastify.LogController)
+  t.assert.strictEqual(Fastify.LogController, LogController)
+})
+
 test('The serializer prevent fails if the request socket is undefined', t => {
   t.plan(1)
 

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

@@ -5,6 +5,7 @@ const http = require('node:http')
 const NotFound = require('http-errors').NotFound
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
+const { LogController } = require('../../lib/log-controller')
 const Fastify = require('../..')
 const { Readable, Writable } = require('node:stream')
 const {
@@ -13,7 +14,8 @@ const {
   kReplySerializer,
   kReplyIsError,
   kReplySerializerDefault,
-  kRouteContext
+  kRouteContext,
+  kLogController
 } = require('../../lib/symbols')
 const fs = require('node:fs')
 const path = require('node:path')
@@ -85,7 +87,14 @@ test('reply.send will logStream error and destroy the stream', t => {
     warn: () => { }
   }
 
-  const reply = new Reply(response, { [kRouteContext]: { onSend: null } }, log)
+  const fakeRequest = {
+    [kRouteContext]: {
+      onSend: null,
+      server: { [kLogController]: new LogController() }
+    }
+  }
+
+  const reply = new Reply(response, fakeRequest, log)
   reply.send(payload)
   payload.destroy(new Error('stream error'))
 
@@ -764,7 +773,7 @@ test('non-string with custom json\'s content-type SHOULD be serialized as json',
 
   const result = await fetch(fastifyServer)
   t.assert.ok(result.ok)
-  t.assert.strictEqual(result.headers.get('content-type'), 'application/json; version=2; charset=utf-8')
+  t.assert.strictEqual(result.headers.get('content-type'), 'application/json; version="2"; charset=utf-8')
   t.assert.deepStrictEqual(await result.text(), JSON.stringify({ key: 'hello world!' }))
 })
 
@@ -1149,7 +1158,7 @@ test('reply.hasHeader computes raw and fastify headers', async t => {
 })
 
 test('Reply should handle JSON content type with a charset', async t => {
-  t.plan(8)
+  t.plan(10)
 
   const fastify = require('../../')()
 
@@ -1199,6 +1208,18 @@ test('Reply should handle JSON content type with a charset', async t => {
       .send({ hello: 'world' })
   })
 
+  fastify.get('/upper-charset', function (req, reply) {
+    reply
+      .header('content-type', 'application/json; CHARSET=utf-8')
+      .send({ hello: 'world' })
+  })
+
+  fastify.get('/random-case', function (req, reply) {
+    reply
+      .header('content-type', 'ApPlIcAtIoN/JsOn; ChArSeT=utf-8')
+      .send({ hello: 'world' })
+  })
+
   {
     const res = await fastify.inject('/default')
     t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
@@ -1233,6 +1254,16 @@ test('Reply should handle JSON content type with a charset', async t => {
     t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-32')
   }
 
+  {
+    const res = await fastify.inject('/upper-charset')
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; CHARSET=utf-8')
+  }
+
+  {
+    const res = await fastify.inject('/random-case')
+    t.assert.strictEqual(res.headers['content-type'], 'ApPlIcAtIoN/JsOn; ChArSeT=utf-8')
+  }
+
   {
     const res = await fastify.inject('/no-space-type-utf32')
     t.assert.strictEqual(res.headers['content-type'], 'application/json;charset=utf-32')