jsonify-error

Convert errors to JSON or to a good string. Develop faster with better error messages.

It's 2019 and still the default behavior of JavaScript could be better with regard to displaying/manipulating errors:

• JSON.stringify(e): Bad
• e.toString(): Bad
• e.toJSON(): Doesn't exist
• console.log(e): Bad in browsers, not so bad in Node but could be better

But jsonify-error comes to the rescue:

• For JSON.stringify(e):
  • Use JSON.stringify(jsonifyError(e)) instead
  • Or call jsonifyError.overrideErrorMethods() once and then JSON.stringify(e) will work.
• For e.toString():
  • Use jsonifyError.asString(e) instead
  • Or call jsonifyError.overrideErrorMethods() once and then e.toString() will work.
• For e.toJSON():
  • Use jsonifyError(e) instead
  • Or call jsonifyError.overrideErrorMethods() once and then e.toJSON() will work.
• For console.log(e):
  • Use jsonifyError.log(e) instead
  • Or call jsonifyError.overrideConsole() once and then console.log(e) will work.

Installation

In Browsers

For browsers, simply include one of the dists in your entry point, such as dist/jsonify-error.js. The dists are available in jsDelivr:

1<script src="https://cdn.jsdelivr.net/npm/jsonify-error@2.0.0/dist/jsonify-error.min.js" integrity="sha384-k3Is8aV5PW6XO2NtZyFbjgZLKNWv4kFrtuN0cnOhaw+qKurzZIlOZZNmih+HGKpN" crossorigin="anonymous"></script>

They are also available as GitHub release assets (since 1.4.2). The following formats are available (with source maps):

• jsonify-error.js
• jsonify-error.min.js (minified)
• jsonify-error.es5.js (ES5 compatible)
• jsonify-error.es5.min.js (ES5 compatible, minified)

Or if you're developing a browser library with Browserify, you can just require it normally, as if you were in a Node environment.

In Node

In node, as usual, simply do:

npm install --save jsonify-error

Purpose

The main purpose of jsonify-error, as the name suggests, is to convert an error to a plain object. Just do jsonifyError(e) and you will get something like:

1{
2    "name": "TypeError",
3    "className": "TypeError",
4    "message": "It can't be a string",
5    "superclasses": ["Error", "Object"],
6    "enumerableFields": {
7        // If the error has other fields they appear here (including in the prototype chain):
8        "someField": "someValue"
9    },
10    "stack": [
11        "TypeError: It can't be a string", 
12        "at z (E:\\test.js:15:15)", 
13        "at E:\\test.js:10:9", 
14        "at Array.forEach (native)", 
15        "at y (E:\\test.js:9:13)", 
16        "at x (E:\\test.js:5:5)", 
17        "at w (E:\\test.js:24:9)", 
18        "at Object.<anonymous> (E:\\test.js:32:1)", 
19        "at Module._compile (module.js:570:32)", 
20        "at Object.Module._extensions..js (module.js:579:10)", 
21        "at Module.load (module.js:487:32)"
22    ]
23}

If you're thinking "Great! Now I can do console.log(jsonifyError(e)) instead of console.log(e)" in a browser, you're in the right track, but you can do even better! A few utility methods are exposed by jsonifyError beyond the main one, as mentioned in the beginning of this README.

• jsonifyError.log(e): Logs the error in a much better way than console.log(e).
• jsonifyError.overrideConsole(): Makes console.log, console.warn, console.error work like jsonifyError.log automatically. Calling this once is enough.
• jsonifyError.overrideErrorMethods(): Heavily improves e.toString() and adds e.toJSON() to all errors automatically. Calling this once is enough.

Example: with try-catch blocks

1const jsonifyError = require("jsonify-error");
2
3try {
4    // ...
5} catch (e) {
6    jsonifyError.log(e);
7    // ...
8}

Example: with promises

1const jsonifyError = require("jsonify-error");
2
3somethingAsync().then(() => {
4    // ...
5}).catch(error => {
6    jsonifyError.log(e);
7    // ...
8});

Also, for promises, there is a sibling module called better-promise-error-log which takes care of showing the improved logs automatically for unhandled rejections.

Example: with express

1var jsonifyError = require("jsonify-error");
2
3app.get('/your/api', (req, res) => {
4    // ...
5    // Instead of res.status(500).json(error), do:
6    res.status(500).json(jsonifyError(error));
7});

Note: if you've overriden error methods (by calling jsonifyError.overrideErrorMethods()), the above can be simplified to res.status(500).json(error) (see the overriding methods section).

Example usage: overriding methods

1const jsonifyError = require("jsonify-error");
2jsonifyError.overrideConsole();
3jsonifyError.overrideErrorMethods();
4// Now `console.log`, `console.warn` and `console.error` will be much better.
5// Also, `e.toString()` will be much better and `e.toJSON()` will be available.

Contributing

Any contribution is very welcome. Feel free to open an issue about anything: questions, suggestions, feature requests, bugs, improvements, mistakes, whatever. I will be always looking.

Changelog

The changelog is available in CHANGELOG.md.

See also

• better-promise-error-log

License

MIT (c) Pedro Augusto de Paula Barbosa