1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
# whoops
[](https://travis-ci.org/Kikobeats/whoops)
[](https://coveralls.io/github/Kikobeats/whoops)
[](https://david-dm.org/Kikobeats/whoops)
[](https://david-dm.org/Kikobeats/whoops#info=devDependencies)
[](https://www.npmjs.org/package/whoops)
[](https://paypal.me/kikobeats)
> It makes simple throw qualified errors. Inspired in [errno](https://github.com/rvagg/node-errno), [create-error-class](https://github.com/floatdrop/create-error-class) and [fault](https://github.com/wooorm/fault).
## Why
- An easy way to create qualified errors.
- Using the standard `Error` interface in browser and NodeJS.
- Attach extra information, being flexible with whatever user case.
This library is a compromise to provide a clean API for use `Error` native class.
## Install
```bash
npm install whoops --save
```
Basically it turns:
```js
const error = Error('Something is wrong')
error.name = 'DAMNError'
throw error // => 'DAMNError: ENOFILE, Something is wrong'
```
Into a one line more productive declaration:
```js
const whoops = require('whoops')
const userError = whoops('UserError')
throw userError('User not found') // => 'UserError: User not found'
```
## Creating Qualified Errors
Call `whoops` to get a constructor function. Every time you call the constructor, you get an `Error` instance:
```js
const whoops = require('whoops')
const myError = whoops()
throw myError()
```
Create domain specific errors providing a `className` as first argument:
```js
const whoops = require('whoops')
const userError = whoops('userError')
throw userError()
```
The qualified error will be extends from `Error`:
```js
const whoops = require('whoops')
const userError = whoops('userError')
const error = userError()
console.log(error instanceof Error); // => true
```
Attach extra information passing a `props` as second argument:
```js
const whoops = require('whoops')
const userError = whoops('userError', {code: 'ENOVALID'})
const err = userError()
console.log(`My error code is ${err.code}`) // => My error code is ENOVALID
```
You can associate dynamic `props` as well:
```js
const whoops = require('whoops')
const userError = whoops('userError', {
code: 'ENOVALID',
message: props => `User '${props.username}' not found`
})
const err = userError({username: 'kiko'})
console.log(err.message) // => User 'kiko' not found
```
## Error Types
By default you will get `Error` instances calling whoops, but you can get different errors calling the properly method:
| Name | Method |
|----------------|------------------|
| [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) | whoops |
| [TypeError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError) | whoops.type |
| [RangeError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RangeError) | whoops.range |
| [EvalError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError) | whoops.eval |
| [SyntaxError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError) | whoops.syntax |
| [ReferenceError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError) | whoops.reference |
| [URIError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/URIError) | whoops.uri |
## Extra: Always throw/return an Error!
If you code implementation is
- **synchronous**, throws `Error`. If you just return the `Error` nothings happens!.
- **asynchronous**, returns `Error` in the first argument of the callback (or using promises).
About asynchronous code, is correct return a `Object` that is not a `Error` in the first argument of the callback to express unexpected behavior, but the `Object` doesn't have a type and definitely can't follow a error interface for determinate a special behavior:
```js
callback('LOL something was wrong') // poor
callback({message: 'LOL something was wrong' } // poor, but better
callback(whoops('LOL, something was wrong') // BEST!
```
Passing always an `Error` you can can associated different type of error with different behavior:
```js
switch (err.name) {
case 'JSONError':
console.log('your error logic here')
break
default:
console.log('undefined code')
break
};
```
## License
MIT © [Kiko Beats](http://www.kikobeats.com)
|
