Improved Error Handling for all packages

[Bullfrog1234]

Hi Everyone,

I have been using firebase for a while now and my pet pev is the error handling in the package and its child packages. As this is a large piece of work I wanted to make it a discussion that if agreed here then can be made to an issue for each product and then the code can be update. I would love for Google contributers to respond so that we get an understand on why we should or shouldn't do.

The Issues

Some of the issues are:

• Available error objects are not classes but instead are interfaces. Being an interface they reduce their useability in code to catch errors.
• There is no list of error codes you can expect this means you can't write robust code to check that you have captured all the edge cases.
• There is no standardised approach accross all of the firebase products to how errors are handled.

The Idea

I am suggesting that a systematic review of all error handling is completed that can follows the following:

• A error class per product is created, it will extend Error like:

class FirstoreError extends Error {
  //
}

• Each error code is made available as a type like, noting the codes I have used are not real error codes:

type FirestoreErrorCodes = "firestore/xxxx" | "firstore/yyyy"

• The error code type is used in the products error class so that intellisense will work. This will ensure that the developer experience is easier.
• That when a error is produced in a child packages child package (e.g. firstore -> grpc) the error is rethrown as a products error if it is wanted to be passed down or made to an internal error that includes the original error in the error class like:

class FirestoreError extends Error {
  private _errorCode: FirestoreErrorCodes = 'firestore/internal';
  private _originalError?: Error = undefined;

  constructor(
    errorCode: FirestoreErrorCodes,
    message: string,
    stack?:string,
    originalError?: Error
  ) {
    super(message);
    this._errorCode = errorCode;
    this._originalError = originalError;
    this.stack = stack
    this.message = message
  }

  errorCode = this._errorCode;
  originalError = this._originalError;
}

• This should be reviewed to try to do without creating breaking changes.

How it would be used

The error classes can then be used in code like the following:

if (err instanceof FirestoreError) {
   if (err.errorCode === 'firestore/internal') {
      // Do something
   }
  if (err.errorCode === 'firestore/xxxx' || err.errorCode === 'firstore/yyyy') {
     // Do something else
  }
}
      

Conculsions

I now open this up to your comments

As this covers multiple packages I am only adding this here.