fastify-error - GitLite

KO | EN

gitlite — search

#python #react #ai #llm #android #machine-learning #rust #linux #docker #nodejs #java #cli #kubernetes #vue

fastify-error

(★ 135)

A small utility, used by Fastify itself, for generating consistent error objects across your codebase and plugins

File Explorer

Download Latest Version (.zip)

- - ci.yml
  - lock-threads.yml
- dependabot.yml
- create.js
- instantiate.js
- no-stack.js
- toString.js
- index.test.js
- instanceof.test.js
- index.d.ts
- index.tst.ts
.gitattributes
.gitignore
.npmrc
eslint.config.js
index.js
LICENSE
package.json
README.md

# Installation Guide

1. Get the code

git clone https://github.com/fastify/fastify-error

Downloads the entire project code from GitHub to your computer.

cd fastify-error

Moves into the project folder you just downloaded.

2. Node.js

Easy Recommended

Prerequisites

Git Needed to download the project code from GitHub.
Node.js Node.js must be installed to use npm. The LTS version is recommended.

npm i @fastify/error

Type this command into your terminal and run it.

✅ After running the command, open the address shown in the terminal (usually something like http://localhost:3000) in your browser.

Pulled directly from this repo's README.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# @fastify/error

[![CI](https://github.com/fastify/fastify-error/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/fastify/fastify-error/actions/workflows/ci.yml)
[![NPM version](https://img.shields.io/npm/v/@fastify/error.svg?style=flat)](https://www.npmjs.com/package/@fastify/error)
[![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)

A small utility, used by Fastify itself, for generating consistent error objects across your codebase and plugins.

### Install
```
npm i @fastify/error
```

### Usage

The module exports a function that you can use for consistent error objects, it takes 4 parameters:

```js
createError(code, message [, statusCode [, Base [, captureStackTrace]]])
```

- `code` (`string`, required) - The error code, you can access it later with `error.code`. For consistency, we recommend prefixing plugin error codes with `FST_`
- `message` (`string`, required) - The error message. You can also use interpolated strings for formatting the message.
- `statusCode` (`number`, optional) - The status code that Fastify will use if the error is sent via HTTP.
- `Base` (`ErrorConstructor`, optional) - The base error object that will be used. (eg `TypeError`, `RangeError`)
- `captureStackTrace` (`boolean`, optional) - Whether to capture the stack trace or not.

```js
const createError = require('@fastify/error')
const CustomError = createError('ERROR_CODE', 'Hello')
console.log(new CustomError()) // error.message => 'Hello'
```

How to use an interpolated string:
```js
const createError = require('@fastify/error')
const CustomError = createError('ERROR_CODE', 'Hello %s')
console.log(new CustomError('world')) // error.message => 'Hello world'
```

How to add cause:
```js
const createError = require('@fastify/error')
const CustomError = createError('ERROR_CODE', 'Hello %s')
console.log(new CustomError('world', {cause: new Error('cause')}))
// error.message => 'Hello world'
// error.cause => Error('cause')
```

### TypeScript

It is possible to limit your error constructor with a generic type using TypeScript:

```ts
const CustomError = createError<[string]>('ERROR_CODE', 'Hello %s')
new CustomError('world')
//@ts-expect-error
new CustomError(1)
```

### instanceof

All errors created with `createError` will be instances of the base error constructor you provided, or `Error` if none was provided.

```js
const createError = require('@fastify/error')
const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
const customError = new CustomError('world')

console.log(customError instanceof CustomError) // true
console.log(customError instanceof TypeError) // true
console.log(customError instanceof Error) // true
```

All instantiated errors are instances of the `FastifyError` class, which can be required directly from the module.

```js
const { createError, FastifyError } = require('@fastify/error')
const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
const customError = new CustomError('world')

console.log(customError instanceof FastifyError) // true
```

A `FastifyError` created by `createError` can extend another `FastifyError` while maintaining correct `instanceof` behavior.

```js
const { createError, FastifyError } = require('@fastify/error')

const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
const ChildCustomError = createError('CHILD_ERROR_CODE', 'Hello %s', 500, CustomError)

const customError = new ChildCustomError('world')

console.log(customError instanceof ChildCustomError) // true
console.log(customError instanceof CustomError) // true
console.log(customError instanceof FastifyError) // true
console.log(customError instanceof TypeError) // true
console.log(customError instanceof Error) // true
```

If `fastify-error` is installed multiple times directly or as a transitive dependency, `instanceof` checks for errors created by `createError` will still work correctly across these installations, as long as their error codes (e.g., `FST_ERR_CUSTOM_ERROR`) are identical.

```js
const { createError, FastifyError } = require('@fastify/error')

// CustomError from `@fastify/some-plugin` is created with `createError` and
// has its own `@fastify/error` installation as dependency. CustomError has
// FST_ERR_CUSTOM_ERROR as code.
const { CustomError: CustomErrorFromPlugin } = require('@fastify/some-plugin')

const CustomError = createError('FST_ERR_CUSTOM_ERROR', 'Hello %s', 500)

const customError = new CustomError('world')
const customErrorFromPlugin = new CustomErrorFromPlugin('world')

console.log(customError instanceof CustomError) // true
console.log(customError instanceof CustomErrorFromPlugin) // true
console.log(customErrorFromPlugin instanceof CustomError) // true
console.log(customErrorFromPlugin instanceof CustomErrorFromPlugin) // true
```

Changing the code of an instantiated Error will not change the result of the `instanceof` operator.

```js
const { createError, FastifyError } = require('@fastify/error')

const CustomError = createError('ERROR_CODE', 'Hello %s', 500, TypeError)
const AnotherCustomError = createError('ANOTHER_ERROR_CODE', 'Hello %s', 500, CustomError)

const customError = new CustomError('world')
customError.code = 'ANOTHER_ERROR_CODE'

console.log(customError instanceof CustomError) // true
console.log(customError instanceof AnotherCustomError) // false
```

## License

Licensed under [MIT](./LICENSE).