Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/onebeyond/error-handler-module
Error handler methods for Node.js app and express middlewares.
https://github.com/onebeyond/error-handler-module
error-handler express middleware-handlers
Last synced: 4 days ago
JSON representation
Error handler methods for Node.js app and express middlewares.
- Host: GitHub
- URL: https://github.com/onebeyond/error-handler-module
- Owner: onebeyond
- License: mit
- Created: 2019-10-28T10:43:41.000Z (about 5 years ago)
- Default Branch: master
- Last Pushed: 2023-07-19T10:45:49.000Z (over 1 year ago)
- Last Synced: 2024-11-07T07:36:05.953Z (12 days ago)
- Topics: error-handler, express, middleware-handlers
- Language: JavaScript
- Homepage: https://onebeyond.github.io/error-handler-module/
- Size: 998 KB
- Stars: 3
- Watchers: 11
- Forks: 3
- Open Issues: 5
-
Metadata Files:
- Readme: README.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
# error-handler-module
[](https://circleci.com/gh/guidesmiths/error-handler-module)
[](https://codeclimate.com/github/onebeyond/error-handler-module/maintainability)
[](https://codeclimate.com/github/onebeyond/error-handler-module/test_coverage)
This module provides a way to handle error in an express app with a few methods that creates error and an express error middleware `handleHttpError`.
1. [Installation](#Installation)
2. [Basic Error types](#Basic-Error-types)
3. [Methods](#methods)
- [errorFactory](#errorFactory)
- [handleHttpError](#handleHttpError)
- [tagError](#tagError)
4. [Implementation example](#Implementation-example)
5. [How to debug the errors](#Debug)
## Installation
```
npm install --save error-handler-module
```
## Basic Error types
We have setup some errors that we use often use in our projects and we store them in an object which is this:
```js
const CustomErrorTypes = {
BAD_REQUEST: 'bad_request',
FORBIDDEN: 'forbidden',
NOT_FOUND: 'not_found',
OAS_VALIDATOR: 'OpenAPIUtilsError:response',
SWAGGER_VALIDATOR: 'swagger_validator', // Deprecated
UNAUTHORIZED: 'unauthorized',
WRONG_INPUT: 'wrong_input',
};
```
*NOTE* If you need another kind of error keep reading on [tagError method](#tagError).
## Methods
### errorFactory(type: String) => (message: String)
This function creates a custom Error with a type and a message you decide.
**Example**
```js
const { errorFactory, CustomErrorTypes } = require('error-handler-module');
// With Basic Errors
const wrongInputError = errorFactory(CustomErrorTypes.WRONG_INPUT);
wrongInputError('Error message');
/* returns
CustomError {
name: 'CustomError',
type: 'wrong_input',
message: 'Error message'
}
*/
// with your custom types
// With Basic Errors
const customTypeError = errorFactory('custom-type');
customTypeError('Error message');
/* returns
CustomError {
name: 'CustomError',
type: 'custom-type',
message: 'Error message'
}
*/
```
### handleHttpError(logger: Object, metrics: Object) => (err, req, res, next)
This is a function which will work as a middleware for your express app so that your errors will response with an HTTP response.
You have to pass logger and metrics objects as parameters (*Metrics is **not required***).
**Example**
```js
const express = require('express');
const { handleHttpError } = require('error-handler-module');
const app = express();
app.use(handleHttpError(logger, metrics));
```
### tagError(error: Error, newTypes: Object)
This function is going to tag your errors from `CustomError` to `HTTPErrors`so that handleHttpError middleware will understand them.
It receives error and newTypes (*not required*)
*NewTypes object*
In order to add new error types, this object must match this structure:
```js
const newTypes = {
: ,
: ,
...
};
````
**Example**
```js
const { errorFactory } = require('error-handler-module');
// With Custom Errors
const customTypeError = errorFactory('tea-pot-error');
const error = customTypeError('Error message');
// const new Type
const newTypes = {
'tea-pot-error': 418,
};
tagError(error, newTypes);
/* This returns
CustomHTTPError {
name: 'CustomHTTPError',
statusCode: 418,
message: 'Error message',
extra: undefined
}
*/
// This tagError will be added to the catch of the enpoints like this
return next(tagError(error, newTypes))
// With Basic Errors
// With Custom Errors
const customTypeError = errorFactory(CustomErrorTypes.WRONG_INPUT);
const error = customTypeError('Error message');
tagError(error);
/* This returns
CustomHTTPError {
name: 'CustomHTTPError',
statusCode: 400,
message: 'Error message',
extra: undefined
}
*/
```
### Implementation example
```js
const express = require('express');
const {
CustomErrorTypes,
errorFactory,
handleHttpError,
tagError,
} = require('error-handler-module');
const app = express();
const loggerMock = {
error: () => '',
};
app.get('/test-error-basic', (req, res, next) => {
// creating tagged error
const wrongInputError = errorFactory(CustomErrorTypes.NOT_FOUND);
try {
throw wrongInputError('Wrong Input message');
} catch (error) {
return next(tagError(error));
}
});
app.get('/test-error-extended', (req, res, next) => {
// creating a custom tag error
// for example custom db-error
const dbError = errorFactory('db-access-not-allowed');
/*
* New types must be objects with error and a valid status code
*/
const newErrors = {
'db-access-not-allowed': 401,
};
try {
throw dbError('db Error');
} catch (error) {
return next(tagError(error, newErrors));
}
});
app.use(handleHttpError(loggerMock));
module.exports = app;
```
### Debug
This project uses Debug if you want more info of your error please run `DEBUG=error-handler-module `.