fastify 4.23.2 → 4.24.0

package/test/logger/request.test.js

@@ -0,0 +1,292 @@
+'use strict'
+
+const stream = require('node:stream')
+
+const t = require('tap')
+const split = require('split2')
+
+const Fastify = require('../../fastify')
+const helper = require('../helper')
+const { on } = stream
+const { request } = require('./logger-test-utils')
+
+t.test('request', (t) => {
+  t.setTimeout(60000)
+
+  let localhost
+
+  t.plan(7)
+  t.before(async function () {
+    [localhost] = await helper.getLoopbackHost()
+  })
+
+  t.test('The request id header key can be customized', async (t) => {
+    const lines = ['incoming request', 'some log message', 'request completed']
+    t.plan(lines.length * 2 + 2)
+    const REQUEST_ID = '42'
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: 'my-custom-request-id'
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/', (req, reply) => {
+      t.equal(req.id, REQUEST_ID)
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    const response = await fastify.inject({ method: 'GET', url: '/', headers: { 'my-custom-request-id': REQUEST_ID } })
+    const body = await response.json()
+    t.equal(body.id, REQUEST_ID)
+
+    for await (const [line] of on(stream, 'data')) {
+      t.equal(line.reqId, REQUEST_ID)
+      t.equal(line.msg, lines.shift(), 'message is set')
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('The request id header key can be ignored', async (t) => {
+    const lines = ['incoming request', 'some log message', 'request completed']
+    t.plan(lines.length * 2 + 2)
+    const REQUEST_ID = 'ignore-me'
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: false
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/', (req, reply) => {
+      t.equal(req.id, 'req-1')
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+    const response = await fastify.inject({ method: 'GET', url: '/', headers: { 'request-id': REQUEST_ID } })
+    const body = await response.json()
+    t.equal(body.id, 'req-1')
+
+    for await (const [line] of on(stream, 'data')) {
+      t.equal(line.reqId, 'req-1')
+      t.equal(line.msg, lines.shift(), 'message is set')
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('The request id header key can be customized along with a custom id generator', async (t) => {
+    const REQUEST_ID = '42'
+    const matches = [
+      { reqId: REQUEST_ID, msg: /incoming request/ },
+      { reqId: REQUEST_ID, msg: /some log message/ },
+      { reqId: REQUEST_ID, msg: /request completed/ },
+      { reqId: 'foo', msg: /incoming request/ },
+      { reqId: 'foo', msg: /some log message 2/ },
+      { reqId: 'foo', msg: /request completed/ }
+    ]
+    t.plan(matches.length + 4)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: 'my-custom-request-id',
+      genReqId (req) {
+        return 'foo'
+      }
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/one', (req, reply) => {
+      t.equal(req.id, REQUEST_ID)
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    fastify.get('/two', (req, reply) => {
+      t.equal(req.id, 'foo')
+      req.log.info('some log message 2')
+      reply.send({ id: req.id })
+    })
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'my-custom-request-id': REQUEST_ID } })
+      const body = await response.json()
+      t.equal(body.id, REQUEST_ID)
+    }
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/two' })
+      const body = await response.json()
+      t.equal(body.id, 'foo')
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, matches.shift())
+      if (matches.length === 0) break
+    }
+  })
+
+  t.test('The request id header key can be ignored along with a custom id generator', async (t) => {
+    const REQUEST_ID = 'ignore-me'
+    const matches = [
+      { reqId: 'foo', msg: /incoming request/ },
+      { reqId: 'foo', msg: /some log message/ },
+      { reqId: 'foo', msg: /request completed/ },
+      { reqId: 'foo', msg: /incoming request/ },
+      { reqId: 'foo', msg: /some log message 2/ },
+      { reqId: 'foo', msg: /request completed/ }
+    ]
+    t.plan(matches.length + 4)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: false,
+      genReqId (req) {
+        return 'foo'
+      }
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/one', (req, reply) => {
+      t.equal(req.id, 'foo')
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    fastify.get('/two', (req, reply) => {
+      t.equal(req.id, 'foo')
+      req.log.info('some log message 2')
+      reply.send({ id: req.id })
+    })
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'request-id': REQUEST_ID } })
+      const body = await response.json()
+      t.equal(body.id, 'foo')
+    }
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/two' })
+      const body = await response.json()
+      t.equal(body.id, 'foo')
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, matches.shift())
+      if (matches.length === 0) break
+    }
+  })
+
+  t.test('The request id log label can be changed', async (t) => {
+    const REQUEST_ID = '42'
+    const matches = [
+      { traceId: REQUEST_ID, msg: /incoming request/ },
+      { traceId: REQUEST_ID, msg: /some log message/ },
+      { traceId: REQUEST_ID, msg: /request completed/ }
+    ]
+    t.plan(matches.length + 2)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: { stream, level: 'info' },
+      requestIdHeader: 'my-custom-request-id',
+      requestIdLogLabel: 'traceId'
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/one', (req, reply) => {
+      t.equal(req.id, REQUEST_ID)
+      req.log.info('some log message')
+      reply.send({ id: req.id })
+    })
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'my-custom-request-id': REQUEST_ID } })
+      const body = await response.json()
+      t.equal(body.id, REQUEST_ID)
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, matches.shift())
+      if (matches.length === 0) break
+    }
+  })
+
+  t.test('should redact the authorization header if so specified', async (t) => {
+    const lines = [
+      { msg: /Server listening at/ },
+      { req: { headers: { authorization: '[Redacted]' } }, msg: 'incoming request' },
+      { res: { statusCode: 200 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 3)
+    const stream = split(JSON.parse)
+    const fastify = Fastify({
+      logger: {
+        stream,
+        redact: ['req.headers.authorization'],
+        level: 'info',
+        serializers: {
+          req (req) {
+            return {
+              method: req.method,
+              url: req.url,
+              headers: req.headers,
+              hostname: req.hostname,
+              remoteAddress: req.ip,
+              remotePort: req.socket.remotePort
+            }
+          }
+        }
+      }
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/', function (req, reply) {
+      t.same(req.headers.authorization, 'Bearer abcde')
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+    await fastify.listen({ port: 0, host: localhost })
+
+    await request({
+      method: 'GET',
+      path: '/',
+      host: localhost,
+      port: fastify.server.address().port,
+      headers: {
+        authorization: 'Bearer abcde'
+      }
+    }, function (response, body) {
+      t.equal(response.statusCode, 200)
+      t.same(body, JSON.stringify({ hello: 'world' }))
+    })
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('should not throw error when serializing custom req', (t) => {
+    t.plan(1)
+
+    const lines = []
+    const dest = new stream.Writable({
+      write: function (chunk, enc, cb) {
+        lines.push(JSON.parse(chunk))
+        cb()
+      }
+    })
+    const fastify = Fastify({ logger: { level: 'info', stream: dest } })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.log.info({ req: {} })
+
+    t.same(lines[0].req, {})
+  })
+})

package/test/logger/response.test.js

@@ -0,0 +1,184 @@
+'use strict'
+
+const stream = require('node:stream')
+
+const t = require('tap')
+const split = require('split2')
+const pino = require('pino')
+
+const Fastify = require('../../fastify')
+const { on } = stream
+
+t.test('response serialization', (t) => {
+  t.setTimeout(60000)
+
+  t.plan(4)
+
+  t.test('Should use serializers from plugin and route', async (t) => {
+    const lines = [
+      { msg: 'incoming request' },
+      { test: 'XHello', test2: 'ZHello' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+
+    const logger = pino({ level: 'info' }, stream)
+    const fastify = Fastify({
+      logger
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.register(context1, {
+      logSerializers: { test: value => 'X' + value }
+    })
+
+    function context1 (instance, opts, done) {
+      instance.get('/', {
+        logSerializers: {
+          test2: value => 'Z' + value
+        }
+      }, (req, reply) => {
+        req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+        reply.send({ hello: 'world' })
+      })
+      done()
+    }
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/' })
+      const body = await response.json()
+      t.same(body, { hello: 'world' })
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('Should use serializers from instance fastify and route', async (t) => {
+    const lines = [
+      { msg: 'incoming request' },
+      { test: 'XHello', test2: 'ZHello' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+
+    const logger = pino({
+      level: 'info',
+      serializers: {
+        test: value => 'X' + value,
+        test2: value => 'This should be override - ' + value
+      }
+    }, stream)
+    const fastify = Fastify({
+      logger
+    })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/', {
+      logSerializers: {
+        test2: value => 'Z' + value
+      }
+    }, (req, reply) => {
+      req.log.info({ test: 'Hello', test2: 'Hello' }) // { test: 'XHello', test2: 'ZHello' }
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/' })
+      const body = await response.json()
+      t.same(body, { hello: 'world' })
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('Should use serializers inherit from contexts', async (t) => {
+    const lines = [
+      { msg: 'incoming request' },
+      { test: 'XHello', test2: 'YHello', test3: 'ZHello' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+
+    const logger = pino({
+      level: 'info',
+      serializers: {
+        test: value => 'X' + value
+      }
+    }, stream)
+
+    const fastify = Fastify({ logger })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.register(context1, { logSerializers: { test2: value => 'Y' + value } })
+
+    function context1 (instance, opts, done) {
+      instance.get('/', {
+        logSerializers: {
+          test3: value => 'Z' + value
+        }
+      }, (req, reply) => {
+        req.log.info({ test: 'Hello', test2: 'Hello', test3: 'Hello' }) // { test: 'XHello', test2: 'YHello', test3: 'ZHello' }
+        reply.send({ hello: 'world' })
+      })
+      done()
+    }
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/' })
+      const body = await response.json()
+      t.same(body, { hello: 'world' })
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+
+  t.test('should serialize request and response', async (t) => {
+    const lines = [
+      { req: { method: 'GET', url: '/500' }, msg: 'incoming request' },
+      { req: { method: 'GET', url: '/500' }, msg: '500 error' },
+      { msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
+
+    const stream = split(JSON.parse)
+    const fastify = Fastify({ logger: { level: 'info', stream } })
+    t.teardown(fastify.close.bind(fastify))
+
+    fastify.get('/500', (req, reply) => {
+      reply.code(500).send(Error('500 error'))
+    })
+
+    await fastify.ready()
+
+    {
+      const response = await fastify.inject({ method: 'GET', url: '/500' })
+      t.equal(response.statusCode, 500)
+    }
+
+    for await (const [line] of on(stream, 'data')) {
+      t.match(line, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+})

package/test/reply-code.test.js

@@ -57,3 +57,67 @@ test('code should handle null/undefined/float', t => {
     t.equal(res.statusCode, 404)
   })
 })
+
+test('code should handle 204', t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+
+  fastify.get('/204', function (request, reply) {
+    reply.status(204)
+    return null
+  })
+
+  fastify.get('/undefined/204', function (request, reply) {
+    reply.status(204).send({ message: 'hello' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/204'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 204)
+    t.equal(res.payload, '')
+    t.equal(res.headers['content-length'], undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/undefined/204'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 204)
+    t.equal(res.payload, '')
+    t.equal(res.headers['content-length'], undefined)
+  })
+})
+
+test('code should handle onSend hook on 204', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  fastify.addHook('onSend', async function (request, reply, payload) {
+    return {
+      ...payload,
+      world: 'hello'
+    }
+  })
+
+  fastify.get('/204', function (request, reply) {
+    reply.status(204).send({
+      hello: 'world'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/204'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 204)
+    t.equal(res.payload, '')
+    t.equal(res.headers['content-length'], undefined)
+    t.equal(res.headers['content-type'], undefined)
+  })
+})

package/test/types/reply.test-d.ts

@@ -1,6 +1,6 @@
 import { Buffer } from 'buffer'
 import { expectAssignable, expectError, expectType } from 'tsd'
-import fastify, { FastifyContext, FastifyReply, FastifyRequest, FastifySchema, FastifySchemaCompiler, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
+import fastify, { FastifyReplyContext, FastifyReply, FastifyRequest, FastifySchema, FastifySchemaCompiler, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { ResolveReplyTypeWithRouteGeneric } from '../../types/reply'
@@ -12,8 +12,8 @@ type DefaultFastifyReplyWithCode<Code extends number> = FastifyReply<RawServerDe
 
 const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<RawReplyDefaultExpression>(reply.raw)
-  expectType<FastifyContext<ContextConfigDefault>>(reply.context)
-  expectType<FastifyContext<ContextConfigDefault>['config']>(reply.context.config)
+  expectType<FastifyReplyContext<ContextConfigDefault>>(reply.context)
+  expectType<FastifyReplyContext<ContextConfigDefault>['config']>(reply.context.config)
   expectType<FastifyLoggerInstance>(reply.log)
   expectType<FastifyRequest<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression>>(reply.request)
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.code)

package/test/types/request.test-d.ts

@@ -2,7 +2,7 @@ import pino from 'pino'
 import { expectAssignable, expectType } from 'tsd'
 import fastify, {
   ContextConfigDefault,
-  FastifyContext,
+  FastifyRequestContext,
   FastifyContextConfig,
   FastifyLogFn,
   FastifySchema,
@@ -75,10 +75,10 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<RawRequestDefaultExpression>(request.raw)
   expectType<RequestBodyDefault>(request.body)
   expectType<RequestParamsDefault>(request.params)
-  expectType<FastifyContext<ContextConfigDefault>>(request.context)
-  expectType<FastifyContext<ContextConfigDefault>['config']>(request.context.config)
-  expectType<FastifyContext<ContextConfigDefault>['config']>(request.routeConfig)
-  expectType<FastifyContext<ContextConfigDefault>['config']>(request.routeOptions.config)
+  expectType<FastifyRequestContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyRequestContext<ContextConfigDefault>['config']>(request.context.config)
+  expectType<FastifyRequestContext<ContextConfigDefault>['config']>(request.routeConfig)
+  expectType<FastifyRequestContext<ContextConfigDefault>['config']>(request.routeOptions.config)
   expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(request.routeOptions.config)
   expectType<FastifySchema>(request.routeSchema)
   expectType<FastifySchema>(request.routeOptions.schema)
@@ -112,8 +112,8 @@ const postHandler: Handler = function (request) {
   expectType<number>(request.params.id)
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
-  expectType<FastifyContext<ContextConfigDefault>>(request.context)
-  expectType<FastifyContext<ContextConfigDefault>['config']>(request.context.config)
+  expectType<FastifyRequestContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyRequestContext<ContextConfigDefault>['config']>(request.context.config)
 }
 
 function putHandler (request: CustomRequest, reply: FastifyReply) {
@@ -130,8 +130,8 @@ function putHandler (request: CustomRequest, reply: FastifyReply) {
   expectType<number>(request.params.id)
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
-  expectType<FastifyContext<ContextConfigDefault>>(request.context)
-  expectType<FastifyContext<ContextConfigDefault>['config']>(request.context.config)
+  expectType<FastifyRequestContext<ContextConfigDefault>>(request.context)
+  expectType<FastifyRequestContext<ContextConfigDefault>['config']>(request.context.config)
 }
 
 const server = fastify()