JavaScript — How to JSON Stringify Errors

You can create a JSON string from anything in JavaScript using the JSON.stringify(anything) method. However, the resulting JSON string may not contain the expected values. For example, if you’re JSON serializing a JavaScript error, you’ll notice that its JSON string doesn’t contain any properties.

JavaScript doesn’t include internal, non-enumerable properties when using JSON.stringify. And all properties of an error are non-enumerable. This tutorial shows you how to JSON-serialize errors in JavaScript.

Node.js Series Overview

  1. String Replace All Appearances
  2. Remove All Whitespace From a String in JavaScript
  3. Generate a Random ID or String in Node.js or JavaScript
  4. Remove Extra Spaces From a String in JavaScript or Node.js
  5. Remove Numbers From a String in JavaScript or Node.js
  6. Get the Part Before a Character in a String in JavaScript or Node.js
  7. Get the Part After a Character in a String in JavaScript or Node.js
  8. How to Check if a Value is a String in JavaScript or Node.js
  9. Check If a String Includes All Strings in JavaScript/Node.js/TypeScript
  10. Check if a Value is a String in JavaScript and Node.js
  11. Limit and Truncate a String to a Given Length in JavaScript and Node.js
  12. Split a String into a List of Characters in JavaScript and Node.js
  13. How to Generage a UUID in Node.js
  14. Reverse a String in JavaScript or Node.js
  15. Split a String into a List of Lines in JavaScript or Node.js
  16. Split a String into a List of Words in JavaScript or Node.js
  17. Detect if a String is in camelCase Format in Javascript or Node.js
  18. Check If a String Is in Lowercase in JavaScript or Node.js
  19. Check If a String is in Uppercase in JavaScript or Node.js
  20. Get the Part After First Occurrence in a String in JavaScript or Node.js
  21. Get the Part Before First Occurrence in a String in JavaScript or Node.js
  22. Get the Part Before Last Occurrence in a String in JavaScript or Node.js
  23. Get the Part After Last Occurrence in a String in JavaScript or Node.js
  24. How to Count Words in a File
  25. How to Shuffle the Characters of a String in JavaScript or Node.js
  26. Append Characters or Words to a String in JavaScript or Node.js
  27. Check if a String is Empty in JavaScript or Node.js
  28. Ensure a String Ends with a Given Character in JavaScript or Node.js
  29. Left-Trim Characters Off a String in JavaScript or Node.js
  30. Right-Trim Characters Off a String in JavaScript or Node.js
  31. Lowercase the First Character of a String in JavaScript or Node.js
  32. Uppercase the First Character of a String in JavaScript or Node.js
  33. Prepend Characters or Words to a String in JavaScript or Node.js
  34. Check if a String is a Number
  35. Convert a String to Buffer
  36. Prevent Line Breaks in String Template Literals

Implement a toJSON Method on Error Classes

When creating and using your own error classes, you can implement a toJSON() method. This toJSON() method returns an object or JSON string that exposes the selected properties.

The default JSON serialization won’t include non-enumerable class properties. It only includes properties that you’re assigning within the class itself, for example within the constructor.

Here’s an example of an HttpError class that doesn’t implement a toJSON method. You’ll only see the assigned statusCode variable in the JSON string:

class HttpError extends Error {  
  constructor(message, statusCode) {
    super(message)
    this.statusCode = statusCode
  }
}

const error = new HttpError('Failed to find user', 404)  
console.log(JSON.stringify(error))  
// {"statusCode":404}

The default JSON-serialization of a JavaScript error doesn’t contain all properties. If possible, you should create your own error class that extends the built-in Error. Your new error class then exposes a toJSON method that returns the error’s properties:

class HttpError extends Error {  
  constructor(message, statusCode, data) {
    super(message)
    this.data = data
    this.statusCode = statusCode
  }

  toJSON() {
    return {
      ...this.data
      message: this.message,
      status: this.statusCode,
    }
  }
}

const error = new HttpError('Failed to find user', 404)  
console.log(JSON.stringify(error))  
// {"message":"Failed to find user","status":404}

const errorWithData = new HttpError('Failed to find user', 404, {  
  userId: 123,
})
console.log(JSON.stringify(errorWithData))  
// {"userId":123,"message":"Failed to find user","status":404}

Notice: we use a data property to inject an object of data into the error itself. This can be useful when you want to provide more context than a string, like validation errors with the failed field and their list of errors.

JSON Stringify Errors You’re Not in Control Of

You can’t extend error classes used in third-party packages. Well, you could do it with a global patch on the Error class. But please don’t do this! Globally patching JavaScript objects has unexpected side-effects on code.

Yet, you can still serialize generic JavaScript errors to JSON. What you need is an error handler that catches all errors within your application and then does the handling. For example, your error handler may check if an error implements a toJSON method, and then call that method. If not, you could use the serialize-error package from Sindre Sorhus.

npm install serialize-error  

The serialize-error package exposes a serializeError() method. Use this method to create a JSON string from a given error:

import { serializeError } from 'serialize-error';

const error = new Error('Failed to find user');  
const serialized = serializeError(error);

console.log(JSON.stringify(serialized));  
// {"name":"Error","message":"Failed to find user","stack":"Error: Failed to find user\n    at Object.<anonymous> …"}

The error’s JSON string contains all non-enumerable properties. All enumerable error fields are included.

Notice: serialize-error will also include the error.stack property in the resulting JSON. Please don’t expose the stack to the outside in production environments. The stack can be helpful during development and internal pre-production environments. In production, you shouldn’t leak server paths or details.

That’s it!


Mentioned Resources

Explore the Library

Find interesting tutorials and solutions for your problems.