je

jsonify-error

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

Showing:

Popularity

Downloads/wk

702

GitHub Stars

5

Maintenance

Last Commit

2yrs ago

Contributors

1

Package

Dependencies

2

Size (min+gzip)

1.0KB

License

MIT

Type Definitions

Tree-Shakeable

No?

Categories

Readme

jsonify-error

npm package

NPM version Build status Minzipped size License NPM downloads Dependency Status Dev Dependency Status Open Issues Closed Issues contributions welcome jsDelivr hits

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:

<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:

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

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

const jsonifyError = require("jsonify-error");

try {
    // ...
} catch (e) {
    jsonifyError.log(e);
    // ...
}

Example: with promises

const jsonifyError = require("jsonify-error");

somethingAsync().then(() => {
    // ...
}).catch(error => {
    jsonifyError.log(e);
    // ...
});

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

var jsonifyError = require("jsonify-error");

app.get('/your/api', (req, res) => {
    // ...
    // Instead of res.status(500).json(error), do:
    res.status(500).json(jsonifyError(error));
});

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

const jsonifyError = require("jsonify-error");
jsonifyError.overrideConsole();
jsonifyError.overrideErrorMethods();
// Now `console.log`, `console.warn` and `console.error` will be much better.
// 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

License

MIT (c) Pedro Augusto de Paula Barbosa

Rate & Review

Great Documentation0
Easy to Use0
Performant0
Highly Customizable0
Bleeding Edge0
Responsive Maintainers0
Poor Documentation0
Hard to Use0
Slow0
Buggy0
Abandoned0
Unwelcoming Community0
100