fastify 3.24.0 → 3.25.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.24.0",
+  "version": "3.25.2",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -108,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",
@@ -163,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",
@@ -179,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/als.test.js

@@ -0,0 +1,74 @@
+'use strict'
+
+const { AsyncLocalStorage } = require('async_hooks')
+const t = require('tap')
+const Fastify = require('..')
+const sget = require('simple-get').concat
+
+if (!AsyncLocalStorage) {
+  t.skip('AsyncLocalStorage not available, skipping test')
+  process.exit(0)
+}
+
+const storage = new AsyncLocalStorage()
+const app = Fastify({ logger: false })
+
+let counter = 0
+app.addHook('onRequest', (req, reply, next) => {
+  const id = counter++
+  storage.run({ id }, next)
+})
+
+app.get('/', function (request, reply) {
+  t.ok(storage.getStore())
+  const id = storage.getStore().id
+  reply.send({ id })
+})
+
+app.post('/', function (request, reply) {
+  t.ok(storage.getStore())
+  const id = storage.getStore().id
+  reply.send({ id })
+})
+
+app.listen(3000, function (err, address) {
+  t.error(err)
+
+  sget({
+    method: 'POST',
+    url: 'http://localhost:' + app.server.address().port,
+    body: {
+      hello: 'world'
+    },
+    json: true
+  }, (err, response, body) => {
+    t.error(err)
+    t.equal(response.statusCode, 200)
+    t.same(body, { id: 0 })
+
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + app.server.address().port,
+      body: {
+        hello: 'world'
+      },
+      json: true
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.same(body, { id: 1 })
+
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + app.server.address().port,
+        json: true
+      }, (err, response, body) => {
+        t.error(err)
+        t.equal(response.statusCode, 200)
+        t.same(body, { id: 2 })
+        app.close()
+        t.end()
+      })
+    })
+  })
+})

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)
+    })
+  })
+})