fastify 3.6.0 → 3.7.0

package/docs/ContentTypeParser.md

@@ -30,7 +30,7 @@ fastify.addContentTypeParser('application/jsoff', async function (request, paylo
 })
 
 // Can use default JSON/Text parser for different content Types
-fastify.addContentTypeParser('text/json', { parseAs: 'string' }, fastify.getDefaultJsonParser('ignore', 'ignore')
+fastify.addContentTypeParser('text/json', { parseAs: 'string' }, fastify.getDefaultJsonParser('ignore', 'ignore'))
 ```
 
 You can also use the `hasContentTypeParser` API to find if a specific content type parser already exists.

package/docs/Ecosystem.md

@@ -17,6 +17,7 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-compress`](https://github.com/fastify/fastify-compress) Fastify compression utils.
 - [`fastify-cookie`](https://github.com/fastify/fastify-cookie) Parse and set cookie headers.
 - [`fastify-cors`](https://github.com/fastify/fastify-cors) Enables the use of CORS in a Fastify application.
+- [`fastify-csrf`](https://github.com/fastify/fastify-csrf) A plugin for adding [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery) protection to Fastify.
 - [`fastify-elasticsearch`](https://github.com/fastify/fastify-elasticsearch) Plugin to share the same ES client.
 - [`fastify-env`](https://github.com/fastify/fastify-env) Load and check configuration.
 - [`fastify-etag`](https://github.com/fastify/fastify-etag) Automatically generate etags for HTTP responses.
@@ -65,7 +66,6 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-cloudevents`](https://github.com/smartiniOnGitHub/fastify-cloudevents) Fastify plugin to generate and forward Fastify events in the Cloudevents format.
 - [`fastify-cockroachdb`](https://github.com/alex-ppg/fastify-cockroachdb) Fastify plugin to connect to a CockroachDB PostgreSQL instance via the Sequelize ORM.
 - [`fastify-couchdb`](https://github.com/nigelhanlon/fastify-couchdb) Fastify plugin to add CouchDB support via [nano](https://github.com/apache/nano).
-- [`fastify-csrf`](https://github.com/Tarang11/fastify-csrf) A csrf plugin for Fastify.
 - [`fastify-decorators`](https://github.com/L2jLiga/fastify-decorators) Fastify plugin that provides the set of TypeScript decorators.
 - [`fastify-dynamodb`](https://github.com/matrus2/fastify-dynamodb) AWS DynamoDB plugin for Fastify. It exposes [AWS.DynamoDB.DocumentClient()](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html) object.
 - [`fastify-dynareg`](https://github.com/greguz/fastify-dynareg) Dynamic plugin register for Fastify.

package/docs/Routes.md

@@ -51,7 +51,7 @@ They need to be in
 * `onSend(request, reply, payload, done)`: a [function](Hooks.md#route-hooks) called right before a response is sent, it could also be an array of functions.
 * `onResponse(request, reply, done)`: a [function](Hooks.md#onresponse) called when a response has been sent, so you will not be able to send more data to the client. It could also be an array of functions.
 * `handler(request, reply)`: the function that will handle this request. The [Fastify server](Server.md) will be bound to `this` when the handler is called. Note: using an arrow function will break the binding of `this`.
-* `errorHandler(error, request, reply)`: a custom error handler for the scope of the request. Overrides the default error global handler, and anything set by [`setErrorHandler`](Server.md#setErrorHandler), for requests to the route.
+* `errorHandler(error, request, reply)`: a custom error handler for the scope of the request. Overrides the default error global handler, and anything set by [`setErrorHandler`](Server.md#setErrorHandler), for requests to the route. To access the default handler, you can access `instance.errorHandler`. Note that this will point to fastify's default `errorHandler` only if a plugin hasn't overridden it already.
 * `validatorCompiler({ schema, method, url, httpPart })`: function that builds schemas for request validations. See the [Validation and Serialization](Validation-and-Serialization.md#schema-validator) documentation.
 * `serializerCompiler({ { schema, method, url, httpStatus } })`: function that builds schemas for response serialization. See the [Validation and Serialization](Validation-and-Serialization.md#schema-serializer) documentation.
 * `schemaErrorFormatter(errors, dataVar)`: function that formats the errors from the validation compiler. See the [Validation and Serialization](Validation-and-Serialization.md#error-handling) documentation. Overrides the global schema error formatter handler, and anything set by `setSchemaErrorFormatter`, for requests to the route.

package/docs/Server.md

@@ -850,7 +850,7 @@ fastify.setErrorHandler(function (error, request, reply) {
 })
 ```
 
-Fastify is provided with a default function that is called if no error handler is set and that logs the error with respect to its `statusCode`:
+Fastify is provided with a default function that is called if no error handler is set. It can be accessed using `fastify.errorHandler` and it logs the error with respect to its `statusCode`.
 
 ```js
 var statusCode = error.statusCode
@@ -901,14 +901,31 @@ fastify.addContentTypeParser('text/json', { asString: true }, fastify.getDefault
 
 
 <a name="defaultTextParser"></a>
-#### defaultTextParser 
+#### defaultTextParser
 
-`fastify.defaultTextParser()` can be used to parse content as plain text. 
+`fastify.defaultTextParser()` can be used to parse content as plain text.
 
 ```js
 fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser())
 ```
 
+<a name="errorHandler"></a>
+#### errorHandler
+
+`fastify.errorHandler` can be used to handle errors using fastify's default error handler.
+
+```js
+fastify.get('/', {
+  errorHandler: (error, request, reply) => {
+    if (error.code === 'SOMETHING_SPECIFIC') {
+      reply.send({ custom: 'response' })
+      return
+    }
+
+    fastify.errorHandler(error, request, response)
+  }
+}, handler)
+```
 
 <a name="initial-config"></a>
 #### initialConfig

package/fastify.js

@@ -26,7 +26,8 @@ const {
   kState,
   kOptions,
   kPluginNameChain,
-  kSchemaErrorFormatter
+  kSchemaErrorFormatter,
+  kErrorHandler
 } = require('./lib/symbols.js')
 
 const { createServer } = require('./lib/server')
@@ -58,6 +59,21 @@ const onBadUrlContext = {
   onError: []
 }
 
+function defaultErrorHandler (error, request, reply) {
+  if (reply.statusCode >= 500) {
+    reply.log.error(
+      { req: request, res: reply, err: error },
+      error && error.message
+    )
+  } else if (reply.statusCode >= 400) {
+    reply.log.info(
+      { res: reply, err: error },
+      error && error.message
+    )
+  }
+  reply.send(error)
+}
+
 function fastify (options) {
   // Options validations
   options = options || {}
@@ -161,6 +177,7 @@ function fastify (options) {
     [kSchemas]: schemas,
     [kValidatorCompiler]: null,
     [kSchemaErrorFormatter]: options.schemaErrorFormatter,
+    [kErrorHandler]: defaultErrorHandler,
     [kSerializerCompiler]: null,
     [kReplySerializerDefault]: null,
     [kContentTypeParser]: new ContentTypeParser(
@@ -274,6 +291,11 @@ function fastify (options) {
         }
         return version
       }
+    },
+    errorHandler: {
+      get () {
+        return this[kErrorHandler]
+      }
     }
   })
 
@@ -561,7 +583,7 @@ function fastify (options) {
   function setErrorHandler (func) {
     throwIfAlreadyStarted('Cannot call "setErrorHandler" when fastify instance is already started!')
 
-    this._errorHandler = func.bind(this)
+    this[kErrorHandler] = func.bind(this)
     return this
   }
 }

package/lib/context.js

@@ -17,7 +17,7 @@ function Context (schema, handler, Reply, Request, contentTypeParser, config, er
   this.preHandler = null
   this.onResponse = null
   this.config = config
-  this.errorHandler = errorHandler || defaultErrorHandler
+  this.errorHandler = errorHandler
   this._middie = null
   this._parserOptions = { limit: bodyLimit || null }
   this.logLevel = logLevel
@@ -28,21 +28,6 @@ function Context (schema, handler, Reply, Request, contentTypeParser, config, er
   this.schemaErrorFormatter = schemaErrorFormatter || defaultSchemaErrorFormatter
 }
 
-function defaultErrorHandler (error, request, reply) {
-  if (reply.statusCode >= 500) {
-    reply.log.error(
-      { req: request, res: reply, err: error },
-      error && error.message
-    )
-  } else if (reply.statusCode >= 400) {
-    reply.log.info(
-      { res: reply, err: error },
-      error && error.message
-    )
-  }
-  reply.send(error)
-}
-
 function defaultSchemaErrorFormatter (errors, dataVar) {
   var text = ''
   var separator = ', '

package/lib/errors.js

@@ -171,8 +171,8 @@ const codes = {
   /**
    * wrapThenable
    */
-  FST_ERR_PROMISE_NOT_FULLFILLED: createError(
-    'FST_ERR_PROMISE_NOT_FULLFILLED',
+  FST_ERR_PROMISE_NOT_FULFILLED: createError(
+    'FST_ERR_PROMISE_NOT_FULFILLED',
     "Promise may not be fulfilled with 'undefined' when statusCode is not 204"
   ),
 

package/lib/fourOhFour.js

@@ -15,7 +15,8 @@ const {
   kBodyLimit,
   kLogLevel,
   kFourOhFourContext,
-  kHooks
+  kHooks,
+  kErrorHandler
 } = require('./symbols.js')
 const { lifecycleHooks } = require('./hooks')
 const fourOhFourContext = {
@@ -28,7 +29,7 @@ const fourOhFourContext = {
 /**
  * Each fastify instance have a:
  * kFourOhFourLevelInstance: point to a fastify instance that has the 404 handler setted
- * kCanSetNotFoundHandler: bool to track if the 404 handler has alredy been set
+ * kCanSetNotFoundHandler: bool to track if the 404 handler has already been set
  * kFourOhFour: the singleton instance of this 404 module
  * kFourOhFourContext: the context in the reply object where the handler will be executed
  */
@@ -124,7 +125,7 @@ function fourOhFour (options) {
       this[kRequest],
       this[kContentTypeParser],
       opts.config || {},
-      this._errorHandler,
+      this[kErrorHandler],
       this[kBodyLimit],
       this[kLogLevel]
     )

package/lib/reply.js

@@ -303,9 +303,9 @@ Reply.prototype.getResponseTime = function () {
 // - https://github.com/fastify/fastify/issues/1864 for the discussions
 // - https://promisesaplus.com/ for the definition of thenable
 // - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then for the signature
-Reply.prototype.then = function (fullfilled, rejected) {
+Reply.prototype.then = function (fulfilled, rejected) {
   if (this.sent) {
-    fullfilled()
+    fulfilled()
     return
   }
 
@@ -317,7 +317,7 @@ Reply.prototype.then = function (fullfilled, rejected) {
         rejected(err)
       }
     } else {
-      fullfilled()
+      fulfilled()
     }
   })
 }

package/lib/route.js

@@ -40,7 +40,8 @@ const {
   kRequest,
   kRequestPayloadStream,
   kDisableRequestLogging,
-  kSchemaErrorFormatter
+  kSchemaErrorFormatter,
+  kErrorHandler
 } = require('./symbols.js')
 
 function buildRouting (options) {
@@ -213,7 +214,7 @@ function buildRouting (options) {
         this[kRequest],
         this[kContentTypeParser],
         config,
-        opts.errorHandler || this._errorHandler,
+        opts.errorHandler || this[kErrorHandler],
         opts.bodyLimit,
         opts.logLevel,
         opts.logSerializers,

package/lib/symbols.js

@@ -38,7 +38,8 @@ const keys = {
   kDisableRequestLogging: Symbol('fastify.disableRequestLogging'),
   kPluginNameChain: Symbol('fastify.pluginNameChain'),
   // This symbol is only meant to be used for fastify tests and should not be used for any other purpose
-  kTestInternals: Symbol('fastify.testInternals')
+  kTestInternals: Symbol('fastify.testInternals'),
+  kErrorHandler: Symbol('fastify.errorHandler')
 }
 
 module.exports = keys

package/lib/validation.js

@@ -97,6 +97,7 @@ function validate (context, request) {
 
 function wrapValidationError (result, dataVar, schemaErrorFormatter) {
   if (result instanceof Error) {
+    result.validationContext = result.validationContext || dataVar
     return result
   }
 

package/lib/wrapThenable.js

@@ -6,7 +6,7 @@ const {
   kReplySentOverwritten
 } = require('./symbols')
 
-const { FST_ERR_PROMISE_NOT_FULLFILLED } = require('./errors')
+const { FST_ERR_PROMISE_NOT_FULFILLED } = require('./errors')
 
 function wrapThenable (thenable, reply) {
   thenable.then(function (payload) {
@@ -27,7 +27,7 @@ function wrapThenable (thenable, reply) {
         reply.send(err)
       }
     } else if (reply[kReplySent] === false) {
-      reply.log.error({ err: new FST_ERR_PROMISE_NOT_FULLFILLED() }, "Promise may not be fulfilled with 'undefined' when statusCode is not 204")
+      reply.log.error({ err: new FST_ERR_PROMISE_NOT_FULFILLED() }, "Promise may not be fulfilled with 'undefined' when statusCode is not 204")
     }
   }, function (err) {
     if (reply[kReplySentOverwritten] === true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -138,7 +138,7 @@
     "eslint-plugin-standard": "^4.0.1",
     "events.once": "^2.0.2",
     "fast-json-body": "^1.1.0",
-    "fastify-plugin": "^2.1.0",
+    "fastify-plugin": "^3.0.0",
     "fluent-schema": "^1.0.0",
     "form-data": "^3.0.0",
     "frameguard": "^3.1.0",
@@ -176,7 +176,7 @@
     "fastify-warning": "^0.2.0",
     "find-my-way": "^3.0.0",
     "flatstr": "^1.0.12",
-    "light-my-request": "^4.1.0",
+    "light-my-request": "^4.2.0",
     "pino": "^6.2.1",
     "proxy-addr": "^2.0.5",
     "readable-stream": "^3.4.0",

package/test/emit-warning.test.js

@@ -3,6 +3,7 @@
 const sget = require('simple-get').concat
 const { test } = require('tap')
 const Fastify = require('..')
+const semver = require('semver')
 
 process.removeAllListeners('warning')
 
@@ -129,3 +130,33 @@ test('Should emit a warning when using payload less preParsing hook', t => {
     })
   })
 })
+
+if (semver.gte(process.versions.node, '13.0.0')) {
+  test('Should emit a warning when accessing request.connection instead of request.socket on Node process greater than 13.0.0', t => {
+    t.plan(4)
+
+    process.on('warning', onWarning)
+    function onWarning (warning) {
+      t.strictEqual(warning.name, 'FastifyDeprecation')
+      t.strictEqual(warning.code, 'FSTDEP005')
+      t.strictEqual(warning.message, 'You are accessing the deprecated "request.connection" property. Use "request.socket" instead.')
+
+      // removed listener before light-my-request emit second warning
+      process.removeListener('warning', onWarning)
+    }
+
+    const fastify = Fastify()
+
+    fastify.get('/', (request, reply) => {
+      reply.send(request.connection)
+    })
+
+    fastify.inject({
+      method: 'GET',
+      path: '/'
+    }, (err, res) => {
+      t.error(err)
+      process.removeListener('warning', onWarning)
+    })
+  })
+}

package/test/fastify-instance.test.js

@@ -4,7 +4,8 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('..')
 const {
-  kOptions
+  kOptions,
+  kErrorHandler
 } = require('../lib/symbols')
 
 test('root fastify instance is an object', t => {
@@ -65,3 +66,34 @@ test('fastify instance get invalid ajv options.plugins', t => {
     }
   }))
 })
+
+test('fastify instance should contain default errorHandler', t => {
+  t.plan(3)
+  const fastify = Fastify()
+  t.ok(fastify[kErrorHandler] instanceof Function)
+  t.same(fastify.errorHandler, fastify[kErrorHandler])
+  t.same(Object.getOwnPropertyDescriptor(fastify, 'errorHandler').set, undefined)
+})
+
+test('errorHandler in plugin should be separate from the external one', async t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, next) => {
+    const inPluginErrHandler = (_, __, reply) => {
+      reply.send({ plugin: 'error-object' })
+    }
+
+    instance.setErrorHandler(inPluginErrHandler)
+
+    t.notSame(instance.errorHandler, fastify.errorHandler)
+    t.equal(instance.errorHandler.name, 'bound inPluginErrHandler')
+
+    next()
+  })
+
+  await fastify.ready()
+
+  t.ok(fastify[kErrorHandler] instanceof Function)
+  t.same(fastify.errorHandler, fastify[kErrorHandler])
+})

package/test/types/instance.test-d.ts

@@ -16,9 +16,6 @@ expectAssignable<FastifyInstance>(server.addSchema({
 expectType<Record<string, unknown>>(server.getSchemas())
 expectType<unknown>(server.getSchema('SchemaId'))
 
-expectType<unknown>(server.use(() => {}))
-expectType<unknown>(server.use('/foo', () => {}))
-
 expectAssignable<FastifyInstance>(
   server.setErrorHandler(function (error, request, reply) {
     expectAssignable<FastifyInstance>(this)

package/test/types/register.test-d.ts

@@ -0,0 +1,16 @@
+import { expectAssignable, expectError } from 'tsd'
+import fastify, { FastifyInstance, FastifyPluginAsync } from '../../fastify'
+
+const testPluginOptsAsync: FastifyPluginAsync = async function (_instance, _opts) { }
+
+// Type validation
+expectError(fastify().register(testPluginOptsAsync, { prefix: 1 }))
+expectError(fastify().register(testPluginOptsAsync, { logLevel: () => ({}) }))
+expectError(fastify().register(testPluginOptsAsync, { logSerializers: () => ({}) }))
+expectError(fastify().register({}))
+
+expectAssignable<FastifyInstance>(
+  fastify().register(
+    testPluginOptsAsync, { prefix: '/example', logLevel: 'info', logSerializers: { key: (value: any) => `${value}` } }
+  )
+)

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

@@ -97,6 +97,72 @@ test('should be able to use setErrorHandler specify custom validation error', t
   })
 })
 
+test('error inside custom error handler should have validationContext', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema,
+    validatorCompiler: ({ schema, method, url, httpPart }) => {
+      return function (data) {
+        return { error: new Error('this failed') }
+      }
+    }
+  }, function (req, reply) {
+    t.fail('should not be here')
+    reply.code(200).send(req.body.name)
+  })
+
+  fastify.setErrorHandler(function (error, request, reply) {
+    t.strictEqual(error.validationContext, 'body')
+    reply.status(500).send(error)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      name: 'michelangelo',
+      work: 'artist'
+    },
+    url: '/'
+  }, () => {})
+})
+
+test('error inside custom error handler should have validationContext if specified by custom error handler', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema,
+    validatorCompiler: ({ schema, method, url, httpPart }) => {
+      return function (data) {
+        const error = new Error('this failed')
+        error.validationContext = 'customContext'
+        return { error: error }
+      }
+    }
+  }, function (req, reply) {
+    t.fail('should not be here')
+    reply.code(200).send(req.body.name)
+  })
+
+  fastify.setErrorHandler(function (error, request, reply) {
+    t.strictEqual(error.validationContext, 'customContext')
+    reply.status(500).send(error)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      name: 'michelangelo',
+      work: 'artist'
+    },
+    url: '/'
+  }, () => {})
+})
+
 test('should be able to attach validation to request', t => {
   t.plan(3)
 

package/types/instance.d.ts

@@ -59,13 +59,6 @@ export interface FastifyInstance<
 
   register: FastifyRegister<FastifyInstance<RawServer, RawRequest, RawReply, Logger> & PromiseLike<undefined>>;
 
-  /**
-   * This method will throw a `FST_ERR_MISSING_MIDDLEWARE` error unless support
-   * for Express-style middlewares is first enabled. Visit
-   * https://fastify.io/docs/latest/Middleware/ for more info.
-   */
-  use(...args: unknown[]): unknown;
-
   route<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault

package/types/register.d.ts

@@ -26,4 +26,5 @@ export type FastifyRegisterOptions<Options> = (RegisterOptions & Options) | (()
 interface RegisterOptions {
   prefix?: string;
   logLevel?: LogLevel;
+  logSerializers?: Record<string, (value: any) => string>;
 }