fastify 3.19.1 → 3.20.2

package/test/async-await.test.js

@@ -646,6 +646,79 @@ test('customErrorHandler only called if reply not already sent', t => {
   })
 })
 
+// See https://github.com/fastify/fastify/issues/3209
+test('setNotFoundHandler should accept return value', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/', async () => ({ hello: 'world' }))
+
+  fastify.setNotFoundHandler((req, reply) => {
+    reply.code(404)
+    return {
+      error: statusCodes['404'],
+      message: 'lost',
+      statusCode: 404
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/elsewhere'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 404)
+    t.same(
+      {
+        error: statusCodes['404'],
+        message: 'lost',
+        statusCode: 404
+      },
+      JSON.parse(res.payload)
+    )
+  })
+})
+
+// See https://github.com/fastify/fastify/issues/3209
+test('customErrorHandler should accept return value', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', async (req, reply) => {
+    const error = new Error('ouch')
+    error.statusCode = 400
+    throw error
+  })
+
+  fastify.setErrorHandler((err, req, reply) => {
+    t.equal(err.message, 'ouch')
+    reply.code(401)
+    return {
+      error: statusCodes['401'],
+      message: 'kaboom',
+      statusCode: 401
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 401)
+    t.same(
+      {
+        error: statusCodes['401'],
+        message: 'kaboom',
+        statusCode: 401
+      },
+      JSON.parse(res.payload)
+    )
+  })
+})
+
 test('await self', async t => {
   const app = Fastify()
   t.equal(await app, app)

package/test/content-parser.test.js

@@ -186,3 +186,79 @@ test('add', t => {
 
   t.end()
 })
+
+test('remove', t => {
+  test('should remove default parser', t => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    const contentTypeParser = fastify[keys.kContentTypeParser]
+
+    contentTypeParser.remove('application/json')
+
+    t.notOk(contentTypeParser.customParsers['application/json'])
+    t.notOk(contentTypeParser.parserList.find(parser => parser === 'application/json'))
+  })
+
+  test('should remove RegExp parser', t => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    fastify.addContentTypeParser(/^text\/*/, first)
+
+    const contentTypeParser = fastify[keys.kContentTypeParser]
+
+    contentTypeParser.remove(/^text\/*/)
+
+    t.notOk(contentTypeParser.customParsers[/^text\/*/])
+    t.notOk(contentTypeParser.parserRegExpList.find(parser => parser.toString() === /^text\/*/.toString()))
+  })
+
+  test('should throw an error if content type is neither string nor RegExp', t => {
+    t.plan(1)
+
+    const fastify = Fastify()
+
+    t.throws(() => fastify[keys.kContentTypeParser].remove(12), FST_ERR_CTP_INVALID_TYPE)
+  })
+
+  test('should not throw error if content type does not exist', t => {
+    t.plan(1)
+
+    const fastify = Fastify()
+
+    t.doesNotThrow(() => fastify[keys.kContentTypeParser].remove('image/png'))
+  })
+
+  test('should not remove any content type parser if content type does not exist', t => {
+    t.plan(1)
+
+    const fastify = Fastify()
+
+    const contentTypeParser = fastify[keys.kContentTypeParser]
+
+    contentTypeParser.remove('image/png')
+
+    t.same(Object.keys(contentTypeParser.customParsers).length, 2)
+  })
+
+  t.end()
+})
+
+test('remove all should remove all existing parsers and reset cache', t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.addContentTypeParser('application/xml', first)
+  fastify.addContentTypeParser(/^image\/.*/, first)
+
+  const contentTypeParser = fastify[keys.kContentTypeParser]
+
+  contentTypeParser.getParser('application/xml') // fill cache with one entry
+  contentTypeParser.removeAll()
+
+  t.same(contentTypeParser.cache.size, 0)
+  t.same(contentTypeParser.parserList.length, 0)
+  t.same(contentTypeParser.parserRegExpList.length, 0)
+  t.same(Object.keys(contentTypeParser.customParsers).length, 0)
+})

package/test/custom-parser.test.js

@@ -1504,3 +1504,206 @@ test('should prefer string content types over RegExp ones', t => {
     })
   })
 })
+
+test('removeContentTypeParser should support arrays of content types to remove', t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+
+  fastify.addContentTypeParser('application/xml', function (req, payload, done) {
+    payload.on('data', () => {})
+    payload.on('end', () => {
+      done(null, 'xml')
+    })
+  })
+
+  fastify.addContentTypeParser(/^image\/.*/, function (req, payload, done) {
+    payload.on('data', () => {})
+    payload.on('end', () => {
+      done(null, 'image')
+    })
+  })
+
+  fastify.removeContentTypeParser([/^image\/.*/, 'application/json'])
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '<?xml version="1.0">',
+      headers: {
+        'Content-Type': 'application/xml'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(body.toString(), 'xml')
+    })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '',
+      headers: {
+        'Content-Type': 'image/png'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 415)
+    })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '{test: "test"}',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 415)
+      fastify.close()
+    })
+  })
+})
+
+test('removeContentTypeParser should support encapsulation', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.addContentTypeParser('application/xml', function (req, payload, done) {
+    payload.on('data', () => {})
+    payload.on('end', () => {
+      done(null, 'xml')
+    })
+  })
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.register(function (instance, options, done) {
+    instance.removeContentTypeParser('application/xml')
+
+    instance.post('/encapsulated', (req, reply) => {
+      reply.send(req.body)
+    })
+
+    done()
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/encapsulated',
+      body: '<?xml version="1.0">',
+      headers: {
+        'Content-Type': 'application/xml'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 415)
+    })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '<?xml version="1.0">',
+      headers: {
+        'Content-Type': 'application/xml'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(body.toString(), 'xml')
+      fastify.close()
+    })
+  })
+})
+
+test('removeAllContentTypeParsers should support encapsulation', t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.register(function (instance, options, done) {
+    instance.removeAllContentTypeParsers()
+
+    instance.post('/encapsulated', (req, reply) => {
+      reply.send(req.body)
+    })
+
+    done()
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port + '/encapsulated',
+      body: '{}',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 415)
+    })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '{"test":1}',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(JSON.parse(body.toString()).test, 1)
+      fastify.close()
+    })
+  })
+})
+
+test('cannot remove all content type parsers after binding', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    t.throws(() => fastify.removeAllContentTypeParsers())
+  })
+})
+
+test('cannot remove content type parsers after binding', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  t.teardown(fastify.close.bind(fastify))
+
+  fastify.listen(0, function (err) {
+    t.error(err)
+
+    t.throws(() => fastify.removeContentTypeParser('application/json'))
+  })
+})

package/test/internals/version.test.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const proxyquire = require('proxyquire')
+
+test('should output an undefined version in case of package.json not available', t => {
+  const Fastify = proxyquire('../..', { fs: { accessSync: () => { throw Error('error') } } })
+  t.plan(1)
+  const srv = Fastify()
+  t.equal(srv.version, undefined)
+})
+
+test('should output an undefined version in case of package.json is not the fastify one', t => {
+  const Fastify = proxyquire('../..', { fs: { accessSync: () => { }, readFileSync: () => JSON.stringify({ name: 'foo', version: '6.6.6' }) } })
+  t.plan(1)
+  const srv = Fastify()
+  t.equal(srv.version, undefined)
+})
+
+test('should skip the version check if the version is undefined', t => {
+  const Fastify = proxyquire('../..', { fs: { accessSync: () => { }, readFileSync: () => JSON.stringify({ name: 'foo', version: '6.6.6' }) } })
+  t.plan(3)
+  const srv = Fastify()
+  t.equal(srv.version, undefined)
+
+  plugin[Symbol.for('skip-override')] = false
+  plugin[Symbol.for('plugin-meta')] = {
+    name: 'plugin',
+    fastify: '>=99.0.0'
+  }
+
+  srv.register(plugin)
+
+  srv.ready((err) => {
+    t.error(err)
+    t.pass('everything right')
+  })
+
+  function plugin (instance, opts, done) {
+    done()
+  }
+})

package/test/request-error.test.js

@@ -127,6 +127,78 @@ test('default clientError handler ignores ECONNRESET', t => {
   })
 })
 
+test('default clientError handler ignores sockets in destroyed state', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    bodyLimit: 1,
+    keepAliveTimeout: 100,
+    logger: {
+      level: 'trace'
+    }
+  })
+  fastify.server.on('clientError', () => {
+    // this handler is called after default handler, so we can make sure end was not called
+    t.pass()
+  })
+  fastify.server.emit('clientError', new Error(), {
+    destroyed: true,
+    end () {
+      t.fail('end should not be called')
+    },
+    destroy () {
+      t.fail('destroy should not be called')
+    }
+  })
+})
+
+test('default clientError handler destroys sockets in writable state', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    bodyLimit: 1,
+    keepAliveTimeout: 100,
+    logger: {
+      level: 'trace'
+    }
+  })
+
+  fastify.server.emit('clientError', new Error(), {
+    destroyed: false,
+    writable: true,
+    encrypted: true,
+    end () {
+      t.fail('end should not be called')
+    },
+    destroy () {
+      t.pass('destroy should be called')
+    }
+  })
+})
+
+test('default clientError handler destroys http sockets in non-writable state', t => {
+  t.plan(1)
+
+  const fastify = Fastify({
+    bodyLimit: 1,
+    keepAliveTimeout: 100,
+    logger: {
+      level: 'trace'
+    }
+  })
+
+  fastify.server.emit('clientError', new Error(), {
+    destroyed: false,
+    writable: false,
+    end () {
+      t.fail('end should not be called')
+    },
+    destroy () {
+      t.pass('destroy should be called')
+    }
+  })
+})
+
 test('error handler binding', t => {
   t.plan(5)
 

package/test/route.test.js

@@ -1190,3 +1190,59 @@ test('HEAD routes properly auto created for GET routes when prefixTrailingSlash:
   t.equal(trailingSlashReply.statusCode, 200)
   t.equal(noneTrailingReply.statusCode, 200)
 })
+
+test('Request and Reply share the route config', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  const config = {
+    this: 'is a string',
+    thisIs: function aFunction () {}
+  }
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    config,
+    handler: (req, reply) => {
+      t.same(req.context, reply.context)
+      t.same(req.context.config, reply.context.config)
+      t.match(req.context.config, config, 'there are url and method additional properties')
+
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  await fastify.inject('/')
+})
+
+test('Will not try to re-createprefixed HEAD route if it already exists and exposeHeadRoutes is true', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify({ exposeHeadRoutes: true })
+
+  fastify.register((scope, opts, next) => {
+    scope.route({
+      method: 'HEAD',
+      path: '/route',
+      handler: (req, reply) => {
+        reply.header('content-type', 'text/plain')
+        reply.send('custom HEAD response')
+      }
+    })
+    scope.route({
+      method: 'GET',
+      path: '/route',
+      handler: (req, reply) => {
+        reply.send({ ok: true })
+      }
+    })
+
+    next()
+  }, { prefix: '/prefix' })
+
+  await fastify.ready()
+
+  t.ok(true)
+})

package/test/schema-special-usage.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { test } = require('tap')
+const Joi = require('@hapi/joi')
 const AJV = require('ajv')
 const S = require('fluent-json-schema')
 const Fastify = require('..')
@@ -748,3 +749,34 @@ test('multiple refs with the same ids', t => {
     t.same(res.json(), { hello: 'world' })
   })
 })
+
+test('JOI validation overwrite request headers', t => {
+  t.plan(3)
+  const schemaValidator = ({ schema }) => data => {
+    const validationResult = schema.validate(data)
+    return validationResult
+  }
+
+  const fastify = Fastify()
+  fastify.setValidatorCompiler(schemaValidator)
+
+  fastify.get('/', {
+    schema: {
+      headers: Joi.object({
+        'user-agent': Joi.string().required(),
+        host: Joi.string().required()
+      })
+    }
+  }, (request, reply) => {
+    reply.send(request.headers)
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 200)
+    t.same(res.json(), {
+      'user-agent': 'lightMyRequest',
+      host: 'localhost:80'
+    })
+  })
+})

package/test/types/content-type-parser.test-d.ts

@@ -62,3 +62,11 @@ expectType<FastifyBodyParser<string>>(fastify().getDefaultJsonParser('error', 'i
 expectError(fastify().getDefaultJsonParser('error', 'skip'))
 
 expectError(fastify().getDefaultJsonParser('nothing', 'ignore'))
+
+expectType<void>(fastify().removeAllContentTypeParsers())
+expectError(fastify().removeAllContentTypeParsers('contentType'))
+
+expectType<void>(fastify().removeContentTypeParser('contentType'))
+expectType<void>(fastify().removeContentTypeParser(/contentType+.*/))
+expectType<void>(fastify().removeContentTypeParser(['contentType', /contentType+.*/]))
+expectError(fastify().removeContentTypeParser({}))

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

@@ -50,6 +50,10 @@ expectAssignable<FastifyInstance>(fastify({ disableRequestLogging: true }))
 expectAssignable<FastifyInstance>(fastify({ requestIdLogLabel: 'request-id' }))
 expectAssignable<FastifyInstance>(fastify({ onProtoPoisoning: 'error' }))
 expectAssignable<FastifyInstance>(fastify({ onConstructorPoisoning: 'error' }))
+expectAssignable<FastifyInstance>(fastify({ serializerOpts: { rounding: 'ceil' } }))
+expectAssignable<FastifyInstance>(fastify({ serializerOpts: { ajv: { missingRefs: 'ignore' } } }))
+expectAssignable<FastifyInstance>(fastify({ serializerOpts: { schema: { } } }))
+expectAssignable<FastifyInstance>(fastify({ serializerOpts: { otherProp: { } } }))
 expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>(fastify({ logger: true }))
 expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({ logger: true }))
 expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyLoggerInstance>>(fastify({
@@ -135,6 +139,18 @@ expectAssignable<FastifyInstance>(fastify({
       }),
       validate () {},
       deriveConstraint: () => 'foo'
+    },
+    withObjectValue: {
+      name: 'withObjectValue',
+      storage: () => ({
+        get: () => () => {},
+        set: () => { },
+        del: () => { },
+        empty: () => { }
+      }),
+      validate () {},
+      deriveConstraint: () => {}
+
     }
   }
 }))

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

@@ -1,5 +1,11 @@
-import fastify, { FastifyBodyParser, FastifyError, FastifyInstance, ValidationResult } from '../../fastify'
-import { expectAssignable, expectError, expectType } from 'tsd'
+import fastify, {
+  FastifyBodyParser,
+  FastifyError,
+  FastifyInstance,
+  FastifyLoggerInstance,
+  ValidationResult
+} from '../../fastify'
+import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
 import { FastifyRequest } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
 import { HookHandlerDoneFunction } from '../../types/hooks'
@@ -124,3 +130,35 @@ expectType<InitialConfig>(fastify().initialConfig)
 expectType<FastifyBodyParser<string>>(server.defaultTextParser)
 
 expectType<FastifyBodyParser<string>>(server.getDefaultJsonParser('ignore', 'error'))
+
+expectType<string>(server.printRoutes({ includeHooks: true, commonPrefix: false, includeMeta: true }))
+
+expectType<string>(server.printRoutes({ includeMeta: ['key1', Symbol('key2')] }))
+
+expectType<string>(server.printRoutes())
+
+server.decorate<(x: string) => void>('test', function (x: string): void {
+  expectType<FastifyInstance>(this)
+})
+server.decorate('test', function (x: string): void {
+  expectType<FastifyInstance>(this)
+})
+
+server.decorateRequest<(x: string, y: number) => void>('test', function (x: string, y: number): void {
+  expectType<FastifyRequest>(this)
+})
+server.decorateRequest('test', function (x: string, y: number): void {
+  expectType<FastifyRequest>(this)
+})
+
+server.decorateReply<(x: string) => void>('test', function (x: string): void {
+  expectType<FastifyReply>(this)
+})
+server.decorateReply('test', function (x: string): void {
+  expectType<FastifyReply>(this)
+})
+
+expectError(server.decorate<string>('test', true))
+expectError(server.decorate<(myNumber: number) => number>('test', function (myNumber: number): string {
+  return ''
+}))