Wrapper function

Error handling in Node.js can be done using try-catch blocks, which allow you to handle exceptions thrown by your code.

However, this approach can become repetitive and verbose when dealing with multiple error-prone functions. To avoid this, you can wrap these functions in a generic error-handling function (a "wrapper function") that takes care of catching any errors and handling them in a centralized way.

For example, you could define a wrapper function that receives a function as a parameter and returns a new function that automatically handles errors:

const wrap = (fn) => (req, res, next) =>
  fn(req, res, next).catch(next);

With this wrapper function, you can simplify your error handling code by simply wrapping your route handlers:

app.post("/shoot", wrap(async (req, res) => {
  const data = await doSomething();
  res.send(data);
}));

Let's work with a better example.

Old code

exports.getAllTrips = async (req, res, next) => {
  try {
    const { id } = req.user;

    console.log(id);

    const trips = await Trip.find({ userId: id })
      .sort({ createdAt: -1 });
    if (!trips) return errorResMsg(res, 404, "No trips found");

    const dataInfo = {
      message: "Trips found",
      trips,
    };

    return successResMsg(res, 200, dataInfo);
  } catch (error) {
    next(error);
  }
};

New Code

First we create wrapper function

// handle callback
const handleCallback = (callback) => {
  return async (req, res, next) => {
    try {
      await callback(req, res, next);
    } catch (error) {
      next(error);
    }
  };
};

Then use the handleCallback to wrap the route

exports.getAllTrips = handleCallback(async (req, res) => {
  const { id } = req.user;
  const trips = await Trip.find({ userId: id }).sort({ createdAt: -1 });
  if (!trips) return errorResMsg(res, 404, "No trips found");

  const dataInfo = {
    message: "Trips found",
    trips,
  };

  return successResMsg(res, 200, dataInfo);
});

Conclusion

Wrapper function can be utilized to streamline the try/catch block and promote DRY (Don't Repeat Yourself) principles in coding.