Errors

Errors

Table of contents

• Errors
  • Error Handling In Node.js
    • Uncaught Errors
    • Catching Errors In Promises
  • Errors In Fastify
    • Errors In Input Data
    • Catching Uncaught Errors In Fastify
  • Errors In Fastify Lifecycle Hooks And A Custom Error Handler
  • Fastify Error Codes
    • FST_ERR_NOT_FOUND
    • FST_ERR_OPTIONS_NOT_OBJ
    • FST_ERR_QSP_NOT_FN
    • FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN
    • FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN
    • FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ
    • FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR
    • FST_ERR_CTP_ALREADY_PRESENT
    • FST_ERR_CTP_INVALID_TYPE
    • FST_ERR_CTP_EMPTY_TYPE
    • FST_ERR_CTP_INVALID_HANDLER
    • FST_ERR_CTP_INVALID_PARSE_TYPE
    • FST_ERR_CTP_BODY_TOO_LARGE
    • FST_ERR_CTP_INVALID_MEDIA_TYPE
    • FST_ERR_CTP_INVALID_CONTENT_LENGTH
    • FST_ERR_CTP_EMPTY_JSON_BODY
    • FST_ERR_CTP_INSTANCE_ALREADY_STARTED
    • FST_ERR_INSTANCE_ALREADY_LISTENING
    • FST_ERR_DEC_ALREADY_PRESENT
    • FST_ERR_DEC_DEPENDENCY_INVALID_TYPE
    • FST_ERR_DEC_MISSING_DEPENDENCY
    • FST_ERR_DEC_AFTER_START
    • FST_ERR_DEC_REFERENCE_TYPE
    • FST_ERR_HOOK_INVALID_TYPE
    • FST_ERR_HOOK_INVALID_HANDLER
    • FST_ERR_HOOK_INVALID_ASYNC_HANDLER
    • FST_ERR_HOOK_NOT_SUPPORTED
    • FST_ERR_MISSING_MIDDLEWARE
    • FST_ERR_HOOK_TIMEOUT
    • FST_ERR_LOG_INVALID_DESTINATION
    • FST_ERR_LOG_INVALID_LOGGER
    • FST_ERR_LOG_INVALID_LOGGER_INSTANCE
    • FST_ERR_LOG_INVALID_LOGGER_CONFIG
    • FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED
    • FST_ERR_REP_INVALID_PAYLOAD_TYPE
    • FST_ERR_REP_RESPONSE_BODY_CONSUMED
    • FST_ERR_REP_ALREADY_SENT
    • FST_ERR_REP_SENT_VALUE
    • FST_ERR_SEND_INSIDE_ONERR
    • FST_ERR_SEND_UNDEFINED_ERR
    • FST_ERR_BAD_STATUS_CODE
    • FST_ERR_BAD_TRAILER_NAME
    • FST_ERR_BAD_TRAILER_VALUE
    • FST_ERR_FAILED_ERROR_SERIALIZATION
    • FST_ERR_MISSING_SERIALIZATION_FN
    • FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN
    • FST_ERR_REQ_INVALID_VALIDATION_INVOCATION
    • FST_ERR_SCH_MISSING_ID
    • FST_ERR_SCH_ALREADY_PRESENT
    • FST_ERR_SCH_CONTENT_MISSING_SCHEMA
    • FST_ERR_SCH_DUPLICATE
    • FST_ERR_SCH_VALIDATION_BUILD
    • FST_ERR_SCH_SERIALIZATION_BUILD
    • FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX
    • FST_ERR_HTTP2_INVALID_VERSION
    • FST_ERR_INIT_OPTS_INVALID
    • FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE
    • FST_ERR_DUPLICATED_ROUTE
    • FST_ERR_BAD_URL
    • FST_ERR_ASYNC_CONSTRAINT
    • FST_ERR_INVALID_URL
    • FST_ERR_ROUTE_OPTIONS_NOT_OBJ
    • FST_ERR_ROUTE_DUPLICATED_HANDLER
    • FST_ERR_ROUTE_HANDLER_NOT_FN
    • FST_ERR_ROUTE_MISSING_HANDLER
    • FST_ERR_ROUTE_METHOD_INVALID
    • FST_ERR_ROUTE_METHOD_NOT_SUPPORTED
    • FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED
    • FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT
    • FST_ERR_ROUTE_REWRITE_NOT_STR
    • FST_ERR_REOPENED_CLOSE_SERVER
    • FST_ERR_REOPENED_SERVER
    • FST_ERR_PLUGIN_VERSION_MISMATCH
    • FST_ERR_PLUGIN_CALLBACK_NOT_FN
    • FST_ERR_PLUGIN_NOT_VALID
    • FST_ERR_ROOT_PLG_BOOTED
    • FST_ERR_PARENT_PLUGIN_BOOTED
    • FST_ERR_PLUGIN_TIMEOUT
    • FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE
    • FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER
    • FST_ERR_VALIDATION
    • FST_ERR_LISTEN_OPTIONS_INVALID
    • FST_ERR_ERROR_HANDLER_NOT_FN

Error Handling In Node.js

Uncaught Errors

In Node.js, uncaught errors are likely to cause memory leaks, file descriptor leaks, and other major production issues. Domains were a failed attempt to fix this.

Given that it is not possible to process all uncaught errors sensibly, the best way to deal with them is to crash.

Catching Errors In Promises

If you are using promises, you should attach a .catch() handler synchronously.

Errors In Fastify

Fastify follows an all-or-nothing approach and aims to be lean and optimal as much as possible. The developer is responsible for making sure that the errors are handled properly.

Errors In Input Data

Most errors are a result of unexpected input data, so we recommend validating your input data against a JSON schema.

Catching Uncaught Errors In Fastify

Fastify tries to catch as many uncaught errors as it can without hindering performance. This includes:

1. synchronous routes, e.g. app.get('/', () => { throw new Error('kaboom') })
2. async routes, e.g. app.get('/', async () => { throw new Error('kaboom') })

The error in both cases will be caught safely and routed to Fastify’s default error handler for a generic 500 Internal Server Error response.

To customize this behavior you should use setErrorHandler.

Errors In Fastify Lifecycle Hooks And A Custom Error Handler

From the Hooks documentation:

If you get an error during the execution of your hook, just pass it to done() and Fastify will automatically close the request and send the appropriate error code to the user.

When a custom error handler has been defined through setErrorHandler, the custom error handler will receive the error passed to the done() callback (or through other supported automatic error handling mechanisms). If setErrorHandler has been used multiple times to define multiple handlers, the error will be routed to the most precedent handler defined within the error encapsulation context. Error handlers are fully encapsulated, so a setErrorHandler call within a plugin will limit the error handler to that plugin’s context.

The root error handler is Fastify’s generic error handler. This error handler will use the headers and status code in the Error object, if they exist. The headers and status code will not be automatically set if a custom error handler is provided.

Some things to consider in your custom error handler:

• you can reply.send(data), which will behave as it would in regular route handlers

  • objects are serialized, triggering the preSerialization lifecycle hook if you have one defined
  • strings, buffers, and streams are sent to the client, with appropriate headers (no serialization)

• You can throw a new error in your custom error handler - errors (new error or the received error parameter re-thrown) - will call the parent errorHandler.

  • onError hook will be triggered once only for the first error being thrown.
  • an error will not be triggered twice from a lifecycle hook - Fastify internally monitors the error invocation to avoid infinite loops for errors thrown in the reply phases of the lifecycle. (those after the route handler)

When utilizing Fastify’s custom error handling through setErrorHandler, you should be aware of how errors are propagated between custom and default error handlers.

If a plugin’s error handler re-throws an error, and the error is not an instance of Error (as seen in the /bad route in the following example), it will not propagate to the parent context error handler. Instead, it will be caught by the default error handler.

To ensure consistent error handling, it is recommended to throw instances of Error. For instance, in the following example, replacing throw 'foo' with throw new Error('foo') in the /bad route ensures that errors propagate through the custom error handling chain as intended. This practice helps avoid potential pitfalls when working with custom error handling in Fastify.

For example:

const Fastify = require('fastify')
// Instantiate the framework
const fastify = Fastify({
  logger: true
})
// Register parent error handler
fastify.setErrorHandler((error, request, reply) => {
  reply.status(500).send({ ok: false })
})
fastify.register((app, options, next) => {
  // Register child error handler
  fastify.setErrorHandler((error, request, reply) => {
    throw error
  })
  fastify.get('/bad', async () => {
    // Throws a non-Error type, 'bar'
    throw 'foo'
  })
  fastify.get('/good', async () => {
    // Throws an Error instance, 'bar'
    throw new Error('bar')
  })
  next()
})
// Run the server
fastify.listen({ port: 3000 }, function (err, address) {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
  // Server is listening at ${address}
})

Fastify Error Codes

You can access errorCodes for mapping:

// ESM
import { errorCodes } from 'fastify'
// CommonJs
const errorCodes = require('fastify').errorCodes

For example:

const Fastify = require('fastify')
// Instantiate the framework
const fastify = Fastify({
  logger: true
})
// Declare a route
fastify.get('/', function (request, reply) {
  reply.code('bad status code').send({ hello: 'world' })
})
fastify.setErrorHandler(function (error, request, reply) {
  if (error instanceof Fastify.errorCodes.FST_ERR_BAD_STATUS_CODE) {
    // Log error
    this.log.error(error)
    // Send error response
    reply.status(500).send({ ok: false })
  } else {
    // fastify will use parent error handler to handle this
    reply.send(error)
  }
})
// Run the server!
fastify.listen({ port: 3000 }, function (err, address) {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
  // Server is now listening on ${address}
})

Below is a table with all the error codes that Fastify uses.