Refactor popup code to have abstract base

sam-gc · sam-gc · commit e7ada098dc06 · 2020-07-08T15:55:37.000-07:00
diff --git a/packages-exp/auth-exp/src/core/strategies/abstract_popup_redirect_action.ts b/packages-exp/auth-exp/src/core/strategies/abstract_popup_redirect_action.ts
@@ -0,0 +1,125 @@
+/**
+ * @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 * as externs from '@firebase/auth-types-exp';
+import { FirebaseError } from '@firebase/util';
+
+import { Auth } from '../../model/auth';
+import {
+    AuthEvent, AuthEventConsumer, AuthEventType, EventManager, PopupRedirectResolver
+} from '../../model/popup_redirect';
+import { User, UserCredential } from '../../model/user';
+import { AuthErrorCode } from '../errors';
+import { fail } from '../util/assert';
+import { _link, _reauth, _signIn, IdpTask, IdpTaskParams } from './idp';
+
+interface PendingPromise {
+  resolve: (cred: UserCredential) => void;
+  reject: (error: Error) => void;
+}
+
+ /**
+ * Popup event manager. Handles the popup's entire lifecycle; listens to auth
+ * events
+ */
+export abstract class AbstractPopupRedirectAction implements AuthEventConsumer {
+  private pendingPromise: PendingPromise | null = null;
+  private eventManager: EventManager | null = null;
+  
+  abstract eventId: string|null;
+
+  constructor(
+    protected readonly auth: Auth,
+    readonly filter: AuthEventType|'redirect',
+    protected readonly resolver: PopupRedirectResolver,
+    protected user?: User
+  ) {
+  }
+
+  protected abstract onExecution(): Promise<void>;
+
+  execute(): Promise<UserCredential> {
+    return new Promise<UserCredential>(async (resolve, reject) => {
+      this.pendingPromise = { resolve, reject };
+
+      this.eventManager = await this.resolver._initialize(this.auth);
+      await this.onExecution();
+      this.eventManager.registerConsumer(this);
+    });
+  }
+
+  async onAuthEvent(event: AuthEvent): Promise<void> {
+    const { urlResponse, sessionId, postBody, tenantId, error, type } = event;
+    if (error) {
+      this.broadcastResult(null, error);
+      return;
+    }
+
+    const params: IdpTaskParams = {
+      auth: this.auth,
+      requestUri: urlResponse!,
+      sessionId: sessionId!,
+      tenantId: tenantId || undefined,
+      postBody: postBody || undefined,
+      user: this.user
+    };
+
+    try {
+      this.broadcastResult(await this.getIdpTask(type)(params));
+    } catch (e) {
+      this.broadcastResult(null, e);
+    }
+  }
+
+  onError(error: FirebaseError): void {
+    this.broadcastResult(null, error);
+  }
+
+  private getIdpTask(type: AuthEventType): IdpTask {
+    switch(type) {
+      case AuthEventType.SIGN_IN_VIA_POPUP:
+      case AuthEventType.SIGN_IN_VIA_REDIRECT:
+        return _signIn;
+      case AuthEventType.LINK_VIA_POPUP:
+      case AuthEventType.LINK_VIA_REDIRECT:
+        return _link;
+      case AuthEventType.REAUTH_VIA_POPUP:
+      case AuthEventType.REAUTH_VIA_REDIRECT:
+        return _reauth;
+      default:
+        fail(this.auth.name, AuthErrorCode.INTERNAL_ERROR);
+    }
+  }
+
+  protected broadcastResult(cred: UserCredential | null, error?: Error): void {
+    if (this.pendingPromise) {
+      if (error) {
+        this.pendingPromise.reject(error);
+      } else {
+        this.pendingPromise.resolve(cred!);
+      }
+    }
+
+    this.pendingPromise = null;
+    if (this.eventManager) {
+      this.eventManager.unregisterConsumer(this);
+    }
+    this.cleanUp();
+  }
+
+  protected abstract cleanUp(): void;
+}
diff --git a/packages-exp/auth-exp/src/core/strategies/popup.test.ts b/packages-exp/auth-exp/src/core/strategies/popup.test.ts
@@ -27,11 +27,7 @@ import { delay } from '../../../test/delay';
 import { testAuth, testUser } from '../../../test/mock_auth';
 import { stubTimeouts, TimerMap } from '../../../test/timeout_stub';
 import { Auth } from '../../model/auth';
-import {
-  AuthEvent,
-  AuthEventType,
-  PopupRedirectResolver
-} from '../../model/popup_redirect';
+import { AuthEvent, AuthEventType, PopupRedirectResolver } from '../../model/popup_redirect';
 import { User } from '../../model/user';
 import { AuthEventManager } from '../auth/auth_event_manager';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
@@ -41,11 +37,8 @@ import * as eid from '../util/event_id';
 import { AuthPopup } from '../util/popup';
 import * as idpTasks from './idp';
 import {
-  _AUTH_EVENT_TIMEOUT,
-  _POLL_WINDOW_CLOSE_TIMEOUT,
-  linkWithPopup,
-  reauthenticateWithPopup,
-  signInWithPopup
+    _AUTH_EVENT_TIMEOUT, _POLL_WINDOW_CLOSE_TIMEOUT, linkWithPopup, reauthenticateWithPopup,
+    signInWithPopup
 } from './popup';
 
 use(sinonChai);
@@ -81,7 +74,8 @@ describe('src/core/strategies/popup', () => {
     provider = new OAuthProvider(ProviderId.GOOGLE);
     resolver = {
       _initialize: async () => eventManager,
-      _openPopup: async () => authPopup
+      _openPopup: async () => authPopup,
+      _openRedirect: () => new Promise(() => {}),
     };
     idpStubs = sinon.stub(idpTasks);
     sinon.stub(eid, '_generateEventId').returns(MATCHING_EVENT_ID);
diff --git a/packages-exp/auth-exp/src/core/strategies/popup.ts b/packages-exp/auth-exp/src/core/strategies/popup.ts
@@ -16,51 +16,36 @@
  */
 
 import * as externs from '@firebase/auth-types-exp';
-import { FirebaseError } from '@firebase/util';
 
 import { Auth } from '../../model/auth';
-import {
-  AuthEvent,
-  AuthEventConsumer,
-  AuthEventType,
-  EventManager,
-  PopupRedirectResolver
-} from '../../model/popup_redirect';
+import { AuthEventType, PopupRedirectResolver } from '../../model/popup_redirect';
 import { User, UserCredential } from '../../model/user';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
 import { Delay } from '../util/delay';
 import { _generateEventId } from '../util/event_id';
+import { _getInstance } from '../util/instantiator';
 import { AuthPopup } from '../util/popup';
-import { _link, _reauth, _signIn, IdpTask, IdpTaskParams } from './idp';
+import { AbstractPopupRedirectAction } from './abstract_popup_redirect_action';
 
 // The event timeout is the same on mobile and desktop, no need for Delay.
 export const _AUTH_EVENT_TIMEOUT = 2020;
 export const _POLL_WINDOW_CLOSE_TIMEOUT = new Delay(2000, 10000);
 
-interface PendingPromise {
-  resolve: (cred: UserCredential) => void;
-  reject: (error: Error) => void;
-}
-
 export async function signInWithPopup(
   authExtern: externs.Auth,
   provider: externs.AuthProvider,
   resolverExtern: externs.PopupRedirectResolver
 ): Promise<UserCredential> {
   const auth = authExtern as Auth;
-  const resolver = resolverExtern as PopupRedirectResolver;
+  const resolver: PopupRedirectResolver = _getInstance(resolverExtern);
 
   const action = new PopupAction(
     auth,
     AuthEventType.SIGN_IN_VIA_POPUP,
-    _signIn,
     provider,
     resolver
   );
-  const cred = await action.execute();
-
-  await auth.updateCurrentUser(cred.user);
-  return cred;
+  return action.execute();
 }
 
 export async function reauthenticateWithPopup(
@@ -69,12 +54,11 @@ export async function reauthenticateWithPopup(
   resolverExtern: externs.PopupRedirectResolver
 ): Promise<UserCredential> {
   const user = userExtern as User;
-  const resolver = resolverExtern as PopupRedirectResolver;
+  const resolver: PopupRedirectResolver = _getInstance(resolverExtern);
 
   const action = new PopupAction(
     user.auth,
     AuthEventType.REAUTH_VIA_POPUP,
-    _reauth,
     provider,
     resolver,
     user
@@ -88,12 +72,11 @@ export async function linkWithPopup(
   resolverExtern: externs.PopupRedirectResolver
 ): Promise<UserCredential> {
   const user = userExtern as User;
-  const resolver = resolverExtern as PopupRedirectResolver;
+  const resolver: PopupRedirectResolver = _getInstance(resolverExtern);
 
   const action = new PopupAction(
     user.auth,
     AuthEventType.LINK_VIA_POPUP,
-    _link,
     provider,
     resolver,
     user
@@ -105,121 +88,66 @@ export async function linkWithPopup(
  * Popup event manager. Handles the popup's entire lifecycle; listens to auth
  * events
  */
-class PopupAction implements AuthEventConsumer {
+class PopupAction extends AbstractPopupRedirectAction {
   // Only one popup is ever shown at once. The lifecycle of the current popup
   // can be managed / cancelled by the constructor.
   private static currentPopupAction: PopupAction | null = null;
-  private pendingPromise: PendingPromise | null = null;
   private authWindow: AuthPopup | null = null;
   private pollId: number | null = null;
-  private eventManager: EventManager | null = null;
 
   constructor(
-    private readonly auth: Auth,
+    auth: Auth,
     readonly filter: AuthEventType,
-    private readonly idpTask: IdpTask,
     private readonly provider: externs.AuthProvider,
-    private readonly resolver: PopupRedirectResolver,
-    private readonly user?: User
+    resolver: PopupRedirectResolver,
+    user?: User
   ) {
+    super(auth, filter, resolver, user)
     if (PopupAction.currentPopupAction) {
       PopupAction.currentPopupAction.cancel();
     }
 
     PopupAction.currentPopupAction = this;
   }
 
-  execute(): Promise<UserCredential> {
-    return new Promise<UserCredential>(async (resolve, reject) => {
-      this.pendingPromise = { resolve, reject };
-
-      this.eventManager = await this.resolver._initialize(this.auth);
-      const eventId = _generateEventId();
-      this.authWindow = await this.resolver._openPopup(
-        this.auth,
-        this.provider,
-        this.filter,
-        eventId
-      );
-      this.authWindow.associatedEvent = eventId;
-
-      this.eventManager.registerConsumer(this);
-
-      // Handle user closure. Notice this does *not* use await
-      this.pollUserCancellation(this.auth.name);
-    });
-  }
-
-  isMatchingEvent(eventId: string | null): boolean {
-    return !!eventId && this.authWindow?.associatedEvent === eventId;
+  protected async onExecution(): Promise<void> {
+    const eventId = _generateEventId();
+    this.authWindow = await this.resolver._openPopup(
+      this.auth,
+      this.provider,
+      this.filter,
+      eventId
+    );
+    this.authWindow.associatedEvent = eventId;
+
+    // Handle user closure. Notice this does *not* use await
+    this.pollUserCancellation(this.auth.name);
   }
 
-  async onAuthEvent(event: AuthEvent): Promise<void> {
-    const { urlResponse, sessionId, postBody, tenantId, error } = event;
-    if (error) {
-      this.broadcastResult(null, error);
-      return;
-    }
-
-    const params: IdpTaskParams = {
-      auth: this.auth,
-      requestUri: urlResponse!,
-      sessionId: sessionId!,
-      tenantId: tenantId || undefined,
-      postBody: postBody || undefined,
-      user: this.user
-    };
-
-    try {
-      this.broadcastResult(await this.idpTask(params));
-    } catch (e) {
-      this.broadcastResult(null, e);
-    }
-  }
-
-  onError(error: FirebaseError): void {
-    this.broadcastResult(null, error);
+  get eventId(): string | null {
+    return this.authWindow?.associatedEvent || null;
   }
 
   cancel(): void {
-    if (this.pendingPromise) {
-      // There was already a pending promise. Expire it.
-      this.broadcastResult(
-        null,
-        AUTH_ERROR_FACTORY.create(AuthErrorCode.EXPIRED_POPUP_REQUEST, {
-          appName: this.auth.name
-        })
-      );
-    }
+    this.broadcastResult(
+      null,
+      AUTH_ERROR_FACTORY.create(AuthErrorCode.EXPIRED_POPUP_REQUEST, {
+        appName: this.auth.name
+      })
+    );
   }
 
-  private broadcastResult(cred: UserCredential | null, error?: Error): void {
+  protected cleanUp(): void {
     if (this.authWindow) {
       this.authWindow.close();
     }
 
     if (this.pollId) {
       window.clearTimeout(this.pollId);
     }
-
-    if (this.pendingPromise) {
-      if (error) {
-        this.pendingPromise.reject(error);
-      } else {
-        this.pendingPromise.resolve(cred!);
-      }
-    }
-
-    this.cleanUp();
-  }
-
-  private cleanUp(): void {
+    
     this.authWindow = null;
-    this.pendingPromise = null;
     this.pollId = null;
-    if (this.eventManager) {
-      this.eventManager.unregisterConsumer(this);
-    }
     PopupAction.currentPopupAction = null;
   }
 
