How to handle Node.js errors like a Pro
Node.js is a powerful and popular platform for building server-side applications. However, like any software, Node.js applications can encounter errors. Handling errors effectively is an important skill for any Node.js developer. In this article, we’ll discuss some best practices for handling errors in Node.js like a pro.
1. Use try-catch blocks
One of the most basic ways to handle errors in Node.js is to use try-catch blocks. This allows you to catch and handle errors that may occur within a specific block of code. By using try-catch blocks, you can gracefully handle errors and prevent them from crashing your entire application.
2. Use error handling middleware
Node.js provides a mechanism for error handling middleware. You can use middleware to catch and handle errors that occur during the processing of HTTP requests. By using error handling middleware, you can centralize your error handling logic and keep it separate from your core application code.
3. Use the ‘error’ event
In Node.js, the ‘error’ event is a built-in mechanism for handling errors that occur within an EventEmitter. By listening for the ‘error’ event, you can catch and handle errors in a clean and consistent way. This is particularly useful for handling errors in asynchronous code.
4. Use a reliable error logging system
Logging is an essential part of error handling. It’s important to have a reliable logging system in place to record and track errors that occur in your Node.js applications. This will help you to diagnose and troubleshoot errors, as well as monitor the overall health of your application.
5. Use third-party error handling libraries
There are several third-party libraries available for error handling in Node.js, such as ‘express-error-handler’ and ‘boom’. These libraries provide additional tools and utilities for handling errors in a more advanced and efficient manner. Consider using these libraries to enhance your error handling capabilities.
By following these best practices, you can handle Node.js errors like a pro and ensure that your applications are robust and reliable. Remember that error handling is a crucial aspect of software development, and mastering it will make you a better and more effective Node.js developer.
Omg I am a self educated begginer developer, and 3 days ago, I did the same thing. I just felt the need to throw custom error. Im glad I fid the right thing
Thanks for this.
such a great video one thing i missed here is . I saw a comment of someone on stack overflow, guy created asyncWrapper as customer middleware around all api routes
const asyncWrapper = (cb) => {
return (req, res, next) => cb(req, res, next).catch(next);
};
I want to know your opinion on this approach.
Basically i am learning nodejs and i wanted to make sure that if i missed any error handling in my api there should be some place from where i can simply return 500 instead of terminating the process or let it get timeout that will of course cause issue on server end.
It's pronounced walla"bee".
Great video. Subscribed!, I have been also following same approach. Would like to request you to consider making videos for topic like best practice, code quality, optimization, debugging, performant code etc.
Very good one! I think we need more videos with this kind of format, not very long but that explains best practices/patterns rather than " how to use this library "
One of the things i struggled with when i started with Node ( a couple of days ago really so i'm pretty new ) was setting up a good boilerplate / project structure with nice error handling etc, i just found out a very nice boilerplate on github and was studying it these days and it follows EXACTLY these things u described in the video.
A global ApiError that extends the Error class so everywhere you can do:
throw new ApiError(httpCode, message etc etc )
a global error handler middleware
export const errorHandler = (err: ApiError, _req: Request, res: Response, _next: NextFunction) => …..
it also has a global " error converter "
export const errorConverter = (err: any, req: Request, _res: Response, next: NextFunction) => …
that checks if the error is not an instance of ApiError it tries to create it from that error so u still get an ApiError
it also has these global which do exactly what you explained
process.on('uncaughtException', unexpectedErrorHandler);
process.on('unhandledRejection', unexpectedErrorHandler);
Also for the schema validation it used Joi but i converted it with Zod cuz i also use it on the FE so i can share the validations there as well.
Glad to know all of these were best practices and i stumbled into them right away!
I think that if u have a very nice & structured error handling you can afford " making a bit of a mess " somewhere else cuz once it starts breaking you can figure out how to fix it right away rather than jumping left & right
Great video. Subscribed!
Not long ago I had to revamp the error handling system of over 20 projects with over 5 different approachs mixed within them.
Working on an enterprise level for a multibillion dollar company that has this kind of anti-pattern and literally no code review can be a nightmare, but it is extremely educational.
Took me not much more than a couple of weeks of work time, but I am glad to see that the final result is pretty much what you taught on this video.
Most junior and mid-level developers dont pay a lot of attention to error handling. This video is absolute gold in terms of best practices.
OMG it is so helpful, I am feeling like a Pro now😅
I have been using a very similar `RequestError` class to throw errors inside my express controllers and components.
I then have a single app.use() middleware that catches and handles errors from `instanceof RequestError` and `instanceof ZodError`.
It makes the code a lot easier to read as it reduces a lot of control flow
awesome in depth video, explained very nicely. Next time in my app Ill try to do the things you just demonstrated, need more video like this. You might also consider making videos for topic like best practice, code quality, optimization, debugging, performant code etc. Just a bit of content ideas from me thats all. overall keep up the good work!
you think it's okey to hardcode in the client side the httpCode ? or was this just an example and that httpCode property should only be used for network request errors?