We Keep Coding

escape loop using an error from async function?

let me explain what I mean using an example
async function async_function(){
await new Promise(r=>setTimeout(r,3000));
throw 'task completed'
}
async function do_something_meanwhile() {
await new Promise(r => setTimeout(r, 500));
console.log(Math.floor(Math.random()*10));
}
(async ()=>{
try {
async_function(); //this returns an error after a while
while (...)
await do_something_meanwhile();
} catch (err) { console.log('exited with error:',err) }
console.log('moving on');
})();
I'm trying to run an async function and after it is complete immediately terminate the loop,
the best way I could think of (without any time delay) was to send an error
but it gives this error instead of moving on after it's done:
node:internal/process/promises:246
triggerUncaughtException(err, true /* fromPromise */);
^
[UnhandledPromiseRejection: This error originated either by throwing
inside of an async function without a catch block,
or by rejecting a promise which was not handled with
.catch(). The promise rejected with the reason "task
completed".] {
code: 'ERR_UNHANDLED_REJECTION'
}
is there a way around this or a better to achieve the desired effect?

You can handle rejection by setting an error variable that you can check in the loop:
try {
let error;
async_function()
.catch(err => error = err);
while (...) {
if (error) {
throw error;
}
await do_something_meanwhile();
}
} catch (err) {
console.log('exited with error:',err)
}
If you need to proactively tell do_something_meanwhile to terminate as well, you could use an AbortController and pass its signal to do_something_meanwhile.
try {
let error;
const controller = new AbortController();
const { signal } = controller;
async_function()
.catch(err => {
error = err;
controller.abort();
});
while (...) {
if (error) {
throw error;
}
await do_something_meanwhile(signal);
}
} catch (err) {
console.log('exited with error:',err)
}
I think if I were doing that, I might subclass AbortController so I can put the error in it:
class AbortContollerWithError extends AbortController {
abort(error) {
this.error = error;
super.abort();
}
}
then:
try {
const controller = new AbortController();
const { signal } = controller;
async_function()
.catch(err => {
controller.abort(err);
});
while (...) {
if (signal.aborted) {
throw controller.error;
}
await do_something_meanwhile(signal);
}
} catch (err) {
console.log('exited with error:',err)
}
...or something along those lines.
You asked how you'd use the signal in do_something_meanwhile, and suggested in a comment that you're really using a timer in it. That's where the signal's abort event comes in handy, you can use that to settle the promise early:
async function do_something_meanwhile(signal) {
let cancelError = {};
try {
await new Promise((resolve, reject) => {
const timer = setTimeout(resolve, 500);
signal.addEventListener("abort", () => {
clearTimeout(timer);
cancelError = new Error();
reject(cancelError);
});
});
console.log(Math.floor(Math.random() * 10));
} catch (error) {
if (error === cancelError) {
// Probably do nothing
} else {
// Something else went wrong, re-throw
throw error;
}
}
}

Promise.all can run async_function and do_something_meanwhile in parallel mode.
While Promise/A doesn't have a cancel method, you can define a stopFlag, and check it in do_something_meanwhile function and the while loop.
let stopFlag = false
async function async_function() {
await new Promise(r=>setTimeout(r, 3000));
throw 'task completed'
}
async function do_something_meanwhile() {
await new Promise(r => setTimeout(r, 500));
if (!stopFlag) {
console.log(Math.floor(Math.random() * 10));
}
}
(async()=>{
try {
await Promise.all([
async_function().catch((err) => {
stopFlag = true
throw err
}), // this returns an error after a while
(async () => {
while (!stopFlag)
await do_something_meanwhile();
})()
])
} catch (err) {
console.log('exited with error:', err)
}
console.log('moving on');
})();

Javascript - .catch async callback

Is it an anti-pattern to use an async method for catching errors?
await something().catch(aysnc (err) => {
console.log(err);
await rollback();
});
I am doing this because I need to make sure that the rollback has been executed before letting the user execute the method again:
const method = async () => {
if(isExecuting.current) return;
isExecuting.current = true;
await something().catch(aysnc (err) => {
console.log(err);
await rollback(); <--- I NEED TO AWAIT THIS TOO
});
isExecuting.current = false;
}

you can do it more clearly using try and catch
const method = async() => {
if (isExecuting.current) return;
isExecuting.current = true;
try {
await something();
} catch (err) {
console.log(err);
await rollback();
}
isExecuting.current = false;
}

How to throw out of then-catch block?

I am currently figuring out how to throw an Exception out of a then catch block. I want to get into the catch that is inside the errorHandler() function.
const errorHandler = function () {
try {
thisFunctionReturnsAnError().then(response => {
console.log(response);
});
} catch (e) {
console.log(e); //How to trigger this?
}
};
const thisFunctionReturnsAnError = function () {
return3()
.then(value => {
throw new Error('This is the error message.');
})
.catch(err => {
//return Promise.reject('this will get rejected');
throw err;
//this one should somehow got to the catch that is located in the errorHandler() function. How to do this?
//I know that this 'err' will be in the next catch block that is written here. This is not what i want.
});
};
const return3 = async function () {
return 3;
};
errorHandler();
I searched a while on stackoverflow but nothing helped me. I am sure that this question got asked often but I could not find the answer, sorry for that.
EDIT:
added here another version of the code but it still does not work
const errorHandler = async function () {
try {
thisFunctionReturnsAnError()
.then(response => console.log(response))
.catch(err => console.log(err));
} catch (e) {
//console.log(e); //How to trigger this?
}
};
const thisFunctionReturnsAnError = function () {
return3()
.then(value => {
throw new Error('This is the error message.');
})
.catch(err => {
return Promise.reject(`Message is: ${err}`);
});
};
const return3 = async function () {
return 3;
};
errorHandler();
I will get the following error message:
Uncaught (in promise) Message is: Error: This is the error message.

Your code can't be executed, because "thisFunctionReturnsAnError" is not returning an Promise. That means that you can't call "then" on the return value.
thisFunctionReturnsAnError().then(response => { // will not work
Why not always use a promise?
const errorHandler = function () {
thisFunctionReturnsAnError()
.then((response) => {
console.log(response);
})
.catch((error) => {
console.log('errorHandler: Handle the error.');
});
};
const thisFunctionReturnsAnError = function () {
return return_Three()
.then((value) => {
throw new Error('This is the error message.');
})
.catch((err) => {
//return Promise.reject('this will get rejected');
throw err;
//this one should somehow got to the catch that is located in the errorHandler() function. How to do this?
//I know that this 'err' will be in the next catch block that is written here. This is not what i want.
});
};
const return_Three = async function () {
return 3;
};
errorHandler();
/*****JUST ANOTHER SYNTAX*******/
const secondErrorHandler = async function () {
try {
await thisFunctionReturnsAnError();
} catch (error) {
console.log('secondErrorHandler: Handle the error.');
}
};
secondErrorHandler();

You cannot handle promise rejections with synchronous try/catch. Don't use it, use the promise .catch() method like in your thisFunctionReturnsAnError function.
You can handle promise rejections with try/catch when using async/await syntax (which you already do, albeit unnecessarily, in return3):
async function errorHandler() { /*
^^^^^ */
try {
const response = await thisFunctionReturnsAnError();
// ^^^^^
console.log(response);
} catch (e) {
console.log(e); // works
}
}

Unhandled Rejection

I am trying to handle (node:29804) UnhandledPromiseRejectionWarning: test1 first throw
, does any one have an idea of how i can cleanly handle it ?
I am not interested in using await in this situation.
const test0 = async () => {
try {
throw('test0 first throw');
}
catch(e) {
console.log('test0 last catch');
throw('test0 last throw');
}
}
const test1 = async () => {
try {
test0()
.catch(e => {
console.log('test1 first catch');
throw('test1 first throw'); // This throws unhandled exception
})
// return(0);
}
catch(e) {
console.log('test1 last catch');
throw('test1 last throw');
}
}
const caller = async () => {
try {
let res = test1().
catch(e => {
console.log('PRE FINAL CATCH');
})
console.log(res);
}
catch(e) {
console.log('FINAL CATCH');
// console.log(e);
}
}
caller();

It's a little uncommon to see a mix of try/catch and then()/catch() styles of handling promises.
You could remove the all the uneccessary try/catches and return where needed. No await involved. If an error happens somewhere in the other functions, it'll be logged and thrown back up to caller:
const test0 = async () => {
try {
throw('test0 first throw');
}
catch(e) {
console.log('test0 last catch');
throw('test0 last throw');
}
}
const test1 = async () => {
return test0()
.catch(e => {
console.log('test1 first catch');
throw('test1 first throw'); // This throws unhandled exception
});
}
const caller = async () => {
return test1().catch((e) => {
console.log('PRE FINAL CATCH');
});
}
caller();
If there are other requirements, I'm happy to amend this answer.

Thanks for your responses, i ended up doing some more reading on how async error handling works here: https://medium.com/javascript-in-plain-english/javascript-async-function-error-handling-is-not-what-you-think-dac10a98edb2
And ended up going with this code structure.
The idea was so have a similar function structure and error handling for async and awaited functions.
The reason i prefer to the try/catch block in this example is because it will catch all the other errors which may be within that function
// If you can NOT use await in the caller function then follow structure A
/************* BEGIN STRUCTURE A *************/
const handlerFnA = async(fnParam) => { await fnParam(); }
const fnDispatcherA = async () => {
try{
await handlerFnA(innerAsyncFnA);
}
catch (e){
console.log('error caught in fnDispatcher: ', e);
}
}
const innerAsyncFnA = async () => {
try {
throw('I am an error from innerAsyncFn');
}
catch(e) {
console.log('innerAsyncFn catch');
throw(e);
}
}
const callerA = async () => {
try {
fnDispatcherA();
}
catch(e) {
console.log('caller catch');
}
}
/*********** END STRUCTURE A ************/
// If you can use await in the caller function then follow structure B
/************* BEGIN STRUCTURE B *************/
const handlerFnB = async(fnParam) => { await fnParam(); }
const innerAsyncFnB = async () => {
try {
throw('I am an error from innerAsyncFn');
}
catch(e) {
console.log('innerAsyncFn catch');
throw(e);
}
}
const callerB = async () => {
try {
await handlerFnB(innerAsyncFnB);
}
catch(e) {
console.log('caller catch');
}
}
/*********** END STRUCTURE B ************/
callerB();

how to handle new Error() in node.js using ES6 Symbol?

I am creating a endpoint in node.js using ES6 Symbol. Example
// ES6 Symbol Method
const taskCreationMethod = {
[Symbol.taskMethod]() {
return {
storeCheckFunc: async function(storeId, employeeId) {
let store = await resourceModel["stores"].findById(storeId).populate(references["stores"]);
if(!store) {
return new Error("Store not found");
}
let employeeCheck = _.find(store.employees, (empObj) => {
return empObj._id == employeeId
})
if(!employeeCheck) {
return new Error("Employee not found");
}
return employeeCheck;
}
};
}
}
//end point
export const taskCreation = async(req, res) => {
const storeCheck = await taskCreationMethod[Symbol.taskMethod]().storeCheckFunc(req.body.store, req.body.assigned_to);
// here How can I handle return with Error Response?
}

You need to throw that error not just return it if you want to use the mechanisms of error handling. The thrown error will become a rejected promise which you can then handle with .catch() directly on the promise or with try/catch if you are using it in an async function. Here's a simplified example:
function populate() {
// always resolves to undefined
return Promise.resolve(undefined)
}
const taskCreationMethod = {
someMethod() {
return {
storeCheckFunc: async function() {
let store = await populate() // always resolves undefined
if (!store) { // so it always fails
throw new Error("Store not found"); // throw error
}
}
};
}
}
// regular promise then().catch()
taskCreationMethod.someMethod().storeCheckFunc()
.then(res => console.log(res))
.catch(err => console.log("Error:", err.message)) // catch
// OR … async function
async function runit() {
try {
let s = await taskCreationMethod.someMethod().storeCheckFunc()
} catch (err) {
console.log("Error:", err.message)
}
}
runit()