Refactor auth error maps to make the verbose error map an optional dependency (#4008)

* Wow

* Fix some broken bits

* Tests

* Fixing tests

* Fix compat

* Formatting

* Remove auth error code from export

* Fix bad rebase

* Formatting

* PR feedback

* Fomratting

* Fix broken bit

* Fix broken build

* Fix broken tests

Author: sam-gc

common/api-review/auth-exp.api.md

@@ -6,6 +6,7 @@
 
 import { Auth } from '@firebase/auth-types-exp';
 import { CompleteFn } from '@firebase/util';
+import { ErrorFactory } from '@firebase/util';
 import { ErrorFn } from '@firebase/util';
 import * as externs from '@firebase/auth-types-exp';
 import { FirebaseApp } from '@firebase/app-types-exp';
@@ -82,6 +83,9 @@ export function createUserWithEmailAndPassword(auth: externs.Auth, email: string
 // @public
 export type CustomParameters = Record<string, string>;
 
+// @public
+export const debugErrorMap: externs.AuthErrorMap;
+
 // @public
 export function deleteUser(user: externs.User): Promise<void>;
 
@@ -309,6 +313,9 @@ export class PhoneMultiFactorGenerator implements externs.PhoneMultiFactorGenera
     static assertion(credential: externs.PhoneAuthCredential): externs.PhoneMultiFactorAssertion;
 }
 
+// @public
+export const prodErrorMap: externs.AuthErrorMap;
+
 // @public
 export function reauthenticateWithCredential(user: externs.User, credential: externs.AuthCredential): Promise<externs.UserCredential>;
 

packages-exp/auth-compat-exp/src/auth.ts

@@ -37,6 +37,7 @@ import {
 import { unwrap, Wrapper } from './wrap';
 
 const PERSISTENCE_KEY = 'persistence';
+const _assert: typeof impl._assert = impl._assert;
 
 export class Auth
   implements compat.FirebaseAuth, Wrapper<externs.Auth>, _FirebaseService {
@@ -59,10 +60,12 @@ export class Auth
     const hierarchy = persistences.map<impl.Persistence>(impl._getInstance);
 
     // TODO: platform needs to be determined using heuristics
-    impl.assertFn(apiKey, impl.AuthErrorCode.INVALID_API_KEY, {
+    _assert(apiKey, impl.AuthErrorCode.INVALID_API_KEY, {
       appName: app.name
     });
 
+    this.auth._updateErrorMap(impl.debugErrorMap);
+
     // This promise is intended to float; auth initialization happens in the
     // background, meanwhile the auth object may be used by the app.
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
@@ -128,10 +131,10 @@ export class Auth
     return impl.isSignInWithEmailLink(this.auth, emailLink);
   }
   async getRedirectResult(): Promise<compat.UserCredential> {
-    impl.assertFn(
+    _assert(
       _isPopupRedirectSupported(),
-      impl.AuthErrorCode.OPERATION_NOT_SUPPORTED,
-      { appName: this.app.name }
+      this.auth,
+      impl.AuthErrorCode.OPERATION_NOT_SUPPORTED
     );
     const credential = await impl.getRedirectResult(
       this.auth,
@@ -201,7 +204,7 @@ export class Auth
         case Persistence.NONE:
           return impl.inMemoryPersistence;
         default:
-          return impl.fail(impl.AuthErrorCode.ARGUMENT_ERROR, {
+          return impl._fail(impl.AuthErrorCode.ARGUMENT_ERROR, {
             appName: auth.name
           });
       }
@@ -266,10 +269,10 @@ export class Auth
   async signInWithPopup(
     provider: compat.AuthProvider
   ): Promise<compat.UserCredential> {
-    impl.assertFn(
+    _assert(
       _isPopupRedirectSupported(),
-      impl.AuthErrorCode.OPERATION_NOT_SUPPORTED,
-      { appName: this.app.name }
+      this.auth,
+      impl.AuthErrorCode.OPERATION_NOT_SUPPORTED
     );
     return convertCredential(
       this.auth,
@@ -281,10 +284,10 @@ export class Auth
     );
   }
   async signInWithRedirect(provider: compat.AuthProvider): Promise<void> {
-    impl.assertFn(
+    _assert(
       _isPopupRedirectSupported(),
-      impl.AuthErrorCode.OPERATION_NOT_SUPPORTED,
-      { appName: this.app.name }
+      this.auth,
+      impl.AuthErrorCode.OPERATION_NOT_SUPPORTED
     );
     this.savePersistenceForRedirect();
     return impl.signInWithRedirect(

packages-exp/auth-compat-exp/src/persistence.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { assertFn, AuthErrorCode } from '@firebase/auth-exp/internal';
+import { _assert, AuthErrorCode } from '@firebase/auth-exp/internal';
 import * as externs from '@firebase/auth-types-exp';
 import { isIndexedDBAvailable, isNode, isReactNative } from '@firebase/util';
 import { _isWebStorageSupported, _isWorker } from './platform';
@@ -34,45 +34,45 @@ export function _validatePersistenceArgument(
   auth: externs.Auth,
   persistence: string
 ): void {
-  assertFn(
+  _assert(
     Object.values(Persistence).includes(persistence),
-    AuthErrorCode.INVALID_PERSISTENCE,
-    { appName: auth.name }
+    auth,
+    AuthErrorCode.INVALID_PERSISTENCE
   );
   // Validate if the specified type is supported in the current environment.
   if (isReactNative()) {
     // This is only supported in a browser.
-    assertFn(
+    _assert(
       persistence !== Persistence.SESSION,
-      AuthErrorCode.UNSUPPORTED_PERSISTENCE,
-      { appName: auth.name }
+      auth,
+      AuthErrorCode.UNSUPPORTED_PERSISTENCE
     );
     return;
   }
   if (isNode()) {
     // Only none is supported in Node.js.
-    assertFn(
+    _assert(
       persistence === Persistence.NONE,
-      AuthErrorCode.UNSUPPORTED_PERSISTENCE,
-      { appName: auth.name }
+      auth,
+      AuthErrorCode.UNSUPPORTED_PERSISTENCE
     );
     return;
   }
   if (_isWorker()) {
     // In a worker environment, either LOCAL or NONE are supported.
     // If indexedDB not supported and LOCAL provided, throw an error
-    assertFn(
+    _assert(
       persistence === Persistence.NONE ||
         (persistence === Persistence.LOCAL && isIndexedDBAvailable()),
-      AuthErrorCode.UNSUPPORTED_PERSISTENCE,
-      { appName: auth.name }
+      auth,
+      AuthErrorCode.UNSUPPORTED_PERSISTENCE
     );
     return;
   }
   // This is restricted by what the browser supports.
-  assertFn(
+  _assert(
     persistence === Persistence.NONE || _isWebStorageSupported(),
-    AuthErrorCode.UNSUPPORTED_PERSISTENCE,
-    { appName: auth.name }
+    auth,
+    AuthErrorCode.UNSUPPORTED_PERSISTENCE
   );
 }

packages-exp/auth-compat-exp/src/recaptcha_verifier.ts

@@ -22,6 +22,8 @@ import * as compat from '@firebase/auth-types';
 import * as externs from '@firebase/auth-types-exp';
 import { unwrap, Wrapper } from './wrap';
 
+const _assert: typeof impl._assert = impl._assert;
+
 export class RecaptchaVerifier
   implements compat.RecaptchaVerifier, Wrapper<externs.ApplicationVerifier> {
   readonly verifier: externs.RecaptchaVerifier;
@@ -32,7 +34,7 @@ export class RecaptchaVerifier
     app: FirebaseApp = firebase.app()
   ) {
     // API key is required for web client RPC calls.
-    impl.assertFn(app.options?.apiKey, impl.AuthErrorCode.INVALID_API_KEY, {
+    _assert(app.options?.apiKey, impl.AuthErrorCode.INVALID_API_KEY, {
       appName: app.name
     });
     this.verifier = new impl.RecaptchaVerifier(

packages-exp/auth-exp/internal/index.ts

@@ -20,8 +20,6 @@
  */
 export * from '../index';
 
-import { assert } from '../src/core/util/assert';
-
 export { SignInWithIdpResponse } from '../src/api/authentication/idp';
 export { AuthErrorCode } from '../src/core/errors';
 export { Persistence } from '../src/core/persistence';
@@ -36,5 +34,4 @@ export { ClientPlatform, _getClientVersion } from '../src/core/util/version';
 
 export { _generateEventId } from '../src/core/util/event_id';
 
-export { fail } from '../src/core/util/assert';
-export const assertFn: typeof assert = assert;
+export { _fail, _assert } from '../src/core/util/assert';

packages-exp/auth-exp/src/api/index.test.ts

@@ -173,7 +173,7 @@ describe('api/_performApiRequest', () => {
       );
       await expect(promise).to.be.rejectedWith(
         FirebaseError,
-        'auth/internal-error'
+        'auth/awesome-error'
       );
       expect(mock.calls[0].request).to.eql(request);
     });

packages-exp/auth-exp/src/api/index.ts

@@ -17,13 +17,8 @@
 
 import { FirebaseError, querystring } from '@firebase/util';
 
-import {
-  AUTH_ERROR_FACTORY,
-  AuthErrorCode,
-  NamedErrorParams,
-  ERRORS
-} from '../core/errors';
-import { fail } from '../core/util/assert';
+import { AuthErrorCode, NamedErrorParams } from '../core/errors';
+import { _createError, _fail } from '../core/util/assert';
 import { Delay } from '../core/util/delay';
 import { _emulatorUrl } from '../core/util/emulator';
 import { FetchProvider } from '../core/util/fetch_provider';
@@ -122,7 +117,7 @@ export async function _performFetchWithErrorHandling<V>(
   (auth as AuthInternal)._canInitEmulator = false;
   const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };
   try {
-    const networkTimeout = new NetworkTimeout<Response>(auth.name);
+    const networkTimeout = new NetworkTimeout<Response>(auth);
     const response: Response = await Promise.race<Promise<Response>>([
       fetchFn(),
       networkTimeout.promise
@@ -154,21 +149,14 @@ export async function _performFetchWithErrorHandling<V>(
         errorMap[serverErrorCode] ||
         ((serverErrorCode
           .toLowerCase()
-          .replace(/_/g, '-') as unknown) as AuthErrorCode);
-      if (authError && Object.keys(ERRORS).includes(authError)) {
-        fail(authError, { appName: auth.name });
-      } else {
-        // TODO probably should handle improperly formatted errors as well
-        // If you see this, add an entry to SERVER_ERROR_MAP for the corresponding error
-        console.error(`Unexpected API error: ${json.error.message}`);
-        fail(AuthErrorCode.INTERNAL_ERROR, { appName: auth.name });
-      }
+          .replace(/[_\s]+/g, '-') as unknown) as AuthErrorCode);
+      _fail(auth, authError);
     }
   } catch (e) {
     if (e instanceof FirebaseError) {
       throw e;
     }
-    fail(AuthErrorCode.NETWORK_REQUEST_FAILED, { appName: auth.name });
+    _fail(auth, AuthErrorCode.NETWORK_REQUEST_FAILED);
   }
 }
 
@@ -187,8 +175,7 @@ export async function _performSignInRequest<T, V extends IdTokenResponse>(
     customErrorMap
   )) as V;
   if ('mfaPendingCredential' in serverResponse) {
-    throw AUTH_ERROR_FACTORY.create(AuthErrorCode.MFA_REQUIRED, {
-      appName: auth.name,
+    _fail(auth, AuthErrorCode.MFA_REQUIRED, {
       serverResponse
     });
   }
@@ -218,19 +205,15 @@ class NetworkTimeout<T> {
   private timer: any | null = null;
   readonly promise = new Promise<T>((_, reject) => {
     this.timer = setTimeout(() => {
-      return reject(
-        AUTH_ERROR_FACTORY.create(AuthErrorCode.TIMEOUT, {
-          appName: this.appName
-        })
-      );
+      return reject(_createError(this.auth, AuthErrorCode.TIMEOUT));
     }, DEFAULT_API_TIMEOUT_MS.get());
   });
 
   clearNetworkTimeout(): void {
     clearTimeout(this.timer);
   }
 
-  constructor(private readonly appName: string) {}
+  constructor(private readonly auth: Auth) {}
 }
 
 interface PotentialResponse extends IdTokenResponse {
@@ -239,12 +222,12 @@ interface PotentialResponse extends IdTokenResponse {
 }
 
 function makeTaggedError(
-  { name }: Auth,
+  auth: Auth,
   code: AuthErrorCode,
   response: PotentialResponse
 ): FirebaseError {
   const errorParams: NamedErrorParams = {
-    appName: name
+    appName: auth.name
   };
 
   if (response.email) {
@@ -254,7 +237,7 @@ function makeTaggedError(
     errorParams.phoneNumber = response.phoneNumber;
   }
 
-  const error = AUTH_ERROR_FACTORY.create(code, errorParams);
+  const error = _createError(auth, code, errorParams);
 
   // We know customData is defined on error because errorParams is defined
   (error.customData! as TaggedWithTokenResponse)._tokenResponse = response;

packages-exp/auth-exp/src/core/action_code_url.ts

@@ -16,7 +16,8 @@
  */
 
 import * as externs from '@firebase/auth-types-exp';
-import { AuthErrorCode, AUTH_ERROR_FACTORY } from './errors';
+import { AuthErrorCode } from './errors';
+import { _assert } from './util/assert';
 
 /**
  * Enums for fields in URL query string.
@@ -108,9 +109,7 @@ export class ActionCodeURL implements externs.ActionCodeURL {
     const code = uri.searchParams.get(QueryField.CODE);
     const operation = parseMode(uri.searchParams.get(QueryField.MODE));
     // Validate API key, code and mode.
-    if (!apiKey || !code || !operation) {
-      throw AUTH_ERROR_FACTORY.create(AuthErrorCode.ARGUMENT_ERROR, {});
-    }
+    _assert(apiKey && code && operation, AuthErrorCode.ARGUMENT_ERROR);
     this.apiKey = apiKey;
     this.operation = operation;
     this.code = code;

packages-exp/auth-exp/src/core/auth/auth_event_manager.test.ts

@@ -18,6 +18,7 @@
 import { expect, use } from 'chai';
 import * as sinon from 'sinon';
 import * as sinonChai from 'sinon-chai';
+import { testAuth } from '../../../test/helpers/mock_auth';
 
 import {
   AuthEvent,
@@ -53,8 +54,8 @@ describe('core/auth/auth_event_manager', () => {
     } as AuthEvent;
   }
 
-  beforeEach(() => {
-    manager = new AuthEventManager('app-name');
+  beforeEach(async () => {
+    manager = new AuthEventManager(await testAuth());
   });
 
   it('multiple consumers may be registered for one event type', () => {

packages-exp/auth-exp/src/core/auth/auth_event_manager.ts

@@ -21,7 +21,9 @@ import {
   AuthEventType,
   EventManager
 } from '../../model/popup_redirect';
-import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
+import { AuthErrorCode } from '../errors';
+import { Auth } from '../../model/auth';
+import { _createError } from '../util/assert';
 
 // The amount of time to store the UIDs of seen events; this is
 // set to 10 min by default
@@ -34,7 +36,7 @@ export class AuthEventManager implements EventManager {
   private hasHandledPotentialRedirect = false;
   private lastProcessedEventTime = Date.now();
 
-  constructor(private readonly appName: string) {}
+  constructor(private readonly auth: Auth) {}
 
   registerConsumer(authEventConsumer: AuthEventConsumer): void {
     this.consumers.add(authEventConsumer);
@@ -90,11 +92,7 @@ export class AuthEventManager implements EventManager {
       const code =
         (event.error.code?.split('auth/')[1] as AuthErrorCode) ||
         AuthErrorCode.INTERNAL_ERROR;
-      consumer.onError(
-        AUTH_ERROR_FACTORY.create(code, {
-          appName: this.appName
-        })
-      );
+      consumer.onError(_createError(this.auth, code));
     } else {
       consumer.onAuthEvent(event);
     }