fastify 3.25.2 → 3.27.1

package/lib/noop-set.js

@@ -0,0 +1,10 @@
+'use strict'
+
+module.exports = function noopSet () {
+  return {
+    [Symbol.iterator]: function * () {},
+    add () {},
+    delete () {},
+    has () { return true }
+  }
+}

package/lib/pluginUtils.js

@@ -14,6 +14,11 @@ function getMeta (fn) {
 }
 
 function getPluginName (func) {
+  const display = getDisplayName(func)
+  if (display) {
+    return display
+  }
+
   // let's see if this is a file, and in that case use that
   // this is common for plugins
   const cache = require.cache

package/lib/reply.js

@@ -365,12 +365,18 @@ function preserializeHookEnd (err, request, reply, payload) {
     return
   }
 
-  if (reply[kReplySerializer] !== null) {
-    payload = reply[kReplySerializer](payload)
-  } else if (reply.context && reply.context[kReplySerializerDefault]) {
-    payload = reply.context[kReplySerializerDefault](payload, reply.raw.statusCode)
-  } else {
-    payload = serialize(reply.context, payload, reply.raw.statusCode)
+  try {
+    if (reply[kReplySerializer] !== null) {
+      payload = reply[kReplySerializer](payload)
+    } else if (reply.context && reply.context[kReplySerializerDefault]) {
+      payload = reply.context[kReplySerializerDefault](payload, reply.raw.statusCode)
+    } else {
+      payload = serialize(reply.context, payload, reply.raw.statusCode)
+    }
+  } catch (e) {
+    wrapSeralizationError(e, reply)
+    onErrorHook(reply, e)
+    return
   }
 
   flatstr(payload)
@@ -378,6 +384,10 @@ function preserializeHookEnd (err, request, reply, payload) {
   onSendHook(reply, payload)
 }
 
+function wrapSeralizationError (error, reply) {
+  error.serialization = reply.context.config
+}
+
 function onSendHook (reply, payload) {
   if (reply.context.onSend !== null) {
     reply[kReplySent] = true

package/lib/route.js

@@ -8,6 +8,7 @@ const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTI
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
 const warning = require('./warnings')
+const { kRequestAcceptVersion } = require('./symbols')
 
 const {
   compileSchemasForValidation,
@@ -17,7 +18,8 @@ const {
 const {
   FST_ERR_SCH_VALIDATION_BUILD,
   FST_ERR_SCH_SERIALIZATION_BUILD,
-  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE
+  FST_ERR_DEFAULT_ROUTE_INVALID_TYPE,
+  FST_ERR_INVALID_URL
 } = require('./errors')
 
 const {
@@ -40,6 +42,7 @@ const {
 } = require('./symbols.js')
 
 function buildRouting (options) {
+  const { keepAliveConnections } = options
   const router = FindMyWay(options.config)
 
   let avvio
@@ -97,6 +100,10 @@ function buildRouting (options) {
 
   // Convert shorthand to extended route declaration
   function prepareRoute (method, url, options, handler) {
+    if (typeof url !== 'string') {
+      throw new FST_ERR_INVALID_URL(typeof url)
+    }
+
     if (!handler && typeof options === 'function') {
       handler = options // for support over direct function calls such as fastify.get() options are reused as the handler
       options = {}
@@ -344,6 +351,23 @@ function buildRouting (options) {
       }
     }
 
+    // When server.forceCloseConnections is true, we will collect any requests
+    // that have indicated they want persistence so that they can be reaped
+    // on server close. Otherwise, the container is a noop container.
+    const connHeader = String.prototype.toLowerCase.call(req.headers.connection || '')
+    if (connHeader === 'keep-alive') {
+      if (keepAliveConnections.has(req.socket) === false) {
+        keepAliveConnections.add(req.socket)
+        req.socket.on('close', removeTrackedSocket.bind({ keepAliveConnections, socket: req.socket }))
+      }
+    }
+
+    // we revert the changes in defaultRoute
+    if (req.headers[kRequestAcceptVersion] !== undefined) {
+      req.headers['accept-version'] = req.headers[kRequestAcceptVersion]
+      req.headers[kRequestAcceptVersion] = undefined
+    }
+
     const id = req.headers[requestIdHeader] || genReqId(req)
 
     const loggerBinding = {
@@ -478,6 +502,15 @@ function preParsingHookRunner (functions, request, reply, cb) {
   next(null, request[kRequestPayloadStream])
 }
 
+/**
+ * Used within the route handler as a `net.Socket.close` event handler.
+ * The purpose is to remove a socket from the tracked sockets collection when
+ * the socket has naturally timed out.
+ */
+function removeTrackedSocket () {
+  this.keepAliveConnections.delete(this.socket)
+}
+
 function noop () { }
 
 module.exports = { buildRouting, validateBodyLimitOption }

package/lib/symbols.js

@@ -21,6 +21,7 @@ const keys = {
   kReply: Symbol('fastify.Reply'),
   kRequest: Symbol('fastify.Request'),
   kRequestPayloadStream: Symbol('fastify.RequestPayloadStream'),
+  kRequestAcceptVersion: Symbol('fastify.RequestAcceptVersion'),
   kCanSetNotFoundHandler: Symbol('fastify.canSetNotFoundHandler'),
   kFourOhFour: Symbol('fastify.404'),
   kFourOhFourLevelInstance: Symbol('fastify.404LogLevelInstance'),
@@ -43,7 +44,8 @@ const keys = {
   kPluginNameChain: Symbol('fastify.pluginNameChain'),
   // This symbol is only meant to be used for fastify tests and should not be used for any other purpose
   kTestInternals: Symbol('fastify.testInternals'),
-  kErrorHandler: Symbol('fastify.errorHandler')
+  kErrorHandler: Symbol('fastify.errorHandler'),
+  kKeepAliveConnections: Symbol('fastify.keepAliveConnections')
 }
 
 module.exports = keys

package/lib/warnings.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const warning = require('fastify-warning')()
+const warning = require('process-warning')()
 
 /**
  * Deprecation codes:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.25.2",
+  "version": "3.27.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -16,7 +16,7 @@
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
     "prepublishOnly": "tap --no-check-coverage test/internals/version.test.js",
     "test": "npm run lint && npm run unit && npm run test:typescript",
-    "test:ci": "npm run lint && npm run unit -- --cov --coverage-report=lcovonly && npm run test:typescript",
+    "test:ci": "npm run unit -- -R terse --cov --coverage-report=lcovonly && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
     "test:typescript": "tsd",
     "unit": "tap -J test/*.test.js test/*/*.test.js",
@@ -129,6 +129,7 @@
     "@types/pino": "^6.0.1",
     "@typescript-eslint/eslint-plugin": "^4.5.0",
     "@typescript-eslint/parser": "^4.5.0",
+    "JSONStream": "^1.3.5",
     "ajv": "^6.0.0",
     "ajv-errors": "^1.0.1",
     "ajv-formats": "^2.1.1",
@@ -152,12 +153,11 @@
     "form-data": "^4.0.0",
     "frameguard": "^4.0.0",
     "h2url": "^0.2.0",
-    "helmet": "^4.0.0",
+    "helmet": "^5.0.1",
     "hide-powered-by": "^1.1.0",
     "hsts": "^2.2.0",
-    "http-errors": "^1.7.1",
+    "http-errors": "^2.0.0",
     "ienoopen": "^1.1.0",
-    "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
     "pem": "^1.14.4",
     "proxyquire": "^2.1.3",
@@ -173,7 +173,7 @@
     "then-sleep": "^1.0.1",
     "tsd": "^0.19.0",
     "typescript": "^4.0.2",
-    "undici": "^3.3.5",
+    "undici": "^3.3.6",
     "x-xss-protection": "^2.0.0",
     "yup": "^0.32.0"
   },
@@ -183,7 +183,7 @@
     "avvio": "^7.1.2",
     "fast-json-stringify": "^2.5.2",
     "fastify-error": "^0.3.0",
-    "fastify-warning": "^0.2.0",
+    "process-warning": "^1.0.0",
     "find-my-way": "^4.5.0",
     "flatstr": "^1.0.12",
     "light-my-request": "^4.2.0",

package/test/404s.test.js

@@ -1221,7 +1221,7 @@ test('preHandler option for setNotFoundHandler', t => {
   })
 
   // https://github.com/fastify/fastify/issues/2229
-  t.test('preHandler hook in setNotFoundHandler should be called when callNotFound', t => {
+  t.test('preHandler hook in setNotFoundHandler should be called when callNotFound', { timeout: 40000 }, t => {
     t.plan(2)
     const fastify = Fastify()
 

package/test/bundler/esbuild/bundler-test.js

@@ -0,0 +1,31 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fastifySuccess = require('./dist/success')
+const fastifyFailPlugin = require('./dist/failPlugin')
+
+test('Bundled package should work', (t) => {
+  t.plan(4)
+  fastifySuccess.ready((err) => {
+    t.error(err)
+    fastifySuccess.inject(
+      {
+        method: 'GET',
+        url: '/'
+      },
+      (error, res) => {
+        t.error(error)
+        t.equal(res.statusCode, 200)
+        t.same(res.json(), { hello: 'world' })
+      }
+    )
+  })
+})
+
+test('Bundled package should not work with bad plugin version', (t) => {
+  t.plan(1)
+  fastifyFailPlugin.ready((err) => {
+    t.match(err.message, /expected '9.x' fastify version/i)
+  })
+})

package/test/bundler/esbuild/package.json

@@ -0,0 +1,10 @@
+{
+  "version": "0.0.1",
+  "scripts": {
+    "bundle": "esbuild success=src/index.js failPlugin=src/fail-plugin-version.js --bundle  --outdir=dist --platform=node",
+    "test": "npm run bundle && node bundler-test.js"
+  },
+  "devDependencies": {
+    "esbuild": "^0.14.11"
+  }
+}

package/test/bundler/esbuild/src/fail-plugin-version.js

@@ -0,0 +1,12 @@
+const fp = require('fastify-plugin')
+const fastify = require('../../../../')()
+
+fastify.get('/', function (request, reply) {
+  reply.send({ hello: 'world' })
+})
+
+fastify.register(fp((instance, opts, done) => {
+  done()
+}, { fastify: '9.x' }))
+
+module.exports = fastify

package/test/bundler/esbuild/src/index.js

@@ -0,0 +1,7 @@
+const fastify = require('../../../../')()
+// Declare a route
+fastify.get('/', function (request, reply) {
+  reply.send({ hello: 'world' })
+})
+
+module.exports = fastify

package/test/bundler/webpack/bundler-test.js

@@ -5,16 +5,27 @@ const test = t.test
 const fastifySuccess = require('./dist/success')
 const fastifyFailPlugin = require('./dist/failPlugin')
 
-test('Bundled package should work', t => {
-  t.plan(1)
+test('Bundled package should work', (t) => {
+  t.plan(4)
   fastifySuccess.ready((err) => {
     t.error(err)
+    fastifySuccess.inject(
+      {
+        method: 'GET',
+        url: '/'
+      },
+      (error, res) => {
+        t.error(error)
+        t.equal(res.statusCode, 200)
+        t.same(res.json(), { hello: 'world' })
+      }
+    )
   })
 })
 
-test('Bundled package should not work with bad plugin version', t => {
+test('Bundled package should not work with bad plugin version', (t) => {
   t.plan(1)
   fastifyFailPlugin.ready((err) => {
-    t.ok(err)
+    t.match(err.message, /expected '9.x' fastify version/i)
   })
 })

package/test/bundler/webpack/src/fail-plugin-version.js

@@ -1,7 +1,5 @@
 const fp = require('fastify-plugin')
-const fastify = require('../../../../')({
-  logger: true
-})
+const fastify = require('../../../../')()
 
 fastify.get('/', function (request, reply) {
   reply.send({ hello: 'world' })

package/test/bundler/webpack/src/index.js

@@ -1,6 +1,4 @@
-const fastify = require('../../../../')({
-  logger: true
-})
+const fastify = require('../../../../')()
 // Declare a route
 fastify.get('/', function (request, reply) {
   reply.send({ hello: 'world' })

package/test/close.test.js

@@ -291,3 +291,41 @@ test('Cannot be reopened the closed server has listen callback', async t => {
     t.ok(err)
   })
 })
+
+test('shutsdown while keep-alive connections are active (non-async)', t => {
+  t.plan(5)
+
+  const timeoutTime = 2 * 60 * 1000
+  const fastify = Fastify({ forceCloseConnections: true })
+
+  fastify.server.setTimeout(timeoutTime)
+  fastify.server.keepAliveTimeout = timeoutTime
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen(0, (err, address) => {
+    t.error(err)
+
+    const client = new Client(
+      'http://localhost:' + fastify.server.address().port,
+      { keepAliveTimeout: 1 * 60 * 1000 }
+    )
+    client.request({ path: '/', method: 'GET' }, (err, response) => {
+      t.error(err)
+      t.equal(client.closed, false)
+
+      fastify.close((err) => {
+        t.error(err)
+
+        // Due to the nature of the way we reap these keep-alive connections,
+        // there hasn't been enough time before the server fully closed in order
+        // for the client to have seen the socket get destroyed. The mere fact
+        // that we have reached this callback is enough indication that the
+        // feature being tested works as designed.
+        t.equal(client.closed, false)
+      })
+    })
+  })
+})

package/test/custom-parser.test.js

@@ -1314,9 +1314,10 @@ test('contentTypeParser should add a custom parser with RegExp value', t => {
   })
 })
 
-test('contentTypeParser should add multiple custom parsers with RegExp values', t => {
-  t.plan(10)
+test('contentTypeParser should add multiple custom parsers with RegExp values', async t => {
+  t.plan(6)
   const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
 
   fastify.post('/', (req, reply) => {
     reply.send(req.body)
@@ -1340,48 +1341,46 @@ test('contentTypeParser should add multiple custom parsers with RegExp values',
     })
   })
 
-  fastify.listen(0, err => {
-    t.error(err)
+  await fastify.ready()
 
-    sget({
+  {
+    const response = await fastify.inject({
       method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
+      path: '/',
+      payload: '{"hello":"world"}',
       headers: {
         'Content-Type': 'application/vnd.hello+json'
       }
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), JSON.stringify({ hello: 'world' }))
     })
+    t.equal(response.statusCode, 200)
+    t.same(response.payload.toString(), '{"hello":"world"}')
+  }
 
-    sget({
+  {
+    const response = await fastify.inject({
       method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
+      path: '/',
+      payload: '{"hello":"world"}',
       headers: {
         'Content-Type': 'application/test+xml'
       }
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), 'xml')
     })
+    t.equal(response.statusCode, 200)
+    t.same(response.payload.toString(), 'xml')
+  }
 
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: 'abcdefg',
-      headers: {
-        'Content-Type': 'application/+myExtension'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), 'abcdefgmyExtension')
-      fastify.close()
-    })
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    payload: 'abcdefg',
+    headers: {
+      'Content-Type': 'application/+myExtension'
+    }
+  }).then((response) => {
+    t.equal(response.statusCode, 200)
+    t.same(response.payload.toString(), 'abcdefgmyExtension')
+  }).catch((err) => {
+    t.error(err)
   })
 })
 

package/test/noop-set.test.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const tap = require('tap')
+const noopSet = require('../lib/noop-set')
+
+tap.test('does a lot of nothing', async t => {
+  const aSet = noopSet()
+  t.type(aSet, 'object')
+
+  const item = {}
+  aSet.add(item)
+  aSet.add({ another: 'item' })
+  aSet.delete(item)
+  t.equal(aSet.has(item), true)
+
+  for (const i of aSet) {
+    t.fail('should not have any items', i)
+  }
+})

package/test/plugin.name.display.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const assert = require('assert')
+
+module.exports = function (fastify, opts, done) {
+  assert.strictEqual(fastify.pluginName, 'test-plugin')
+  done()
+}
+
+module.exports[Symbol.for('fastify.display-name')] = 'test-plugin'

package/test/plugin.test.js

@@ -41,6 +41,24 @@ test('plugin metadata - ignore prefix', t => {
   }
 })
 
+test('plugin metadata - naming plugins', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.register(require('./plugin.name.display'))
+  fastify.register(function (fastify, opts, done) {
+    // one line
+    t.equal(fastify.pluginName, 'function (fastify, opts, done) { -- // one line')
+    done()
+  })
+  fastify.register(function fooBar (fastify, opts, done) {
+    t.equal(fastify.pluginName, 'fooBar')
+    done()
+  })
+
+  await fastify.ready()
+})
+
 test('fastify.register with fastify-plugin should not encapsulate his code', t => {
   t.plan(10)
   const fastify = Fastify()

package/test/route.test.js

@@ -8,6 +8,7 @@ const sget = require('simple-get').concat
 const joi = require('@hapi/joi')
 const Fastify = require('..')
 const proxyquire = require('proxyquire')
+const { FST_ERR_INVALID_URL } = require('../lib/errors')
 
 test('route', t => {
   t.plan(9)
@@ -1268,3 +1269,14 @@ test('Correct error message is produced if "path" option is used', t => {
     })
   }, new Error('Error Handler for POST:/test route, if defined, must be a function'))
 })
+
+test('invalid url attribute - non string URL', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  try {
+    fastify.get(/^\/(donations|skills|blogs)/, () => {})
+  } catch (error) {
+    t.equal(error.code, FST_ERR_INVALID_URL().code)
+  }
+})

package/test/schema-serialization.test.js

@@ -670,3 +670,44 @@ test('error in custom schema serialize compiler, throw FST_ERR_SCH_SERIALIZATION
     t.equal(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
   })
 })
+
+test('Errors in searilizer sended to errorHandler', async t => {
+  let savedError
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            power: { type: 'string' }
+          },
+          required: ['name']
+        }
+      }
+    }
+
+  }, function (req, reply) {
+    reply.code(200).send({ no: 'thing' })
+  })
+  fastify.setErrorHandler((error, request, reply) => {
+    savedError = error
+    reply.code(500).send(error)
+  })
+
+  const res = await fastify.inject('/')
+
+  t.equal(res.statusCode, 500)
+
+  // t.same(savedError, new Error('"name" is required!'));
+  t.same(res.json(), {
+    statusCode: 500,
+    error: 'Internal Server Error',
+    message: '"name" is required!'
+  })
+  t.ok(savedError, 'error presents')
+  t.ok(savedError.serialization, 'Serialization sign presents')
+  t.end()
+})

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

@@ -57,6 +57,7 @@ fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
 expectAssignable<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>(fastify({ http2: true }))
 expectAssignable<FastifyInstance>(fastify({ ignoreTrailingSlash: true }))
 expectAssignable<FastifyInstance>(fastify({ connectionTimeout: 1000 }))
+expectAssignable<FastifyInstance>(fastify({ forceCloseConnections: true }))
 expectAssignable<FastifyInstance>(fastify({ keepAliveTimeout: 1000 }))
 expectAssignable<FastifyInstance>(fastify({ pluginTimeout: 1000 }))
 expectAssignable<FastifyInstance>(fastify({ bodyLimit: 100 }))
@@ -178,6 +179,22 @@ expectAssignable<FastifyInstance>(fastify({
     plugins: [() => { }]
   }
 }))
+expectAssignable<FastifyInstance>(fastify({
+  ajv: {
+    customOptions: {
+      nullable: false
+    },
+    plugins: [[() => { }, 'keyword']]
+  }
+}))
+expectAssignable<FastifyInstance>(fastify({
+  ajv: {
+    customOptions: {
+      nullable: false
+    },
+    plugins: [[() => { }, ['keyword1', 'keyword2']]]
+  }
+}))
 expectAssignable<FastifyInstance>(fastify({ frameworkErrors: () => { } }))
 expectAssignable<FastifyInstance>(fastify({
   rewriteUrl: (req) => req.url === '/hi' ? '/hello' : req.url!