fastify 5.6.1 → 5.7.0

package/test/logger/logging.test.js

@@ -16,7 +16,7 @@ t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost
   let localhostForURL
 
-  t.plan(13)
+  t.plan(14)
 
   t.before(async function () {
     [localhost, localhostForURL] = await helper.getLoopbackHost()
@@ -282,6 +282,43 @@ t.test('logging', { timeout: 60000 }, async (t) => {
     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',
+      'request completed'
+    ]
+    t.plan(lines.length)
+
+    const stream = split(JSON.parse)
+    const loggerInstance = pino(stream)
+
+    const fastify = Fastify({
+      disableRequestLogging: (request) => {
+        return request.url !== '/not-logged'
+      },
+      loggerInstance
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/logged', (req, reply) => {
+      return reply.code(200).send({})
+    })
+
+    fastify.get('/not-logged', (req, reply) => {
+      return reply.code(200).send({})
+    })
+
+    await fastify.ready()
+
+    await fastify.inject({ method: 'GET', url: '/not-logged' })
+    await fastify.inject({ method: 'GET', url: '/logged' })
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.strictEqual(line.msg, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+
   await t.test('defaults to info level', async (t) => {
     const lines = [
       { req: { method: 'GET' }, msg: 'incoming request' },

package/test/promises.test.js

@@ -64,7 +64,7 @@ fastify.get('/return-reply', opts, function (req, reply) {
 fastify.listen({ port: 0 }, (err, fastifyServer) => {
   assert.ifError(err)
 
-  test('shorthand - sget return promise es6 get', async t => {
+  test('shorthand - fetch return promise es6 get', async t => {
     t.plan(4)
 
     const result = await fetch(`${fastifyServer}/return`)
@@ -75,7 +75,7 @@ fastify.listen({ port: 0 }, (err, fastifyServer) => {
     t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   })
 
-  test('shorthand - sget promise es6 get return error', async t => {
+  test('shorthand - fetch promise es6 get return error', async t => {
     t.plan(2)
 
     const result = await fetch(`${fastifyServer}/return-error`)
@@ -83,7 +83,7 @@ fastify.listen({ port: 0 }, (err, fastifyServer) => {
     t.assert.strictEqual(result.status, 500)
   })
 
-  test('sget promise double send', async t => {
+  test('fetch promise double send', async t => {
     t.plan(3)
 
     const result = await fetch(`${fastifyServer}/double`)

package/test/reply-web-stream-locked.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { ReadableStream } = require('node:stream/web')
+const { test, after } = require('node:test')
+const Fastify = require('..')
+
+test('reply.send(web ReadableStream) throws if locked', async t => {
+  t.plan(3)
+
+  const app = Fastify()
+  after(() => app.close())
+
+  app.get('/', (req, reply) => {
+    const rs = new ReadableStream({
+      start (controller) { controller.enqueue(new TextEncoder().encode('hi')); controller.close() }
+    })
+    // lock the stream
+    const reader = rs.getReader()
+    t.assert.strictEqual(rs.locked, true, 'stream is locked')
+
+    // sending a locked stream should trigger the Fastify error
+    reply.send(rs)
+    reader.releaseLock()
+  })
+
+  const res = await app.inject({ method: 'GET', url: '/' })
+  t.assert.strictEqual(res.statusCode, 500)
+  t.assert.deepStrictEqual(
+    JSON.parse(res.body),
+    {
+      statusCode: 500,
+      code: 'FST_ERR_REP_READABLE_STREAM_LOCKED',
+      error: 'Internal Server Error',
+      message: 'ReadableStream was locked. You should call releaseLock() method on reader before sending.'
+    }
+  )
+})

package/test/request-error.test.js

@@ -4,6 +4,9 @@ const { connect } = require('node:net')
 const { test } = require('node:test')
 const Fastify = require('..')
 const { kRequest } = require('../lib/symbols.js')
+const split = require('split2')
+const { Readable } = require('node:stream')
+const { getServerUrl } = require('./helper')
 
 test('default 400 on request error', (t, done) => {
   t.plan(4)
@@ -465,3 +468,116 @@ test('test request.routeOptions.version', async t => {
   t.assert.ok(result2.ok)
   t.assert.strictEqual(result2.status, 200)
 })
+
+test('customErrorHandler should throw for json err and stream response', async (t) => {
+  t.plan(5)
+
+  const logStream = split(JSON.parse)
+  const fastify = Fastify({
+    logger: {
+      stream: logStream,
+      level: 'error'
+    }
+  })
+  t.after(() => fastify.close())
+
+  fastify.get('/', async (req, reply) => {
+    const stream = new Readable({
+      read () {
+        this.push('hello')
+      }
+    })
+    process.nextTick(() => stream.destroy(new Error('stream error')))
+
+    reply.type('application/text')
+    await reply.send(stream)
+  })
+
+  fastify.setErrorHandler((err, req, reply) => {
+    t.assert.strictEqual(err.message, 'stream error')
+    reply.code(400)
+    reply.send({ error: err.message })
+  })
+
+  logStream.once('data', line => {
+    t.assert.strictEqual(line.msg, 'Attempted to send payload of invalid type \'object\'. Expected a string or Buffer.')
+    t.assert.strictEqual(line.level, 50)
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const response = await fetch(getServerUrl(fastify) + '/')
+
+  t.assert.strictEqual(response.status, 500)
+  t.assert.deepStrictEqual(await response.json(), { statusCode: 500, code: 'FST_ERR_REP_INVALID_PAYLOAD_TYPE', error: 'Internal Server Error', message: "Attempted to send payload of invalid type 'object'. Expected a string or Buffer." })
+})
+
+test('customErrorHandler should not throw for json err and stream response with content-type defined', async (t) => {
+  t.plan(4)
+
+  const logStream = split(JSON.parse)
+  const fastify = Fastify({
+    logger: {
+      stream: logStream,
+      level: 'error'
+    }
+  })
+
+  t.after(() => fastify.close())
+
+  fastify.get('/', async (req, reply) => {
+    const stream = new Readable({
+      read () {
+        this.push('hello')
+      }
+    })
+    process.nextTick(() => stream.destroy(new Error('stream error')))
+
+    reply.type('application/text')
+    await reply.send(stream)
+  })
+
+  fastify.setErrorHandler((err, req, reply) => {
+    t.assert.strictEqual(err.message, 'stream error')
+    reply
+      .code(400)
+      .type('application/json')
+      .send({ error: err.message })
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const response = await fetch(getServerUrl(fastify) + '/')
+
+  t.assert.strictEqual(response.status, 400)
+  t.assert.strictEqual(response.headers.get('content-type'), 'application/json; charset=utf-8')
+  t.assert.deepStrictEqual(await response.json(), { error: 'stream error' })
+})
+
+test('customErrorHandler should not call handler for in-stream error', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.get('/', async (req, reply) => {
+    const stream = new Readable({
+      read () {
+        this.push('hello')
+        stream.destroy(new Error('stream error'))
+      }
+    })
+
+    reply.type('application/text')
+    await reply.send(stream)
+  })
+
+  fastify.setErrorHandler(() => {
+    t.assert.fail('must not be called')
+  })
+  await fastify.listen({ port: 0 })
+
+  await t.assert.rejects(fetch(getServerUrl(fastify) + '/'), {
+    message: 'fetch failed'
+  })
+})

package/test/route.6.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const stream = require('node:stream')
+const { ReadableStream } = require('node:stream/web')
 const { test } = require('node:test')
 const Fastify = require('..')
 
@@ -90,13 +91,14 @@ test('Will not create a HEAD route that is not GET', async t => {
 })
 
 test('HEAD route should handle properly each response type', async t => {
-  t.plan(20)
+  t.plan(24)
 
   const fastify = Fastify({ exposeHeadRoutes: true })
   const resString = 'Found me!'
   const resJSON = { here: 'is Johnny' }
   const resBuffer = Buffer.from('I am a buffer!')
   const resStream = stream.Readable.from('I am a stream!')
+  const resWebStream = ReadableStream.from('I am a web stream!')
 
   fastify.route({
     method: 'GET',
@@ -139,6 +141,14 @@ test('HEAD route should handle properly each response type', async t => {
     }
   })
 
+  fastify.route({
+    method: 'GET',
+    path: '/web-stream',
+    handler: (req, reply) => {
+      return resWebStream
+    }
+  })
+
   let res = await fastify.inject({
     method: 'HEAD',
     url: '/json'
@@ -183,6 +193,15 @@ test('HEAD route should handle properly each response type', async t => {
   t.assert.strictEqual(res.headers['content-type'], undefined)
   t.assert.strictEqual(res.headers['content-length'], undefined)
   t.assert.strictEqual(res.body, '')
+
+  res = await fastify.inject({
+    method: 'HEAD',
+    url: '/web-stream'
+  })
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.headers['content-type'], undefined)
+  t.assert.strictEqual(res.headers['content-length'], undefined)
+  t.assert.strictEqual(res.body, '')
 })
 
 test('HEAD route should respect custom onSend handlers', async t => {

package/test/route.7.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const stream = require('node:stream')
+const { ReadableStream } = require('node:stream/web')
 const split = require('split2')
 const { test } = require('node:test')
 const Fastify = require('..')
@@ -47,6 +48,54 @@ test("HEAD route should handle stream.on('error')", (t, done) => {
   })
 })
 
+test('HEAD route should handle ReadableStream.cancel() error', (t, done) => {
+  t.plan(7)
+
+  const logStream = split(JSON.parse)
+  const expectedError = new Error('Cancel error!')
+  const fastify = Fastify({
+    logger: {
+      stream: logStream,
+      level: 'error'
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    path: '/web-stream',
+    exposeHeadRoute: true,
+    handler: (req, reply) => {
+      const webStream = new ReadableStream({
+        start (controller) {
+          controller.enqueue('Hello from web stream!')
+        },
+        cancel (reason) {
+          t.assert.strictEqual(reason, 'Stream cancelled by HEAD route')
+          throw expectedError
+        }
+      })
+      return webStream
+    }
+  })
+
+  logStream.once('data', line => {
+    const { message, stack } = expectedError
+    t.assert.deepStrictEqual(line.err, { type: 'Error', message, stack })
+    t.assert.strictEqual(line.msg, 'Error on Stream found for HEAD route')
+    t.assert.strictEqual(line.level, 50)
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/web-stream'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-type'], undefined)
+    done()
+  })
+})
+
 test('HEAD route should be exposed by default', async t => {
   t.plan(5)
 

package/test/router-options.test.js

@@ -447,6 +447,157 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
   )
 })
 
+test('Should honor disableRequestLogging function in frameworkErrors wrapper - FST_ERR_BAD_URL', (t, done) => {
+  t.plan(4)
+
+  let logCallCount = 0
+  const logStream = split(JSON.parse)
+
+  const fastify = Fastify({
+    disableRequestLogging: (req) => {
+      // Disable logging for URLs containing 'silent'
+      return req.url.includes('silent')
+    },
+    frameworkErrors: function (err, req, res) {
+      res.send(`${err.message} - ${err.code}`)
+    },
+    logger: {
+      stream: logStream,
+      level: 'info'
+    }
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  logStream.on('data', (json) => {
+    if (json.msg === 'incoming request') {
+      logCallCount++
+    }
+  })
+
+  // First request: URL does not contain 'silent', so logging should happen
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/%world'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+
+      // Second request: URL contains 'silent', so logging should be disabled
+      fastify.inject(
+        {
+          method: 'GET',
+          url: '/silent/%world'
+        },
+        (err2, res2) => {
+          t.assert.ifError(err2)
+          // Give time for any potential log events
+          setImmediate(() => {
+            // Only the first request should have logged
+            t.assert.strictEqual(logCallCount, 1)
+            done()
+          })
+        }
+      )
+    }
+  )
+})
+
+test('Should honor disableRequestLogging function in frameworkErrors wrapper - FST_ERR_ASYNC_CONSTRAINT', (t, done) => {
+  t.plan(4)
+
+  let logCallCount = 0
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx, done) => {
+      done(Error('kaboom'))
+    },
+    validate () { return true }
+  }
+
+  const logStream = split(JSON.parse)
+
+  const fastify = Fastify({
+    constraints: { secret: constraint },
+    disableRequestLogging: (req) => {
+      // Disable logging for URLs containing 'silent'
+      return req.url.includes('silent')
+    },
+    frameworkErrors: function (err, req, res) {
+      res.send(`${err.message} - ${err.code}`)
+    },
+    logger: {
+      stream: logStream,
+      level: 'info'
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/silent',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  logStream.on('data', (json) => {
+    if (json.msg === 'incoming request') {
+      logCallCount++
+    }
+  })
+
+  // First request: URL does not contain 'silent', so logging should happen
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+
+      // Second request: URL contains 'silent', so logging should be disabled
+      fastify.inject(
+        {
+          method: 'GET',
+          url: '/silent'
+        },
+        (err2, res2) => {
+          t.assert.ifError(err2)
+          // Give time for any potential log events
+          setImmediate(() => {
+            // Only the first request should have logged
+            t.assert.strictEqual(logCallCount, 1)
+            done()
+          })
+        }
+      )
+    }
+  )
+})
+
 test('Should honor routerOptions.defaultRoute', async t => {
   t.plan(3)
   const fastify = Fastify({
@@ -895,3 +1046,21 @@ test('Should honor routerOptions.useSemicolonDelimiter over useSemicolonDelimite
   })
   t.assert.strictEqual(res.statusCode, 200)
 })
+
+test('Should support extra find-my-way options', async t => {
+  t.plan(1)
+  // Use a real upstream option from find-my-way
+  const fastify = Fastify({
+    routerOptions: {
+      buildPrettyMeta: (route) => {
+        const cleanMeta = Object.assign({}, route.store)
+        return cleanMeta
+      }
+    }
+  })
+
+  await fastify.ready()
+
+  // Ensure the option is preserved after validation
+  t.assert.strictEqual(typeof fastify.initialConfig.routerOptions.buildPrettyMeta, 'function')
+})

package/test/schema-validation.test.js

@@ -1241,7 +1241,13 @@ test('Custom validator builder override by custom validator compiler', async t =
   }
   const ajv1 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_one', type: 'object', validator: () => true })
   const ajv2 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_two', type: 'object', validator: () => true })
-  const fastify = Fastify({ schemaController: { compilersFactory: { buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema) } } })
+  const fastify = Fastify({
+    schemaController: {
+      compilersFactory: {
+        buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema)
+      }
+    }
+  })
 
   fastify.setValidatorCompiler((routeSchemaDef) => ajv2.compile(routeSchemaDef.schema))
 
@@ -1281,7 +1287,13 @@ test('Custom validator builder override by custom validator compiler in child in
   }
   const ajv1 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_one', type: 'object', validator: () => true })
   const ajv2 = new AJV(ajvDefaults).addKeyword({ keyword: 'extended_two', type: 'object', validator: () => true })
-  const fastify = Fastify({ schemaController: { compilersFactory: { buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema) } } })
+  const fastify = Fastify({
+    schemaController: {
+      compilersFactory: {
+        buildValidator: () => (routeSchemaDef) => ajv1.compile(routeSchemaDef.schema)
+      }
+    }
+  })
 
   fastify.register((embedded, _opts, done) => {
     embedded.setValidatorCompiler((routeSchemaDef) => ajv2.compile(routeSchemaDef.schema))
@@ -1426,6 +1438,17 @@ test('Schema validation will not be bypass by different content type', async t =
   t.assert.strictEqual(correct2.status, 200)
   await correct2.bytes()
 
+  const correct3 = await fetch(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json\t; charset=utf-8'
+    },
+    body: JSON.stringify({ foo: 'string' })
+  })
+  t.assert.strictEqual(correct2.status, 200)
+  await correct3.bytes()
+
   const invalid1 = await fetch(address, {
     method: 'POST',
     url: '/',
@@ -1489,8 +1512,8 @@ test('Schema validation will not be bypass by different content type', async t =
     },
     body: JSON.stringify({ invalid: 'string' })
   })
-  t.assert.strictEqual(invalid6.status, 415)
-  t.assert.strictEqual((await invalid6.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
+  t.assert.strictEqual(invalid6.status, 400)
+  t.assert.strictEqual((await invalid6.json()).code, 'FST_ERR_VALIDATION')
 
   const invalid7 = await fetch(address, {
     method: 'POST',

package/test/server.test.js

@@ -1,11 +1,14 @@
 'use strict'
 
 const dns = require('node:dns')
+const { networkInterfaces } = require('node:os')
 const { test } = require('node:test')
 const Fastify = require('..')
 const undici = require('undici')
 const proxyquire = require('proxyquire')
 
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
+
 test('listen should accept null port', async t => {
   const fastify = Fastify()
   t.after(() => fastify.close())
@@ -67,13 +70,13 @@ test('listen should reject string port', async (t) => {
 })
 
 test('Test for hostname and port', async (t) => {
+  t.plan(3)
   const app = Fastify()
   t.after(() => app.close())
   app.get('/host', (req, res) => {
-    const host = 'localhost:8000'
-    t.assert.strictEqual(req.host, host)
-    t.assert.strictEqual(req.hostname, req.host.split(':')[0])
-    t.assert.strictEqual(req.port, Number(req.host.split(':')[1]))
+    t.assert.strictEqual(req.host, 'localhost:8000')
+    t.assert.strictEqual(req.hostname, 'localhost')
+    t.assert.strictEqual(req.port, 8000)
     res.send('ok')
   })
 
@@ -81,6 +84,24 @@ test('Test for hostname and port', async (t) => {
   await fetch('http://localhost:8000/host')
 })
 
+test('Test for IPV6 port', { skip: isIPv6Missing }, async (t) => {
+  t.plan(3)
+  const app = Fastify()
+  t.after(() => app.close())
+  app.get('/host', (req, res) => {
+    t.assert.strictEqual(req.host, '[::1]:3040')
+    t.assert.strictEqual(req.hostname, '[::1]')
+    t.assert.strictEqual(req.port, 3040)
+    res.send('ok')
+  })
+
+  await app.listen({
+    port: 3040,
+    host: '::1'
+  })
+  await fetch('http://[::1]:3040/host')
+})
+
 test('abort signal', async t => {
   await t.test('should close server when aborted after', (t, end) => {
     t.plan(2)

package/test/stream.5.test.js

@@ -35,8 +35,8 @@ test('should mark reply as sent before pumping the payload stream into response
   t.plan(2)
   t.after(() => fastify.close())
 
-  const handleRequest = proxyquire('../lib/handleRequest', {
-    './wrapThenable': (thenable, reply) => {
+  const handleRequest = proxyquire('../lib/handle-request', {
+    './wrap-thenable': (thenable, reply) => {
       thenable.then(function (payload) {
         t.assert.strictEqual(reply.sent, true)
       })
@@ -44,7 +44,7 @@ test('should mark reply as sent before pumping the payload stream into response
   })
 
   const route = proxyquire('../lib/route', {
-    './handleRequest': handleRequest
+    './handle-request': handleRequest
   })
 
   const Fastify = proxyquire('..', {