fastify 4.9.2 → 4.10.1

package/test/reply-trailers.test.js

@@ -5,6 +5,8 @@ const test = t.test
 const Fastify = require('..')
 const { Readable } = require('stream')
 const { createHash } = require('crypto')
+const { promisify } = require('util')
+const sleep = promisify(setTimeout)
 
 test('send trailers when payload is empty string', t => {
   t.plan(5)
@@ -12,8 +14,8 @@ test('send trailers when payload is empty string', t => {
   const fastify = Fastify()
 
   fastify.get('/', function (request, reply) {
-    reply.trailer('ETag', function (reply, payload) {
-      return 'custom-etag'
+    reply.trailer('ETag', function (reply, payload, done) {
+      done(null, 'custom-etag')
     })
     reply.send('')
   })
@@ -36,8 +38,8 @@ test('send trailers when payload is empty buffer', t => {
   const fastify = Fastify()
 
   fastify.get('/', function (request, reply) {
-    reply.trailer('ETag', function (reply, payload) {
-      return 'custom-etag'
+    reply.trailer('ETag', function (reply, payload, done) {
+      done(null, 'custom-etag')
     })
     reply.send(Buffer.alloc(0))
   })
@@ -60,8 +62,8 @@ test('send trailers when payload is undefined', t => {
   const fastify = Fastify()
 
   fastify.get('/', function (request, reply) {
-    reply.trailer('ETag', function (reply, payload) {
-      return 'custom-etag'
+    reply.trailer('ETag', function (reply, payload, done) {
+      done(null, 'custom-etag')
     })
     reply.send(undefined)
   })
@@ -88,11 +90,11 @@ test('send trailers when payload is json', t => {
   const md5 = hash.digest('hex')
 
   fastify.get('/', function (request, reply) {
-    reply.trailer('Content-MD5', function (reply, payload) {
+    reply.trailer('Content-MD5', function (reply, payload, done) {
       t.equal(data, payload)
       const hash = createHash('md5')
       hash.update(payload)
-      return hash.digest('hex')
+      done(null, hash.digest('hex'))
     })
     reply.send(data)
   })
@@ -116,9 +118,9 @@ test('send trailers when payload is stream', t => {
   const fastify = Fastify()
 
   fastify.get('/', function (request, reply) {
-    reply.trailer('ETag', function (reply, payload) {
+    reply.trailer('ETag', function (reply, payload, done) {
       t.same(payload, null)
-      return 'custom-etag'
+      done(null, 'custom-etag')
     })
     const stream = Readable.from([JSON.stringify({ hello: 'world' })])
     reply.send(stream)
@@ -137,6 +139,161 @@ test('send trailers when payload is stream', t => {
   })
 })
 
+test('send trailers when using async-await', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', async 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('error in trailers should be ignored', t => {
+  t.plan(5)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload, done) {
+      done('error')
+    })
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.equal(res.headers.trailer, 'etag')
+    t.notHas(res.trailers, 'etag')
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
+test('should emit deprecation warning when using direct return', t => {
+  t.plan(7)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload) {
+      return 'custom-etag'
+    })
+    reply.send('')
+  })
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyDeprecation')
+    t.equal(warning.code, 'FSTDEP013')
+  }
+  t.teardown(() => process.removeListener('warning', onWarning))
+
+  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('trailer handler counter', t => {
+  t.plan(2)
+
+  const data = JSON.stringify({ hello: 'world' })
+  const hash = createHash('md5')
+  hash.update(data)
+  const md5 = hash.digest('hex')
+
+  t.test('callback with timeout', t => {
+    t.plan(9)
+    const fastify = Fastify()
+
+    fastify.get('/', function (request, reply) {
+      reply.trailer('Return-Early', function (reply, payload, done) {
+        t.equal(data, payload)
+        done(null, 'return')
+      })
+      reply.trailer('Content-MD5', function (reply, payload, done) {
+        t.equal(data, payload)
+        const hash = createHash('md5')
+        hash.update(payload)
+        setTimeout(() => {
+          done(null, hash.digest('hex'))
+        }, 500)
+      })
+      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, 'return-early content-md5')
+      t.equal(res.trailers['return-early'], 'return')
+      t.equal(res.trailers['content-md5'], md5)
+      t.notHas(res.headers, 'content-length')
+    })
+  })
+
+  t.test('async-await', t => {
+    t.plan(9)
+    const fastify = Fastify()
+
+    fastify.get('/', function (request, reply) {
+      reply.trailer('Return-Early', async function (reply, payload) {
+        t.equal(data, payload)
+        return 'return'
+      })
+      reply.trailer('Content-MD5', async function (reply, payload) {
+        t.equal(data, payload)
+        const hash = createHash('md5')
+        hash.update(payload)
+        await sleep(500)
+        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, 'return-early content-md5')
+      t.equal(res.trailers['return-early'], 'return')
+      t.equal(res.trailers['content-md5'], md5)
+      t.notHas(res.headers, 'content-length')
+    })
+  })
+})
+
 test('removeTrailer', t => {
   t.plan(6)
 
@@ -144,12 +301,12 @@ test('removeTrailer', t => {
 
   fastify.get('/', function (request, reply) {
     reply.removeTrailer('ETag') // remove nothing
-    reply.trailer('ETag', function (reply, payload) {
-      return 'custom-etag'
+    reply.trailer('ETag', function (reply, payload, done) {
+      done(null, 'custom-etag')
     })
-    reply.trailer('Should-Not-Call', function (reply, payload) {
+    reply.trailer('Should-Not-Call', function (reply, payload, done) {
       t.fail('it should not called as this trailer is removed')
-      return 'should-not-call'
+      done(null, 'should-not-call')
     })
     reply.removeTrailer('Should-Not-Call')
     reply.send(undefined)
@@ -168,6 +325,38 @@ test('removeTrailer', t => {
   })
 })
 
+test('remove all trailers', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.trailer('ETag', function (reply, payload, done) {
+      t.fail('it should not called as this trailer is removed')
+      done(null, 'custom-etag')
+    })
+    reply.removeTrailer('ETag')
+    reply.trailer('Should-Not-Call', function (reply, payload, done) {
+      t.fail('it should not called as this trailer is removed')
+      done(null, 'should-not-call')
+    })
+    reply.removeTrailer('Should-Not-Call')
+    reply.send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+    t.notOk(res.headers.trailer)
+    t.notOk(res.trailers.etag)
+    t.notOk(res.trailers['should-not-call'])
+    t.notHas(res.headers, 'content-length')
+  })
+})
+
 test('hasTrailer', t => {
   t.plan(10)
 
@@ -175,13 +364,13 @@ test('hasTrailer', t => {
 
   fastify.get('/', function (request, reply) {
     t.equal(reply.hasTrailer('ETag'), false)
-    reply.trailer('ETag', function (reply, payload) {
-      return 'custom-etag'
+    reply.trailer('ETag', function (reply, payload, done) {
+      done(null, 'custom-etag')
     })
     t.equal(reply.hasTrailer('ETag'), true)
-    reply.trailer('Should-Not-Call', function (reply, payload) {
+    reply.trailer('Should-Not-Call', function (reply, payload, done) {
       t.fail('it should not called as this trailer is removed')
-      return 'should-not-call'
+      done(null, 'should-not-call')
     })
     t.equal(reply.hasTrailer('Should-Not-Call'), true)
     reply.removeTrailer('Should-Not-Call')

package/test/request-error.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { connect } = require('net')
+const sget = require('simple-get').concat
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
@@ -313,3 +314,98 @@ test('default clientError replies with bad request on reused keep-alive connecti
     client.write('\r\n\r\n')
   })
 })
+
+test('request.routeOptions should be immutable', t => {
+  t.plan(14)
+  const fastify = Fastify()
+  const handler = function (req, res) {
+    t.equal('POST', req.routeOptions.method)
+    t.equal('/', req.routeOptions.url)
+    t.throws(() => { req.routeOptions = null }, new TypeError('Cannot set property routeOptions of #<Request> which has only a getter'))
+    t.throws(() => { req.routeOptions.method = 'INVALID' }, new TypeError('Cannot assign to read only property \'method\' of object \'#<Object>\''))
+    t.throws(() => { req.routeOptions.url = '//' }, new TypeError('Cannot assign to read only property \'url\' of object \'#<Object>\''))
+    t.throws(() => { req.routeOptions.bodyLimit = 0xDEADBEEF }, new TypeError('Cannot assign to read only property \'bodyLimit\' of object \'#<Object>\''))
+    t.throws(() => { req.routeOptions.attachValidation = true }, new TypeError('Cannot assign to read only property \'attachValidation\' of object \'#<Object>\''))
+    t.throws(() => { req.routeOptions.logLevel = 'invalid' }, new TypeError('Cannot assign to read only property \'logLevel\' of object \'#<Object>\''))
+    t.throws(() => { req.routeOptions.version = '95.0.1' }, new TypeError('Cannot assign to read only property \'version\' of object \'#<Object>\''))
+    t.throws(() => { req.routeOptions.prefixTrailingSlash = true }, new TypeError('Cannot assign to read only property \'prefixTrailingSlash\' of object \'#<Object>\''))
+    t.throws(() => { req.routeOptions.newAttribute = {} }, new TypeError('Cannot add property newAttribute, object is not extensible'))
+
+    for (const key of Object.keys(req.routeOptions)) {
+      if (typeof req.routeOptions[key] === 'object' && req.routeOptions[key] !== null) {
+        t.fail('Object.freeze must run recursively on nested structures to ensure that routeOptions is immutable.')
+      }
+    }
+
+    res.send({})
+  }
+  fastify.post('/', {
+    bodyLimit: 1000,
+    handler
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})
+
+test('test request.routeOptions.version', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'POST',
+    url: '/version',
+    constraints: { version: '1.2.0' },
+    handler: function (request, reply) {
+      t.equal('1.2.0', request.routeOptions.version)
+      reply.send({})
+    }
+  })
+
+  fastify.route({
+    method: 'POST',
+    url: '/version-undefined',
+    handler: function (request, reply) {
+      t.equal(undefined, request.routeOptions.version)
+      reply.send({})
+    }
+  })
+  fastify.listen({ port: 0 }, function (err) {
+    t.error(err)
+    t.teardown(() => { fastify.close() })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/version',
+      headers: { 'Content-Type': 'application/json', 'Accept-Version': '1.2.0' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/version-undefined',
+      headers: { 'Content-Type': 'application/json' },
+      body: [],
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+    })
+  })
+})

package/test/server.test.js

@@ -36,19 +36,18 @@ test('listen should accept stringified number port', t => {
 
 test('listen should reject string port', async (t) => {
   t.plan(2)
-
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
 
   try {
     await fastify.listen({ port: 'hello-world' })
   } catch (error) {
-    t.same(error.message, 'options.port should be >= 0 and < 65536. Received hello-world.')
+    t.equal(error.code, 'ERR_SOCKET_BAD_PORT')
   }
 
   try {
     await fastify.listen({ port: '1234hello' })
   } catch (error) {
-    t.same(error.message, 'options.port should be >= 0 and < 65536. Received 1234hello.')
+    t.equal(error.code, 'ERR_SOCKET_BAD_PORT')
   }
 })

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

@@ -10,7 +10,8 @@ import fastify, {
   InjectOptions, FastifyBaseLogger,
   RouteGenericInterface,
   ValidationResult,
-  FastifyErrorCodes
+  FastifyErrorCodes,
+  FastifyError
 } from '../../fastify'
 import { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'http'
@@ -235,6 +236,12 @@ const ajvErrorObject: AjvErrorObject = {
 }
 expectAssignable<ValidationResult>(ajvErrorObject)
 
+expectAssignable<FastifyError['validation']>([ajvErrorObject])
+expectAssignable<FastifyError['validationContext']>('body')
+expectAssignable<FastifyError['validationContext']>('headers')
+expectAssignable<FastifyError['validationContext']>('parameters')
+expectAssignable<FastifyError['validationContext']>('querystring')
+
 const routeGeneric: RouteGenericInterface = {}
 expectType<unknown>(routeGeneric.Body)
 expectType<unknown>(routeGeneric.Headers)

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

@@ -123,35 +123,6 @@ const serverAutoInferredFileOption = fastify({
 
 expectType<FastifyBaseLogger>(serverAutoInferredFileOption.log)
 
-const serverAutoInferredPinoPrettyBooleanOption = fastify({
-  logger: {
-    prettyPrint: true
-  }
-})
-
-expectType<FastifyBaseLogger>(serverAutoInferredPinoPrettyBooleanOption.log)
-
-const serverAutoInferredPinoPrettyObjectOption = fastify({
-  logger: {
-    prettyPrint: {
-      translateTime: true,
-      levelFirst: false,
-      messageKey: 'msg',
-      timestampKey: 'time',
-      messageFormat: false,
-      colorize: true,
-      crlf: false,
-      errorLikeObjectKeys: ['err', 'error'],
-      errorProps: '',
-      search: 'foo == `bar`',
-      ignore: 'pid,hostname',
-      suppressFlushSyncWarning: true
-    }
-  }
-})
-
-expectType<FastifyBaseLogger>(serverAutoInferredPinoPrettyObjectOption.log)
-
 const serverAutoInferredSerializerObjectOption = fastify({
   logger: {
     serializers: {
@@ -200,9 +171,6 @@ const passPinoOption = fastify({
     redact: ['custom'],
     messageKey: 'msg',
     nestedKey: 'nested',
-    prettyPrint: {
-
-    },
     enabled: true
   }
 })
@@ -215,6 +183,7 @@ expectDeprecated({} as FastifyLoggerInstance)
 const childParent = fastify().log
 // we test different option variant here
 expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'info' }))
+expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'silent' }))
 expectType<FastifyLoggerInstance>(childParent.child({}, { redact: ['pass', 'pin'] }))
 expectType<FastifyLoggerInstance>(childParent.child({}, { serializers: { key: () => {} } }))
 expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'info', redact: ['pass', 'pin'], serializers: { key: () => {} } }))

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

@@ -17,7 +17,7 @@ import fastify, {
 } from '../../fastify'
 import { RequestParamsDefault, RequestHeadersDefault, RequestQuerystringDefault } from '../../types/utils'
 import { FastifyLoggerInstance } from '../../types/logger'
-import { FastifyRequest } from '../../types/request'
+import { FastifyRequest, RequestRouteOptions } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
 import { FastifyInstance } from '../../types/instance'
 import { RouteGenericInterface } from '../../types/route'
@@ -66,6 +66,7 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<string>(request.method)
   expectType<string>(request.routerPath)
   expectType<string>(request.routerMethod)
+  expectType<Readonly<RequestRouteOptions>>(request.routeOptions)
   expectType<boolean>(request.is404)
   expectType<string>(request.hostname)
   expectType<string>(request.ip)