Add caching of events to event manager

Author: sam-gc

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

@@ -20,17 +20,14 @@ import * as sinon from 'sinon';
 import * as sinonChai from 'sinon-chai';
 
 import {
-  AuthEvent,
-  AuthEventConsumer,
-  AuthEventError,
-  AuthEventType
+    AuthEvent, AuthEventConsumer, AuthEventError, AuthEventType
 } from '../../model/popup_redirect';
 import { AuthErrorCode } from '../errors';
 import { AuthEventManager } from './auth_event_manager';
 
 use(sinonChai);
 
-describe('src/core/auth/auth_event_manager', () => {
+describe.only('src/core/auth/auth_event_manager', () => {
   let manager: AuthEventManager;
 
   function makeConsumer(
@@ -191,4 +188,49 @@ describe('src/core/auth/auth_event_manager', () => {
       expect(consumer.onAuthEvent).to.have.been.calledWith(event);
     });
   });
+
+  context('caching', () => {
+    let clock: sinon.SinonFakeTimers;
+
+    beforeEach(() => {
+      clock = sinon.useFakeTimers();
+    });
+
+    it('only runs the event once for the consumer', () => {
+      const consumer = makeConsumer(AuthEventType.LINK_VIA_POPUP);
+  
+      const evt = makeEvent(AuthEventType.LINK_VIA_POPUP);
+      manager.registerConsumer(consumer);
+      manager.onEvent(evt);
+      manager.onEvent(evt);
+  
+      expect(consumer.onAuthEvent).to.have.been.calledOnce;
+    });
+
+    it('clears the cache after ten minutes', () => {
+      const consumer = makeConsumer(AuthEventType.LINK_VIA_POPUP);
+  
+      const evt = makeEvent(AuthEventType.LINK_VIA_POPUP);
+      manager.registerConsumer(consumer);
+      manager.onEvent(evt);
+      clock.tick(11 * 60 * 1000);
+      manager.onEvent(evt);
+  
+      expect(consumer.onAuthEvent).to.have.been.calledTwice;
+    });
+
+    it('also caches stored redirects', () => {
+      const consumer = makeConsumer([
+        AuthEventType.SIGN_IN_VIA_REDIRECT,
+        AuthEventType.LINK_VIA_REDIRECT,
+        AuthEventType.REAUTH_VIA_REDIRECT,
+        AuthEventType.UNKNOWN
+      ]);
+      const event = makeEvent(AuthEventType.REAUTH_VIA_REDIRECT);
+      manager.onEvent(event);
+      manager.registerConsumer(consumer);
+      manager.onEvent(event);
+      expect(consumer.onAuthEvent).to.have.been.calledOnce;
+    });
+  });
 });

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

@@ -16,17 +16,20 @@
  */
 
 import {
-  AuthEvent,
-  AuthEventConsumer,
-  AuthEventType,
-  EventManager
+    AuthEvent, AuthEventConsumer, AuthEventType, EventManager
 } from '../../model/popup_redirect';
 import { AUTH_ERROR_FACTORY, AuthErrorCode } from '../errors';
 
+// The amount of time to store the UIDs of seen events; this is
+// set to 10 min by default
+const EVENT_DUPLICATION_CACHE_DURATION_MS = 10 * 60 * 1000;
+
 export class AuthEventManager implements EventManager {
+  private readonly cachedEventUids: Set<string> = new Set();
   private readonly consumers: Set<AuthEventConsumer> = new Set();
   private queuedRedirectEvent: AuthEvent | null = null;
   private hasHandledPotentialRedirect = false;
+  private lastProcessedEventTime = Date.now();
 
   constructor(private readonly appName: string) {}
 
@@ -38,6 +41,7 @@ export class AuthEventManager implements EventManager {
       this.isEventForConsumer(this.queuedRedirectEvent, authEventConsumer)
     ) {
       this.sendToConsumer(this.queuedRedirectEvent, authEventConsumer);
+      this.saveEventToCache(this.queuedRedirectEvent);
       this.queuedRedirectEvent = null;
     }
   }
@@ -47,11 +51,17 @@ export class AuthEventManager implements EventManager {
   }
 
   onEvent(event: AuthEvent): boolean {
+    // Check if the event has already been handled
+    if (this.hasEventBeenHandled(event)) {
+      return false;
+    }
+
     let handled = false;
     this.consumers.forEach(consumer => {
       if (this.isEventForConsumer(event, consumer)) {
         handled = true;
         this.sendToConsumer(event, consumer);
+        this.saveEventToCache(event);
       }
     });
 
@@ -96,6 +106,28 @@ export class AuthEventManager implements EventManager {
       (!!event.eventId && event.eventId === consumer.eventId);
     return consumer.filter.includes(event.type) && eventIdMatches;
   }
+
+  private hasEventBeenHandled(event: AuthEvent): boolean {
+    if (Date.now() - this.lastProcessedEventTime >= EVENT_DUPLICATION_CACHE_DURATION_MS) {
+      this.cachedEventUids.clear();
+    }
+
+    return this.cachedEventUids.has(eventUid(event));
+  }
+
+  private saveEventToCache(event: AuthEvent): void {
+    this.cachedEventUids.add(eventUid(event));
+    this.lastProcessedEventTime = Date.now();
+  }
+}
+
+function eventUid(e: AuthEvent): string {
+  return [
+    e.type,
+    e.eventId,
+    e.sessionId,
+    e.tenantId
+  ].filter(v => v).join('-');
 }
 
 function isNullRedirectEvent({ type, error }: AuthEvent): boolean {