fastify 3.23.0 → 3.25.0

package/lib/schema-controller.js

@@ -79,6 +79,14 @@ class SchemaController {
     return this.serializerCompiler || (this.parent && this.parent.getSerializerCompiler())
   }
 
+  getSerializerBuilder () {
+    return this.compilersFactory.buildSerializer || (this.parent && this.parent.getSerializerBuilder())
+  }
+
+  getValidatorBuilder () {
+    return this.compilersFactory.buildValidator || (this.parent && this.parent.getValidatorBuilder())
+  }
+
   /**
    * This method will be called when a validator must be setup.
    * Do not setup the compiler more than once
@@ -89,7 +97,7 @@ class SchemaController {
     if (isReady) {
       return
     }
-    this.validatorCompiler = this.compilersFactory.buildValidator(this.schemaBucket.getSchemas(), serverOption.ajv)
+    this.validatorCompiler = this.getValidatorBuilder()(this.schemaBucket.getSchemas(), serverOption.ajv)
   }
 
   /**
@@ -102,7 +110,8 @@ class SchemaController {
     if (isReady) {
       return
     }
-    this.serializerCompiler = this.compilersFactory.buildSerializer(this.schemaBucket.getSchemas(), serverOption.serializerOpts)
+
+    this.serializerCompiler = this.getSerializerBuilder()(this.schemaBucket.getSchemas(), serverOption.serializerOpts)
   }
 }
 

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.0",
+  "version": "3.25.0",
   "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",

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,27 @@ test('decorateRequest/decorateReply is not set to a value', t => {
     })
   })
 })
+
+test('decorateRequest with dependencies', (t) => {
+  t.plan(2)
+  const app = Fastify()
+
+  const decorator1 = {
+    config: {},
+    app: {}
+  }
+  const decorator2 = {
+    stuff: {}
+  }
+
+  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/internals/logger.test.js

@@ -112,3 +112,23 @@ test('The logger should error if both stream and file destination are given', t
     t.equal(err.message, 'Cannot specify both logger.stream and logger.file options')
   }
 })
+
+test('The serializer prevent fails if the request socket is undefined', t => {
+  t.plan(1)
+
+  const serialized = loggerUtils.serializers.req({
+    method: 'GET',
+    url: '/',
+    socket: undefined,
+    headers: {}
+  })
+
+  t.same(serialized, {
+    method: 'GET',
+    url: '/',
+    version: undefined,
+    hostname: undefined,
+    remoteAddress: undefined,
+    remotePort: undefined
+  })
+})

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('../..')()

package/test/internals/version.test.js

@@ -1,43 +1,15 @@
 'use strict'
 
+const fs = require('fs')
+const path = require('path')
 const t = require('tap')
 const test = t.test
-const proxyquire = require('proxyquire')
+const fastify = require('../..')()
 
-test('should output an undefined version in case of package.json not available', t => {
-  const Fastify = proxyquire('../..', { fs: { accessSync: () => { throw Error('error') } } })
+test('should be the same as package.json', t => {
   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')
-  })
+  const json = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json')).toString('utf8'))
 
-  function plugin (instance, opts, done) {
-    done()
-  }
+  t.equal(fastify.version, json.version)
 })