Implement user.reload()

Author: sam-gc

packages-exp/auth-exp/src/api/account_management/account.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { Endpoint, HttpMethod, performApiRequest } from '..';
+import { Endpoint, HttpMethod, performApiRequest } from '../';
 import { Auth } from '../../model/auth';
 import { APIMFAInfo } from '../../model/id_token';
 
@@ -74,7 +74,7 @@ export interface APIUserInfo {
   createdAt?: number;
   tenantId?: string;
   passwordHash?: string;
-  providerUserInfo: ProviderUserInfo[];
+  providerUserInfo?: ProviderUserInfo[];
   mfaInfo?: APIMFAInfo[];
 }
 

packages-exp/auth-exp/src/core/user/reload.test.ts

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { expect, use } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import * as sinon from 'sinon';
+import * as sinonChai from 'sinon-chai';
+
+import { mockEndpoint } from '../../../test/api/helper';
+import { testUser } from '../../../test/mock_auth';
+import * as fetch from '../../../test/mock_fetch';
+import { Endpoint } from '../../api';
+import { APIUserInfo, ProviderUserInfo } from '../../api/account_management/account';
+import { UserInfo } from '../../model/user';
+import { ProviderId } from '../providers';
+import { _reloadWithoutSaving, reload } from './reload';
+
+use(chaiAsPromised);
+use(sinonChai);
+
+const BASIC_USER_INFO: UserInfo = {
+  providerId: ProviderId.FIREBASE,
+  uid: 'uid',
+  email: 'email',
+  displayName: 'displayName',
+  phoneNumber: 'phoneNumber',
+  photoURL: 'photoURL',
+};
+
+const BASIC_PROVIDER_USER_INFO: ProviderUserInfo = {
+  providerId: ProviderId.FIREBASE,
+  rawId: 'uid',
+  email: 'email',
+  displayName: 'displayName',
+  phoneNumber: 'phoneNumber',
+  photoUrl: 'photoURL',
+};
+
+describe('reload()', () => {
+  beforeEach(fetch.setUp);
+  afterEach(fetch.tearDown);
+
+  it('sets all the new properties', async () => {
+    const serverUser: APIUserInfo = {
+      localId: 'localId',
+      displayName: 'displayName',
+      photoUrl: 'photoURL',
+      email: 'email',
+      emailVerified: true,
+      phoneNumber: 'phoneNumber',
+      tenantId: 'tenantId',
+      createdAt: 123,
+      lastLoginAt: 456,
+    };
+
+    mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {
+      users: [serverUser],
+    });
+
+    const user = testUser('abc', '', true);
+    await _reloadWithoutSaving(user);
+    expect(user.uid).to.eq('localId');
+    expect(user.displayName).to.eq('displayName');
+    expect(user.photoURL).to.eq('photoURL');
+    expect(user.email).to.eq('email');
+    expect(user.emailVerified).to.be.true;
+    expect(user.phoneNumber).to.eq('phoneNumber');
+    expect(user.tenantId).to.eq('tenantId');
+    expect(user.metadata).to.eql({
+      creationTime: '123',
+      lastSignInTime: '456',
+    });
+  });
+
+  it('adds missing provider data', async () => {
+    const user = testUser('abc', '', true);
+    user.providerData = [{...BASIC_USER_INFO}];
+    mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {
+      users: [{
+        providerUserInfo: [{...BASIC_PROVIDER_USER_INFO, providerId: ProviderId.FACEBOOK}],
+      }],
+    });
+    await _reloadWithoutSaving(user);
+    expect(user.providerData).to.eql([
+      {...BASIC_USER_INFO},
+      {...BASIC_USER_INFO, providerId: ProviderId.FACEBOOK},
+    ]);
+  });
+
+  it('merges provider data, using the new data for overlaps', async () => {
+    const user = testUser('abc', '', true);
+    user.providerData = [
+      {
+        ...BASIC_USER_INFO,
+        providerId: ProviderId.GITHUB,
+        uid: 'i-will-be-overwritten',
+      },
+      {
+        ...BASIC_USER_INFO
+      }
+    ];
+    mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {
+      users: [{
+        providerUserInfo: [{...BASIC_PROVIDER_USER_INFO, providerId: ProviderId.GITHUB, rawId: 'new-uid'}],
+      }],
+    });
+    await _reloadWithoutSaving(user);
+    console.warn(user.providerData);
+    expect(user.providerData).to.eql([
+      {...BASIC_USER_INFO},
+      {
+        ...BASIC_USER_INFO,
+        providerId: ProviderId.GITHUB,
+        uid: 'new-uid',
+      },
+    ]);
+  });
+
+  it('reload calls auth.updateCurrentUser after completion', async () => {
+    mockEndpoint(Endpoint.GET_ACCOUNT_INFO, {
+      users: [{}],
+    });
+
+    const user = testUser('user', '', true);
+    const spy = sinon.spy(user.auth, 'updateCurrentUser');
+    await reload(user);
+    expect(spy).to.have.been.calledWith(user);
+  });
+});

packages-exp/auth-exp/src/core/user/reload.ts

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { getAccountInfo, ProviderUserInfo } from '../../api/account_management/account';
+import { User, UserInfo } from '../../model/user';
+import { ProviderId } from '../providers';
+import { assert } from '../util/assert';
+
+export async function _reloadWithoutSaving(
+  user: User
+): Promise<void> {
+  const auth = user.auth;
+  const idToken = await user.getIdToken();
+  const response = await getAccountInfo(auth, { idToken });
+
+  assert(response?.users.length, auth.name);
+
+  const coreAccount = response.users[0];
+  const newProviderData = coreAccount.providerUserInfo?.length
+    ? extractProviderData(coreAccount.providerUserInfo)
+    : [];
+  const updates: Partial<User> = {
+    uid: coreAccount.localId,
+    displayName: coreAccount.displayName || null,
+    photoURL: coreAccount.photoUrl || null,
+    email: coreAccount.email || null,
+    emailVerified: coreAccount.emailVerified || false,
+    phoneNumber: coreAccount.phoneNumber || null,
+    tenantId: coreAccount.tenantId || null,
+    providerData: mergeProviderData(user.providerData, newProviderData),
+    metadata: {
+      creationTime: coreAccount.createdAt?.toString(),
+      lastSignInTime: coreAccount.lastLoginAt?.toString()
+    }
+  };
+
+  Object.assign(user, updates);
+}
+
+export async function reload(user: User): Promise<void> {
+  await _reloadWithoutSaving(user);
+
+  // Even though the current user hasn't changed, update
+  // current user will trigger a persistence update w/ the
+  // new info.
+  return user.auth.updateCurrentUser(user);
+}
+
+function mergeProviderData(
+  original: UserInfo[],
+  newData: UserInfo[]
+): UserInfo[] {
+  const deduped = original.filter(
+    o => !newData.some(n => n.providerId === o.providerId)
+  );
+  return [...deduped, ...newData];
+}
+
+function extractProviderData(providers: ProviderUserInfo[]): UserInfo[] {
+  return providers.map(provider => ({
+    uid: provider.rawId || '',
+    displayName: provider.displayName || null,
+    email: provider.email || null,
+    phoneNumber: provider.phoneNumber || null,
+    providerId: provider.providerId as ProviderId,
+    photoURL: provider.photoUrl || null
+  }));
+}

packages-exp/auth-exp/src/core/user/user_impl.test.ts

@@ -17,11 +17,13 @@
 
 import { expect, use } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
+
+import { FirebaseError } from '@firebase/util';
+
 import { mockAuth } from '../../../test/mock_auth';
 import { IdTokenResponse } from '../../model/id_token';
 import { StsTokenManager } from './token_manager';
 import { UserImpl } from './user_impl';
-import { FirebaseError } from '@firebase/util';
 
 use(chaiAsPromised);
 
@@ -93,13 +95,6 @@ describe('core/user/user_impl', () => {
     });
   });
 
-  describe('#reload', () => {
-    it('throws', () => {
-      const user = new UserImpl({ uid: 'uid', auth, stsTokenManager });
-      expect(() => user.reload()).to.throw();
-    });
-  });
-
   describe('#delete', () => {
     it('throws', () => {
       const user = new UserImpl({ uid: 'uid', auth, stsTokenManager });

packages-exp/auth-exp/src/core/user/user_impl.ts

@@ -21,6 +21,7 @@ import { User } from '../../model/user';
 import { PersistedBlob } from '../persistence';
 import { ProviderId } from '../providers';
 import { assert, assertType } from '../util/assert';
+import { reload } from './reload';
 import { StsTokenManager } from './token_manager';
 
 export interface UserParameters {
@@ -43,6 +44,9 @@ export class UserImpl implements User {
   uid: string;
   auth: Auth;
   emailVerified = false;
+  tenantId = null;
+  metadata = {};
+  providerData = [];
 
   // Optional fields from UserInfo
   displayName: string | null;
@@ -77,7 +81,7 @@ export class UserImpl implements User {
   }
 
   reload(): Promise<void> {
-    throw new Error('Method not implemented.');
+    return reload(this);
   }
 
   delete(): Promise<void> {

packages-exp/auth-exp/src/model/user.d.ts

@@ -17,21 +17,31 @@
 
 import { PersistedBlob } from '../core/persistence';
 import { ProviderId } from '../core/providers';
+import { Auth } from './auth';
 import { IdTokenResult } from './id_token';
 
+export interface UserMetadata {
+  readonly creationTime?: string;
+  readonly lastSignInTime?: string;
+}
+
 export interface UserInfo {
-  readonly uid: string;
-  readonly providerId: ProviderId;
-  readonly displayName: string | null;
-  readonly email: string | null;
-  readonly phoneNumber: string | null;
-  readonly photoURL: string | null;
+  uid: string;
+  providerId: ProviderId;
+  displayName: string | null;
+  email: string | null;
+  phoneNumber: string | null;
+  photoURL: string | null;
 }
 
 export interface User extends UserInfo {
+  auth: Auth;
   providerId: ProviderId.FIREBASE;
   refreshToken: string;
   emailVerified: boolean;
+  tenantId: string | null;
+  providerData: UserInfo[];
+  metadata: UserMetadata;
 
   getIdToken(forceRefresh?: boolean): Promise<string>;
   getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult>;

packages-exp/auth-exp/test/mock_auth.ts

@@ -42,11 +42,21 @@ export const mockAuth: Auth = {
   _notifyStateListeners() {},
 };
 
-export function testUser(uid: string, email?: string): User {
+export function testUser(uid: string, email?: string, fakeTokens = false): User {
+  // Create a token manager that's valid off the bat to avoid refresh calls
+  const stsTokenManager = new StsTokenManager();
+  if (fakeTokens) {
+    Object.assign<StsTokenManager, Partial<StsTokenManager>>(stsTokenManager, {
+      expirationTime: Date.now() + 100_000,
+      accessToken: 'access-token',
+      refreshToken: 'refresh-token',
+    });
+  }
+
   return new UserImpl({
     uid,
     auth: mockAuth,
-    stsTokenManager: new StsTokenManager(),
+    stsTokenManager,
     email
   });
 }