Refactor the way UserCredentials work in anticipation of mudularization (#3489)

* Refactor the way UserCredentials work in anticipation of mudularization

* Formatting

* PR feedback

* Linter fixes

* Formatting

Author: sam-gc

packages-exp/auth-exp/src/core/credentials/from_token_response.test.ts

@@ -16,15 +16,18 @@
  */
 
 import * as externs from '@firebase/auth-types-exp';
-
 // eslint-disable-next-line import/no-extraneous-dependencies
 import { FirebaseError } from '@firebase/util';
+
+import { SignInWithPhoneNumberResponse } from '../../api/authentication/sms';
+import { ApplicationVerifier } from '../../model/application_verifier';
 import { Auth } from '../../model/auth';
+import { UserCredential } from '../../model/user';
 import { initializeAuth } from '../auth/auth_impl';
 import { PhoneAuthCredential } from '../credentials/phone';
+import { AuthErrorCode } from '../errors';
 import { _verifyPhoneNumber } from '../strategies/phone';
-import { debugFail } from '../util/assert';
-import { ApplicationVerifier } from '../../model/application_verifier';
+import { assert, debugFail, fail } from '../util/assert';
 
 export class PhoneAuthProvider implements externs.PhoneAuthProvider {
   static readonly PROVIDER_ID = externs.ProviderId.PHONE;
@@ -58,11 +61,27 @@ export class PhoneAuthProvider implements externs.PhoneAuthProvider {
     );
   }
 
-  static _credentialFromResult(
+  static credentialFromResult(
     userCredential: externs.UserCredential
   ): externs.AuthCredential | null {
-    void userCredential;
-    return debugFail('not implemented');
+    const credential = userCredential as UserCredential;
+    assert(
+      credential._tokenResponse,
+      credential.user.auth.name,
+      AuthErrorCode.ARGUMENT_ERROR
+    );
+    const {
+      phoneNumber,
+      temporaryProof
+    } = credential._tokenResponse as SignInWithPhoneNumberResponse;
+    if (phoneNumber && temporaryProof) {
+      return PhoneAuthCredential._fromTokenResponse(
+        phoneNumber,
+        temporaryProof
+      );
+    }
+
+    fail(credential.user.auth.name, AuthErrorCode.ARGUMENT_ERROR);
   }
 
   static _credentialFromError(

packages-exp/auth-exp/src/core/credentials/from_token_response.ts

@@ -20,10 +20,11 @@ import * as chaiAsPromised from 'chai-as-promised';
 import * as sinon from 'sinon';
 import * as sinonChai from 'sinon-chai';
 
-import { OperationType } from '@firebase/auth-types-exp';
+import { OperationType, ProviderId } from '@firebase/auth-types-exp';
 import { FirebaseError } from '@firebase/util';
 
 import { delay } from '../../../test/helpers/delay';
+import { TEST_ID_TOKEN_RESPONSE } from '../../../test/helpers/id_token_response';
 import { authEvent, BASE_AUTH_EVENT } from '../../../test/helpers/iframe_event';
 import { testAuth, testUser } from '../../../test/helpers/mock_auth';
 import { makeMockPopupRedirectResolver } from '../../../test/helpers/mock_popup_redirect_resolver';
@@ -85,11 +86,12 @@ describe('src/core/strategies/abstract_popup_redirect_operation', () => {
       );
       idpStubs._signIn.returns(
         Promise.resolve(
-          new UserCredentialImpl(
-            testUser(auth, 'uid'),
-            null,
-            OperationType.SIGN_IN
-          )
+          new UserCredentialImpl({
+            user: testUser(auth, 'uid'),
+            providerId: ProviderId.GOOGLE,
+            _tokenResponse: { ...TEST_ID_TOKEN_RESPONSE },
+            operationType: OperationType.SIGN_IN
+          })
         )
       );
     });
@@ -146,7 +148,7 @@ describe('src/core/strategies/abstract_popup_redirect_operation', () => {
       finishPromise(authEvent());
       const cred = (await operation.execute())!;
       expect(cred.user.uid).to.eq('uid');
-      expect(cred.credential).to.be.null;
+      expect(cred._tokenResponse).to.eql(TEST_ID_TOKEN_RESPONSE);
       expect(cred.operationType).to.eq(OperationType.SIGN_IN);
     });
 

packages-exp/auth-exp/src/core/providers/phone.ts

@@ -17,11 +17,7 @@
 
 import { expect } from 'chai';
 
-import {
-  OperationType,
-  ProviderId,
-  SignInMethod
-} from '@firebase/auth-types-exp';
+import { OperationType } from '@firebase/auth-types-exp';
 
 import { mockEndpoint } from '../../../test/helpers/api/helper';
 import { testAuth, testUser } from '../../../test/helpers/mock_auth';
@@ -54,9 +50,7 @@ describe('core/strategies/anonymous', () => {
 
   describe('signInAnonymously', () => {
     it('should sign in an anonymous user', async () => {
-      const { credential, user, operationType } = await signInAnonymously(auth);
-      expect(credential?.providerId).to.eq(ProviderId.ANONYMOUS);
-      expect(credential?.signInMethod).to.eq(SignInMethod.ANONYMOUS);
+      const { user, operationType } = await signInAnonymously(auth);
       expect(operationType).to.eq(OperationType.SIGN_IN);
       expect(user.uid).to.eq(serverUser.localId);
       expect(user.isAnonymous).to.be.true;
@@ -67,11 +61,7 @@ describe('core/strategies/anonymous', () => {
         const userCredential = await signInAnonymously(auth);
         expect(userCredential.user.isAnonymous).to.be.true;
 
-        const { credential, user, operationType } = await signInAnonymously(
-          auth
-        );
-        expect(credential?.providerId).to.eq(ProviderId.ANONYMOUS);
-        expect(credential?.signInMethod).to.eq(SignInMethod.ANONYMOUS);
+        const { user, operationType } = await signInAnonymously(auth);
         expect(operationType).to.eq(OperationType.SIGN_IN);
         expect(user.uid).to.eq(userCredential.user.uid);
         expect(user.isAnonymous).to.be.true;
@@ -84,11 +74,7 @@ describe('core/strategies/anonymous', () => {
         await auth.updateCurrentUser(fakeUser);
         expect(fakeUser.isAnonymous).to.be.false;
 
-        const { credential, user, operationType } = await signInAnonymously(
-          auth
-        );
-        expect(credential?.providerId).to.eq(ProviderId.ANONYMOUS);
-        expect(credential?.signInMethod).to.eq(SignInMethod.ANONYMOUS);
+        const { user, operationType } = await signInAnonymously(auth);
         expect(operationType).to.eq(OperationType.SIGN_IN);
         expect(user.uid).to.not.eq(fakeUser.uid);
         expect(user.isAnonymous).to.be.true;

packages-exp/auth-exp/src/core/strategies/abstract_popup_redirect_operation.test.ts

@@ -16,6 +16,7 @@
  */
 
 import * as externs from '@firebase/auth-types-exp';
+
 import { Auth } from '../../model/auth';
 import { AnonymousProvider } from '../providers/anonymous';
 import { UserCredentialImpl } from '../user/user_credential_impl';
@@ -28,11 +29,11 @@ export async function signInAnonymously(
   const credential = AnonymousProvider.credential();
   if (auth.currentUser?.isAnonymous) {
     // If an anonymous user is already signed in, no need to sign them in again.
-    return new UserCredentialImpl(
-      auth.currentUser,
-      credential,
-      externs.OperationType.SIGN_IN
-    );
+    return new UserCredentialImpl({
+      user: auth.currentUser,
+      providerId: null,
+      operationType: externs.OperationType.SIGN_IN
+    });
   }
   return signInWithCredential(auth, credential);
 }

packages-exp/auth-exp/src/core/strategies/anonymous.test.ts

@@ -37,7 +37,7 @@ import { IdTokenMfaResponse } from '../../api/authentication/mfa';
 import { MultiFactorError } from '../../mfa/mfa_error';
 import { Auth } from '../../model/auth';
 import { IdTokenResponse, IdTokenResponseKind } from '../../model/id_token';
-import { User } from '../../model/user';
+import { User, UserCredential } from '../../model/user';
 import { AuthCredential } from '../credentials';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
 import {
@@ -95,12 +95,11 @@ describe('core/strategies/credential', () => {
       stub(authCredential, '_getIdTokenResponse').returns(
         Promise.resolve(idTokenResponse)
       );
-      const { credential, user, operationType } = await signInWithCredential(
+      const { user, operationType, ...rest } = await signInWithCredential(
         auth,
         authCredential
       );
-      expect(credential!.providerId).to.eq(ProviderId.FIREBASE);
-      expect(credential!.signInMethod).to.eq(SignInMethod.EMAIL_LINK);
+      expect((rest as UserCredential)._tokenResponse).to.eq(idTokenResponse);
       expect(user.uid).to.eq('local-id');
       expect(user.tenantId).to.eq('tenant-id');
       expect(user.displayName).to.eq('display-name');
@@ -171,13 +170,16 @@ describe('core/strategies/credential', () => {
       );
 
       const {
-        credential,
         user: newUser,
-        operationType
+        operationType,
+        ...rest
       } = await reauthenticateWithCredential(user, authCredential);
       expect(operationType).to.eq(OperationType.REAUTHENTICATE);
       expect(newUser).to.eq(user);
-      expect(credential).to.be.null;
+      expect((rest as UserCredential)._tokenResponse).to.eql({
+        ...idTokenResponse,
+        idToken: makeJWT({ sub: 'uid' })
+      });
     });
   });
 
@@ -206,13 +208,13 @@ describe('core/strategies/credential', () => {
         Promise.resolve(idTokenResponse)
       );
       const {
-        credential,
         user: newUser,
-        operationType
+        operationType,
+        ...rest
       } = await linkWithCredential(user, authCredential);
       expect(operationType).to.eq(OperationType.LINK);
       expect(newUser).to.eq(user);
-      expect(credential).to.be.null;
+      expect((rest as UserCredential)._tokenResponse).to.eq(idTokenResponse);
     });
   });
 });

packages-exp/auth-exp/src/core/strategies/anonymous.ts

@@ -16,8 +16,8 @@
  */
 
 import * as externs from '@firebase/auth-types-exp';
-
 import { OperationType, UserCredential } from '@firebase/auth-types-exp';
+
 import { _processCredentialSavingMfaContextIfNecessary } from '../../mfa/mfa_error';
 import { Auth } from '../../model/auth';
 import { User } from '../../model/user';

packages-exp/auth-exp/src/core/strategies/credential.test.ts

@@ -27,6 +27,7 @@ import { Endpoint } from '../../api';
 import { APIUserInfo } from '../../api/account_management/account';
 import { Auth } from '../../model/auth';
 import { IdTokenResponse, IdTokenResponseKind } from '../../model/id_token';
+import { UserCredential } from '../../model/user';
 import { signInWithCustomToken } from './custom_token';
 
 use(chaiAsPromised);
@@ -65,11 +66,15 @@ describe('core/strategies/signInWithCustomToken', () => {
   afterEach(mockFetch.tearDown);
 
   it('should return a valid user credential', async () => {
-    const { credential, user, operationType } = await signInWithCustomToken(
+    const {
+      user,
+      operationType,
+      _tokenResponse
+    } = (await signInWithCustomToken(
       auth,
       'look-at-me-im-a-jwt'
-    );
-    expect(credential).to.be.null;
+    )) as UserCredential;
+    expect(_tokenResponse).to.eql(idTokenResponse);
     expect(user.uid).to.eq('local-id');
     expect(user.tenantId).to.eq('tenant-id');
     expect(user.displayName).to.eq('display-name');