fastify 5.8.5 → 5.10.0

package/test/internals/request.test.js

@@ -331,10 +331,10 @@ test('Request with trust proxy - no x-forwarded-host header', t => {
 })
 
 test('Request with trust proxy - no x-forwarded-host header and fallback to authority', t => {
-  t.plan(2)
+  t.plan(3)
   const headers = {
     'x-forwarded-for': '2.2.2.2, 1.1.1.1',
-    ':authority': 'authority'
+    ':authority': 'authority:4321'
   }
   const req = {
     method: 'GET',
@@ -370,15 +370,16 @@ test('Request with trust proxy - no x-forwarded-host header and fallback to auth
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log', context)
   t.assert.ok(request instanceof TpRequest)
-  t.assert.strictEqual(request.host, 'authority')
+  t.assert.strictEqual(request.host, 'authority:4321')
+  t.assert.strictEqual(request.port, 4321)
 })
 
 test('Request with trust proxy - x-forwarded-host header has precedence over host', t => {
-  t.plan(2)
+  t.plan(4)
   const headers = {
     'x-forwarded-for': ' 2.2.2.2, 1.1.1.1',
-    'x-forwarded-host': 'fastify.test',
-    host: 'hostname'
+    'x-forwarded-host': 'fastify.test:1234',
+    host: 'hostname:5678'
   }
   const req = {
     method: 'GET',
@@ -390,7 +391,9 @@ test('Request with trust proxy - x-forwarded-host header has precedence over hos
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
   t.assert.ok(request instanceof TpRequest)
-  t.assert.strictEqual(request.host, 'fastify.test')
+  t.assert.strictEqual(request.host, 'fastify.test:1234')
+  t.assert.strictEqual(request.hostname, 'fastify.test')
+  t.assert.strictEqual(request.port, 1234)
 })
 
 test('Request with trust proxy - handles multiple entries in x-forwarded-host/proto', t => {
@@ -487,11 +490,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 +507,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

@@ -7,6 +7,7 @@ const split = require('split2')
 const pino = require('pino')
 
 const Fastify = require('../../fastify')
+const { LogController } = require('../../lib/log-controller')
 const helper = require('../helper')
 const { once, on } = stream
 const { request } = require('./logger-test-utils')
@@ -16,7 +17,7 @@ t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost
   let localhostForURL
 
-  t.plan(14)
+  t.plan(16)
 
   t.before(async function () {
     [localhost, localhostForURL] = await helper.getLoopbackHost()
@@ -80,6 +81,44 @@ t.test('logging', { timeout: 60000 }, async (t) => {
     }
   })
 
+  await t.test('should not log if logController option disables logging', async (t) => {
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: {
+        stream,
+        level: 'info'
+      },
+      logController: new class extends LogController {
+        isLogDisabled () {
+          t.assert.ok(true, 'isLogDisabled should be called')
+          return true // disable logging to test that incomingRequest is not called
+        }
+      }()
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/info', function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` }
+    ]
+    // 2:
+    // - incoming request
+    // - request completed
+    t.plan(lines.length + 2)
+
+    await request(`http://${localhostForURL}:` + fastify.server.address().port + '/info')
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
+      if (lines.length === 0) break
+    }
+  })
+
   await t.test('should log the error if no error handler is defined', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
@@ -282,6 +321,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,

package/test/reply-trailers.test.js

@@ -192,6 +192,46 @@ test('error in trailers should be ignored', (t, testDone) => {
   })
 })
 
+test('send is called once when multiple trailer callbacks run synchronously', (t, testDone) => {
+  t.plan(6)
+  const fastify = Fastify()
+  let endCalls = 0
+  let addTrailersCalls = 0
+
+  fastify.get('/', function (request, reply) {
+    const originalEnd = reply.raw.end.bind(reply.raw)
+    reply.raw.end = function (...args) {
+      endCalls++
+      return originalEnd(...args)
+    }
+    const originalAddTrailers = reply.raw.addTrailers.bind(reply.raw)
+    reply.raw.addTrailers = function (...args) {
+      addTrailersCalls++
+      return originalAddTrailers(...args)
+    }
+    reply.trailer('Return-Early', function (reply, payload, done) {
+      done(null, 'a')
+    })
+    reply.trailer('Content-MD5', function (reply, payload, done) {
+      done(null, 'b')
+    })
+    reply.send('hello')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.trailers['return-early'], 'a')
+    t.assert.strictEqual(res.trailers['content-md5'], 'b')
+    t.assert.strictEqual(endCalls, 1)
+    t.assert.strictEqual(addTrailersCalls, 1)
+    testDone()
+  })
+})
+
 describe('trailer handler counter', () => {
   const data = JSON.stringify({ hello: 'world' })
   const hash = createHash('md5')
@@ -266,6 +306,36 @@ describe('trailer handler counter', () => {
       testDone()
     })
   })
+
+  test('mixed callback and promise trailers only use the first completion', (t, testDone) => {
+    t.plan(7)
+    const fastify = Fastify()
+
+    fastify.get('/', function (request, reply) {
+      reply.trailer('Async', function (reply, payload, done) {
+        setTimeout(() => done(null, 'async'), 10)
+      })
+      reply.trailer('Mixed', function (reply, payload, done) {
+        done(null, 'correct')
+        return Promise.resolve('corrupted')
+      })
+      reply.send('hello')
+    })
+
+    fastify.inject({
+      method: 'GET',
+      url: '/'
+    }, (error, res) => {
+      t.assert.ifError(error)
+      t.assert.strictEqual(res.statusCode, 200)
+      t.assert.strictEqual(res.headers['transfer-encoding'], 'chunked')
+      t.assert.strictEqual(res.headers.trailer, 'async mixed')
+      t.assert.strictEqual(res.trailers.async, 'async')
+      t.assert.strictEqual(res.trailers.mixed, 'correct')
+      t.assert.ok(!res.headers['content-length'])
+      testDone()
+    })
+  })
 })
 
 test('removeTrailer', (t, testDone) => {

package/test/request-media-type.test.js

@@ -0,0 +1,105 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('request.mediaType should match the content-type header', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (request, reply) => {
+    t.assert.strictEqual(request.mediaType, 'application/json')
+    reply.send({ mediaType: request.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: {
+      'content-type': 'application/json'
+    }
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('request.mediaType should strip the charset parameter', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (request, reply) => {
+    t.assert.strictEqual(request.mediaType, 'application/json')
+    reply.send({ mediaType: request.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: {
+      'content-type': 'application/json; charset=utf-8'
+    }
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('request.mediaType should strip the space', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (request, reply) => {
+    t.assert.strictEqual(request.mediaType, 'application/json')
+    reply.send({ mediaType: request.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: {
+      'content-type': ' application/json ; charset=utf-8'
+    }
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})
+
+test('request.mediaType supported in hooks', async (t) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    preParsing: (request, reply, payload, done) => {
+      t.assert.strictEqual(request.mediaType, 'application/json')
+      done(null, payload)
+    },
+    preValidation: (request, reply, done) => {
+      t.assert.strictEqual(request.mediaType, 'application/json')
+      done()
+    },
+    preHandler: (request, reply, done) => {
+      t.assert.strictEqual(request.mediaType, 'application/json')
+      done()
+    }
+  }, (request, reply) => {
+    t.assert.strictEqual(request.mediaType, 'application/json')
+    reply.send({ mediaType: request.mediaType })
+  })
+
+  const response = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    body: JSON.stringify({ hello: 'world' }),
+    headers: {
+      'content-type': 'application/json'
+    }
+  })
+  const body = await response.json()
+  t.assert.strictEqual(body.mediaType, 'application/json')
+})

package/test/route-prefix.test.js

@@ -241,6 +241,40 @@ test('Prefix with trailing /', (t, testDone) => {
   completion.patience.then(testDone)
 })
 
+test('Prefix with trailing / and nested prefix without leading /', (t, testDone) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.register(function (fastify, opts, done) {
+      fastify.get('/route', (req, reply) => {
+        reply.send({ hello: 'world' })
+      })
+      done()
+    }, { prefix: 'inner' })
+    done()
+  }, { prefix: '/v1/' })
+
+  const completion = waitForCb({ steps: 2 })
+  fastify.inject({
+    method: 'GET',
+    url: '/v1/inner/route'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    completion.stepIn()
+  })
+  fastify.inject({
+    method: 'GET',
+    url: '/v1//inner/route'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    completion.stepIn()
+  })
+  completion.patience.then(testDone)
+})
+
 test('Prefix works multiple levels deep', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()