Handle some edge cases in responses from the server

packages-exp/auth-exp/demo/src/index.js

@@ -1220,18 +1220,18 @@ function onPopupRedirectProviderClick(_event) {
   const providerId = $(event.currentTarget).data('provider');
   let provider = null;
   switch (providerId) {
-      case 'google.com':
-        provider = new GoogleAuthProvider();
-        break;
-      case 'facebook.com':
-        provider = new FacebookAuthProvider();
-        break;
-      case 'github.com':
-        provider = new GithubAuthProvider();
-        break;
-      case 'twitter.com':
-        provider = new TwitterAuthProvider();
-        break;
+    case 'google.com':
+      provider = new GoogleAuthProvider();
+      break;
+    case 'facebook.com':
+      provider = new FacebookAuthProvider();
+      break;
+    case 'github.com':
+      provider = new GithubAuthProvider();
+      break;
+    case 'twitter.com':
+      provider = new TwitterAuthProvider();
+      break;
     default:
       return;
   }

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

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { expect, use } from 'chai';
+import { assert, expect, use } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
 import { SinonStub, stub, useFakeTimers } from 'sinon';
 
@@ -180,10 +180,10 @@ describe('api/_performApiRequest', () => {
         {
           error: {
             code: 400,
-            message: ServerError.EMAIL_EXISTS,
+            message: ServerError.EXPIRED_OOB_CODE,
             errors: [
               {
-                message: ServerError.EMAIL_EXISTS
+                message: ServerError.EXPIRED_OOB_CODE
               }
             ]
           }
@@ -196,7 +196,7 @@ describe('api/_performApiRequest', () => {
         Endpoint.SIGN_UP,
         request,
         {
-          [ServerError.EMAIL_EXISTS]: AuthErrorCode.ARGUMENT_ERROR
+          [ServerError.EXPIRED_OOB_CODE]: AuthErrorCode.ARGUMENT_ERROR
         }
       );
       await expect(promise).to.be.rejectedWith(
@@ -252,4 +252,88 @@ describe('api/_performApiRequest', () => {
       );
     });
   });
+
+  context('edgcase error mapping', () => {
+    beforeEach(mockFetch.setUp);
+    afterEach(mockFetch.tearDown);
+
+    it('should generate a need_conirmation error with the response', async () => {
+      mockEndpoint(Endpoint.SIGN_UP, {
+        needConfirmation: true,
+        idToken: 'id-token'
+      });
+      try {
+        await _performApiRequest<typeof request, typeof serverResponse>(
+          auth,
+          HttpMethod.POST,
+          Endpoint.SIGN_UP,
+          request
+        );
+        assert.fail('Call should have failed');
+      } catch (e) {
+        expect(e.code).to.eq(`auth/${AuthErrorCode.NEED_CONFIRMATION}`);
+        expect(e._tokenResponse).to.eql({
+          needConfirmation: true,
+          idToken: 'id-token'
+        });
+      }
+    });
+
+    it('should generate a credential already in use error', async () => {
+      const response = {
+        error: {
+          code: 400,
+          message: ServerError.FEDERATED_USER_ID_ALREADY_LINKED,
+          errors: [
+            {
+              message: ServerError.FEDERATED_USER_ID_ALREADY_LINKED
+            }
+          ]
+        }
+      };
+      mockEndpoint(Endpoint.SIGN_UP, response, 400);
+      try {
+        await _performApiRequest<typeof request, typeof serverResponse>(
+          auth,
+          HttpMethod.POST,
+          Endpoint.SIGN_UP,
+          request
+        );
+        assert.fail('Call should have failed');
+      } catch (e) {
+        expect(e.code).to.eq(`auth/${AuthErrorCode.CREDENTIAL_ALREADY_IN_USE}`);
+        expect(e._tokenResponse).to.eql(response);
+      }
+    });
+
+    it('should pull out email and phone number', async () => {
+      const response = {
+        error: {
+          code: 400,
+          message: ServerError.EMAIL_EXISTS,
+          errors: [
+            {
+              message: ServerError.EMAIL_EXISTS
+            }
+          ]
+        },
+        email: '[email protected]',
+        phoneNumber: '+1555-this-is-a-number'
+      };
+      mockEndpoint(Endpoint.SIGN_UP, response, 400);
+      try {
+        await _performApiRequest<typeof request, typeof serverResponse>(
+          auth,
+          HttpMethod.POST,
+          Endpoint.SIGN_UP,
+          request
+        );
+        assert.fail('Call should have failed');
+      } catch (e) {
+        expect(e.code).to.eq(`auth/${AuthErrorCode.EMAIL_EXISTS}`);
+        expect(e.email).to.eq('[email protected]');
+        expect(e.phoneNumber).to.eq('+1555-this-is-a-number');
+      }
+    });
+  });
 });

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

@@ -17,18 +17,17 @@
 
 import { FirebaseError, querystring } from '@firebase/util';
 
-import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../core/errors';
-import { Delay } from '../core/util/delay';
-import { Auth } from '../model/auth';
-import { IdTokenResponse } from '../model/id_token';
 import {
-  JsonError,
-  SERVER_ERROR_MAP,
-  ServerError,
-  ServerErrorMap
-} from './errors';
+  AUTH_ERROR_FACTORY,
+  AuthErrorCode,
+  NamedErrorParams
+} from '../core/errors';
 import { fail } from '../core/util/assert';
+import { Delay } from '../core/util/delay';
+import { Auth } from '../model/auth';
+import { IdTokenResponse, TaggedWithTokenResponse } from '../model/id_token';
 import { IdTokenMfaResponse } from './authentication/mfa';
+import { SERVER_ERROR_MAP, ServerError, ServerErrorMap } from './errors';
 
 export enum HttpMethod {
   POST = 'POST',
@@ -121,11 +120,26 @@ export async function _performFetchWithErrorHandling<V>(
       fetchFn(),
       makeNetworkTimeout(auth.name)
     ]);
+
+    const json = await response.json();
+    if ('needConfirmation' in json) {
+      throw makeTaggedError(auth, AuthErrorCode.NEED_CONFIRMATION, json);
+    }
+
     if (response.ok) {
-      return response.json();
+      return json;
     } else {
-      const json: JsonError = await response.json();
       const serverErrorCode = json.error.message.split(' : ')[0] as ServerError;
+      if (serverErrorCode === ServerError.FEDERATED_USER_ID_ALREADY_LINKED) {
+        throw makeTaggedError(
+          auth,
+          AuthErrorCode.CREDENTIAL_ALREADY_IN_USE,
+          json
+        );
+      } else if (serverErrorCode === ServerError.EMAIL_EXISTS) {
+        throw makeTaggedError(auth, AuthErrorCode.EMAIL_EXISTS, json);
+      }
+
       const authError = errorMap[serverErrorCode];
       if (authError) {
         fail(auth.name, authError);
@@ -179,3 +193,29 @@ function makeNetworkTimeout<T>(appName: string): Promise<T> {
     }, DEFAULT_API_TIMEOUT_MS.get())
   );
 }
+
+interface PotentialResponse extends IdTokenResponse {
+  email?: string;
+  phoneNumber?: string;
+}
+
+function makeTaggedError(
+  { name }: Auth,
+  code: AuthErrorCode,
+  response: PotentialResponse
+): FirebaseError {
+  const errorParams: NamedErrorParams = {
+    appName: name
+  };
+
+  if (response.email) {
+    errorParams.email = response.email;
+  }
+  if (response.phoneNumber) {
+    errorParams.phoneNumber = response.phoneNumber;
+  }
+
+  const error = AUTH_ERROR_FACTORY.create(code, errorParams);
+  (error as TaggedWithTokenResponse)._tokenResponse = response;
+  return error;
+}

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

@@ -18,6 +18,7 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 import * as externs from '@firebase/auth-types-exp';
 import { ErrorFactory, ErrorMap } from '@firebase/util';
+
 import { AppName } from '../model/auth';
 
 /*
@@ -329,6 +330,16 @@ const ERRORS: ErrorMap<AuthErrorCode> = {
     'This browser is not supported or 3rd party cookies and data may be disabled.'
 };
 
+export interface NamedErrorParams {
+  appName: AppName;
+  credential?: externs.AuthCredential;
+  email?: string;
+  phoneNumber?: string;
+  tenantId?: string;
+  user?: externs.User;
+  serverResponse?: object;
+}
+
 type AuthErrorParams = {
   [key in AuthErrorCode]: {
     appName: AppName;