Validation Error Data

Data validation and error handling are important aspects of building robust and reliable web applications. In an Express.js application, you can use middleware to handle data validation and error handling.

Here's an overview of how to handle data validation and error handling in an Express.js application:

Data validation

Data validation is the process of ensuring that the data entered by the user is in the correct format and meets the specified criteria. In an Express.js application, you can use middleware like express-validator to handle data validation.

To use express-validator, you'll need to install the express-validator package using npm:

npm install express-validator

Once you have installed express-validator, you can create a middleware function to handle data validation. Here's an example:

const { body, validationResult } = require('express-validator');

app.post('/user', [
  body('name').isLength({ min: 3 }),
  body('email').isEmail(),
], (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }

  // Save user to database
});

In the above code, we create a middleware function to validate the name and email fields of the request body. If there are any errors, we return a 400 response with the validation errors. If there are no errors, we save the user to the database.

Error handling

Error handling is the process of handling errors that occur during the execution of your application. In an Express.js application, you can use middleware to handle errors.

To handle errors, you can create a middleware function that takes four parameters (err, req, res, and next). Here's an example:

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

In the above code, we create a middleware function to handle errors. If an error occurs, we log the error stack trace to the console and return a 500 response with a generic error message.

You can also create custom error handling middleware to handle specific types of errors. Here's an example:

class CustomError extends Error {
  constructor(message, status) {
    super(message);
    this.status = status;
  }
}

app.use((err, req, res, next) => {
  if (err instanceof CustomError) {
    res.status(err.status).json({ error: err.message });
  } else {
    console.error(err.stack);
    res.status(500).send('Something broke!');
  }
});

app.get('/user/:id', (req, res, next) => {
  const user = getUserById(req.params.id);
  if (!user) {
    throw new CustomError('User not found', 404);
  }
  res.json(user);
});

In the above code, we define a custom error class CustomError that takes a message and a status code. We then create a middleware function to handle errors. If the error is an instance of CustomError, we return a JSON response with the error message and status code. If the error is not an instance of CustomError, we log the error stack trace to the console and return a 500 response with a generic error message. We then use the custom error handling middleware in a route handler to throw an error if the user is not found.