fastify 2.14.0 → 2.14.1

package/docs/Recommendations.md

@@ -67,6 +67,10 @@ defaults
   option        dontlognull
   retries       3
   option redispatch
+  # The following option make haproxy close connections to backend servers
+  # instead of keeping them open. This can alleviate unexpected connection
+  # reset errors in the Node process.
+  option http-server-close
   maxconn       2000
   timeout connect 5000
   timeout client 50000

package/docs/Reply.md

@@ -147,7 +147,8 @@ reply.code(303).redirect(302, '/home')
 
 <a name="call-not-found"></a>
 ### .callNotFound()
-Invokes the custom not found handler.
+Invokes the custom not found handler. Note that it will only call `preHandler` hook specified in [`setNotFoundHandler`](https://github.com/fastify/fastify/blob/master/docs/Server.md#set-not-found-handler).
+
 ```js
 reply.callNotFound()
 ```

package/docs/Server.md

@@ -720,6 +720,8 @@ This property can be used to set the schema compiler, it is a shortcut for the `
 
 You can also register a [`preValidation`](https://www.fastify.io/docs/latest/Hooks/#route-hooks) and [preHandler](https://www.fastify.io/docs/latest/Hooks/#route-hooks) hook for the 404 handler.
 
+_Note: The `preValidation` hook registered using this method will run for a route that Fastify does not recognize and **not** when a route handler manually calls [`reply.callNotFound`](https://github.com/fastify/fastify/blob/master/docs/Reply.md#call-not-found)_. In which case only preHandler will be run.
+
 ```js
 fastify.setNotFoundHandler({
   preValidation: (req, reply, done) => {

package/docs/Validation-and-Serialization.md

@@ -658,7 +658,91 @@ fastify.setErrorHandler(function (error, request, reply) {
 })
 ```
 
-If you want custom error response in schema without headaches and quickly, you can take a look at [here](https://github.com/epoberezkin/ajv-errors)
+If you want custom error response in schema without headaches and quickly, you can take a look at [`ajv-errors`](https://github.com/epoberezkin/ajv-errors). Checkout the [example](https://github.com/fastify/example/blob/master/validation-messages/custom-errors-messages.js) usage.
+
+Below is an example showing how to add **custom error messages for each property** of a schema by supplying custom AJV options.
+Inline comments in the schema below describe how to configure it to show a different error message for each case:
+
+```js
+const fastify = Fastify({
+  ajv: {
+    customOptions: { allErrors: true, jsonPointers: true },
+    plugins: [
+      require('ajv-errors')
+    ]
+  }
+})
+
+const schema = {
+  body: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+        errorMessage: {
+          type: 'Bad name'
+        }
+      },
+      age: {
+        type: 'number',
+        errorMessage: {
+          type: 'Bad age', // specify custom message for
+          min: 'Too young' // all constraints except required
+        }
+      }
+    },
+    required: ['name', 'age'],
+    errorMessage: {
+      required: {
+        name: 'Why no name!', // specify error message for when the
+        age: 'Why no age!' // property is missing from input
+      }
+    }
+  }
+}
+
+fastify.post('/', { schema, }, (request, reply) => {
+  reply.send({
+    hello: 'world'
+  })
+})
+```
+
+If you want to return localized error messages, take a look at [ajv-i18n](https://github.com/epoberezkin/ajv-i18n)
+
+```js
+const localize = require('ajv-i18n')
+
+const fastify = Fastify({
+  ajv: {
+    customOptions: { allErrors: true }
+  }
+})
+
+const schema = {
+  body: {
+    type: 'object',
+    properties: {
+      name: {
+        type: 'string',
+      },
+      age: {
+        type: 'number',
+      }
+    },
+    required: ['name', 'age'],
+  }
+}
+
+fastify.setErrorHandler(function (error, request, reply) {
+  if (error.validation) {
+    localize.ru(error.validation)
+    reply.status(400).send(error.validation)
+    return
+  }
+  reply.send(error)
+})
+```
 
 ### JSON Schema and Shared Schema support
 

package/fastify.js

@@ -423,7 +423,11 @@ function build (options) {
       message: 'Client Error',
       statusCode: 400
     })
-    logger.debug({ err }, 'client error')
+
+    // Most devs do not know what to do with this error.
+    // In the vast majority of cases, it's a network error and/or some
+    // config issue on the the load balancer side.
+    logger.trace({ err }, 'client error')
     socket.end(`HTTP/1.1 400 Bad Request\r\nContent-Length: ${body.length}\r\nContent-Type: application/json\r\n\r\n${body}`)
   }
 

package/lib/handleRequest.js

@@ -121,4 +121,4 @@ function preHandlerCallback (err, request, reply) {
 }
 
 module.exports = handleRequest
-module.exports[Symbol.for('internals')] = { handler }
+module.exports[Symbol.for('internals')] = { handler, preHandlerCallback }

package/lib/reply.js

@@ -18,10 +18,11 @@ const {
   kReplyIsRunningOnErrorHook,
   kDisableRequestLogging
 } = require('./symbols.js')
-const { hookRunner, onSendHookRunner } = require('./hooks')
+const { hookRunner, hookIterator, onSendHookRunner } = require('./hooks')
 const validation = require('./validation')
 const serialize = validation.serialize
 
+const internals = require('./handleRequest')[Symbol.for('internals')]
 const loggerUtils = require('./logger')
 const now = loggerUtils.now
 const wrapThenable = require('./wrapThenable')
@@ -569,7 +570,19 @@ function notFound (reply) {
   }
 
   reply.context = reply.context[kFourOhFourContext]
-  reply.context.handler(reply.request, reply)
+
+  // preHandler hook
+  if (reply.context.preHandler !== null) {
+    hookRunner(
+      reply.context.preHandler,
+      hookIterator,
+      reply.request,
+      reply,
+      internals.preHandlerCallback
+    )
+  } else {
+    internals.preHandlerCallback(null, reply.request, reply)
+  }
 }
 
 function noop () {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "2.14.0",
+  "version": "2.14.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -96,6 +96,8 @@
     "@typescript-eslint/eslint-plugin": "^2.24.0",
     "@typescript-eslint/parser": "^2.24.0",
     "JSONStream": "^1.3.5",
+    "ajv-errors": "^1.0.1",
+    "ajv-i18n": "^3.5.0",
     "ajv-merge-patch": "^4.1.0",
     "ajv-pack": "^0.3.1",
     "autocannon": "^3.2.2",

package/test/404s.test.js

@@ -1290,7 +1290,7 @@ test('onSend hooks run when an encapsulated route invokes the notFound handler',
 
 // https://github.com/fastify/fastify/issues/713
 test('preHandler option for setNotFoundHandler', t => {
-  t.plan(8)
+  t.plan(10)
 
   t.test('preHandler option', t => {
     t.plan(2)
@@ -1316,6 +1316,69 @@ test('preHandler option for setNotFoundHandler', t => {
     })
   })
 
+  // https://github.com/fastify/fastify/issues/2229
+  t.test('preHandler hook in setNotFoundHandler should be called when callNotFound', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    fastify.setNotFoundHandler({
+      preHandler: (req, reply, done) => {
+        req.body.preHandler = true
+        done()
+      }
+    }, function (req, reply) {
+      reply.code(404).send(req.body)
+    })
+
+    fastify.post('/', function (req, reply) {
+      reply.callNotFound()
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      payload: { hello: 'world' }
+    }, (err, res) => {
+      t.error(err)
+      var payload = JSON.parse(res.payload)
+      t.deepEqual(payload, { preHandler: true, hello: 'world' })
+    })
+  })
+
+  t.test('preHandler hook in setNotFoundHandler should accept an array of functions and be called when callNotFound', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    fastify.setNotFoundHandler({
+      preHandler: [
+        (req, reply, done) => {
+          req.body.preHandler1 = true
+          done()
+        },
+        (req, reply, done) => {
+          req.body.preHandler2 = true
+          done()
+        }
+      ]
+    }, function (req, reply) {
+      reply.code(404).send(req.body)
+    })
+
+    fastify.post('/', function (req, reply) {
+      reply.callNotFound()
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      payload: { hello: 'world' }
+    }, (err, res) => {
+      t.error(err)
+      var payload = JSON.parse(res.payload)
+      t.deepEqual(payload, { preHandler1: true, preHandler2: true, hello: 'world' })
+    })
+  })
+
   t.test('preHandler option should be called after preHandler hook', t => {
     t.plan(2)
     const fastify = Fastify()

package/test/validation-error-handling.test.js

@@ -2,6 +2,7 @@
 
 const t = require('tap')
 const Joi = require('joi')
+const localize = require('ajv-i18n')
 const Fastify = require('..')
 const test = t.test
 
@@ -65,6 +66,105 @@ test('should fail immediately with invalid payload', t => {
   })
 })
 
+test('should return custom error messages with ajv-errors', t => {
+  t.plan(3)
+
+  const fastify = Fastify({
+    ajv: {
+      customOptions: { allErrors: true, jsonPointers: true },
+      plugins: [
+        require('ajv-errors')
+      ]
+    }
+  })
+
+  const schema = {
+    body: {
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        work: { type: 'string' },
+        age: {
+          type: 'number',
+          errorMessage: {
+            type: 'bad age - should be num'
+          }
+        }
+      },
+      required: ['name', 'work'],
+      errorMessage: {
+        required: {
+          name: 'name please',
+          work: 'work please',
+          age: 'age please'
+        }
+      }
+    }
+  }
+
+  fastify.post('/', { schema }, function (req, reply) {
+    reply.code(200).send(req.body.name)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      hello: 'salman',
+      age: 'bad'
+    },
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.deepEqual(JSON.parse(res.payload), {
+      statusCode: 400,
+      error: 'Bad Request',
+      message: 'body/age bad age - should be num, body name please, body work please'
+    })
+    t.strictEqual(res.statusCode, 400)
+  })
+})
+
+test('should return localized error messages with ajv-i18n', t => {
+  t.plan(3)
+
+  const fastify = Fastify({
+    ajv: {
+      customOptions: { allErrors: true }
+    }
+  })
+
+  fastify.setErrorHandler(function (error, request, reply) {
+    if (error.validation) {
+      localize.ru(error.validation)
+      reply.status(400).send(error.validation)
+      return
+    }
+    reply.send(error)
+  })
+
+  fastify.post('/', { schema }, function (req, reply) {
+    reply.code(200).send(req.body.name)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      name: 'salman'
+    },
+    url: '/'
+  }, (err, res) => {
+    t.error(err)
+    t.deepEqual(JSON.parse(res.payload), [{
+      dataPath: '',
+      keyword: 'required',
+      message: 'должно иметь обязательное поле work',
+      params: { missingProperty: 'work' },
+      schemaPath: '#/required'
+    }])
+    t.strictEqual(res.statusCode, 400)
+  })
+})
+
 test('should be able to use setErrorHandler specify custom validation error', t => {
   t.plan(3)