Try/Catch not catching with async function using await - promise

Question

When I have this code:
export default async ({
inputs,
stdin = process.stdin,
timeoutBetweenInputs = DEFAULT_TIMEOUT_BETWEEN_INPUTS
}: ISendInputsToCli): Promise<void> => {
// go through each input, waiting for the last timeout to
// resolve
// write the input to stdin
return inputs.reduce(
(previousPromise, input) =>
new Promise(async (resolve, reject) => {
await previousPromise;
let inputString;
if (typeof input !== "string") {
timeoutBetweenInputs = input.timeoutBeforeInput;
inputString = input.input;
} else {
inputString = input;
}
setTimeout(() => {
try {
stdin.write(inputString);
} catch (e) {
throw new Error(
`Unable to send input "${inputString}" to the cli. Please check to make sure your script didn't exit early.`
);
inputs.splice(0, inputs.length);
}
resolve();
}, timeoutBetweenInputs);
}),
Promise.resolve()
);
};
try {
await sendInputsToCLI({
inputs,
stdin: proc.stdin,
timeoutBetweenInputs
});
} catch (e) {
console.log("error here");
}
The application doesn't catch the error:
" to the cli. Please check to make sure your script didn't exit ea
rly.
52 | stdin.write(inputString);
53 | } catch (e) {
> 54 | throw new Error(
| ^
55 | `Unable to send input "${inputString}" to the cli. Please check to make sure your script didn't exit early.`
56 | );
57 | inputs.splice(0, inputs.length);
at Timeout._onTimeout (index.ts:54:19)

Answer 1

When you throw in the catch handler here:
setTimeout(() => {
try {
stdin.write(inputString);
} catch (e) {
throw new Error(
`Unable to send input "${inputString}" to the cli. Please check to make sure your script didn't exit early.`
);
inputs.splice(0, inputs.length);
}
the exception just goes back into the setTimeout() infrastructure. Because it calls its timeout callback from the event loop, not from your own code, there's no code of yours on the call stack at that time so you can't catch that exception.
Exceptions are difficult to propagate back through plain asynchronous callbacks. In fact, can't do it directly the way you've coded it. If this were my code, I would control my flow of asynchronous operations using only functions that return promises. When you have an asynchronous operation that uses a plain callback, not a promise, you "promisify" it with a small something like util.promisify() or a custom little promise wrapper and then you can throw to your hearts content and it will automatically propagate up to higher levels or back to the caller as a rejected promise.
FYI, it's also unclear why you have the line of code:
inputs.splice(0, inputs.length);
in that snippet since it can never be hit as it's after the throw.