fastify 2.4.1 → 2.7.1

package/lib/decorate.js

@@ -1,5 +1,7 @@
 'use strict'
 
+/* eslint no-prototype-builtins: 0 */
+
 const {
   kReply,
   kRequest

package/lib/errors.js

@@ -53,6 +53,7 @@ createError('FST_ERR_SEND_INSIDE_ONERR', 'You cannot use `send` inside the `onEr
 createError('FST_ERR_SCH_MISSING_ID', `Missing schema $id property`)
 createError('FST_ERR_SCH_ALREADY_PRESENT', `Schema with id '%s' already declared!`)
 createError('FST_ERR_SCH_NOT_PRESENT', `Schema with id '%s' does not exist!`)
+createError('FST_ERR_SCH_DUPLICATE', `Schema with '%s' already present!`)
 
 /**
  * wrapThenable

package/lib/handleRequest.js

@@ -72,7 +72,7 @@ function handler (request, reply) {
 }
 
 function preValidationCallback (err, request, reply) {
-  if (reply.res.finished === true) return
+  if (reply.sent === true || reply.res.finished === true) return
   if (err != null) {
     reply.send(err)
     return
@@ -103,7 +103,7 @@ function preValidationCallback (err, request, reply) {
 }
 
 function preHandlerCallback (err, request, reply) {
-  if (reply.res.finished === true) return
+  if (reply.sent || reply.res.finished === true) return
   if (err != null) {
     reply.send(err)
     return

package/lib/reply.js

@@ -11,6 +11,7 @@ const {
   kReplySentOverwritten,
   kReplyStartTime,
   kReplySerializer,
+  kReplySerializerDefault,
   kReplyIsError,
   kReplyHeaders,
   kReplyHasStatusCode,
@@ -195,7 +196,11 @@ Reply.prototype.serialize = function (payload) {
   if (this[kReplySerializer] !== null) {
     return this[kReplySerializer](payload)
   } else {
-    return serialize(this.context, payload, this.res.statusCode)
+    if (this.context && this.context[kReplySerializerDefault]) {
+      return this.context[kReplySerializerDefault](payload, this.res.statusCode)
+    } else {
+      return serialize(this.context, payload, this.res.statusCode)
+    }
   }
 }
 
@@ -222,6 +227,16 @@ Reply.prototype.callNotFound = function () {
   notFound(this)
 }
 
+Reply.prototype.getResponseTime = function () {
+  var responseTime = 0
+
+  if (this[kReplyStartTime] !== undefined) {
+    responseTime = now() - this[kReplyStartTime]
+  }
+
+  return responseTime
+}
+
 function preserializeHook (reply, payload) {
   if (reply.context.preSerialization !== null) {
     onSendHookRunner(
@@ -242,7 +257,12 @@ function preserializeHookEnd (err, request, reply, payload) {
     return
   }
 
-  payload = serialize(reply.context, payload, reply.res.statusCode)
+  if (reply.context && reply.context[kReplySerializerDefault]) {
+    payload = reply.context[kReplySerializerDefault](payload, reply.res.statusCode)
+  } else {
+    payload = serialize(reply.context, payload, reply.res.statusCode)
+  }
+
   flatstr(payload)
 
   onSendHook(reply, payload)
@@ -460,11 +480,8 @@ function onResponseCallback (err, request, reply) {
   if (reply.log[kDisableRequestLogging]) {
     return
   }
-  var responseTime = 0
 
-  if (reply[kReplyStartTime] !== undefined) {
-    responseTime = now() - reply[kReplyStartTime]
-  }
+  var responseTime = reply.getResponseTime()
 
   if (err != null) {
     reply.log.error({

package/lib/request.js

@@ -30,12 +30,12 @@ function buildRequest (R) {
 }
 
 Object.defineProperties(Request.prototype, {
-  'req': {
+  req: {
     get: function () {
       return this.raw
     }
   },
-  'id': {
+  id: {
     get: function () {
       return this.raw.id
     }

package/lib/route.js

@@ -19,6 +19,7 @@ const {
   kSchemaCompiler,
   kContentTypeParser,
   kReply,
+  kReplySerializerDefault,
   kRequest,
   kMiddlewares,
   kGlobalHooks,
@@ -45,6 +46,8 @@ function buildRouting (options) {
   let modifyCoreObjects
   let genReqId
   let disableRequestLogging
+  let ignoreTrailingSlash
+  let return503OnClosing
 
   let closing = false
 
@@ -65,6 +68,8 @@ function buildRouting (options) {
       modifyCoreObjects = options.modifyCoreObjects
       genReqId = options.genReqId
       disableRequestLogging = options.disableRequestLogging
+      ignoreTrailingSlash = options.ignoreTrailingSlash
+      return503OnClosing = Object.prototype.hasOwnProperty.call(options, 'return503OnClosing') ? options.return503OnClosing : true
     },
     routing: router.lookup.bind(router), // router func to find the right handler to call
     route, // configure a route in the fastify instance
@@ -142,7 +147,10 @@ function buildRouting (options) {
           case 'both':
           default:
             afterRouteAdded.call(this, '', notHandledErr, done)
-            afterRouteAdded.call(this, path, notHandledErr, done)
+            // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
+            if (ignoreTrailingSlash !== true) {
+              afterRouteAdded.call(this, path, notHandledErr, done)
+            }
         }
       } else if (path[0] === '/' && prefix.endsWith('/')) {
         // Ensure that '/prefix/' + '/route' gets registered as '/prefix/route'
@@ -190,7 +198,8 @@ function buildRouting (options) {
         this._errorHandler,
         opts.bodyLimit,
         opts.logLevel,
-        opts.attachValidation
+        opts.attachValidation,
+        this[kReplySerializerDefault]
       )
 
       // TODO this needs to be refactored so that buildSchemaCompiler is
@@ -212,7 +221,7 @@ function buildRouting (options) {
 
       const hooks = ['preParsing', 'preValidation', 'onRequest', 'preHandler', 'preSerialization']
 
-      for (let hook of hooks) {
+      for (const hook of hooks) {
         if (opts[hook]) {
           if (Array.isArray(opts[hook])) {
             opts[hook] = opts[hook].map(fn => fn.bind(this))
@@ -241,7 +250,7 @@ function buildRouting (options) {
         context.onError = onError.length ? onError : null
         context.onResponse = onResponse.length ? onResponse : null
 
-        for (let hook of hooks) {
+        for (const hook of hooks) {
           const toSet = this[kHooks][hook].concat(opts[hook] || [])
           context[hook] = toSet.length ? toSet : null
         }
@@ -260,20 +269,20 @@ function buildRouting (options) {
   // HTTP request entry point, the routing has already been executed
   function routeHandler (req, res, params, context) {
     if (closing === true) {
-      const headers = {
-        'Content-Type': 'application/json',
-        'Content-Length': '80'
-      }
       if (req.httpVersionMajor !== 2) {
-        headers.Connection = 'close'
+        res.once('finish', () => req.destroy())
+        res.setHeader('Connection', 'close')
       }
-      res.writeHead(503, headers)
-      res.end('{"error":"Service Unavailable","message":"Service Unavailable","statusCode":503}')
-      if (req.httpVersionMajor !== 2) {
-        // This is not needed in HTTP/2
-        setImmediate(() => req.destroy())
+
+      if (return503OnClosing) {
+        const headers = {
+          'Content-Type': 'application/json',
+          'Content-Length': '80'
+        }
+        res.writeHead(503, headers)
+        res.end('{"error":"Service Unavailable","message":"Service Unavailable","statusCode":503}')
+        return
       }
-      return
     }
 
     req.id = req.headers[requestIdHeader] || genReqId(req)

package/lib/schemas.js

@@ -1,12 +1,14 @@
 'use strict'
 
 const fastClone = require('rfdc')({ circles: false, proto: true })
+const kFluentSchema = Symbol.for('fluent-schema-object')
 
 const {
   codes: {
     FST_ERR_SCH_MISSING_ID,
     FST_ERR_SCH_ALREADY_PRESENT,
-    FST_ERR_SCH_NOT_PRESENT
+    FST_ERR_SCH_NOT_PRESENT,
+    FST_ERR_SCH_DUPLICATE
   }
 } = require('./errors')
 
@@ -17,7 +19,10 @@ function Schemas () {
 }
 
 Schemas.prototype.add = function (inputSchema) {
-  const schema = fastClone(inputSchema)
+  var schema = fastClone(inputSchema[kFluentSchema]
+    ? inputSchema.valueOf()
+    : inputSchema
+  )
   const id = schema['$id']
   if (id === undefined) {
     throw new FST_ERR_SCH_MISSING_ID()
@@ -38,6 +43,15 @@ Schemas.prototype.resolve = function (id) {
 }
 
 Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId) {
+  // alias query to querystring schema
+  if (routeSchemas.query) {
+    // check if our schema has both querystring and query
+    if (routeSchemas.querystring) {
+      throw new FST_ERR_SCH_DUPLICATE('querystring')
+    }
+    routeSchemas.querystring = routeSchemas.query
+  }
+
   // let's check if our schemas have a custom prototype
   for (const key of ['headers', 'querystring', 'params', 'body']) {
     if (typeof routeSchemas[key] === 'object' && Object.getPrototypeOf(routeSchemas[key]) !== Object.prototype) {
@@ -45,6 +59,9 @@ Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId) {
     }
   }
 
+  // See issue https://github.com/fastify/fastify/issues/1767
+  const cachedSchema = Object.assign({}, routeSchemas)
+
   try {
     // this will work only for standard json schemas
     // other compilers such as Joi will fail
@@ -58,9 +75,13 @@ Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId) {
       this.cleanId(routeSchemas)
     }
   } catch (err) {
-    // if we have failed because `resolve has thrown
+    // if we have failed because `resolve` has thrown
     // let's rethrow the error and let avvio handle it
     if (/FST_ERR_SCH_*/.test(err.code)) throw err
+
+    // otherwise, the schema must not be a JSON schema
+    // so we let the user configured schemaCompiler handle it
+    return cachedSchema
   }
 
   if (routeSchemas.headers) {

package/lib/symbols.js

@@ -8,6 +8,7 @@ const keys = {
   kHooks: Symbol('fastify.hooks'),
   kSchemas: Symbol('fastify.schemas'),
   kSchemaCompiler: Symbol('fastify.schemaCompiler'),
+  kReplySerializerDefault: Symbol('fastify.replySerializerDefault'),
   kContentTypeParser: Symbol('fastify.contentTypeParser'),
   kReply: Symbol('fastify.Reply'),
   kRequest: Symbol('fastify.Request'),

package/lib/validation.js

@@ -8,6 +8,7 @@ const querystringSchema = Symbol('querystring-schema')
 const paramsSchema = Symbol('params-schema')
 const responseSchema = Symbol('response-schema')
 const headersSchema = Symbol('headers-schema')
+const kFluentSchema = Symbol.for('fluent-schema-object')
 
 function getValidatorForStatusCodeSchema (statusCodeDefinition, externalSchema) {
   return fastJsonStringify(statusCodeDefinition, { schema: externalSchema })
@@ -26,6 +27,7 @@ function build (context, compile, schemas) {
     return
   }
 
+  generateFluentSchema(context.schema)
   context.schema = schemas.resolveRefs(context.schema)
 
   const headers = context.schema.headers
@@ -66,6 +68,22 @@ function build (context, compile, schemas) {
   }
 }
 
+function generateFluentSchema (schema) {
+  ;['params', 'body', 'querystring', 'query', 'headers'].forEach(key => {
+    if (schema[key] && schema[key][kFluentSchema]) {
+      schema[key] = schema[key].valueOf()
+    }
+  })
+
+  if (schema.response) {
+    Object.keys(schema.response).forEach(code => {
+      if (schema.response[code][kFluentSchema]) {
+        schema.response[code] = schema.response[code].valueOf()
+      }
+    })
+  }
+}
+
 function validateParam (validatorFunction, request, paramName) {
   var ret = validatorFunction && validatorFunction(request[paramName])
   if (ret === false) return validatorFunction.errors
@@ -152,6 +170,7 @@ function buildSchemaCompiler (externalSchemas, cache) {
     useDefaults: true,
     removeAdditional: true,
     allErrors: true,
+    nullable: true,
     cache
   })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "2.4.1",
+  "version": "2.7.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -8,8 +8,8 @@
     "lint": "npm run lint:standard && npm run lint:typescript",
     "lint:standard": "standard --verbose | snazzy",
     "lint:typescript": "standard --parser @typescript-eslint/parser --plugin @typescript-eslint/eslint-plugin test/types/*.ts fastify.d.ts",
-    "unit": "tap -J test/*.test.js test/*/*.test.js",
-    "unit:report": "tap -J test/*.test.js test/*/*.test.js --cov --coverage-report=html --coverage-report=cobertura | tee out.tap",
+    "unit": "tap --no-esm -J test/*.test.js test/*/*.test.js",
+    "unit:report": "tap --no-esm -J test/*.test.js test/*/*.test.js --cov --coverage-report=html --coverage-report=cobertura | tee out.tap",
     "unit:junit": "tap-mocha-reporter xunit < out.tap > test/junit-testresults.xml",
     "typescript": "tsc --project ./test/types/tsconfig.json",
     "test:report": "npm run lint && npm run unit:report && npm run typescript",
@@ -88,25 +88,25 @@
     "node": ">=6"
   },
   "devDependencies": {
-    "@types/node": "^11.9.3",
-    "@typescript-eslint/eslint-plugin": "^1.4.2",
-    "@typescript-eslint/parser": "^1.4.2",
+    "@types/node": "^11.13.18",
+    "@typescript-eslint/eslint-plugin": "^1.13.0",
+    "@typescript-eslint/parser": "^1.13.0",
     "JSONStream": "^1.3.5",
     "ajv-pack": "^0.3.1",
     "autocannon": "^3.2.0",
     "branch-comparer": "^0.4.0",
-    "concurrently": "^4.1.0",
+    "concurrently": "^4.1.1",
     "cors": "^2.8.5",
-    "coveralls": "^3.0.3",
+    "coveralls": "^3.0.5",
     "dns-prefetch-control": "^0.2.0",
     "eslint-import-resolver-node": "^0.3.2",
     "fast-json-body": "^1.1.0",
     "fastify-plugin": "^1.5.0",
-    "fluent-schema": "^0.7.0",
-    "form-data": "^2.3.3",
+    "fluent-schema": "^0.7.3",
+    "form-data": "^2.5.0",
     "frameguard": "^3.0.0",
     "h2url": "^0.1.2",
-    "helmet": "^3.15.1",
+    "helmet": "^3.20.0",
     "hide-powered-by": "^1.0.0",
     "hsts": "^2.1.0",
     "http-errors": "^1.7.1",
@@ -115,31 +115,31 @@
     "license-checker": "^25.0.1",
     "lolex": "^4.0.1",
     "pre-commit": "^1.2.2",
-    "proxyquire": "^2.1.0",
+    "proxyquire": "^2.1.1",
     "pump": "^3.0.0",
-    "semver": "^6.0.0",
+    "semver": "^6.3.0",
     "send": "^0.17.0",
     "serve-static": "^1.13.2",
     "simple-get": "^3.0.3",
     "snazzy": "^8.0.0",
     "split2": "^3.1.0",
-    "standard": "^12.0.1",
+    "standard": "^13.0.1",
     "tap": "^12.5.2",
     "tap-mocha-reporter": "^3.0.7",
     "then-sleep": "^1.0.1",
-    "typescript": "^3.3.3333",
+    "typescript": "^3.5.3",
     "x-xss-protection": "^1.1.0"
   },
   "dependencies": {
     "abstract-logging": "^1.0.0",
-    "ajv": "^6.9.2",
+    "ajv": "^6.10.2",
     "avvio": "^6.1.1",
     "fast-json-stringify": "^1.15.0",
     "find-my-way": "^2.0.0",
     "flatstr": "^1.0.12",
-    "light-my-request": "^3.2.0",
+    "light-my-request": "^3.4.1",
     "middie": "^4.0.1",
-    "pino": "^5.11.1",
+    "pino": "^5.13.1",
     "proxy-addr": "^2.0.4",
     "readable-stream": "^3.1.1",
     "rfdc": "^1.1.2",
@@ -148,6 +148,7 @@
   },
   "greenkeeper": {
     "ignore": [
+      "autocannon",
       "boom",
       "joi",
       "@types/node",

package/test/async-await.js

@@ -419,7 +419,7 @@ function asyncTest (t) {
 
     var fastify = null
     var stream = split(JSON.parse)
-    var payload = { 'hello': 'world' }
+    var payload = { hello: 'world' }
     try {
       fastify = Fastify({
         logger: {

package/test/close-pipelining.test.js

@@ -28,8 +28,49 @@ test('Should return 503 while closing - pipelining', t => {
       t.strictEqual(statusCode, codes.shift())
     })
 
-    instance.on('done', () => t.end('Done'))
-    instance.on('reqError', () => t.deepEqual(codes.shift(), null))
+    instance.on('done', () => {
+      t.strictEqual(codes.length, 0)
+      t.end('Done')
+    })
+    instance.on('reqError', () => {
+      t.strictEqual(codes.shift(), undefined)
+    })
+    instance.on('error', err => t.fail(err))
+  })
+})
+
+test('Should not return 503 while closing - pipelining - return503OnClosing', t => {
+  const fastify = Fastify({
+    return503OnClosing: false
+  })
+
+  fastify.get('/', (req, reply) => {
+    fastify.close()
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    const instance = autocannon({
+      url: 'http://localhost:' + fastify.server.address().port,
+      pipelining: 1,
+      connections: 1,
+      amount: 10
+    })
+
+    const codes = [200, 200]
+    instance.on('response', (client, statusCode) => {
+      t.strictEqual(statusCode, codes.shift())
+    })
+
+    instance.on('done', () => {
+      t.strictEqual(codes.length, 0)
+      t.end('Done')
+    })
+    instance.on('reqError', () => {
+      t.strictEqual(codes.shift(), undefined)
+    })
     instance.on('error', err => t.fail(err))
   })
 })

package/test/close.test.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const net = require('net')
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
@@ -114,8 +115,8 @@ test('onClose should keep the context', t => {
   })
 })
 
-test('Should return 503 while closing - injection', t => {
-  t.plan(8)
+test('Should return error while closing - injection', t => {
+  t.plan(4)
   const fastify = Fastify()
 
   fastify.addHook('onClose', (instance, done) => {
@@ -139,17 +140,73 @@ test('Should return 503 while closing - injection', t => {
         method: 'GET',
         url: '/'
       }, (err, res) => {
-        t.error(err)
-        t.strictEqual(res.statusCode, 503)
-        t.strictEqual(res.headers['content-type'], 'application/json')
-        t.strictEqual(res.headers['content-length'], '80')
-        t.strictEqual(res.headers['connection'], 'close')
-        t.deepEqual(JSON.parse(res.payload), {
-          error: 'Service Unavailable',
-          message: 'Service Unavailable',
-          statusCode: 503
-        })
+        t.ok(err)
+        t.equal(err.message, 'Server is closed')
       })
     }, 100)
   })
 })
+
+t.test('Current opened connection should continue to work after closing and return "connection: close" header - return503OnClosing: false', t => {
+  const fastify = Fastify({
+    return503OnClosing: false
+  })
+
+  fastify.get('/', (req, reply) => {
+    fastify.close()
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    const port = fastify.server.address().port
+    const client = net.createConnection({ port: port }, () => {
+      client.write('GET / HTTP/1.1\r\n\r\n')
+
+      client.once('data', data => {
+        t.match(data.toString(), /Connection:\s*keep-alive/i)
+        t.match(data.toString(), /200 OK/i)
+
+        client.write('GET / HTTP/1.1\r\n\r\n')
+
+        client.once('data', data => {
+          t.match(data.toString(), /Connection:\s*close/i)
+          t.match(data.toString(), /200 OK/i)
+
+          // Test that fastify closes the TCP connection
+          client.once('close', () => {
+            t.end()
+          })
+        })
+      })
+    })
+  })
+})
+
+t.test('Current opened connection should not accept new incoming connections', t => {
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    fastify.close()
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen(0, err => {
+    t.error(err)
+
+    const port = fastify.server.address().port
+    const client = net.createConnection({ port: port }, () => {
+      client.write('GET / HTTP/1.1\r\n\r\n')
+
+      const newConnection = net.createConnection({ port: port })
+      newConnection.on('error', err => {
+        t.ok(err)
+        t.ok(['ECONNREFUSED', 'ECONNRESET'].includes(err.code))
+
+        client.end()
+        t.end()
+      })
+    })
+  })
+})

package/test/content-length.test.js

@@ -34,7 +34,7 @@ test('default 413 with bodyLimit option', t => {
   })
 })
 
-test('default 413 with wrong content-length', t => {
+test('default 400 with wrong content-length', t => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -102,7 +102,7 @@ test('custom 413 with bodyLimit option', t => {
   })
 })
 
-test('custom 413 with wrong content-length', t => {
+test('custom 400 with wrong content-length', t => {
   t.plan(4)
 
   const fastify = Fastify()

package/test/decorator.test.js

@@ -1,5 +1,7 @@
 'use strict'
 
+/* eslint no-prototype-builtins: 0 */
+
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')