Merge d13b99c into c1e9229

Author: avolkovi

packages-exp/auth-exp/index.ts

@@ -21,7 +21,7 @@ import { Auth } from '@firebase/auth-types-exp';
 import { initializeAuth } from './src';
 import { registerAuth } from './src/core/auth/register';
 import { ClientPlatform } from './src/core/util/version';
-import { browserLocalPersistence } from './src/platform_browser/persistence/browser';
+import { browserLocalPersistence } from './src/platform_browser/persistence/local_storage';
 import { indexedDBLocalPersistence } from './src/platform_browser/persistence/indexed_db';
 import { browserPopupRedirectResolver } from './src/platform_browser/popup_redirect';
 
@@ -31,10 +31,8 @@ export * from './src';
 // Additional DOM dependend functionality
 
 // persistence
-export {
-  browserLocalPersistence,
-  browserSessionPersistence
-} from './src/platform_browser/persistence/browser';
+export { browserLocalPersistence } from './src/platform_browser/persistence/local_storage';
+export { browserSessionPersistence } from './src/platform_browser/persistence/session_storage';
 export { indexedDBLocalPersistence } from './src/platform_browser/persistence/indexed_db';
 
 // providers

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

@@ -29,6 +29,9 @@ import { indexedDBLocalPersistence } from './src/platform_browser/persistence/in
 // Core functionality shared by all clients
 export * from './src';
 
+// persistence
+export { indexedDBLocalPersistence } from './src/platform_browser/persistence/indexed_db';
+
 registerAuth(ClientPlatform.WORKER);
 
 export function getAuth(app = getApp()): Auth {

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

@@ -265,4 +265,126 @@ describe('core/auth/auth_impl', () => {
       });
     });
   });
+
+  describe('#_onStorageEvent', () => {
+    let authStateCallback: sinon.SinonSpy;
+    let idTokenCallback: sinon.SinonSpy;
+
+    beforeEach(async () => {
+      authStateCallback = sinon.spy();
+      idTokenCallback = sinon.spy();
+      auth._onAuthStateChanged(authStateCallback);
+      auth._onIdTokenChanged(idTokenCallback);
+      await auth.updateCurrentUser(null); // force event handlers to clear out
+      authStateCallback.resetHistory();
+      idTokenCallback.resetHistory();
+    });
+
+    context('previously logged out', () => {
+      context('still logged out', () => {
+        it('should do nothing', async () => {
+          await auth._onStorageEvent();
+
+          expect(authStateCallback).not.to.have.been.called;
+          expect(idTokenCallback).not.to.have.been.called;
+        });
+      });
+
+      context('now logged in', () => {
+        let user: User;
+
+        beforeEach(() => {
+          user = testUser(auth, 'uid');
+          persistenceStub.get.returns(Promise.resolve(user.toJSON()));
+        });
+
+        it('should update the current user', async () => {
+          await auth._onStorageEvent();
+
+          expect(auth.currentUser?.toJSON()).to.eql(user.toJSON());
+          expect(authStateCallback).to.have.been.called;
+          expect(idTokenCallback).to.have.been.called;
+        });
+      });
+    });
+
+    context('previously logged in', () => {
+      let user: User;
+
+      beforeEach(async () => {
+        user = testUser(auth, 'uid', undefined, true);
+        await auth.updateCurrentUser(user);
+        authStateCallback.resetHistory();
+        idTokenCallback.resetHistory();
+      });
+
+      context('now logged out', () => {
+        beforeEach(() => {
+          persistenceStub.get.returns(Promise.resolve(null));
+        });
+
+        it('should log out', async () => {
+          await auth._onStorageEvent();
+
+          expect(auth.currentUser).to.be.null;
+          expect(authStateCallback).to.have.been.called;
+          expect(idTokenCallback).to.have.been.called;
+        });
+      });
+
+      context('still logged in as same user', () => {
+        it('should do nothing if nothing changed', async () => {
+          persistenceStub.get.returns(Promise.resolve(user.toJSON()));
+
+          await auth._onStorageEvent();
+
+          expect(auth.currentUser?.toJSON()).to.eql(user.toJSON());
+          expect(authStateCallback).not.to.have.been.called;
+          expect(idTokenCallback).not.to.have.been.called;
+        });
+
+        it('should update fields if they have changed', async () => {
+          const userObj = user.toJSON();
+          userObj['displayName'] = 'other-name';
+          persistenceStub.get.returns(Promise.resolve(userObj));
+
+          await auth._onStorageEvent();
+
+          expect(auth.currentUser?.uid).to.eq(user.uid);
+          expect(auth.currentUser?.displayName).to.eq('other-name');
+          expect(authStateCallback).not.to.have.been.called;
+          expect(idTokenCallback).not.to.have.been.called;
+        });
+
+        it('should update tokens if they have changed', async () => {
+          const userObj = user.toJSON();
+          (userObj['stsTokenManager'] as any)['accessToken'] =
+            'new-access-token';
+          persistenceStub.get.returns(Promise.resolve(userObj));
+
+          await auth._onStorageEvent();
+
+          expect(auth.currentUser?.uid).to.eq(user.uid);
+          expect(auth.currentUser?.stsTokenManager.accessToken).to.eq(
+            'new-access-token'
+          );
+          expect(authStateCallback).not.to.have.been.called;
+          expect(idTokenCallback).to.have.been.called;
+        });
+      });
+
+      context('now logged in as different user', () => {
+        it('should re-login as the new user', async () => {
+          const newUser = testUser(auth, 'other-uid', undefined, true);
+          persistenceStub.get.returns(Promise.resolve(newUser.toJSON()));
+
+          await auth._onStorageEvent();
+
+          expect(auth.currentUser?.toJSON()).to.eql(newUser.toJSON());
+          expect(authStateCallback).to.have.been.called;
+          expect(idTokenCallback).to.have.been.called;
+        });
+      });
+    });
+  });
 });

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

@@ -107,6 +107,34 @@ export class AuthImplCompat<T extends User> implements Auth, _FirebaseService {
     return this._initializationPromise;
   }
 
+  /**
+   * If the persistence is changed in another window, the user manager will let us know
+   */
+  async _onStorageEvent(): Promise<void> {
+    const user = await this.persistenceManager!.getCurrentUser();
+
+    if (!this.currentUser && !user) {
+      // No change, do nothing (was signed out and remained signed out).
+      return;
+    }
+
+    // If the same user is to be synchronized.
+    if (this.currentUser && user && this.currentUser.uid === user.uid) {
+      // Data update, simply copy data changes.
+      this.currentUser._copy(user);
+      // If tokens changed from previous user tokens, this will trigger
+      // notifyAuthListeners_.
+      await this.currentUser.getIdToken();
+      return;
+    }
+
+    // Update current Auth state. Either a new login or logout.
+    await this.updateCurrentUser(user);
+    // TODO: If a new user is signed in, enabled popup and redirect on that user.
+    // Notify external Auth changes of Auth change event.
+    this.notifyAuthListeners();
+  }
+
   _createUser(params: UserParameters): T {
     return new this._userProvider(params);
   }

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

@@ -70,13 +70,9 @@ describe('src/core/auth/firebase_internal', () => {
     beforeEach(async () => {
       user = testUser(auth, 'uid', undefined, true);
       await auth.updateCurrentUser(user);
-      sinon.stub(user.stsTokenManager, 'getToken').returns(
-        Promise.resolve({
-          accessToken: 'access-token',
-          refreshToken: 'refresh-tken',
-          wasRefreshed: true
-        })
-      );
+      sinon
+        .stub(user.stsTokenManager, 'getToken')
+        .returns(Promise.resolve('new-access-token'));
       sinon
         .stub(user, '_startProactiveRefresh')
         .callsFake(() => (isProactiveRefresh = true));

packages-exp/auth-exp/src/core/persistence/in_memory.ts

@@ -17,7 +17,12 @@
 
 import * as externs from '@firebase/auth-types-exp';
 
-import { Persistence, PersistenceType, PersistenceValue } from '../persistence';
+import {
+  Persistence,
+  PersistenceType,
+  PersistenceValue,
+  StorageEventListener
+} from '../persistence';
 
 export class InMemoryPersistence implements Persistence {
   static type: 'NONE' = 'NONE';
@@ -40,6 +45,16 @@ export class InMemoryPersistence implements Persistence {
   async remove(key: string): Promise<void> {
     delete this.storage[key];
   }
+
+  addListener(_key: string, _listener: StorageEventListener): void {
+    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers
+    return;
+  }
+
+  removeListener(_key: string, _listener: StorageEventListener): void {
+    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers
+    return;
+  }
 }
 
 export const inMemoryPersistence: externs.Persistence = InMemoryPersistence;

packages-exp/auth-exp/src/core/persistence/index.ts

@@ -31,10 +31,16 @@ export type PersistenceValue = PersistedBlob | string;
 
 export const STORAGE_AVAILABLE_KEY = '__sak';
 
+export interface StorageEventListener {
+  (value: PersistenceValue | null): void;
+}
+
 export interface Persistence {
   type: PersistenceType;
   isAvailable(): Promise<boolean>;
   set(key: string, value: PersistenceValue): Promise<void>;
   get<T extends PersistenceValue>(key: string): Promise<T | null>;
   remove(key: string): Promise<void>;
+  addListener(key: string, listener: StorageEventListener): void;
+  removeListener(key: string, listener: StorageEventListener): void;
 }

packages-exp/auth-exp/src/core/persistence/persistence_user_manager.test.ts

@@ -23,7 +23,7 @@ import * as sinonChai from 'sinon-chai';
 import { testAuth, testUser, TestAuth } from '../../../test/helpers/mock_auth';
 import { UserImpl } from '../user/user_impl';
 import { _getInstance } from '../util/instantiator';
-import { Persistence, PersistenceType } from './';
+import { Persistence, PersistenceType, StorageEventListener } from './';
 import { inMemoryPersistence } from './in_memory';
 import { PersistenceUserManager } from './persistence_user_manager';
 
@@ -42,7 +42,9 @@ function makePersistence(
     get() {
       return Promise.resolve(null);
     },
-    remove: async () => {}
+    remove: async () => {},
+    addListener(_key: string, _listener: StorageEventListener) {},
+    removeListener(_key: string, _listener: StorageEventListener) {}
   };
 
   const stub = sinon.stub(persistence);

packages-exp/auth-exp/src/core/persistence/persistence_user_manager.ts

@@ -16,11 +16,11 @@
  */
 
 import { ApiKey, AppName, Auth } from '../../model/auth';
+import { User } from '../../model/user';
 import { PersistedBlob, Persistence } from '../persistence';
+import { UserImpl } from '../user/user_impl';
 import { _getInstance } from '../util/instantiator';
 import { inMemoryPersistence } from './in_memory';
-import { User } from '../../model/user';
-import { UserImpl } from '../user/user_impl';
 
 export const _AUTH_USER_KEY_NAME = 'authUser';
 export const _REDIRECT_USER_KEY_NAME = 'redirectUser';
@@ -38,6 +38,7 @@ function _persistenceKeyName(
 export class PersistenceUserManager {
   private readonly fullUserKey: string;
   private readonly fullPersistenceKey: string;
+
   private constructor(
     public persistence: Persistence,
     private readonly auth: Auth,
@@ -50,6 +51,10 @@ export class PersistenceUserManager {
       config.apiKey,
       name
     );
+    this.persistence.addListener(
+      this.fullUserKey,
+      auth._onStorageEvent.bind(auth)
+    );
   }
 
   setCurrentUser(user: User): Promise<void> {
@@ -84,6 +89,13 @@ export class PersistenceUserManager {
     }
   }
 
+  delete(): void {
+    this.persistence.removeListener(
+      this.fullUserKey,
+      this.auth._onStorageEvent
+    );
+  }
+
   static async create(
     auth: Auth,
     persistenceHierarchy: Persistence[],

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

@@ -31,7 +31,7 @@ import {
   ProviderUserInfo
 } from '../../api/account_management/account';
 import { _reloadWithoutSaving, reload } from './reload';
-import { UserMetadata } from './user_impl';
+import { UserMetadata } from './user_metadata';
 
 use(chaiAsPromised);
 use(sinonChai);

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

@@ -22,7 +22,7 @@ import {
   ProviderUserInfo
 } from '../../api/account_management/account';
 import { User } from '../../model/user';
-import { UserMetadata } from './user_impl';
+import { UserMetadata } from './user_metadata';
 import { assert } from '../util/assert';
 import { AuthErrorCode } from '../errors';
 

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

@@ -110,11 +110,7 @@ describe('core/user/token_manager', () => {
         expect(stsTokenManager.refreshToken).to.eq('new-refresh-token');
         expect(stsTokenManager.expirationTime).to.eq(now + 3_600_000);
 
-        expect(tokens).to.eql({
-          accessToken: 'new-access-token',
-          refreshToken: 'new-refresh-token',
-          wasRefreshed: true
-        });
+        expect(tokens).to.eql('new-access-token');
       });
 
       it('refreshes the token if token is expired', async () => {
@@ -130,11 +126,7 @@ describe('core/user/token_manager', () => {
         expect(stsTokenManager.refreshToken).to.eq('new-refresh-token');
         expect(stsTokenManager.expirationTime).to.eq(now + 3_600_000);
 
-        expect(tokens).to.eql({
-          accessToken: 'new-access-token',
-          refreshToken: 'new-refresh-token',
-          wasRefreshed: true
-        });
+        expect(tokens).to.eql('new-access-token');
       });
     });
 
@@ -162,11 +154,7 @@ describe('core/user/token_manager', () => {
       });
 
       const tokens = (await stsTokenManager.getToken(auth))!;
-      expect(tokens).to.eql({
-        accessToken: 'token',
-        refreshToken: 'refresh',
-        wasRefreshed: false
-      });
+      expect(tokens).to.eql('token');
     });
   });