[Fixed] How do I send more than one error at a time when validating?


When I create a POST request for I need to validate the following fields: first_name, last_name, mobile_number, reservation_date, reservation_time and people(party size).

Right now I have a middleware function that checks if any of the fields are missing:

function hasProperties(...properties) {
  return function (res, req, next) {
    const { data = {} } = res.body;

    try {
      properties.forEach((property) => {
        if (!data[property]) {
          const error = new Error(`${property}`);
          error.status = 400;
          throw error;
    } catch (error) {

Then in my controller:

const hasAllProps = hasProperties(

This is working great however I have to add additional validation to several of the fields. I have 2 additional functions: one is making sure the people field is a number, and the other is making sure the reservation_date is a date:

const validPeople = (req, res, next) => {
  const { people } = req.body;
  if (Number.isInteger(people)) {
    return next();
  next({ status: 400, message: 'people' });

const validDate = (req, res, next) => {
  const { reservation_date } = req.body;
  if (reservation_date instanceof Date) {
    return next();
  next({ status: 400, message: 'reservation_date' });

Then I pass them all in to my exports:

create: [hasAllProps, validDate, validPeople]

I am only ever able to send one error at a time, in this case its validDate because it comes before validPeople in the exports array. I am unable to throw all of my errors into an array because I need to response with:

status: 400, message: '<the-specific-field>'

Is there a way to individually send all these error messages?


As the other response has stated, if you’re trying to send multiple responses, that’s not possible. You can, however, construct an array of the errors.

You could technically pass data between middleware… (Can I send data via express next() function?)

… but my recommendation would be to be to try to merge them into a single middleware. For example, hasAllProps, validPeople, and validDate should ideally all take in a req and return null or an error. Then you could do:

function validDate(req) {
  return null;

function validOtherProp(req) {
  return 'error_here';

function anotherValidation(req) {
  return 'second_error';

const errorCollectorMiddleware = (...validators) =>
  (req, res, next) => {
    const errors = validators.map(v => v(req)).filter(error => error !== null);

    if (errors.length > 0) {
        status: 400,
    } else {

// This is how you construct a middleware
const middleware = errorCollectorMiddleware(validDate, validOtherProp, anotherValidation);

// And here's a test. You wouldn't do this in your actual code.
console.log(middleware(null, null, console.log))
  "status": 400,
  "errors": [

Leave a Reply

(*) Required, Your email will not be published