Conditionally send responses in an Express app

Question

I'm curious whether you can write if statements in an Express app to conditionally execute your code without providing else statements.

if(pred) {
  doSomething()
}
return foo;
calcBar(); // doesn't run.

Above is the synchronous code that stops execution after the return statement.

My Express function looks like this:

app.get('/matches', async function(req, res) {
  try {
    const data = await someGraphQLCall();
    if(data.length === 0) {
      res.json({ message: "No data." });
    }
    const someOtherData = await someOtherGraphQLCall(data.foo);
    res.json({ someOtherData });
  } catch (err) {
    res.json({err})
  }
}

I know because of this question that code after the first res.json might still be executed. Is there a way to stop that? I don't want the second GraphQL call to execute if the first if condition is met. Is that possible without using else ?

Edit:

As the question I linked above mentioned, using a return statement is a bad option because:

it also makes it less meaningful and vague, cause it uses incorrect semantics. If you are not using the value from the function, then you shouldn't return one.

That is a bad reason in my opinion. If your REST API returns no data then you might as well throw a 404 to the user and then continue your code. Return statements is such a basic block of programming that is it no vague what it does. And also what would your return be returning? Well it obviously returns the data to the user asking for it, what more precise statement could you use. I would say that wrapping and hiding this away in single if statements is vague and a horrible solution to this. You could use it to check something like ` if (data.hasSomeData) fetchFromGQL ` — Thomas Johansen, Jul 04 '19 at 06:24

Oresztesz · Accepted Answer · 2019-06-27T12:52:47.813

You can use return keyword on the first response to immediately return from the function.

app.get('/matches', async function(req, res) {
  try {
    const data = await someGraphQLCall();
    if(data.length === 0) {
      return res.json({ message: "No data." });
    }
    const someOtherData = await someOtherGraphQLCall(data.foo);
    res.json({ someOtherData });
  } catch (err) {
    res.json({err})
  }
}

Edit:

As an alternative, you can split the logic of the data and building up response. This way you can use return and it's easier to read:

app.get('/matches', async function (req, res) {
    try {
        const data = await getDataFromGraphQLCall();
        res.json(data);
    } catch (err) {
        res.json({ err })
    }
});

async function getDataFromGraphQLCall() {
    const data = await someGraphQLCall();
    if (data.length === 0) {
        return { message: "No data." };
    }
    const someOtherData = await someOtherGraphQLCall(data.foo);
    return { someOtherData };
}

Thank you Oresztresz. I know I can use `else`, but I asked whether there are possibilities without `else`. And I don't want to use the `return` statement (I edited the question with the reason. — J. Hesters, Jun 27 '19 at 12:25
Would you prefer returning in the next statement? `res.json({ message: "No data." }); return;` In my opinion guard clauses are well known and readable. See: https://refactoring.com/catalog/replaceNestedConditionalWithGuardClauses.html — Oresztesz, Jun 27 '19 at 12:37

Anand Undavia · Answer 2 · 2019-07-03T17:41:11.063

If you are wondering if there is a way to achieve that without the else, yes it is. But, It might not be THE cleanest way. IMO, using return is the best way to stop the execution of the controller.

Anyways, You can split the chunk of code into middlewares and use ternary operator to conditionally send responses.

In your example, separate out data = await someGraphQLCall(); as follows:

const middlewareOne = async function(req, res, next) {
    let data = [];
    let response = { message: "No data." };
    try {
        data = await someGraphQLCall();
        req.locals.data = data; // <- attach the data to req.locals
    } catch (err) {
        response = { err };
    }
    data.length === 0 ? res.json(response) : next();
};

And then, mount the middlewareOne BEFORE your controller:

app.get("/matches", middlewareOne, async function controller(req, res) {
    try {
        const someOtherData = await someOtherGraphQLCall(req.locals.data.foo);
        res.json({ someOtherData });
    } catch (err) {
        res.json({ err });
    }
});

How this works is, the controller function would only be executed by express if the next() is called from the previous middleware -- middlewareOne in the example.
And as middlewareOne only calls next() if the data.length is not 0, it would work as you expected.

For more information on passing data from one middleware to other, read this

Wow, thank you. Admittedly, using `else` is a lot better then. — J. Hesters, Jul 03 '19 at 12:29
Does the `app.get()` have access to data, even though it was declared using `let` in `middlewareOne`? Because there you use it with (and I need to use it with) `data.foo` as input for the next GraphQL call. — J. Hesters, Jul 03 '19 at 12:31
Do you want to access the data from `middlewareOne` into the `controller`? — Anand Undavia, Jul 03 '19 at 13:18

Akinjide · Answer 3 · 2019-06-27T12:47:27.140

The return statement terminates the function execution in this context. In my opinion, you should handle the success case then the error case since the code will be read top to bottom.

In if statement, data could be undefined or null.

You can read more here: MDN - return

app.get('/matches', async function(req, res) {
  try {
    const data = await someGraphQLCall();

    // alternative, if (data && data[0]) {
    if (data && data.length) {
      const someOtherData = await someOtherGraphQLCall(data.foo);
      return res.json({ someOtherData });
    }

    return res.json({ message: "No data." });
  } catch (err) {
    console.log(err); // log error with logger and drain to loggly.
    res.json({ err })
  }
}

With Void operator:

Void operator allows you to return undefined but evaluate the given expression.

You can read more here: MDN - Void

app.get('/matches', async function(req, res) {
  try {
    const data = await someGraphQLCall();

    // alternative, if (data && data[0]) {
    if (data && data.length) {
      const someOtherData = await someOtherGraphQLCall(data.foo);
      return void res.json({ someOtherData });
    }

    return void res.json({ message: "No data." });
  } catch (err) {
    console.log(err); // log error with logger and drain to loggly.
    res.json({ err })
  }
}

Thank you akinjide. I don't want to use the `return` statement (I edited the question with the reason. — J. Hesters, Jun 27 '19 at 12:25
Hi Hester, That's a valid reason, you should look at the void operator — Akinjide, Jun 27 '19 at 12:47

Conditionally send responses in an Express app

3 Answers3