Firebase Functions How To Handle Errors Properly [duplicate]

Question

NOTE: this question is mainly about error handling, and if this is an ok approach, not about nesting promises, please read before closing

Since there are currently no error codes for services like firestore and firebase database, i'm using a system to know where the function failed and to handle error accordingly, simplified version below:

exports.doStuff = functions.https.onCall((data, context) => {

    return [promise doing stuff goes here].catch(error => { throw new Error('ERROR0') })
        .then(result => {
            return [promise doing stuff goes here, needs result of previous promise]
                .catch(error => { throw new Error('ERROR1') })
        })
        .then(result => {
            return [promise doing stuff goes here, needs result of previous promise]
                .catch(error => { throw new Error('ERROR2') })
        })
        .then(result => {
            //inform client function successful
            return {
                success: true
            }
        })
        .catch(error => {
            if (error !== null) {
                switch (error.message) {
                    case 'ERROR0':
                        //do stuff
                        throw new functions.https.HttpsError('unknown', 'ERROR0');
                    case 'ERROR1':
                        //do stuff
                        throw new functions.https.HttpsError('unknown', 'ERROR1');
                    case 'ERROR2':
                        //do stuff
                        throw new functions.https.HttpsError('unknown', 'ERROR2');
                    default:
                        console.error('uncaught error: ', error);
                        throw error;
                }
            }
        });
});

the thing is, for each .catch() inside each returned promise, i'm getting the following warning: warning Avoid nesting promises

so my question is, is there a better way to handle errors?

Answer 1

Ultimately it's a style recommendation to prevent bizarre and hard to recognise errors. Most of the time a rewrite can eliminate the warning. As an example, you could rewrite your code as the following whilst retaining the same functionality.

exports.doStuff = functions.https.onCall(async (data, context) => {

    const result1 = await [promise doing stuff goes here]
      .catch(error => {
          throw new functions.https.HttpsError('unknown', 'ERROR0', { message: error.message } )
      });

    const result2 = await [promise based on result1 goes here]
      .catch(error => {
          throw new functions.https.HttpsError('unknown', 'ERROR1', { message: error.message } )
      });

    const result3 = await [promise based on result1/result2 goes here]
      .catch(error => {
          throw new functions.https.HttpsError('unknown', 'ERROR2', { message: error.message } )
      });

    return {
      success: true
    };
});

Lastly, rather than using unknown everywhere, you could use one of several possible values for the first argument whilst passing in whatever supporting information you need as the third argument (as shown above where I pass through the original error message).