Update event manager and abstract popup redirect operation to handle redirect events

Author: sam-gc

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

@@ -16,45 +16,89 @@
  */
 
 import {
-  AuthEvent,
-  AuthEventConsumer,
-  EventManager
+    AuthEvent, AuthEventConsumer, AuthEventType, EventManager
 } from '../../model/popup_redirect';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
 
 export class AuthEventManager implements EventManager {
   private readonly consumers: Set<AuthEventConsumer> = new Set();
+  private queuedRedirectEvent: AuthEvent | null = null;
+  private hasHandledPotentialRedirect = false;
 
   constructor(private readonly appName: string) {}
 
   registerConsumer(authEventConsumer: AuthEventConsumer): void {
     this.consumers.add(authEventConsumer);
+
+    if (this.queuedRedirectEvent && this.isEventForConsumer(this.queuedRedirectEvent, authEventConsumer)) {
+      this.sendToConsumer(this.queuedRedirectEvent, authEventConsumer);
+      this.queuedRedirectEvent = null;
+    }
   }
 
   unregisterConsumer(authEventConsumer: AuthEventConsumer): void {
     this.consumers.delete(authEventConsumer);
   }
 
-  onEvent(event: AuthEvent): void {
+  onEvent(event: AuthEvent): boolean {
+    let handled = false;
     this.consumers.forEach(consumer => {
-      if (
-        consumer.filter === event.type &&
-        consumer.isMatchingEvent(event.eventId)
-      ) {
-        if (event.error) {
-          console.error('ERROR');
-          const code =
-            (event.error.code?.split('auth/')[1] as AuthErrorCode) ||
-            AuthErrorCode.INTERNAL_ERROR;
-          consumer.onError(
-            AUTH_ERROR_FACTORY.create(code, {
-              appName: this.appName
-            })
-          );
-        } else {
-          consumer.onAuthEvent(event);
-        }
+      if (this.isEventForConsumer(event, consumer)) {
+        handled = true;
+        this.sendToConsumer(event, consumer);
       }
     });
+
+    // The redirect event is always available immediately, unlike popup
+    // events (which happen in the normal app lifetime). Since the user
+    // may open the iframe (through a popup method) before getRedirectResult()
+    // is called, we need to queue up the redirect event so the user has access
+    // to it later. On the other hand, if we get a "unknown" auth event with
+    // the message "no-auth-event", we know there will never be a redirect event
+    // for this session.
+    if (event.type === AuthEventType.UNKNOWN && event.error?.code === `auth/${AuthErrorCode.NO_AUTH_EVENT}`) {
+      this.hasHandledPotentialRedirect = true;
+      return true;
+
+    } else if (!handled && isRedirectEvent(event.type) && !this.hasHandledPotentialRedirect) {
+      this.queuedRedirectEvent = event;
+      handled = true;
+    }
+
+    this.hasHandledPotentialRedirect = this.hasHandledPotentialRedirect || isRedirectEvent(event.type);
+
+    return handled;
+  }
+
+  private sendToConsumer(event: AuthEvent, consumer: AuthEventConsumer): void {
+    if (event.error) {
+      console.error('ERROR');
+      const code =
+        (event.error.code?.split('auth/')[1] as AuthErrorCode) ||
+        AuthErrorCode.INTERNAL_ERROR;
+      consumer.onError(
+        AUTH_ERROR_FACTORY.create(code, {
+          appName: this.appName
+        })
+      );
+    } else {
+      consumer.onAuthEvent(event);
+    }
+  }
+
+  private isEventForConsumer(event: AuthEvent, consumer: AuthEventConsumer): boolean {
+    const eventIdMatches = consumer.eventId === null || (!!event.eventId && event.eventId === consumer.eventId);
+    return consumer.filter.includes(event.type) && eventIdMatches;
+  }
+}
+
+function isRedirectEvent(type: AuthEventType): boolean {
+  switch (type) {
+    case AuthEventType.SIGN_IN_VIA_REDIRECT:
+    case AuthEventType.LINK_VIA_REDIRECT:
+    case AuthEventType.REAUTH_VIA_REDIRECT:
+      return true;
+    default:
+      return false;
   }
 }

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

@@ -19,11 +19,7 @@ import { FirebaseError } from '@firebase/util';
 
 import { Auth } from '../../model/auth';
 import {
-  AuthEvent,
-  AuthEventConsumer,
-  AuthEventType,
-  EventManager,
-  PopupRedirectResolver
+    AuthEvent, AuthEventConsumer, AuthEventType, EventManager, PopupRedirectResolver
 } from '../../model/popup_redirect';
 import { User, UserCredential } from '../../model/user';
 import { AuthErrorCode } from '../errors';
@@ -43,15 +39,18 @@ export abstract class AbstractPopupRedirectOperation
   implements AuthEventConsumer {
   private pendingPromise: PendingPromise | null = null;
   private eventManager: EventManager | null = null;
+  readonly filter: AuthEventType[];
 
   abstract eventId: string | null;
 
   constructor(
     protected readonly auth: Auth,
-    readonly filter: AuthEventType,
+    filter: AuthEventType|AuthEventType[],
     protected readonly resolver: PopupRedirectResolver,
     protected user?: User
-  ) {}
+  ) {
+    this.filter = Array.isArray(filter) ? filter : [filter];
+  }
 
   abstract onExecution(): Promise<void>;
 

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

@@ -18,10 +18,7 @@
 import * as externs from '@firebase/auth-types-exp';
 
 import { Auth } from '../../model/auth';
-import {
-  AuthEventType,
-  PopupRedirectResolver
-} from '../../model/popup_redirect';
+import { AuthEventType, PopupRedirectResolver } from '../../model/popup_redirect';
 import { User } from '../../model/user';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
 import { Delay } from '../util/delay';
@@ -100,7 +97,7 @@ class PopupOperation extends AbstractPopupRedirectOperation {
 
   constructor(
     auth: Auth,
-    readonly filter: AuthEventType,
+    filter: AuthEventType,
     private readonly provider: externs.AuthProvider,
     resolver: PopupRedirectResolver,
     user?: User
@@ -118,7 +115,7 @@ class PopupOperation extends AbstractPopupRedirectOperation {
     this.authWindow = await this.resolver._openPopup(
       this.auth,
       this.provider,
-      this.filter,
+      this.filter[0],  // There's always one, see constructor
       eventId
     );
     this.authWindow.associatedEvent = eventId;

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

@@ -62,8 +62,8 @@ export interface AuthEvent {
 }
 
 export interface AuthEventConsumer {
-  readonly filter: AuthEventType;
-  isMatchingEvent(eventId: string | null): boolean;
+  readonly filter: AuthEventType[];
+  eventId: string|null;
   onAuthEvent(event: AuthEvent): unknown;
   onError(error: FirebaseError): unknown;
 }
@@ -81,4 +81,10 @@ export interface PopupRedirectResolver extends externs.PopupRedirectResolver {
     authType: AuthEventType,
     eventId?: string
   ): Promise<AuthPopup>;
+  _openRedirect(
+    auth: Auth,
+    provider: externs.AuthProvider,
+    authType: AuthEventType,
+    eventId?: string
+  ): Promise<never>;
 }