Error Handling With Express

Question 1

How can we catch all types of response methods?

Answer 1

We can use the all method on the app object.

Question 2

How can we match any path in our app?

Answer 2

We can use * to match any URL in our app.

Question 3

Where would we create middleware to handle unhandled routes?

Answer 3

We want to create the middleware inside our main file.

Question 4

What are operational errors?

Answer 4

These are predictable errors that we anticipate and handle in advance.

Question 5

What are Programming errors?

Answer 5

These are bugs or mistakes introduced during development.

Question 6

How can we implement a global error-handling middleware?

Answer 6

We use the app method and pass in the arguments (err, req, res, next).

Question 7

What do we do inside our global error-handling middleware?

Answer 7

Set up properties to handle the status code, defaulting to 500 if not specified, and the status message, defaulting to ‘error’ if absent.

Next, we will send a response with the status code from the error object and a JSON object containing status (set to err.status) and message (set to err.message).

Question 8

How can we call our global error-handling middleware?

Answer 8

We invoke next() with our error instance as an argument. Calling next() with an argument triggers the error-handling middleware we previously defined.

Question 9

Where should we add the error-handling middleware?

Answer 9

You want to create its controller. Export the function, and make a middleware for it in the main file.

Question 10

How can we create operational errors?

Answer 10

Create a class that extends from the Error class. This custom class constructor accepts a statusCode and message. From the parent Error class, we only inherit the message property.

Question 11

What does isOperational mean?

Answer 11

Indicates that any error created with this class is an operational error. This distinction will be useful later when handling different types of errors.

Question 12

What folder should the operational error class be in?

Answer 12

It should be in the utils folder.

Question 13

How can we refactor handling async errors?

Answer 13

We can remove all the catch blocks and create a helper function that will handle the errors.

Question 14

Tell me what should the error helper function have?

Answer 14

It should accept a function as an argument. This function should return a function with req, res, and next passed in. This returned function should execute the passed-in function, chaining it with a catch method that passes the next method. This next method will automatically receive the error object.

Question 15

How can we handle docs not found in our DB due to bad input?

Answer 15

We want to check if the document was returned. If the document was not found, we want to return a next function with the error class passed in.

Question 16

Why should we create two separate errors for devs and users?

Answer 16

For users, we want to generate a friendly and easy-to-understand message. For developers, we aim to provide errors that are more detailed and useful.

Question 17

How can we check if our environment is in production mode or development mode?

Answer 17

We use if and else if statements.

Question 18

What should we do if our environment is in production mode?

Answer 18

Invoke a function, this function should receive two arguments. The error object and response object. This function checks if our error is isOperational if so, it sends a message, or else it sends a generic message.

Question 19

Why should we check if an error is an operational error during production?

Answer 19

This is because some non-operational errors can send error messages that can leak information.

Question 20

How can we handle an invalid database ID?

Answer 20

We want to check if the error name is equal to CastError. If it is, we want to call a function named handleCastError.

Question 21

What should we do before working with the error object in our production environment?

Answer 21

Create a copy.

Question 22

What will be in the handleCastErr function?

Answer 22

In this function, we will pass in a copy of the error object. Inside, we will create a message saying invalid err.path and err.value. This message will be passed into our AppError class, which handles operational errors and marks them as operational errors. We also want to pass in 404 for a bad request status code.

Question 23

How can we handle duplicate errors?

Answer 23

We want to check if the error code is equal to 110000. If it is we want to create a function that will return the new error.

Question 24

How can we handle validation errors?

Answer 24

We want to check if the error name is equal to ValidationError. If it is, we want to create a function that will return a new error.

Question 25

How can we fetch all the validation errors?

Answer 25

To get each error, we use `Object.values` and pass in `err.errors`, which will put every object into its own index in an array. We can then loop through this array and return a new array containing each error message, and finally, join them together into a single string.

Question 26

What are unhandled rejections?

Answer 26

They are promise rejections that are not handled.

Question 27

How can we catch them?

Answer 27

Use the `on` method found on the `process` object. Inside, we pass in `unhandledRejection` and the `err` object we get from it.

Question 28

What do we do when we have an unhandled rejection?

Answer 28

We want to shut down our app.

Question 29

What are uncaught exceptions?

Answer 29

They are errors in our synchronous code. Such as calling an undefined variable.

Question 30

How can we handle uncaught exceptions?

Answer 30

We need to use the `on` method on our `process` object. Inside, we pass in `uncaughtException` and the error object. We handle this similarly to how we handle unhandled promise rejections.

Question 31

Why do we need to close the app if we have an uncaught exception?

Answer 31

We need to close the app because our Node app is in an unclean state.

Question 32

Where do we want to handle our uncaught exceptions?

Answer 32

We want to create this process at the very top of our file.