JS- Inner and Outer Catch

Say I have 2 catchs. like so:

try {
axios.get('https://example.com', {})
  .then(function (responseOne: any) {
    return axios.post('https://example.com', {}, {})
  }).then(function (responseTwo: any) {
    return axios.put('https://example.com', {}, {})
  }).then(function (responseThree: any) {
    return axios.post('https://example.com', {}, {})
  }).then(function () {
    reply.send
  }).catch(error) => {}
} catch(errorOuter) => {}

From what I've read - it would only go into the outer catch the first axios call was await axios.get(...). Is this correct? What if each of the then blocks was also await?

If the code remains as is, would it only ever go into the inner catch. And if so, I guess I can remove the outer catch.

> it would only go into the outer catch the first axios call was await axios.get(...). Is this correct?

Not really.

The promise returned by axios.get('https://example.com', {}) is handled by then, and the same is true for the subsequence promises up until the end of catch.

If you added await at the start of line 2 then you would be awaiting the promise returned by the call to catch().

The callback you pass to catch() captures and discards any exception anywhere on that chain of promises.

Thus it would never go into the outer catch.

> If the code remains as is, would it only ever go into the inner catch. And if so, I guess I can remove the outer catch.

Technically, yes, but you'd be better off getting rid of then and just using await. It would make the code easier to follow.

try {
    await axios.get('https://example.com', {});
    await axios.post('https://example.com', {}, {});
    await axios.put('https://example.com', {}, {});
    await axios.post('https://example.com', {}, {});
    reply.send;
} catch (e) {
    // do something with e
}

In this particular example I don't see any way that the "outer" catch (the one matched to the original try) would be invoked, unless somehow Axios threw an exception just trying to invoke its asynchronous operation.

The chained promises for each subsequent operation will eventually land in the chained call to .catch() in that Promise if something failed. But the whole chain is one big asynchronous operation, and that overall try block completes and exits before that operation ever gets anywhere.

(That is... If you were to add a console.log statement immediately after all of the code shown, you'd see that statement is reached before any of the AJAX operations have returned.)

The "outer" try/catch in this case would only be useful if you switched from chaining .then() callbacks to using await. For example:

try {
  const responseOne = await axios.get('https://example.com', {});
  const responseTwo = await axios.post('https://example.com', {}, {});
  const responseThree = await axios.put('https://example.com', {}, {});
  // etc.
} catch(errorOuter) {
  // handle error
}