https://github.com/nickuraltsev/composite-error
Error wrapping in Node.js
https://github.com/nickuraltsev/composite-error
error-handling error-wrapping errors inner-errors stack-traces
Last synced: 3 months ago
JSON representation
Error wrapping in Node.js
- Host: GitHub
- URL: https://github.com/nickuraltsev/composite-error
- Owner: nickuraltsev
- License: mit
- Created: 2015-06-13T18:32:56.000Z (over 10 years ago)
- Default Branch: master
- Last Pushed: 2017-03-30T04:33:57.000Z (over 8 years ago)
- Last Synced: 2025-06-15T00:51:59.199Z (4 months ago)
- Topics: error-handling, error-wrapping, errors, inner-errors, stack-traces
- Language: JavaScript
- Size: 13.7 KB
- Stars: 12
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# composite-error
[](https://badge.fury.io/js/composite-error)
'composite-errors' allows you to wrap and re-throw an error, providing additional context without losing the original error information.
## Overview
- You can wrap one or multiple errors into a `CompositeError`.
- You can use the `CompositeError` class as a base class for your own custom errors that can wrap other errors.
- The `stack` property of a `CompositeError` returns a string containing the stack trace of the `CompositeError` and the stack traces of the wrapped errors.
## Installation
```
$ npm install --save composite-error
```
## Usage
### Wrapping an error
```javascript
const CompositeError = require('composite-error');
try {
doSomething();
} catch (error) {
throw new CompositeError('Error occurred while trying to do something.', error);
}
```
### Wrapping multiple errors
```javascript
throw new CompositeError('Multiple errors occurred', [error1, error2]);
```
### Creating custom errors
Using the ES2015 class syntax:
```javascript
class MyCustomError extends CompositeError {
constructor(message, innerErrors) {
super(message, innerErrors);
this.name = 'MyCustomError';
}
}
```
Not using the ES2015 class syntax:
```javascript
const util = require('util');
function MyCustomError(message, innerErrors) {
CompositeError.call(this, message, innerErrors);
this.name = 'MyCustomError';
}
util.inherits(MyCustomError, CompositeError);
```
### Stack trace
The `stack` property of a `CompositeError` returns a string containing the stack trace of the `CompositeError` and the stack traces of the wrapped errors.
For example, the following code
```javascript
const firstError = new Error('First error');
const secondError = new CompositeError('Second error', firstError);
const thirdError = new CompositeError('Third error', secondError);
console.log(thirdError.stack);
```
will produce the following output:
```
CompositeError: Third error
at Object. (/Users/nick/Projects/composite-error/example1.js:7:18)
at Module._compile (module.js:460:26)
at Object.Module._extensions..js (module.js:478:10)
[... snipped for brevity ...]
--- Inner error: CompositeError: Second error
at Object. (/Users/nick/Projects/composite-error/example1.js:6:19)
at Module._compile (module.js:460:26)
at Object.Module._extensions..js (module.js:478:10)
[... snipped for brevity ...]
--- Inner error: Error: First error
at Object. (/Users/nick/Projects/composite-error/example1.js:5:18)
at Module._compile (module.js:460:26)
at Object.Module._extensions..js (module.js:478:10)
[... snipped for brevity ...]
--- End of inner error
--- End of inner error
```
### Accessing inner errors
The inner errors can be accessed using the `CompositeError#innerErrors` property.
## License
[MIT](https://github.com/nickuraltsev/composite-error/blob/master/LICENSE)