fastify 2.12.1 → 2.13.0

package/README.md

@@ -16,7 +16,7 @@
 <div align="center">
 
 [![NPM version](https://img.shields.io/npm/v/fastify.svg?style=flat)](https://www.npmjs.com/package/fastify)
-[![NPM downloads](https://img.shields.io/npm/dm/fastify.svg?style=flat)](https://www.npmjs.com/package/fastify) [![Gitter](https://badges.gitter.im/gitterHQ/gitter.svg)](https://gitter.im/fastify)
+[![NPM downloads](https://img.shields.io/npm/dm/fastify.svg?style=flat)](https://www.npmjs.com/package/fastify)
 [![Security Responsible
 Disclosure](https://img.shields.io/badge/Security-Responsible%20Disclosure-yellow.svg)](https://github.com/nodejs/security-wg/blob/master/processes/responsible_disclosure_template.md)
 
@@ -29,8 +29,47 @@ How can you efficiently handle the resources of your server, knowing that you ar
 
 Enter Fastify. Fastify is a web framework highly focused on providing the best developer experience with the least overhead and a powerful plugin architecture. It is inspired by Hapi and Express and as far as we know, it is one of the fastest web frameworks in town.
 
+### Quick start
+
+Create a folder and make it your current working directory:
+
+```
+mkdir my-app
+cd my-app
+```
+
+Generate a fastify project with `npm init`:
+
+```sh
+npm init fastify
+```
+
+Install dependencies:
+
+```js
+npm install
+```
+
+To start the app in dev mode:
+
+```sh
+npm run dev
+```
+
+For production mode:
+
+```sh
+npm start
+```
+
+Under the hood `npm init` downloads and runs [Fastify Create](https://github.com/fastify/fastify-create),
+which in turn uses the generate functionality of [Fastify CLI](https://github.com/fastify/fastify-cli).
+
+
 ### Install
 
+If installing in an existing project, then Fastify can be installed into the project as a dependency:
+
 Install with npm:
 ```
 npm i fastify --save
@@ -80,29 +119,6 @@ fastify.listen(3000, (err, address) => {
 
 Do you want to know more? Head to the <a href="https://github.com/fastify/fastify/blob/master/docs/Getting-Started.md"><code><b>Getting Started</b></code></a>.
 
-### Quick start with Fastify CLI
-
-Good tools make API development quicker and easier to maintain than doing everything manually.
-
-The [Fastify CLI](https://github.com/fastify/fastify-cli) is a command line interface tool that can create new projects, manage plugins, and perform a variety of development tasks testing and running the application.
-
-The goal in this guide is to build and run a simple Fastify project, using the [Fastify CLI](https://github.com/fastify/fastify-cli), while adhering to the Style Guide recommendations that benefit every Fastify project.
-
-### Example
-
-Open a terminal window.
-
-```
-npm install fastify-cli --global
-```
-
-Generate a new project and default app by running the following command:
-
-```
-fastify generate
-```
-
-For more information, see the [Fastify CLI documentation](https://github.com/fastify/fastify-cli).
 
 ### Fastify v1.x
 
@@ -176,8 +192,8 @@ matters to you.
 - [Live Examples](https://github.com/fastify/example) - Multirepo with a broad set of real working examples.
 
 ## Support
-- [Fastify help](https://github.com/fastify/help)
-- [Gitter Chat](https://gitter.im/fastify)
+Please visit [Fastify help](https://github.com/fastify/help) to view prior
+support issues and to ask new support questions.
 
 ## Team
 
@@ -191,6 +207,7 @@ Team members are listed in alphabetical order.
 ### Fastify Core team
 * [__Tommaso Allevi__](https://github.com/allevo), <https://twitter.com/allevitommaso>, <https://www.npmjs.com/~allevo>
 * [__Ethan Arrowood__](https://github.com/Ethan-Arrowood/), <https://twitter.com/arrowoodtech>, <https://www.npmjs.com/~ethan_arrowood>
+* [__David Mark Clements__](https://github.com/davidmarkclements), <https://twitter.com/davidmarkclem>, <https://www.npmjs.com/~davidmarkclements>
 * [__Matteo Collina__](https://github.com/mcollina), <https://twitter.com/matteocollina>, <https://www.npmjs.com/~matteo.collina>
 * [__Tomas Della Vedova__](https://github.com/delvedor), <https://twitter.com/delvedor>, <https://www.npmjs.com/~delvedor>
 * [__Dustin Deus__](https://github.com/StarpTech), <https://twitter.com/dustindeus>, <https://www.npmjs.com/~starptech>

package/docs/Decorators.md

@@ -2,22 +2,81 @@
 
 ## Decorators
 
-If you need to add functionality to the Fastify instance, the `decorate` API is what you want.
+The decorators API allows customization of the core Fastify objects, such as
+the server instance itself and any request and reply objects used during the
+HTTP request lifecycle. The decorators API can be used to attach any type of
+property to the core objects, e.g. functions, plain objects, or native types.
+
+This API is a *synchronous* API. Attempting to define a decoration
+asynchronously could result in the Fastify instance booting prior to the
+decoration completing its initialization. To avoid this issue, and register an
+asynchronous decoration, the `register` API, in combination with
+`fastify-plugin`, must be used instead. To learn more, see the
+[Plugins](Plugins.md) documentation.
+
+Decorating core objects with this API allows the underlying JavaScript engine
+to optimize handling of the server, request, and reply objects. This is
+accomplished by defining the shape of all such object instances before they are
+instantiated and used. As an example, the following is not recommended because
+it will change the shape of objects during their lifecycle:
 
-The API allows you to add new properties to the Fastify instance. Possible values are not restricted by type and could be functions, objects or strings, for example.
+```js
+// Bad example! Continue reading.
+
+// Attach a user property to the incoming request before the request
+// handler is invoked.
+fastify.addHook('preHandler', function (req, reply, done) {
+  req.user = 'Bob Dylan'
+  done()
+})
+
+// Use the attached user property in the request handler.
+fastify.get('/', function (req, reply) {
+  reply.send(`Hello, ${req.user}`)
+})
+```
+
+Since the above example mutates the request object after it has already
+been instantiated, the JavaScript engine must deoptimize access to the request
+object. By using the decoration API this deoptimization is avoided:
+
+```js
+// Decorate request with a 'user' property
+fastify.decorateRequest('user', '')
+
+// Update our property
+fastify.addHook('preHandler', (req, reply, done) => {
+  req.user = 'Bob Dylan'
+  done()
+})
+// And finally access it
+fastify.get('/', (req, reply) => {
+  reply.send(`Hello, ${req.user}!`)
+})
+```
+
+See
+[JavaScript engine fundamentals: Shapes and Inline Caches](https://web.archive.org/web/20200201163000/https://mathiasbynens.be/notes/shapes-ics)
+for more information on this topic.
 
-<a name="usage"></a>
 ### Usage
+<a name="usage"></a>
+
+#### `decorate(name, value, [dependencies])`
 <a name="decorate"></a>
-**decorate**
-Just call the `decorate` API and pass the name of the new property and its value.
+
+This method is used to customize the Fastify [server](Server.md) instance.
+
+For example, to attach a new method to the server instance:
+
 ```js
-fastify.decorate('utility', () => {
+fastify.decorate('utility', function () {
   // Something very useful
 })
 ```
 
-As mentioned above, you can also decorate the instance with non-function values:
+As mentioned above, non-function values can be attached:
+
 ```js
 fastify.decorate('conf', {
   db: 'some.db',
@@ -25,39 +84,95 @@ fastify.decorate('conf', {
 })
 ```
 
-Once the instance was decorated, you can access the new value by using the name you passed as a parameter:
+To access decorated properties, simply use the name provided to the
+decoration API:
+
 ```js
 fastify.utility()
 
 console.log(fastify.conf.db)
 ```
 
+The `dependencies` parameter is an optional list of decorators that the
+decorator being defined relies upon. This list is simply a list of string names
+of other decorators. In the following example, the "utility" decorator depends
+upon "greet" and "log" decorators:
+
+```js
+fastify.decorate('utility', fn, ['greet', 'log'])
+```
+
+If a dependency is not satisfied, the `decorate` method will throw an exception.
+The dependency check is peformed before the server instance is booted. Thus,
+it cannot occur during runtime.
+
+#### `decorateReply(name, value, [dependencies])`
 <a name="decorate-reply"></a>
-**decorateReply**
-As the name suggests, this API can be used to add new methods to the `Reply` core object. Just call the `decorateReply` API and pass the name of the new property and its value:
+
+As the name suggests, this API is used to add new methods/properties to the core
+`Reply` object:
+
 ```js
 fastify.decorateReply('utility', function () {
   // Something very useful
 })
 ```
 
-Note: using an arrow function will break the binding of `this` to the Fastify `Reply` instance.
+Note: using an arrow function will break the binding of `this` to the Fastify
+`Reply` instance.
 
+See [`decorate`](#decorate) for information about the `dependencies` parameter.
+
+#### `decorateRequest(name, value, [dependencies])`
 <a name="decorate-request"></a>
-**decorateRequest**
-As above, this API is needed if you want to add new methods to the `Request` core object. Just call the `decorateRequest` API and pass the name of the new property and its value:
+
+As above with [`decorateReply`](#decorate-reply), this API is used add new
+methods/properties to the core `Request` object:
+
 ```js
 fastify.decorateRequest('utility', function () {
   // something very useful
 })
 ```
 
-Note: using an arrow function will break the binding of `this` to the Fastify `Request` instance.
+Note: using an arrow function will break the binding of `this` to the Fastify
+`Request` instance.
+
+See [`decorate`](#decorate) for information about the `dependencies` parameter.
+
+#### `hasDecorator(name)`
+<a name="has-decorator"></a>
+
+Used to check for the existence of a server instance decoration:
+
+```js
+fastify.hasDecorator('utility')
+```
+
+#### hasRequestDecorator
+<a name="has-request-decorator"></a>
+
+Used to check for the existence of a Request decoration:
+
+```js
+fastify.hasRequestDecorator('utility')
+```
+
+#### hasReplyDecorator
+<a name="has-reply-decorator"></a>
+
+Used to check for the existence of a Reply decoration:
+
+```js
+fastify.hasReplyDecorator('utility')
+```
 
+### Decorators and Encapsulation
 <a name="decorators-encapsulation"></a>
-#### Decorators and Encapsulation
 
-If you define a decorator (using `decorate`, `decorateRequest` or `decorateReply`) with the same name more than once in the same **encapsulated** plugin, Fastify will throw an exception.
+Defining a decorator (using `decorate`, `decorateRequest` or `decorateReply`)
+with the same name more than once in the same **encapsulated** context will
+throw an exception.
 
 As an example, the following will throw:
 
@@ -107,10 +222,12 @@ server.register(async function (server, opts) {
 server.listen(3000)
 ```
 
+### Getters and Setters
 <a name="getters-setters"></a>
-#### Getters and Setters
 
-Decorators accept special "getter/setter" objects. These objects have functions named `getter` and `setter` (though, the `setter` function is optional). This allows defining properties via decorators. For example:
+Decorators accept special "getter/setter" objects. These objects have functions
+named `getter` and `setter` (though, the `setter` function is optional). This
+allows defining properties via decorators. For example:
 
 ```js
 fastify.decorate('foo', {
@@ -120,64 +237,8 @@ fastify.decorate('foo', {
 })
 ```
 
-Will define the `foo` property on the *Fastify* instance:
+Will define the `foo` property on the Fastify instance:
 
 ```js
 console.log(fastify.foo) // 'a getter'
 ```
-
-<a name="usage_notes"></a>
-#### Usage Notes
-`decorateReply` and `decorateRequest` are used to modify the `Reply` and `Request` constructors respectively by adding methods or properties. To update these properties you should directly access the desired property of the `Reply` or `Request` object.
-
-As an example let's add a user property to the `Request` object:
-
-```js
-// Decorate request with a 'user' property
-fastify.decorateRequest('user', '')
-
-// Update our property
-fastify.addHook('preHandler', (req, reply, done) => {
-  req.user = 'Bob Dylan'
-  done()
-})
-// And finally access it
-fastify.get('/', (req, reply) => {
-  reply.send(`Hello ${req.user}!`)
-})
-```
-Note: The usage of `decorateReply` and `decorateRequest` is optional in this case but will allow Fastify to optimize for performance.
-
-<a name="sync-async"></a>
-#### Sync and Async
-`decorate` is a *synchronous* API. If you need to add a decorator that has an *asynchronous* bootstrap, Fastify could boot up before your decorator is ready. To avoid this issue, you must use the `register` API in combination with `fastify-plugin`. To learn more, check out the [Plugins](https://github.com/fastify/fastify/blob/master/docs/Plugins.md) documentation as well.
-
-<a name="dependencies"></a>
-#### Dependencies
-If your decorator depends on another decorator, you can easily declare the other decorator as a dependency. You just need to add an array of strings (representing the names of the decorators on which yours depends) as the third parameter:
-```js
-fastify.decorate('utility', fn, ['greet', 'log'])
-```
-
-If a dependency is not satisfied, `decorate` will throw an exception, but don't worry: the dependency check is executed before the server boots up, so it won't ever happen at runtime.
-
-<a name="has-decorator"></a>
-#### hasDecorator
-You can check for the presence of a decorator with the `hasDecorator` API:
-```js
-fastify.hasDecorator('utility')
-```
-
-<a name="has-request-decorator"></a>
-#### hasRequestDecorator
-You can check for the presence of a Request decorator with the `hasRequestDecorator` API:
-```js
-fastify.hasRequestDecorator('utility')
-```
-
-<a name="has-reply-decorator"></a>
-#### hasReplyDecorator
-You can check for the presence of a Reply decorator with the `hasReplyDecorator` API:
-```js
-fastify.hasReplyDecorator('utility')
-```

package/docs/Errors.md

@@ -16,6 +16,11 @@ If routes are declared as `async` though - the error will safely be caught by th
 <a name="fastify-error-codes"></a>
 ### Fastify Error Codes
 
+<a name="FST_ERR_BAD_URL"></a>
+#### FST_ERR_BAD_URL
+
+The router received an invalid url.
+
 <a name="FST_ERR_CTP_ALREADY_PRESENT"></a>
 #### FST_ERR_CTP_ALREADY_PRESENT
 

package/docs/Reply.md

@@ -338,7 +338,7 @@ fastify.get('/async-await', options, async function (request, reply) {
 })
 ```
 
-Rejected promises default to a `500` HTTP status code. Reject the promise, or `throw` in an `async function`, with an object that has `statusCode` (or `status`) and `message` properties to modify the reply.
+Rejected promises default to a `500` HTTP status code. Reject the promise, or `throw` in an `async function`, with an _Error_ object that has `statusCode` (or `status`) and `message` properties to modify the reply. Throwing plain objects is not supported, it must be an instance of _Error_, see:
 
 ```js
 fastify.get('/teapot', async function (request, reply) => {

package/docs/Server.md

@@ -418,6 +418,30 @@ Set a default
 Note that this is needed to offer the graceful "close" experience when
 using http2. Node core defaults this to `0`.
 
+<a name="framework-errors"></a>
+### `frameworkErrors`
+
++ Default: `null`
+
+Fastify provides default error handlers for the most common use cases.
+Using this option it is possible to override one or more of those handlers with custom code.
+
+*Note: Only `FST_ERR_BAD_URL` is implemented at the moment.*
+
+```js
+const fastify = require('fastify')({
+  frameworkErrors: function (error, req, res) {
+    if (error instanceof FST_ERR_BAD_URL) {
+      res.code(400)
+      return res.send("Provided url is not valid")
+    } else {
+      res.send(err)
+    }
+  }
+})
+```
+
+
 ## Instance
 
 ### Server Methods

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
    */

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]') {
@@ -431,6 +437,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
@@ -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/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.13.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -92,28 +92,28 @@
     "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-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,28 +130,28 @@
     "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.2",
     "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": {

package/test/decorator.test.js

@@ -708,3 +708,35 @@ test('after can access to a decorated instance and previous plugin decoration',
       t.equal(response.statusCode, 200)
     })
 })
+
+test('decorate* should throw if called after ready', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.get('/', (request, reply) => {
+    reply.send({
+      hello: 'world'
+    })
+  })
+
+  fastify.listen(0)
+    .then(() => {
+      try {
+        fastify.decorate('test', true)
+      } catch (e) {
+        t.is(e.message, "FST_ERR_DEC_AFTER_START: The decorator 'test' has been added after start!")
+      }
+      try {
+        fastify.decorateRequest('test', true)
+      } catch (e) {
+        t.is(e.message, "FST_ERR_DEC_AFTER_START: The decorator 'test' has been added after start!")
+      }
+      try {
+        fastify.decorateReply('test', true)
+      } catch (e) {
+        t.is(e.message, "FST_ERR_DEC_AFTER_START: The decorator 'test' has been added after start!")
+      }
+      return fastify.close()
+    })
+    .catch(err => t.fail(err))
+})

package/test/internals/decorator.test.js

@@ -5,11 +5,19 @@
 const t = require('tap')
 const test = t.test
 const decorator = require('../../lib/decorate')
+const {
+  kState
+} = require('../../lib/symbols')
 
 test('decorate should add the given method to its instance', t => {
   t.plan(1)
   function build () {
     server.add = decorator.add
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
     return server
     function server () {}
   }
@@ -23,6 +31,11 @@ test('decorate is chainable', t => {
   t.plan(3)
   function build () {
     server.add = decorator.add
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
     return server
     function server () {}
   }
@@ -49,6 +62,11 @@ test('checkExistence should find the instance if not given', t => {
   function build () {
     server.add = decorator.add
     server.check = decorator.exist
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
     return server
     function server () {}
   }
@@ -83,6 +101,11 @@ test('decorate should internally call checkDependencies', t => {
   t.plan(2)
   function build () {
     server.add = decorator.add
+    server[kState] = {
+      listening: false,
+      closing: false,
+      started: false
+    }
     return server
     function server () {}
   }
@@ -101,7 +124,13 @@ test('decorate should internally call checkDependencies', t => {
 test('decorate should recognize getter/setter objects', t => {
   t.plan(6)
 
-  const one = {}
+  const one = {
+    [kState]: {
+      listening: false,
+      closing: false,
+      started: false
+    }
+  }
   decorator.add.call(one, 'foo', {
     getter: () => this._a,
     setter: (val) => {
@@ -115,7 +144,13 @@ test('decorate should recognize getter/setter objects', t => {
   t.is(one.foo, 'a')
 
   // getter only
-  const two = {}
+  const two = {
+    [kState]: {
+      listening: false,
+      closing: false,
+      started: false
+    }
+  }
   decorator.add.call(two, 'foo', {
     getter: () => 'a getter'
   })

package/test/route.test.js

@@ -7,7 +7,7 @@ const joi = require('joi')
 const Fastify = require('..')
 
 test('route', t => {
-  t.plan(10)
+  t.plan(9)
   const test = t.test
   const fastify = Fastify()
 
@@ -65,29 +65,6 @@ test('route', t => {
     }
   })
 
-  test('invalid schema - route', t => {
-    t.plan(1)
-    try {
-      fastify.route({
-        method: 'GET',
-        url: '/invalid',
-        schema: {
-          querystring: {
-            id: 'string'
-          }
-        },
-        handler: function (req, reply) {
-          reply.send({ hello: 'world' })
-        }
-      })
-      fastify.after(err => {
-        t.ok(err instanceof Error)
-      })
-    } catch (e) {
-      t.fail()
-    }
-  })
-
   test('Multiple methods', t => {
     t.plan(1)
     try {
@@ -190,6 +167,29 @@ test('route', t => {
   })
 })
 
+test('invalid schema - route', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.route({
+    handler: () => {},
+    method: 'GET',
+    url: '/invalid',
+    schema: {
+      querystring: {
+        id: 'string'
+      }
+    }
+  })
+  fastify.after(err => {
+    t.notOk(err, 'the error is throw on preReady')
+  })
+  fastify.ready(err => {
+    t.is(err.code, 'FST_ERR_SCH_BUILD')
+    t.isLike(err.message, /Failed building the schema for GET: \/invalid/)
+  })
+})
+
 test('path can be specified in place of uri', t => {
   t.plan(3)
   const fastify = Fastify()

package/test/router-options.test.js

@@ -3,6 +3,11 @@
 const test = require('tap').test
 const sget = require('simple-get')
 const Fastify = require('../')
+const {
+  codes: {
+    FST_ERR_BAD_URL
+  }
+} = require('../lib/errors')
 
 test('Should honor ignoreTrailingSlash option', t => {
   t.plan(4)
@@ -58,3 +63,32 @@ test('Should honor maxParamLength option', t => {
     t.strictEqual(res.statusCode, 404)
   })
 })
+
+test('Should honor frameworkErrors option', t => {
+  t.plan(3)
+  const fastify = Fastify({
+    frameworkErrors: function (err, req, res) {
+      if (err instanceof FST_ERR_BAD_URL) {
+        t.ok(true)
+      } else {
+        t.fail()
+      }
+      res.send(err.message)
+    }
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/%world'
+    },
+    (err, res) => {
+      t.error(err)
+      t.equals(res.body, 'FST_ERR_BAD_URL: \'%world\' is not a valid url component')
+    }
+  )
+})

package/test/schemas.test.js

@@ -3,6 +3,7 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
+const fp = require('fastify-plugin')
 
 const ajvMergePatch = require('ajv-merge-patch')
 const AJV = require('ajv')
@@ -448,3 +449,32 @@ test('Should handle root $patch keywords in header', t => {
     })
   })
 })
+
+test('Add schema order should not break the startup', t => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.get('/', { schema: { random: 'options' } }, () => {})
+
+  fastify.register(fp((f, opts) => {
+    f.addSchema({
+      $id: 'https://example.com/bson/objectId',
+      type: 'string',
+      pattern: '\\b[0-9A-Fa-f]{24}\\b'
+    })
+    return Promise.resolve() // avoid async for node 6
+  }))
+
+  fastify.get('/:id', {
+    schema: {
+      params: {
+        type: 'object',
+        properties: {
+          id: { $ref: 'https://example.com/bson/objectId#' }
+        }
+      }
+    }
+  }, () => {})
+
+  fastify.ready(err => { t.error(err) })
+})

package/test/types/index.ts

@@ -6,6 +6,7 @@ import * as fastify from '../../fastify'
 import * as http from 'http'
 import * as http2 from 'http2'
 import { readFileSync } from 'fs'
+import * as LightMyRequest from 'light-my-request'
 
 // were importing cors using require, which causes it to be an `any`. This is done because `cors` exports
 // itself as an express.RequestHandler which is not compatible with the fastify TypeScript types
@@ -609,11 +610,20 @@ server.listen({
 }).then((address: string) => console.log(address))
 
 // http injections
+server.inject({ url: '/test' }, (err: Error, res: LightMyRequest.Response) => {
+  server.log.debug(err)
+  server.log.debug(res.payload)
+})
+
+// http injections with the fastify types
 server.inject({ url: '/test' }, (err: Error, res: fastify.HTTPInjectResponse) => {
   server.log.debug(err)
   server.log.debug(res.payload)
 })
 
+server.inject({ url: '/testAgain' })
+  .then((res: LightMyRequest.Response) => console.log(res.payload))
+
 server.inject({ url: '/testAgain' })
   .then((res: fastify.HTTPInjectResponse) => console.log(res.payload))