translate-error.js

function translateError(msg) {
  var newErr = new Error(msg); // placed here to get correct stack
  return e => { 
    newErr.originalError = e;
    throw newErr;
  }
}

async function asyncTask() {  
    const user = await UserModel.findById(1).catch(translateError('No user found'))
    if(!user) throw new Error('No user found');

    const savedTask = await TaskModel({userId: user.id, name: 'Demo Task'})
      .catch(translateError('Error occurred while saving task'))

    if(user.notificationsEnabled) {
         await NotificationService.sendNotification(user.id, 'Task Created')
           .catch(translateError('Error while sending notification'))
    }

    if(savedTask.assignedUser.id !== user.id) {
        await NotificationService.sendNotification(savedTask.assignedUser.id, 'Task was created for you')
          .catch(translateError('Error while sending notification'))
    }
    
    return savedTask
}

i see some design flaws with this approach:

const p = new Promise((resolve, reject) => {
  return new Promise((r1, r2) => {
    throw new Error(42) // ERROR
  }).catch(e => reject(e))
})

async function main() {
  const res = await p.catch(e => { console.log('ERROR', e) })
  if (res) console.log('RES', res)
}

main()

and

const p = new Promise((resolve, reject) => {
  return new Promise((r1, r2) => {
    r2(42) // REJECTION
  }).catch(e => reject(e))
})

async function main() {
  const res = await p.catch(e => { console.log('ERROR', e) })
  if (res) console.log('RES', res)
}

main()

print out ERROR 42 and so they work correctly, BUT the following will not:

const p = new Promise((resolve, reject) => {
  return new Promise((r1, r2) => {
    r1(42) // RESOLVE
  }).catch(e => reject(e))
})

async function main() {
  const res = await p.catch(e => { console.log('ERROR', e) })
  if (res) console.log('RES', res)
}

main()

INSTEAD with these changes it will work:

const p = new Promise((resolve, reject) => {
  resolve(new Promise((r1, r2) => {
    r1(42)
  }).catch(e => reject(e)))
})

async function main() {
  const res = await p.catch(e => { console.log('ERROR', e) })
  if (res) console.log('RES', res)
}

main()

so as you can see in the case of nested promises, the catch error handling approach is not compatible for both success/failure scenarios.
what do you think about this, @spion?

I think you may've forgotten to paste the last two examples 😁 so I am not sure?

I think @phra has a point. @spion

Ok now I see it. No, that code has an error - returning a promise from a promise constructor doesn't do anything, that return value is ignored.

In the first examples it does something not because there is a return, but because an error is thrown and the catch statement rejects the outer promise.

In the non-working case an error is not thrown, so the catch statement doesn't run, so the outer promise never gets resolved.