fastify 4.0.0-rc.3 → 4.0.0

package/lib/errors.js

@@ -200,6 +200,10 @@ const codes = {
     'FST_ERR_INIT_OPTS_INVALID',
     "Invalid initialization options: '%s'"
   ),
+  FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE: createError(
+    'FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE',
+    "Cannot set forceCloseConnections to 'idle' as your HTTP server does not support closeIdleConnections method"
+  ),
 
   /**
    * router

package/lib/request.js

@@ -65,8 +65,8 @@ function buildRegularRequest (R) {
       this[prop.key] = prop.value
     }
   }
-  Object.setPrototypeOf(_Request.prototype, Request.prototype)
-  Object.setPrototypeOf(_Request, Request)
+  Object.setPrototypeOf(_Request.prototype, R.prototype)
+  Object.setPrototypeOf(_Request, R)
   _Request.props = props
   _Request.parent = R
 

package/lib/route.js

@@ -42,7 +42,6 @@ const {
 const { buildErrorHandler } = require('./error-handler')
 
 function buildRouting (options) {
-  const { keepAliveConnections } = options
   const router = FindMyWay(options.config)
 
   let avvio
@@ -56,9 +55,11 @@ function buildRouting (options) {
   let genReqId
   let disableRequestLogging
   let ignoreTrailingSlash
+  let ignoreDuplicateSlashes
   let return503OnClosing
   let globalExposeHeadRoutes
   let validateHTTPVersion
+  let keepAliveConnections
 
   let closing = false
 
@@ -78,7 +79,9 @@ function buildRouting (options) {
       genReqId = options.genReqId
       disableRequestLogging = options.disableRequestLogging
       ignoreTrailingSlash = options.ignoreTrailingSlash
+      ignoreDuplicateSlashes = options.ignoreDuplicateSlashes
       return503OnClosing = Object.prototype.hasOwnProperty.call(options, 'return503OnClosing') ? options.return503OnClosing : true
+      keepAliveConnections = fastifyArgs.keepAliveConnections
     },
     routing: router.lookup.bind(router), // router func to find the right handler to call
     route, // configure a route in the fastify instance
@@ -182,7 +185,7 @@ function buildRouting (options) {
         default:
           addNewRoute.call(this, '')
           // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
-          if (ignoreTrailingSlash !== true) {
+          if (ignoreTrailingSlash !== true && (ignoreDuplicateSlashes !== true || !prefix.endsWith('/'))) {
             addNewRoute.call(this, path, true)
           }
       }

package/lib/schemas.js

@@ -143,6 +143,9 @@ function getSchemaSerializer (context, statusCode) {
   if (responseSchemaDef[fallbackStatusCode]) {
     return responseSchemaDef[fallbackStatusCode]
   }
+  if (responseSchemaDef.default) {
+    return responseSchemaDef.default
+  }
   return false
 }
 

package/lib/validation.js

@@ -7,17 +7,23 @@ const {
   kSchemaBody: bodySchema,
   kSchemaResponse: responseSchema
 } = require('./symbols')
+const scChecker = /^[1-5]{1}[0-9]{2}$|^[1-5]xx$|^default$/
 
 function compileSchemasForSerialization (context, compile) {
   if (!context.schema || !context.schema.response) {
     return
   }
-
   const { method, url } = context.config || {}
   context[responseSchema] = Object.keys(context.schema.response)
     .reduce(function (acc, statusCode) {
+      const schema = context.schema.response[statusCode]
+      statusCode = statusCode.toLowerCase()
+      if (!scChecker.exec(statusCode)) {
+        throw new Error('response schemas should be nested under a valid status code, e.g { 2xx: { type: "object" } }')
+      }
+
       acc[statusCode] = compile({
-        schema: context.schema.response[statusCode],
+        schema,
         url,
         method,
         httpStatus: statusCode

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.0.0-rc.3",
+  "version": "4.0.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -124,13 +124,13 @@
   },
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
-    "@fastify/pre-commit": "^2.0.1",
-    "@sinclair/typebox": "^0.23.1",
-    "@sinonjs/fake-timers": "^9.1.0",
-    "@types/node": "^17.0.18",
-    "@typescript-eslint/eslint-plugin": "^5.7.0",
-    "@typescript-eslint/parser": "^5.7.0",
-    "ajv": "^8.10.0",
+    "@fastify/pre-commit": "^2.0.2",
+    "@sinclair/typebox": "^0.23.5",
+    "@sinonjs/fake-timers": "^9.1.2",
+    "@types/node": "^17.0.38",
+    "@typescript-eslint/eslint-plugin": "^5.27.0",
+    "@typescript-eslint/parser": "^5.27.0",
+    "ajv": "^8.11.0",
     "ajv-errors": "^3.0.0",
     "ajv-formats": "^2.1.1",
     "ajv-i18n": "^4.2.0",
@@ -138,57 +138,57 @@
     "branch-comparer": "^1.1.0",
     "cors": "^2.8.5",
     "dns-prefetch-control": "^0.3.0",
-    "eslint": "^8.0.1",
+    "eslint": "^8.16.0",
     "eslint-config-standard": "^17.0.0-1",
-    "eslint-import-resolver-node": "^0.3.2",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-n": "^15.1.0",
+    "eslint-import-resolver-node": "^0.3.6",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.2.0",
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
-    "fast-json-stringify": "^3.0.0",
-    "fastify-plugin": "^3.0.0",
-    "fluent-json-schema": "^3.0.1",
+    "fast-json-stringify": "^4.0.0",
+    "fastify-plugin": "^3.0.1",
+    "fluent-json-schema": "^3.1.0",
     "form-data": "^4.0.0",
     "frameguard": "^4.0.0",
     "h2url": "^0.2.0",
-    "helmet": "^5.0.1",
+    "helmet": "^5.1.0",
     "hide-powered-by": "^1.1.0",
     "http-errors": "^2.0.0",
-    "joi": "^17.5.0",
-    "json-schema-to-ts": "^2.0.1",
+    "joi": "^17.6.0",
+    "json-schema-to-ts": "^2.5.3",
     "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "self-cert": "^2.0.0",
     "send": "^0.18.0",
-    "serve-static": "^1.14.1",
-    "simple-get": "^4.0.0",
+    "serve-static": "^1.15.0",
+    "simple-get": "^4.0.1",
     "snazzy": "^9.0.0",
     "split2": "^4.1.0",
     "standard": "^17.0.0-2",
-    "tap": "^16.0.0",
+    "tap": "^16.2.0",
     "tsd": "^0.20.0",
-    "typescript": "^4.5.4",
-    "undici": "^4.11.3",
+    "typescript": "^4.7.2",
+    "undici": "^5.4.0",
     "x-xss-protection": "^2.0.0",
     "yup": "^0.32.11"
   },
   "dependencies": {
     "@fastify/ajv-compiler": "^3.1.0",
-    "@fastify/error": "^2.0.0",
-    "@fastify/fast-json-stringify-compiler": "^1.0.0",
+    "@fastify/error": "^3.0.0",
+    "@fastify/fast-json-stringify-compiler": "^3.0.0",
     "abstract-logging": "^2.0.1",
-    "avvio": "^8.1.0",
-    "find-my-way": "^6.0.0",
-    "light-my-request": "^4.7.0",
-    "pino": "^7.5.1",
-    "process-warning": "^1.0.0",
+    "avvio": "^8.1.3",
+    "find-my-way": "^6.3.0",
+    "light-my-request": "^5.0.0",
+    "pino": "^8.0.0",
+    "process-warning": "^2.0.0",
     "proxy-addr": "^2.0.7",
-    "rfdc": "^1.1.4",
-    "secure-json-parse": "^2.0.0",
-    "semver": "^7.3.2",
-    "tiny-lru": "^8.0.1"
+    "rfdc": "^1.3.0",
+    "secure-json-parse": "^2.4.0",
+    "semver": "^7.3.7",
+    "tiny-lru": "^8.0.2"
   },
   "standard": {
     "ignore": [

package/test/close-pipelining.test.js

@@ -7,7 +7,8 @@ const { Client } = require('undici')
 
 test('Should return 503 while closing - pipelining', t => {
   const fastify = Fastify({
-    return503OnClosing: true
+    return503OnClosing: true,
+    forceCloseConnections: false
   })
 
   fastify.get('/', (req, reply) => {
@@ -40,7 +41,8 @@ test('Should return 503 while closing - pipelining', t => {
 
 test('Should not return 503 while closing - pipelining - return503OnClosing', t => {
   const fastify = Fastify({
-    return503OnClosing: false
+    return503OnClosing: false,
+    forceCloseConnections: false
   })
 
   fastify.get('/', (req, reply) => {

package/test/close.test.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const net = require('net')
+const http = require('http')
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
@@ -203,7 +204,8 @@ test('Should return error while closing (callback) - injection', t => {
 
 t.test('Current opened connection should continue to work after closing and return "connection: close" header - return503OnClosing: false', t => {
   const fastify = Fastify({
-    return503OnClosing: false
+    return503OnClosing: false,
+    forceCloseConnections: false
   })
 
   fastify.get('/', (req, reply) => {
@@ -240,7 +242,7 @@ t.test('Current opened connection should continue to work after closing and retu
 
 t.test('Current opened connection should not accept new incoming connections', t => {
   t.plan(3)
-  const fastify = Fastify()
+  const fastify = Fastify({ forceCloseConnections: false })
   fastify.get('/', (req, reply) => {
     fastify.close()
     setTimeout(() => {
@@ -292,7 +294,10 @@ test('Cannot be reopened the closed server has listen callback', async t => {
   })
 })
 
-test('shutsdown while keep-alive connections are active (non-async)', t => {
+const server = http.createServer()
+const noSupport = typeof server.closeAllConnections !== 'function'
+
+test('shutsdown while keep-alive connections are active (non-async, native)', { skip: noSupport }, t => {
   t.plan(5)
 
   const timeoutTime = 2 * 60 * 1000
@@ -329,3 +334,88 @@ test('shutsdown while keep-alive connections are active (non-async)', t => {
     })
   })
 })
+
+test('shutsdown while keep-alive connections are active (non-async, idle, native)', { skip: noSupport }, t => {
+  t.plan(5)
+
+  const timeoutTime = 2 * 60 * 1000
+  const fastify = Fastify({ forceCloseConnections: 'idle' })
+
+  fastify.server.setTimeout(timeoutTime)
+  fastify.server.keepAliveTimeout = timeoutTime
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 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)
+      })
+    })
+  })
+})
+
+test('shutsdown while keep-alive connections are active (non-async, custom)', t => {
+  t.plan(5)
+
+  const timeoutTime = 2 * 60 * 1000
+  const fastify = Fastify({
+    forceCloseConnections: true,
+    serverFactory (handler) {
+      const server = http.createServer(handler)
+
+      server.closeAllConnections = null
+
+      return server
+    }
+  })
+
+  fastify.server.setTimeout(timeoutTime)
+  fastify.server.keepAliveTimeout = timeoutTime
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 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-http-server.test.js

@@ -4,6 +4,7 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 const http = require('http')
+const { FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE } = require('../lib/errors')
 const sget = require('simple-get').concat
 const dns = require('dns').promises
 
@@ -49,3 +50,24 @@ test('Should support a custom http server', async t => {
     })
   })
 })
+
+test('Should not allow forceCloseConnection=idle if the server does not support closeIdleConnections', t => {
+  t.plan(1)
+
+  t.throws(
+    () => {
+      Fastify({
+        forceCloseConnections: 'idle',
+        serverFactory (handler, opts) {
+          return {
+            on () {
+
+            }
+          }
+        }
+      })
+    },
+    FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE,
+    "Cannot set forceCloseConnections to 'idle' as your HTTP server does not support closeIdleConnections method"
+  )
+})

package/test/decorator.test.js

@@ -1060,3 +1060,149 @@ test('decorateRequest with dependencies (functions)', (t) => {
     t.ok(app.hasRequestDecorator('decorator2'))
   }
 })
+
+test('chain of decorators on Request', async (t) => {
+  const fastify = Fastify()
+  fastify.register(fp(async function (fastify) {
+    fastify.decorateRequest('foo', 'toto')
+    fastify.decorateRequest('bar', () => 'tata')
+  }, {
+    name: 'first'
+  }))
+
+  fastify.get('/foo', async function (request, reply) {
+    return request.foo
+  })
+  fastify.get('/bar', function (request, reply) {
+    return request.bar()
+  })
+  fastify.register(async function second (fastify) {
+    fastify.get('/foo', async function (request, reply) {
+      return request.foo
+    })
+    fastify.get('/bar', async function (request, reply) {
+      return request.bar()
+    })
+    fastify.register(async function fourth (fastify) {
+      fastify.get('/plugin3/foo', async function (request, reply) {
+        return request.foo
+      })
+      fastify.get('/plugin3/bar', function (request, reply) {
+        return request.bar()
+      })
+    })
+    fastify.register(fp(async function (fastify) {
+      fastify.decorateRequest('fooB', 'toto')
+      fastify.decorateRequest('barB', () => 'tata')
+    }, {
+      name: 'third'
+    }))
+  },
+  { prefix: '/plugin2', name: 'plugin2' }
+  )
+
+  await fastify.ready()
+
+  {
+    const response = await fastify.inject('/foo')
+    t.equal(response.body, 'toto')
+  }
+
+  {
+    const response = await fastify.inject('/bar')
+    t.equal(response.body, 'tata')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/foo')
+    t.equal(response.body, 'toto')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/bar')
+    t.equal(response.body, 'tata')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/plugin3/foo')
+    t.equal(response.body, 'toto')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/plugin3/bar')
+    t.equal(response.body, 'tata')
+  }
+})
+
+test('chain of decorators on Reply', async (t) => {
+  const fastify = Fastify()
+  fastify.register(fp(async function (fastify) {
+    fastify.decorateReply('foo', 'toto')
+    fastify.decorateReply('bar', () => 'tata')
+  }, {
+    name: 'first'
+  }))
+
+  fastify.get('/foo', async function (request, reply) {
+    return reply.foo
+  })
+  fastify.get('/bar', function (request, reply) {
+    return reply.bar()
+  })
+  fastify.register(async function second (fastify) {
+    fastify.get('/foo', async function (request, reply) {
+      return reply.foo
+    })
+    fastify.get('/bar', async function (request, reply) {
+      return reply.bar()
+    })
+    fastify.register(async function fourth (fastify) {
+      fastify.get('/plugin3/foo', async function (request, reply) {
+        return reply.foo
+      })
+      fastify.get('/plugin3/bar', function (request, reply) {
+        return reply.bar()
+      })
+    })
+    fastify.register(fp(async function (fastify) {
+      fastify.decorateReply('fooB', 'toto')
+      fastify.decorateReply('barB', () => 'tata')
+    }, {
+      name: 'third'
+    }))
+  },
+  { prefix: '/plugin2', name: 'plugin2' }
+  )
+
+  await fastify.ready()
+
+  {
+    const response = await fastify.inject('/foo')
+    t.equal(response.body, 'toto')
+  }
+
+  {
+    const response = await fastify.inject('/bar')
+    t.equal(response.body, 'tata')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/foo')
+    t.equal(response.body, 'toto')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/bar')
+    t.equal(response.body, 'tata')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/plugin3/foo')
+    t.equal(response.body, 'toto')
+  }
+
+  {
+    const response = await fastify.inject('/plugin2/plugin3/bar')
+    t.equal(response.body, 'tata')
+  }
+})

package/test/internals/initialConfig.test.js

@@ -32,7 +32,6 @@ test('without options passed to Fastify, initialConfig should expose default val
   const fastifyDefaultOptions = {
     connectionTimeout: 0,
     keepAliveTimeout: 72000,
-    forceCloseConnections: false,
     maxRequestsPerSocket: 0,
     requestTimeout: 0,
     bodyLimit: 1024 * 1024,
@@ -41,6 +40,7 @@ test('without options passed to Fastify, initialConfig should expose default val
     disableRequestLogging: false,
     jsonShorthand: true,
     ignoreTrailingSlash: false,
+    ignoreDuplicateSlashes: false,
     maxParamLength: 100,
     onProtoPoisoning: 'error',
     onConstructorPoisoning: 'error',
@@ -55,7 +55,7 @@ test('without options passed to Fastify, initialConfig should expose default val
 })
 
 test('Fastify.initialConfig should expose all options', t => {
-  t.plan(19)
+  t.plan(20)
 
   const serverFactory = (handler, opts) => {
     const server = http.createServer((req, res) => {
@@ -88,6 +88,7 @@ test('Fastify.initialConfig should expose all options', t => {
       cert: global.context.cert
     },
     ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: true,
     maxParamLength: 200,
     connectionTimeout: 0,
     keepAliveTimeout: 72000,
@@ -115,6 +116,7 @@ test('Fastify.initialConfig should expose all options', t => {
   t.equal(fastify.initialConfig.http2, true)
   t.equal(fastify.initialConfig.https, true, 'for security reason the key cert is hidden')
   t.equal(fastify.initialConfig.ignoreTrailingSlash, true)
+  t.equal(fastify.initialConfig.ignoreDuplicateSlashes, true)
   t.equal(fastify.initialConfig.maxParamLength, 200)
   t.equal(fastify.initialConfig.connectionTimeout, 0)
   t.equal(fastify.initialConfig.keepAliveTimeout, 72000)
@@ -262,7 +264,6 @@ test('Should not have issues when passing stream options to Pino.js', t => {
     t.same(fastify.initialConfig, {
       connectionTimeout: 0,
       keepAliveTimeout: 72000,
-      forceCloseConnections: false,
       maxRequestsPerSocket: 0,
       requestTimeout: 0,
       bodyLimit: 1024 * 1024,
@@ -271,6 +272,7 @@ test('Should not have issues when passing stream options to Pino.js', t => {
       disableRequestLogging: false,
       jsonShorthand: true,
       ignoreTrailingSlash: true,
+      ignoreDuplicateSlashes: false,
       maxParamLength: 100,
       onProtoPoisoning: 'error',
       onConstructorPoisoning: 'error',

package/test/output-validation.test.js

@@ -127,9 +127,13 @@ fastify.listen({ port: 0 }, err => {
       url: 'http://localhost:' + fastify.server.address().port + '/wrong-object-for-schema'
     }, (err, response, body) => {
       t.error(err)
-      t.equal(response.statusCode, 201)
+      t.equal(response.statusCode, 500)
       t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), {})
+      t.same(JSON.parse(body), {
+        statusCode: 500,
+        error: 'Internal Server Error',
+        message: 'The value "world" cannot be converted to a number.'
+      })
     })
   })