fastify 3.23.1 → 3.25.1

package/lib/server.js

@@ -14,19 +14,20 @@ function createServer (options, httpHandler) {
   let server = null
   if (options.serverFactory) {
     server = options.serverFactory(httpHandler, options)
-  } else if (options.https) {
-    if (options.http2) {
+  } else if (options.http2) {
+    if (options.https) {
       server = http2().createSecureServer(options.https, httpHandler)
-      server.on('session', sessionTimeout(options.http2SessionTimeout))
     } else {
-      server = https.createServer(options.https, httpHandler)
-      server.keepAliveTimeout = options.keepAliveTimeout
+      server = http2().createServer(httpHandler)
     }
-  } else if (options.http2) {
-    server = http2().createServer(httpHandler)
     server.on('session', sessionTimeout(options.http2SessionTimeout))
   } else {
-    server = http.createServer(httpHandler)
+    // this is http1
+    if (options.https) {
+      server = https.createServer(options.https, httpHandler)
+    } else {
+      server = http.createServer(httpHandler)
+    }
     server.keepAliveTimeout = options.keepAliveTimeout
     server.requestTimeout = options.requestTimeout
     // we treat zero as null

package/lib/symbols.js

@@ -33,6 +33,7 @@ const keys = {
   kReplySent: Symbol('fastify.reply.sent'),
   kReplySentOverwritten: Symbol('fastify.reply.sentOverwritten'),
   kReplyStartTime: Symbol('fastify.reply.startTime'),
+  kReplyEndTime: Symbol('fastify.reply.endTime'),
   kReplyErrorHandlerCalled: Symbol('fastify.reply.errorHandlerCalled'),
   kReplyIsRunningOnErrorHook: Symbol('fastify.reply.isRunningOnErrorHook'),
   kSchemaVisited: Symbol('fastify.schemas.visited'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.23.1",
+  "version": "3.25.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -14,6 +14,7 @@
     "lint:fix": "standard --fix",
     "lint:standard": "standard --verbose | snazzy",
     "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:report": "npm run lint && npm run unit:report && npm run test:typescript",
@@ -107,6 +108,11 @@
       "name": "Vincent Le Goff",
       "email": "vince.legoff@gmail.com",
       "url": "https://github.com/zekth"
+    },
+    {
+      "name": "Luis Orbaiceta",
+      "email": "luisorbaiceta@gmail.com",
+      "url": "https://luisorbaiceta.com"
     }
   ],
   "license": "MIT",
@@ -118,7 +124,7 @@
     "@fastify/ajv-compiler-8": "npm:@fastify/ajv-compiler@^2.0.0",
     "@fastify/pre-commit": "^2.0.1",
     "@hapi/joi": "^17.1.1",
-    "@sinonjs/fake-timers": "^7.0.0",
+    "@sinonjs/fake-timers": "^8.1.0",
     "@types/node": "^16.0.0",
     "@types/pino": "^6.0.1",
     "@typescript-eslint/eslint-plugin": "^4.5.0",
@@ -162,10 +168,10 @@
     "snazzy": "^9.0.0",
     "split2": "^4.1.0",
     "standard": "^16.0.1",
-    "tap": "^15.0.5",
+    "tap": "^15.1.1",
     "tap-mocha-reporter": "^5.0.1",
     "then-sleep": "^1.0.1",
-    "tsd": "^0.18.0",
+    "tsd": "^0.19.0",
     "typescript": "^4.0.2",
     "undici": "^3.3.5",
     "x-xss-protection": "^2.0.0",
@@ -178,7 +184,7 @@
     "fast-json-stringify": "^2.5.2",
     "fastify-error": "^0.3.0",
     "fastify-warning": "^0.2.0",
-    "find-my-way": "^4.1.0",
+    "find-my-way": "^4.5.0",
     "flatstr": "^1.0.12",
     "light-my-request": "^4.2.0",
     "pino": "^6.13.0",

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

@@ -12,13 +12,9 @@ test('Bundled package should work', t => {
   })
 })
 
-// In the webpack bundle context the fastify package.json is not read
-// Because of this the version is set to `undefined`, this makes the plugin
-// version check not able to work properly. By then this test shouldn't work
-// in non-bundled environment but works in bundled environment
-test('Bundled package should work with bad plugin version, undefined version fallback', t => {
+test('Bundled package should not work with bad plugin version', t => {
   t.plan(1)
   fastifyFailPlugin.ready((err) => {
-    t.error(err)
+    t.ok(err)
   })
 })

package/test/constrained-routes.test.js

@@ -182,3 +182,223 @@ test('Should allow registering custom constrained routes', t => {
     t.equal(res.statusCode, 404)
   })
 })
+
+test('Should allow registering an unconstrained route after a constrained route', t => {
+  t.plan(6)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from fastify.io' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'from fastify.io' })
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      host: 'example.com'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'from any other domain' })
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should allow registering constrained routes in a prefixed plugin', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.register(async (scope, opts) => {
+    scope.route({
+      method: 'GET',
+      constraints: { host: 'fastify.io' },
+      path: '/route',
+      handler: (req, reply) => {
+        reply.send({ ok: true })
+      }
+    })
+  }, { prefix: '/prefix' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix/route',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { ok: true })
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should allow registering a constrained GET route after a constrained HEAD route', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'HEAD',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.header('content-type', 'text/plain')
+      reply.send('custom HEAD response')
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'custom HEAD response')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should allow registering a constrained GET route after an unconstrained HEAD route', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'HEAD',
+    url: '/',
+    handler: (req, reply) => {
+      reply.header('content-type', 'text/plain')
+      reply.send('custom HEAD response')
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'custom HEAD response')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Will not try to re-createprefixed HEAD route if it already exists and exposeHeadRoutes is true for constrained routes', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify({ exposeHeadRoutes: true })
+
+  fastify.register((scope, opts, next) => {
+    scope.route({
+      method: 'HEAD',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.header('content-type', 'text/plain')
+        reply.send('custom HEAD response')
+      }
+    })
+    scope.route({
+      method: 'GET',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.send({ ok: true })
+      }
+    })
+
+    next()
+  }, { prefix: '/prefix' })
+
+  await fastify.ready()
+
+  t.ok(true)
+})
+
+test('allows separate constrained and unconstrained HEAD routes', 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('unconstrained HEAD response')
+      }
+    })
+
+    scope.route({
+      method: 'HEAD',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.header('content-type', 'text/plain')
+        reply.send('constrained HEAD response')
+      }
+    })
+
+    scope.route({
+      method: 'GET',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.send({ ok: true })
+      }
+    })
+
+    next()
+  }, { prefix: '/prefix' })
+
+  await fastify.ready()
+
+  t.ok(true)
+})

package/test/custom-parser.test.js

@@ -25,6 +25,15 @@ function plainTextParser (request, callback) {
   }
 }
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 process.removeAllListeners('warning')
 
 test('contentTypeParser method should exist', t => {
@@ -61,7 +70,7 @@ test('contentTypeParser should add a custom parser', t => {
 
       sget({
         method: 'POST',
-        url: 'http://localhost:' + fastify.server.address().port,
+        url: getUrl(fastify),
         body: '{"hello":"world"}',
         headers: {
           'Content-Type': 'application/jsoff'
@@ -78,7 +87,7 @@ test('contentTypeParser should add a custom parser', t => {
 
       sget({
         method: 'OPTIONS',
-        url: 'http://localhost:' + fastify.server.address().port,
+        url: getUrl(fastify),
         body: '{"hello":"world"}',
         headers: {
           'Content-Type': 'application/jsoff'

package/test/decorator.test.js

@@ -1024,3 +1024,41 @@ test('decorateRequest/decorateReply is not set to a value', t => {
     })
   })
 })
+
+test('decorateRequest with dependencies', (t) => {
+  t.plan(2)
+  const app = Fastify()
+
+  const decorator1 = 'bar'
+  const decorator2 = 'foo'
+
+  app.decorate('decorator1', decorator1)
+  app.decorateRequest('decorator1', decorator1)
+
+  if (
+    app.hasDecorator('decorator1') &&
+    app.hasRequestDecorator('decorator1')
+  ) {
+    t.doesNotThrow(() => app.decorateRequest('decorator2', decorator2, ['decorator1']))
+    t.ok(app.hasRequestDecorator('decorator2'))
+  }
+})
+
+test('decorateRequest with dependencies (functions)', (t) => {
+  t.plan(2)
+  const app = Fastify()
+
+  const decorator1 = () => 'bar'
+  const decorator2 = () => 'foo'
+
+  app.decorate('decorator1', decorator1)
+  app.decorateRequest('decorator1', decorator1)
+
+  if (
+    app.hasDecorator('decorator1') &&
+    app.hasRequestDecorator('decorator1')
+  ) {
+    t.doesNotThrow(() => app.decorateRequest('decorator2', decorator2, ['decorator1']))
+    t.ok(app.hasRequestDecorator('decorator2'))
+  }
+})

package/test/handler-context.test.js

@@ -4,6 +4,15 @@ const http = require('http')
 const test = require('tap').test
 const fastify = require('../')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('handlers receive correct `this` context', (t) => {
   t.plan(4)
 
@@ -29,8 +38,7 @@ test('handlers receive correct `this` context', (t) => {
     t.ok(instance.foo)
     t.equal(instance.foo, 'foo')
 
-    const address = `http://127.0.0.1:${instance.server.address().port}/`
-    http.get(address, () => {}).on('error', t.threw)
+    http.get(getUrl(instance), () => {}).on('error', t.threw)
   })
 })
 
@@ -50,7 +58,6 @@ test('handlers have access to the internal context', (t) => {
   instance.listen(0, (err) => {
     instance.server.unref()
     if (err) t.threw(err)
-    const address = `http://127.0.0.1:${instance.server.address().port}/`
-    http.get(address, () => {}).on('error', t.threw)
+    http.get(getUrl(instance), () => {}).on('error', t.threw)
   })
 })

package/test/http2/closing.test.js

@@ -11,6 +11,15 @@ const { once } = require('events')
 const { buildCertificate } = require('../build-certificate')
 t.before(buildCertificate)
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 t.test('http/2 request while fastify closing', t => {
   let fastify
   try {
@@ -30,7 +39,7 @@ t.test('http/2 request while fastify closing', t => {
 
     // Skipped because there is likely a bug on Node 8.
     t.test('return 200', { skip: semver.lt(process.versions.node, '10.15.0') }, t => {
-      const url = `http://127.0.0.1:${fastify.server.address().port}`
+      const url = getUrl(fastify)
       const session = http2.connect(url, function () {
         this.request({
           ':method': 'GET',
@@ -78,7 +87,7 @@ t.test('http/2 request while fastify closing - return503OnClosing: false', t =>
 
     // Skipped because there is likely a bug on Node 8.
     t.test('return 200', { skip: semver.lt(process.versions.node, '10.15.0') }, t => {
-      const url = `http://127.0.0.1:${fastify.server.address().port}`
+      const url = getUrl(fastify)
       const session = http2.connect(url, function () {
         this.request({
           ':method': 'GET',
@@ -115,7 +124,7 @@ t.test('http/2 closes successfully with async await', { skip: semver.lt(process.
 
   await fastify.listen(0)
 
-  const url = `http://127.0.0.1:${fastify.server.address().port}`
+  const url = getUrl(fastify)
   const session = await connect(url)
   // An error might or might not happen, as it's OS dependent.
   session.on('error', () => {})
@@ -135,7 +144,7 @@ t.test('https/2 closes successfully with async await', { skip: semver.lt(process
 
   await fastify.listen(0)
 
-  const url = `http://127.0.0.1:${fastify.server.address().port}`
+  const url = getUrl(fastify)
   const session = await connect(url)
   // An error might or might not happen, as it's OS dependent.
   session.on('error', () => {})
@@ -159,7 +168,7 @@ t.test('http/2 server side session emits a timeout event', { skip: semver.lt(pro
 
   await fastify.listen(0)
 
-  const url = `http://127.0.0.1:${fastify.server.address().port}`
+  const url = getUrl(fastify)
   const session = await connect(url)
   const req = session.request({
     ':method': 'GET',

package/test/http2/constraint.test.js

@@ -0,0 +1,91 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('../..')
+const h2url = require('h2url')
+
+const alpha = { res: 'alpha' }
+const beta = { res: 'beta' }
+
+const { buildCertificate } = require('../build-certificate')
+t.before(buildCertificate)
+
+test('A route supports host constraints under http2 protocol and secure connection', (t) => {
+  t.plan(5)
+
+  let fastify
+  try {
+    fastify = Fastify({
+      http2: true,
+      https: {
+        key: global.context.key,
+        cert: global.context.cert
+      }
+    })
+    t.pass('Key/cert successfully loaded')
+  } catch (e) {
+    t.fail('Key/cert loading failed', e)
+  }
+
+  const constrain = 'fastify.io'
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: function (_, reply) {
+      reply.code(200).send(alpha)
+    }
+  })
+  fastify.route({
+    method: 'GET',
+    url: '/beta',
+    constraints: { host: constrain },
+    handler: function (_, reply) {
+      reply.code(200).send(beta)
+    }
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+    fastify.server.unref()
+
+    t.test('https get request - no constrain', async (t) => {
+      t.plan(3)
+
+      const url = `https://localhost:${fastify.server.address().port}`
+      const res = await h2url.concat({ url })
+
+      t.equal(res.headers[':status'], 200)
+      t.equal(res.headers['content-length'], '' + JSON.stringify(alpha).length)
+      t.same(JSON.parse(res.body), alpha)
+    })
+
+    t.test('https get request - constrain', async (t) => {
+      t.plan(3)
+
+      const url = `https://localhost:${fastify.server.address().port}/beta`
+      const res = await h2url.concat({
+        url,
+        headers: {
+          ':authority': constrain
+        }
+      })
+
+      t.equal(res.headers[':status'], 200)
+      t.equal(res.headers['content-length'], '' + JSON.stringify(beta).length)
+      t.same(JSON.parse(res.body), beta)
+    })
+
+    t.test('https get request - constrain - not found', async (t) => {
+      t.plan(1)
+
+      const url = `https://localhost:${fastify.server.address().port}/beta`
+      const res = await h2url.concat({
+        url
+      })
+
+      t.equal(res.headers[':status'], 404)
+    })
+  })
+})

package/test/internals/reply.test.js

@@ -1368,6 +1368,48 @@ test('reply.getResponseTime() should return a number greater than 0 after the ti
   fastify.inject({ method: 'GET', url: '/' })
 })
 
+test('reply.getResponseTime() should return the time since a request started while inflight', t => {
+  t.plan(1)
+  const fastify = require('../..')()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send('hello world')
+    }
+  })
+
+  fastify.addHook('preValidation', (req, reply, done) => {
+    t.not(reply.getResponseTime(), reply.getResponseTime())
+    done()
+  })
+
+  fastify.addHook('onResponse', (req, reply) => {
+    t.end()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' })
+})
+
+test('reply.getResponseTime() should return the same value after a request is finished', t => {
+  t.plan(1)
+  const fastify = require('../..')()
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send('hello world')
+    }
+  })
+
+  fastify.addHook('onResponse', (req, reply) => {
+    t.equal(reply.getResponseTime(), reply.getResponseTime())
+    t.end()
+  })
+
+  fastify.inject({ method: 'GET', url: '/' })
+})
+
 test('reply should use the custom serializer', t => {
   t.plan(4)
   const fastify = require('../..')()