fastify 2.12.1 → 2.14.1

package/docs/Validation-and-Serialization.md

@@ -552,9 +552,9 @@ fastify.route({
   method: 'POST',
   url: '/',
   schema: {
-    body: ajv.getSchema('urn:schema:request').schema,
+    body: { $ref: 'urn:schema:request#' },
     response: {
-      '2xx': ajv.getSchema('urn:schema:response').schema
+      '2xx': { $ref: 'urn:schema:response#' }
     }
   },
   handler (req, reply) {
@@ -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.d.ts

@@ -8,6 +8,7 @@ import * as ajv from 'ajv'
 import * as http from 'http'
 import * as http2 from 'http2'
 import * as https from 'https'
+import * as LightMyRequest from 'light-my-request'
 
 declare function fastify<
   HttpServer extends (http.Server | http2.Http2Server) = http.Server,
@@ -36,6 +37,10 @@ declare namespace fastify {
 
   type HTTPMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'OPTIONS'
 
+  // // Keep the original name of the interfaces to avoid braking change
+  interface HTTPInjectOptions extends LightMyRequest.InjectOptions {}
+  interface HTTPInjectResponse extends LightMyRequest.Response {}
+
   interface ValidationResult {
     keyword: string;
     dataPath: string;
@@ -317,42 +322,6 @@ declare namespace fastify {
     logSerializers?: Object
   }
 
-  /**
-   * Fake http inject options
-   */
-  interface HTTPInjectOptions {
-    url: string,
-    method?: HTTPMethod,
-    authority?: string,
-    headers?: DefaultHeaders,
-    query?: DefaultQuery,
-    remoteAddress?: string,
-    payload?: string | object | Buffer | NodeJS.ReadableStream
-    simulate?: {
-      end?: boolean,
-      split?: boolean,
-      error?: boolean,
-      close?: boolean
-    },
-    validate?: boolean
-  }
-
-  /**
-   * Fake http inject response
-   */
-  interface HTTPInjectResponse {
-    raw: {
-      req: NodeJS.ReadableStream,
-      res: http.ServerResponse
-    },
-    headers: Record<string, string>,
-    statusCode: number,
-    statusMessage: string,
-    payload: string,
-    rawPayload: Buffer,
-    trailers: object
-  }
-
   /**
    * Server listen options
    */
@@ -685,6 +654,11 @@ declare namespace fastify {
      */
     inject(opts: HTTPInjectOptions | string): Promise<HTTPInjectResponse>
 
+    /**
+     * Useful for testing http requests without running a sever
+     */
+    inject(): LightMyRequest.Chain;
+
     /**
      * Set the 404 handler
      */

package/fastify.js

@@ -42,6 +42,11 @@ const { buildRouting, validateBodyLimitOption } = require('./lib/route')
 const build404 = require('./lib/fourOhFour')
 const getSecuredInitialConfig = require('./lib/initialConfigValidation')
 const { defaultInitOptions } = getSecuredInitialConfig
+const {
+  codes: {
+    FST_ERR_BAD_URL
+  }
+} = require('./lib/errors')
 
 function build (options) {
   // Options validations
@@ -73,6 +78,7 @@ function build (options) {
     customOptions: {},
     plugins: []
   }, options.ajv)
+  const frameworkErrors = options.frameworkErrors
 
   // Ajv options
   if (!ajvOptions.customOptions || Object.prototype.toString.call(ajvOptions.customOptions) !== '[object Object]') {
@@ -417,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}`)
   }
 
@@ -431,6 +441,20 @@ function build (options) {
   }
 
   function onBadUrl (path, req, res) {
+    if (frameworkErrors) {
+      req.id = genReqId(req)
+      req.originalUrl = req.url
+      var childLogger = logger.child({ reqId: req.id })
+      if (modifyCoreObjects) {
+        req.log = res.log = childLogger
+      }
+
+      childLogger.info({ req }, 'incoming request')
+
+      const request = new Request(null, req, null, req.headers, childLogger)
+      const reply = new Reply(res, { onSend: [], onError: [] }, request, childLogger)
+      return frameworkErrors(new FST_ERR_BAD_URL(path), request, reply)
+    }
     const body = `{"error":"Bad Request","message":"'${path}' is not a valid url component","statusCode":400}`
     res.writeHead(400, {
       'Content-Type': 'application/json',

package/lib/decorate.js

@@ -4,13 +4,15 @@
 
 const {
   kReply,
-  kRequest
+  kRequest,
+  kState
 } = require('./symbols.js')
 
 const {
   codes: {
     FST_ERR_DEC_ALREADY_PRESENT,
-    FST_ERR_DEC_MISSING_DEPENDENCY
+    FST_ERR_DEC_MISSING_DEPENDENCY,
+    FST_ERR_DEC_AFTER_START
   }
 } = require('./errors')
 
@@ -34,6 +36,7 @@ function decorate (instance, name, fn, dependencies) {
 }
 
 function decorateFastify (name, fn, dependencies) {
+  assertNotStarted(this, name)
   decorate(this, name, fn, dependencies)
   return this
 }
@@ -63,15 +66,23 @@ function checkDependencies (instance, deps) {
 }
 
 function decorateReply (name, fn, dependencies) {
+  assertNotStarted(this, name)
   decorate(this[kReply].prototype, name, fn, dependencies)
   return this
 }
 
 function decorateRequest (name, fn, dependencies) {
+  assertNotStarted(this, name)
   decorate(this[kRequest].prototype, name, fn, dependencies)
   return this
 }
 
+function assertNotStarted (instance, name) {
+  if (instance[kState].started) {
+    throw new FST_ERR_DEC_AFTER_START(name)
+  }
+}
+
 module.exports = {
   add: decorateFastify,
   exist: checkExistence,

package/lib/errors.js

@@ -27,6 +27,7 @@ createError('FST_ERR_CTP_EMPTY_JSON_BODY', "Body cannot be empty when content-ty
 */
 createError('FST_ERR_DEC_ALREADY_PRESENT', "The decorator '%s' has already been added!")
 createError('FST_ERR_DEC_MISSING_DEPENDENCY', "The decorator is missing dependency '%s'.")
+createError('FST_ERR_DEC_AFTER_START', "The decorator '%s' has been added after start!")
 
 /**
  * hooks
@@ -47,7 +48,7 @@ createError('FST_ERR_REP_ALREADY_SENT', 'Reply was already sent.')
 createError('FST_ERR_REP_SENT_VALUE', 'The only possible value for reply.sent is true.')
 createError('FST_ERR_SEND_INSIDE_ONERR', 'You cannot use `send` inside the `onError` hook')
 createError('FST_ERR_SEND_UNDEFINED_ERR', 'Undefined error has occured')
-createError('FST_ERR_BAD_STATUS_CODE', 'Called reply with malformed status code')
+createError('FST_ERR_BAD_STATUS_CODE', 'Called reply with an invalid status code: %s')
 
 /**
  * schemas
@@ -74,6 +75,11 @@ createError('FST_ERR_HTTP2_INVALID_VERSION', 'HTTP2 is available only from node
  */
 createError('FST_ERR_INIT_OPTS_INVALID', "Invalid initialization options: '%s'")
 
+/**
+ * router
+ */
+createError('FST_ERR_BAD_URL', "'%s' is not a valid url component", 400)
+
 function createError (code, message, statusCode = 500, Base = Error) {
   if (!code) throw new Error('Fastify error code must not be empty')
   if (!message) throw new Error('Fastify error message must not be empty')

package/lib/handleRequest.js

@@ -71,7 +71,10 @@ function handler (request, reply) {
 }
 
 function preValidationCallback (err, request, reply) {
-  if (reply.sent === true || reply.res.finished === true) return
+  if (reply.sent === true ||
+    reply.res.writableEnded === true ||
+    (reply.res.writable === false && reply.res.finished === true)) return
+
   if (err != null) {
     reply.send(err)
     return
@@ -102,7 +105,10 @@ function preValidationCallback (err, request, reply) {
 }
 
 function preHandlerCallback (err, request, reply) {
-  if (reply.sent || reply.res.finished === true) return
+  if (reply.sent ||
+    reply.res.writableEnded === true ||
+    (reply.res.writable === false && reply.res.finished === true)) return
+
   if (err != null) {
     reply.send(err)
     return
@@ -115,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')
@@ -198,11 +199,12 @@ Reply.prototype.headers = function (headers) {
 }
 
 Reply.prototype.code = function (code) {
-  if (statusCodes[code] === undefined) {
-    throw new FST_ERR_BAD_STATUS_CODE()
+  const intValue = parseInt(code)
+  if (isNaN(intValue) || intValue < 100 || intValue > 600) {
+    throw new FST_ERR_BAD_STATUS_CODE(String(code))
   }
 
-  this.res.statusCode = code
+  this.res.statusCode = intValue
   this[kReplyHasStatusCode] = true
   return this
 }
@@ -475,13 +477,13 @@ function handleError (reply, error, cb) {
   })
   flatstr(payload)
   reply[kReplyHeaders]['content-type'] = CONTENT_TYPE.JSON
+  reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
 
   if (cb) {
     cb(reply, payload)
     return
   }
 
-  reply[kReplyHeaders]['content-length'] = '' + Buffer.byteLength(payload)
   reply[kReplySent] = true
   res.writeHead(res.statusCode, reply[kReplyHeaders])
   res.end(payload)
@@ -568,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/lib/route.js

@@ -218,29 +218,6 @@ function buildRouting (options) {
         this[kReplySerializerDefault]
       )
 
-      // TODO this needs to be refactored so that buildSchemaCompiler is
-      // not called for every single route. Creating a new one for every route
-      // is going to be very expensive.
-      if (opts.schema) {
-        if (this[kSchemaCompiler] == null && this[kSchemaResolver]) {
-          done(new FST_ERR_SCH_MISSING_COMPILER(opts.method, url))
-          return
-        }
-
-        try {
-          if (opts.schemaCompiler == null && this[kSchemaCompiler] == null) {
-            const externalSchemas = this[kSchemas].getJsonSchemas({ onlyAbsoluteUri: true })
-            this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, this[kOptions].ajv, schemaCache))
-          }
-
-          buildSchema(context, opts.schemaCompiler || this[kSchemaCompiler], this[kSchemas], this[kSchemaResolver])
-        } catch (error) {
-          // bubble up the FastifyError instance
-          done(error.code ? error : new FST_ERR_SCH_BUILD(opts.method, url, error.message))
-          return
-        }
-      }
-
       for (const hook of supportedHooks) {
         if (opts[hook]) {
           if (Array.isArray(opts[hook])) {
@@ -280,6 +257,24 @@ function buildRouting (options) {
         // Must store the 404 Context in 'preReady' because it is only guaranteed to
         // be available after all of the plugins and routes have been loaded.
         fourOhFour.setContext(this, context)
+
+        if (opts.schema) {
+          if (this[kSchemaCompiler] == null && this[kSchemaResolver]) {
+            throw new FST_ERR_SCH_MISSING_COMPILER(opts.method, url)
+          }
+
+          try {
+            if (opts.schemaCompiler == null && this[kSchemaCompiler] == null) {
+              const externalSchemas = this[kSchemas].getJsonSchemas({ onlyAbsoluteUri: true })
+              this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, this[kOptions].ajv, schemaCache))
+            }
+
+            buildSchema(context, opts.schemaCompiler || this[kSchemaCompiler], this[kSchemas], this[kSchemaResolver])
+          } catch (error) {
+            // bubble up the FastifyError instance
+            throw (error.code ? error : new FST_ERR_SCH_BUILD(opts.method, url, error.message))
+          }
+        }
       })
 
       done(notHandledErr)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "2.12.1",
+  "version": "2.14.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -92,28 +92,30 @@
     "node": ">=6"
   },
   "devDependencies": {
-    "@types/node": "^12.12.17",
-    "@typescript-eslint/eslint-plugin": "^2.11.0",
-    "@typescript-eslint/parser": "^2.11.0",
+    "@types/node": "^12.12.30",
+    "@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",
     "branch-comparer": "^0.4.0",
-    "concurrently": "^5.0.1",
+    "concurrently": "^5.1.0",
     "cors": "^2.8.5",
-    "coveralls": "^3.0.9",
+    "coveralls": "^3.0.11",
     "dns-prefetch-control": "^0.2.0",
     "eslint": "^6.7.2",
-    "eslint-import-resolver-node": "^0.3.2",
+    "eslint-import-resolver-node": "^0.3.3",
     "events.once": "^2.0.2",
     "fast-json-body": "^1.1.0",
-    "fastify-plugin": "^1.5.0",
+    "fastify-plugin": "^1.6.1",
     "fluent-schema": "^0.10.0",
     "form-data": "^3.0.0",
     "frameguard": "^3.0.0",
     "h2url": "^0.2.0",
-    "helmet": "^3.20.0",
+    "helmet": "^3.21.3",
     "hide-powered-by": "^1.0.0",
     "hsts": "^2.1.0",
     "http-errors": "^1.7.1",
@@ -130,43 +132,30 @@
     "simple-get": "^3.0.3",
     "snazzy": "^8.0.0",
     "split2": "^3.1.0",
-    "standard": "^14.0.0",
+    "standard": "^14.3.3",
     "tap": "^12.5.2",
     "tap-mocha-reporter": "^3.0.7",
     "then-sleep": "^1.0.1",
-    "typescript": "^3.7.3",
+    "typescript": "^3.8.3",
     "x-xss-protection": "^1.1.0",
-    "yup": "^0.28.1"
+    "yup": "^0.28.3"
   },
   "dependencies": {
     "abstract-logging": "^2.0.0",
-    "ajv": "^6.10.2",
-    "avvio": "^6.3.0",
-    "fast-json-stringify": "^1.16.0",
-    "find-my-way": "^2.2.0",
+    "ajv": "^6.12.0",
+    "avvio": "^6.3.1",
+    "fast-json-stringify": "^1.18.0",
+    "find-my-way": "^2.2.2",
     "flatstr": "^1.0.12",
-    "light-my-request": "^3.7.0",
+    "light-my-request": "^3.7.3",
     "middie": "^4.1.0",
-    "pino": "^5.15.0",
-    "proxy-addr": "^2.0.4",
-    "readable-stream": "^3.1.1",
+    "pino": "^5.17.0",
+    "proxy-addr": "^2.0.6",
+    "readable-stream": "^3.6.0",
     "rfdc": "^1.1.2",
-    "secure-json-parse": "^2.0.0",
+    "secure-json-parse": "^2.1.0",
     "tiny-lru": "^7.0.2"
   },
-  "greenkeeper": {
-    "ignore": [
-      "autocannon",
-      "boom",
-      "joi",
-      "@types/node",
-      "semver",
-      "tap",
-      "tap-mocha-reporter",
-      "@typescript-eslint/eslint-plugin",
-      "lolex"
-    ]
-  },
   "standard": {
     "ignore": [
       "lib/configValidator.js"

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/content-length.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('../fastify')
+
+test('#2214 - wrong content-length', t => {
+  const fastify = Fastify()
+
+  fastify.get('/', async () => {
+    const error = new Error('MY_ERROR_MESSAGE')
+    error.headers = {
+      'content-length': 2
+    }
+    throw error
+  })
+
+  fastify.inject({
+    method: 'GET',
+    path: '/'
+  })
+    .then(response => {
+      t.strictEqual(response.headers['content-length'], '' + response.rawPayload.length)
+      t.end()
+    })
+})

package/test/content-length.test.js

@@ -3,6 +3,11 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
+const semver = require('semver')
+
+if (semver.gt(process.versions.node, '8.0.0')) {
+  require('./content-length')
+}
 
 test('default 413 with bodyLimit option', t => {
   t.plan(4)