useonlythebuiltinerror.md

Use only the built-in Error object

One Paragraph Explainer

The permissive nature of JS along with its variety code-flow options (e.g. EventEmitter, Callbacks, Promises, etc) pushes to great variance in how developers raise errors – some use strings, other define their own custom types. Using Node.js built-in Error object helps to keep uniformity within your code and with 3rd party libraries, it also preserves significant information like the StackTrace. When raising the exception, it’s usually a good practice to fill it with additional contextual properties like the error name and the associated HTTP error code. To achieve this uniformity and practices, consider extending the Error object with additional properties, see code example below Blog Quote: “I don’t see the value in having lots of different types” From the blog Ben Nadel, ranked 5 for the keywords “Node.js error object” …”Personally, I don’t see the value in having lots of different types of error objects – JavaScript, as a language, doesn’t seem to cater to Constructor-based error-catching. As such, differentiating on an object property seems far easier than differentiating on a Constructor type…

Code Example – doing it right

// throwing an Error from typical function, whether sync or async
if(!productToAdd)
    throw new Error("How can I add new product when no value provided?");
 
// 'throwing' an Error from EventEmitter
const myEmitter = new MyEmitter();
myEmitter.emit('error', new Error('whoops!'));
 
// 'throwing' an Error from a Promise
return new Promise(function (resolve, reject) {
    Return DAL.getProduct(productToAdd.id).then((existingProduct) =>{
		 if(existingProduct != null)
			reject(new Error("Why fooling us and trying to add an existing product?"));
    })
});

Code example – Anti Pattern

// throwing a string lacks any stack trace information and other important data properties
if(!productToAdd)
    throw ("How can I add new product when no value provided?");

Code example – doing it even better

// centralized error object that derives from Node’s Error
function appError(name, httpCode, description, isOperational) {
    Error.call(this);
    Error.captureStackTrace(this);
    this.name = name;
    //...other properties assigned here
};

appError.prototype.__proto__ = Error.prototype;

module.exports.appError = appError;
 
// client throwing an exception
if(user == null)
    throw new appError(commonErrors.resourceNotFound, commonHTTPErrors.notFound, "further explanation", true)

Blog Quote: "A string is not an error"

From the blog devthought.com, ranked 6 for the keywords “Node.js error object”

…passing a string instead of an error results in reduced interoperability between modules. It breaks contracts with APIs that might be performing instanceof Error checks, or that want to know more about the error. Error objects, as we’ll see, have very interesting properties in modern JavaScript engines besides holding the message passed to the constructor…
Blog Quote: “All JavaScript and System errors raised by Node.js inherit from Error”

Blog Quote: "Inheriting from Error doesn’t add too much value"

From the blog machadogj

…One problem that I have with the Error class is that is not so simple to extend. Of course you can inherit the class and create your own Error classes like HttpError, DbError, etc. However that takes time, and doesn’t add too much value unless you are doing something with types. Sometimes, you just want to add a message, and keep the inner error, and sometimes you might want to extend the error with parameters, and such…

Blog Quote: "All JavaScript and System errors raised by Node.js inherit from Error"

From Node.js official documentation

…All JavaScript and System errors raised by Node.js inherit from, or are instances of, the standard JavaScript Error class and are guaranteed to provide at least the properties available on that class. A generic JavaScript Error object that does not denote any specific circumstance of why the error occurred. Error objects capture a “stack trace” detailing the point in the code at which the Error was instantiated, and may provide a text description of the error.All errors generated by Node.js, including all System and JavaScript errors, will either be instances of, or inherit from, the Error class…