Refactor the way UserCredentials work in anticipation of mudularization

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,20 @@ 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,19 +20,17 @@ 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';
 import { Auth } from '../../model/auth';
 import {
-  AuthEvent,
-  AuthEventType,
-  EventManager,
-  PopupRedirectResolver
+    AuthEvent, AuthEventType, EventManager, PopupRedirectResolver
 } from '../../model/popup_redirect';
 import { AuthEventManager } from '../auth/auth_event_manager';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
@@ -87,7 +85,8 @@ describe('src/core/strategies/abstract_popup_redirect_operation', () => {
         Promise.resolve(
           new UserCredentialImpl(
             testUser(auth, 'uid'),
-            null,
+            ProviderId.GOOGLE,
+            {...TEST_ID_TOKEN_RESPONSE},
             OperationType.SIGN_IN
           )
         )
@@ -146,7 +145,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, ProviderId, SignInMethod } 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,9 @@ describe('core/strategies/anonymous', () => {
         const userCredential = await signInAnonymously(auth);
         expect(userCredential.user.isAnonymous).to.be.true;
 
-        const { credential, user, operationType } = await signInAnonymously(
+        const { user, operationType } = await signInAnonymously(
           auth
         );
-        expect(credential?.providerId).to.eq(ProviderId.ANONYMOUS);
-        expect(credential?.signInMethod).to.eq(SignInMethod.ANONYMOUS);
         expect(operationType).to.eq(OperationType.SIGN_IN);
         expect(user.uid).to.eq(userCredential.user.uid);
         expect(user.isAnonymous).to.be.true;
@@ -84,11 +76,9 @@ describe('core/strategies/anonymous', () => {
         await auth.updateCurrentUser(fakeUser);
         expect(fakeUser.isAnonymous).to.be.false;
 
-        const { credential, user, operationType } = await signInAnonymously(
+        const { user, operationType } = await signInAnonymously(
           auth
         );
-        expect(credential?.providerId).to.eq(ProviderId.ANONYMOUS);
-        expect(credential?.signInMethod).to.eq(SignInMethod.ANONYMOUS);
         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';
@@ -30,7 +31,8 @@ export async function signInAnonymously(
     // If an anonymous user is already signed in, no need to sign them in again.
     return new UserCredentialImpl(
       auth.currentUser,
-      credential,
+      null,
+      undefined,
       externs.OperationType.SIGN_IN
     );
   }

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

@@ -19,11 +19,7 @@ import { expect, use } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
 import { stub } from 'sinon';
 
-import {
-  OperationType,
-  ProviderId,
-  SignInMethod
-} from '@firebase/auth-types-exp';
+import { OperationType, ProviderId, SignInMethod } from '@firebase/auth-types-exp';
 import { FirebaseError } from '@firebase/util';
 
 import { mockEndpoint } from '../../../test/helpers/api/helper';
@@ -37,13 +33,11 @@ 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 {
-  linkWithCredential,
-  reauthenticateWithCredential,
-  signInWithCredential
+    linkWithCredential, reauthenticateWithCredential, signInWithCredential
 } from './credential';
 
 use(chaiAsPromised);
@@ -95,12 +89,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 +164,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 +202,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,11 @@ 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');