fastify 3.27.2 → 3.28.0

package/test/reply-trailers.test.js

@@ -0,0 +1,277 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const { Readable } = require('stream')
+const { createHash } = require('crypto')
+
+test('send trailers when payload is empty string', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('send trailers when payload is empty buffer', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send(Buffer.alloc(0))
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('send trailers when payload is undefined', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('send trailers when payload is json', t => {
+  t.plan(7)
+
+  const fastify = Fastify()
+  const data = JSON.stringify({ hello: 'world' })
+  const hash = createHash('md5')
+  hash.update(data)
+  const md5 = hash.digest('hex')
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('Content-MD5', function (reply, payload) {
+      t.equal(data, payload)
+      const hash = createHash('md5')
+      hash.update(payload)
+      return hash.digest('hex')
+    })
+    reply.send(data)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['transfer-encoding'], 'chunked')
+    t.equal(res.headers.trailer, 'content-md5')
+    t.equal(res.trailers['content-md5'], md5)
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('send trailers when payload is stream', t => {
+  t.plan(7)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      t.same(payload, null)
+      return 'custom-etag'
+    })
+    const stream = Readable.from([JSON.stringify({ hello: 'world' })])
+    reply.send(stream)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers['transfer-encoding'], 'chunked')
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('removeTrailer', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.removeTrailer('ETag') // remove nothing
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.trailer('Should-Not-Call', function (reply, payload) {
+      t.fail('it should not called as this trailer is removed')
+      return 'should-not-call'
+    })
+    reply.removeTrailer('Should-Not-Call')
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notOk(res.trailers['should-not-call'])
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('hasTrailer', t => {
+  t.plan(10)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    t.equal(reply.hasTrailer('ETag'), false)
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    t.equal(reply.hasTrailer('ETag'), true)
+    reply.trailer('Should-Not-Call', function (reply, payload) {
+      t.fail('it should not called as this trailer is removed')
+      return 'should-not-call'
+    })
+    t.equal(reply.hasTrailer('Should-Not-Call'), true)
+    reply.removeTrailer('Should-Not-Call')
+    t.equal(reply.hasTrailer('Should-Not-Call'), false)
+    reply.send(undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.equal(res.trailers.etag, 'custom-etag')
+    t.notOk(res.trailers['should-not-call'])
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('throw error when trailer header name is not allowed', t => {
+  const INVALID_TRAILERS = [
+    'transfer-encoding',
+    'content-length',
+    'host',
+    'cache-control',
+    'max-forwards',
+    'te',
+    'authorization',
+    'set-cookie',
+    'content-encoding',
+    'content-type',
+    'content-range',
+    'trailer'
+  ]
+  t.plan(INVALID_TRAILERS.length + 2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    for (const key of INVALID_TRAILERS) {
+      try {
+        reply.trailer(key, () => {})
+      } catch (err) {
+        t.equal(err.message, `Called reply.trailer with an invalid header name: ${key}`)
+      }
+    }
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('throw error when trailer header value is not function', t => {
+  const INVALID_TRAILERS_VALUE = [
+    undefined,
+    null,
+    true,
+    false,
+    'invalid',
+    [],
+    new Date(),
+    {}
+  ]
+  t.plan(INVALID_TRAILERS_VALUE.length + 2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    for (const value of INVALID_TRAILERS_VALUE) {
+      try {
+        reply.trailer('invalid', value)
+      } catch (err) {
+        t.equal(err.message, `Called reply.trailer('invalid', fn) with an invalid type: ${typeof value}. Expected a function.`)
+      }
+    }
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})

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

@@ -9,9 +9,11 @@ import fastify, {
   RawServerBase,
   RouteOptions,
   RegisterOptions,
-  FastifyPluginOptions
+  FastifyPluginOptions,
+  FastifyContextConfig, RawServerDefault
 } from '../../fastify'
 import { preHandlerAsyncHookHandler, RequestPayload } from '../../types/hooks'
+import { RouteGenericInterface } from '../../types/route'
 
 const server = fastify()
 
@@ -213,7 +215,7 @@ server.addHook('onClose', async (instance) => {
 // Use case to monitor any regression on issue #3620
 // ref.: https://github.com/fastify/fastify/issues/3620
 const customTypedHook: preHandlerAsyncHookHandler<
-RawServerBase,
+RawServerDefault,
 RawRequestDefaultExpression,
 RawReplyDefaultExpression,
 Record<string, unknown>
@@ -226,3 +228,51 @@ Record<string, unknown>
 server.register(async (instance) => {
   instance.addHook('preHandler', customTypedHook)
 })
+
+// Test custom Context Config types for hooks
+type CustomContextConfig = FastifyContextConfig & {
+  foo: string;
+  bar: number;
+}
+
+server.route<RouteGenericInterface, CustomContextConfig>({
+  method: 'GET',
+  url: '/',
+  handler: () => {},
+  onRequest: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preParsing: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preValidation: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preHandler: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  preSerialization: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onSend: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onResponse: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onTimeout: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  },
+  onError: (request, reply) => {
+    expectType<CustomContextConfig>(request.context.config)
+    expectType<CustomContextConfig>(reply.context.config)
+  }
+})

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

@@ -1,10 +1,23 @@
 import { expectType } from 'tsd'
-import fastify, { RouteHandler, RawRequestDefaultExpression, RequestBodyDefault, RequestGenericInterface, FastifyContext, ContextConfigDefault, FastifyContextConfig } from '../../fastify'
+import fastify, {
+  RouteHandler,
+  RawRequestDefaultExpression,
+  RequestBodyDefault,
+  RequestGenericInterface,
+  FastifyContext,
+  ContextConfigDefault,
+  FastifyContextConfig,
+  FastifyLogFn,
+  RawServerDefault,
+  RawReplyDefaultExpression,
+  RouteHandlerMethod
+} from '../../fastify'
 import { RequestParamsDefault, RequestHeadersDefault, RequestQuerystringDefault } from '../../types/utils'
 import { FastifyLoggerInstance } from '../../types/logger'
 import { FastifyRequest } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
 import { FastifyInstance } from '../../types/instance'
+import { RouteGenericInterface } from '../../types/route'
 
 interface RequestBody {
   content: string;
@@ -38,6 +51,10 @@ type CustomRequest = FastifyRequest<{
   Headers: RequestHeaders;
 }>
 
+interface CustomLoggerInterface extends FastifyLoggerInstance {
+  foo: FastifyLogFn; // custom severity logger method
+}
+
 const getHandler: RouteHandler = function (request, _reply) {
   expectType<string>(request.url)
   expectType<string>(request.method)
@@ -64,6 +81,10 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<FastifyInstance>(request.server)
 }
 
+const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, CustomLoggerInterface> = function (request, _reply) {
+  expectType<CustomLoggerInterface>(request.log)
+}
+
 const postHandler: Handler = function (request) {
   expectType<RequestBody>(request.body)
   expectType<RequestParams>(request.params)
@@ -96,3 +117,22 @@ const server = fastify()
 server.get('/get', getHandler)
 server.post('/post', postHandler)
 server.put('/put', putHandler)
+
+const customLogger: CustomLoggerInterface = {
+  info: () => { },
+  warn: () => { },
+  error: () => { },
+  fatal: () => { },
+  trace: () => { },
+  debug: () => { },
+  foo: () => { }, // custom severity logger method
+  child: () => customLogger
+}
+
+const serverWithCustomLogger = fastify({ logger: customLogger })
+expectType<
+FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+& PromiseLike<FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>>
+>(serverWithCustomLogger)
+
+serverWithCustomLogger.get('/get', getHandlerWithCustomLogger)

package/types/.eslintrc.json

@@ -36,7 +36,9 @@
         "@typescript-eslint/explicit-function-return-type": "off",
         "@typescript-eslint/no-unused-vars": "off",
         "@typescript-eslint/no-non-null-assertion": "off",
-        "@typescript-eslint/no-misused-promises": ["error"]
+        "@typescript-eslint/no-misused-promises": ["error", {
+          "checksVoidReturn": false
+        }]
       },
       "globals": {
         "NodeJS": "readonly"