@azure/msal-browser 3.25.0 → 3.26.1

package/src/controllers/NestedAppAuthController.ts

@@ -35,6 +35,7 @@ import {
     WrapperSKU,
     InteractionType,
     DEFAULT_REQUEST,
+    CacheLookupPolicy,
 } from "../utils/BrowserConstants.js";
 import { IController } from "./IController.js";
 import { NestedAppOperatingContext } from "../operatingcontext/NestedAppOperatingContext.js";
@@ -118,7 +119,7 @@ export class NestedAppAuthController implements IController {
                   this.logger
               );
 
-        this.eventHandler = new EventHandler(this.logger, this.browserCrypto);
+        this.eventHandler = new EventHandler(this.logger);
 
         this.nestedAppAuthAdapter = new NestedAppAuthAdapter(
             this.config.auth.clientId,
@@ -140,14 +141,6 @@ export class NestedAppAuthController implements IController {
         }
     }
 
-    /**
-     * Returns the event handler instance
-     * @returns EventHandler
-     */
-    getEventHandler(): EventHandler {
-        return this.eventHandler;
-    }
-
     /**
      * Factory function to create a new instance of NestedAppAuthController
      * @param operatingContext
@@ -220,12 +213,13 @@ export class NestedAppAuthController implements IController {
             const response = await this.bridgeProxy.getTokenInteractive(
                 naaRequest
             );
-            const result: AuthenticationResult =
-                this.nestedAppAuthAdapter.fromNaaTokenResponse(
+            const result: AuthenticationResult = {
+                ...this.nestedAppAuthAdapter.fromNaaTokenResponse(
                     naaRequest,
                     response,
                     reqTimestamp
-                );
+                ),
+            };
 
             // cache the tokens in the response
             await this.hydrateCache(result, request);
@@ -285,7 +279,6 @@ export class NestedAppAuthController implements IController {
 
         // Look for tokens in the cache first
         const result = await this.acquireTokenFromCache(validRequest);
-
         if (result) {
             this.eventHandler.emitEvent(
                 EventType.ACQUIRE_TOKEN_SUCCESS,
@@ -375,7 +368,25 @@ export class NestedAppAuthController implements IController {
             nestedAppAuthRequest: true,
         });
 
-        const result = await this.acquireTokenFromCacheInternal(request);
+        // if the request has claims, we cannot look up in the cache
+        if (request.claims) {
+            this.logger.verbose(
+                "Claims are present in the request, skipping cache lookup"
+            );
+            return null;
+        }
+
+        // respect cache lookup policy
+        let result: AuthenticationResult | null = null;
+        switch (request.cacheLookupPolicy) {
+            case CacheLookupPolicy.Default:
+            case CacheLookupPolicy.AccessToken:
+            case CacheLookupPolicy.AccessTokenAndRefreshToken:
+                result = await this.acquireTokenFromCacheInternal(request);
+                break;
+            default:
+                return null;
+        }
 
         if (result) {
             this.eventHandler.emitEvent(
@@ -466,7 +477,6 @@ export class NestedAppAuthController implements IController {
         if (!cachedAccessToken) {
             this.logger.verbose("No cached access token found");
             return Promise.resolve(null);
-            // If access token has expired, remove the token from cache and return null
         } else if (
             TimeUtils.wasClockTurnedBack(cachedAccessToken.cachedAt) ||
             TimeUtils.isTokenExpired(
@@ -474,12 +484,7 @@ export class NestedAppAuthController implements IController {
                 this.config.system.tokenRenewalOffsetSeconds
             )
         ) {
-            this.logger.verbose(
-                "Cached access token has expired, deleting all related tokens from cache"
-            );
-            const accountEntity =
-                AccountEntity.createFromAccountInfo(currentAccount);
-            await this.browserStorage.removeAccountContext(accountEntity);
+            this.logger.verbose("Cached access token has expired");
             return Promise.resolve(null);
         }
 
@@ -588,9 +593,13 @@ export class NestedAppAuthController implements IController {
     /**
      * Adds event callbacks to array
      * @param callback
+     * @param eventTypes
      */
-    addEventCallback(callback: EventCallbackFunction): string | null {
-        return this.eventHandler.addEventCallback(callback);
+    addEventCallback(
+        callback: EventCallbackFunction,
+        eventTypes?: Array<EventType>
+    ): string | null {
+        return this.eventHandler.addEventCallback(callback, eventTypes);
     }
 
     /**

package/src/controllers/StandardController.ts

@@ -28,6 +28,8 @@ import {
     AccountFilter,
     buildStaticAuthorityOptions,
     InteractionRequiredAuthErrorCodes,
+    PersistentCacheKeys,
+    CacheManager,
 } from "@azure/msal-common/browser";
 import {
     BrowserCacheManager,
@@ -176,6 +178,9 @@ export class StandardController implements IController {
 
     private ssoSilentMeasurement?: InProgressPerformanceEvent;
     private acquireTokenByCodeAsyncMeasurement?: InProgressPerformanceEvent;
+
+    // Flag which indicates if we're currently listening for account storage events
+    private listeningToStorageEvents: boolean;
     /**
      * @constructor
      * Constructor for the PublicClientApplication used to instantiate the PublicClientApplication object
@@ -228,7 +233,7 @@ export class StandardController implements IController {
             ? new CryptoOps(this.logger, this.performanceClient)
             : DEFAULT_CRYPTO_IMPLEMENTATION;
 
-        this.eventHandler = new EventHandler(this.logger, this.browserCrypto);
+        this.eventHandler = new EventHandler(this.logger);
 
         // Initialize the browser storage class.
         this.browserStorage = this.isBrowserEnvironment
@@ -279,6 +284,11 @@ export class StandardController implements IController {
         // Register listener functions
         this.trackPageVisibilityWithMeasurement =
             this.trackPageVisibilityWithMeasurement.bind(this);
+
+        // account storage events
+        this.listeningToStorageEvents = false;
+        this.handleAccountCacheChange =
+            this.handleAccountCacheChange.bind(this);
     }
 
     static async createController(
@@ -314,6 +324,13 @@ export class StandardController implements IController {
             return;
         }
 
+        if (!this.isBrowserEnvironment) {
+            this.logger.info("in non-browser environment, exiting early.");
+            this.initialized = true;
+            this.eventHandler.emitEvent(EventType.INITIALIZE_END);
+            return;
+        }
+
         const initCorrelationId =
             request?.correlationId || this.getRequestCorrelationId();
         const allowNativeBroker = this.config.system.allowNativeBroker;
@@ -354,7 +371,6 @@ export class StandardController implements IController {
 
         this.initialized = true;
         this.eventHandler.emitEvent(EventType.INITIALIZE_END);
-
         initMeasurement.end({ allowNativeBroker, success: true });
     }
 
@@ -1336,6 +1352,10 @@ export class StandardController implements IController {
      * @param logoutRequest
      */
     async clearCache(logoutRequest?: ClearCacheRequest): Promise<void> {
+        if (!this.isBrowserEnvironment) {
+            this.logger.info("in non-browser environment, returning early.");
+            return;
+        }
         const correlationId = this.getRequestCorrelationId(logoutRequest);
         const cacheClient = this.createSilentCacheClient(correlationId);
         return cacheClient.logout(logoutRequest);
@@ -1697,8 +1717,11 @@ export class StandardController implements IController {
      * Adds event callbacks to array
      * @param callback
      */
-    addEventCallback(callback: EventCallbackFunction): string | null {
-        return this.eventHandler.addEventCallback(callback);
+    addEventCallback(
+        callback: EventCallbackFunction,
+        eventTypes?: Array<EventType>
+    ): string | null {
+        return this.eventHandler.addEventCallback(callback, eventTypes);
     }
 
     /**
@@ -1716,6 +1739,7 @@ export class StandardController implements IController {
      * @returns {string}
      */
     addPerformanceCallback(callback: PerformanceCallbackFunction): string {
+        BrowserUtils.blockNonBrowserEnvironment();
         return this.performanceClient.addPerformanceCallback(callback);
     }
 
@@ -1733,14 +1757,89 @@ export class StandardController implements IController {
      * Adds event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
      */
     enableAccountStorageEvents(): void {
-        this.eventHandler.enableAccountStorageEvents();
+        if (typeof window === "undefined") {
+            return;
+        }
+
+        if (!this.listeningToStorageEvents) {
+            this.logger.verbose("Adding account storage listener.");
+            this.listeningToStorageEvents = true;
+            window.addEventListener("storage", this.handleAccountCacheChange);
+        } else {
+            this.logger.verbose("Account storage listener already registered.");
+        }
     }
 
     /**
      * Removes event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
      */
     disableAccountStorageEvents(): void {
-        this.eventHandler.disableAccountStorageEvents();
+        if (typeof window === "undefined") {
+            return;
+        }
+
+        if (this.listeningToStorageEvents) {
+            this.logger.verbose("Removing account storage listener.");
+            window.removeEventListener(
+                "storage",
+                this.handleAccountCacheChange
+            );
+            this.listeningToStorageEvents = false;
+        } else {
+            this.logger.verbose("No account storage listener registered.");
+        }
+    }
+
+    /**
+     * Emit account added/removed events when cached accounts are changed in a different tab or frame
+     */
+    protected handleAccountCacheChange(e: StorageEvent): void {
+        try {
+            // Handle active account filter change
+            if (e.key?.includes(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS)) {
+                // This event has no payload, it only signals cross-tab app instances that the results of calling getActiveAccount() will have changed
+                this.eventHandler.emitEvent(EventType.ACTIVE_ACCOUNT_CHANGED);
+            }
+
+            // Handle account object change
+            const cacheValue = e.newValue || e.oldValue;
+            if (!cacheValue) {
+                return;
+            }
+            const parsedValue = JSON.parse(cacheValue);
+            if (
+                typeof parsedValue !== "object" ||
+                !AccountEntity.isAccountEntity(parsedValue)
+            ) {
+                return;
+            }
+            const accountEntity = CacheManager.toObject<AccountEntity>(
+                new AccountEntity(),
+                parsedValue
+            );
+            const accountInfo = accountEntity.getAccountInfo();
+            if (!e.oldValue && e.newValue) {
+                this.logger.info(
+                    "Account was added to cache in a different window"
+                );
+                this.eventHandler.emitEvent(
+                    EventType.ACCOUNT_ADDED,
+                    undefined,
+                    accountInfo
+                );
+            } else if (!e.newValue && e.oldValue) {
+                this.logger.info(
+                    "Account was removed from cache in a different window"
+                );
+                this.eventHandler.emitEvent(
+                    EventType.ACCOUNT_REMOVED,
+                    undefined,
+                    accountInfo
+                );
+            }
+        } catch (e) {
+            return;
+        }
     }
 
     /**
@@ -1804,13 +1903,6 @@ export class StandardController implements IController {
         return this.isBrowserEnvironment;
     }
 
-    /**
-     * Returns the event handler
-     */
-    getEventHandler(): EventHandler {
-        return this.eventHandler;
-    }
-
     /**
      * Generates a correlation id for a request if none is provided.
      *

package/src/controllers/UnknownOperatingContextController.ts

@@ -37,9 +37,9 @@ import {
     blockAPICallsBeforeInitialize,
     blockNonBrowserEnvironment,
 } from "../utils/BrowserUtils.js";
-import { EventHandler } from "../event/EventHandler.js";
 import { EventCallbackFunction } from "../event/EventMessage.js";
 import { ClearCacheRequest } from "../request/ClearCacheRequest.js";
+import { EventType } from "../event/EventType.js";
 
 /**
  * UnknownOperatingContextController class
@@ -80,8 +80,6 @@ export class UnknownOperatingContextController implements IController {
     // Flag representing whether or not the initialize API has been called and completed
     protected initialized: boolean = false;
 
-    protected readonly eventHandler: EventHandler;
-
     constructor(operatingContext: UnknownOperatingContext) {
         this.operatingContext = operatingContext;
 
@@ -114,17 +112,11 @@ export class UnknownOperatingContextController implements IController {
                   this.config.auth.clientId,
                   this.logger
               );
-
-        this.eventHandler = new EventHandler(this.logger, this.browserCrypto);
     }
     getBrowserStorage(): BrowserCacheManager {
         return this.browserStorage;
     }
 
-    getEventHandler(): EventHandler {
-        return this.eventHandler;
-    }
-
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     getAccount(accountFilter: AccountFilter): AccountInfo | null {
         return null;
@@ -210,12 +202,18 @@ export class UnknownOperatingContextController implements IController {
         blockNonBrowserEnvironment();
         return {} as Promise<AuthenticationResult>;
     }
-    addEventCallback(callback: EventCallbackFunction): string | null {
-        return this.eventHandler.addEventCallback(callback);
-    }
-    removeEventCallback(callbackId: string): void {
-        this.eventHandler.removeEventCallback(callbackId);
+    addEventCallback(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        callback: EventCallbackFunction,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        eventTypes?: Array<EventType>
+    ): string | null {
+        return null;
     }
+    removeEventCallback(
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        callbackId: string
+    ): void {}
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     addPerformanceCallback(callback: PerformanceCallbackFunction): string {
         blockAPICallsBeforeInitialize(this.initialized);

package/src/event/EventHandler.ts

@@ -3,13 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import {
-    ICrypto,
-    Logger,
-    AccountEntity,
-    CacheManager,
-    PersistentCacheKeys,
-} from "@azure/msal-common/browser";
+import { Logger } from "@azure/msal-common/browser";
 import { InteractionType } from "../utils/BrowserConstants.js";
 import {
     EventCallbackFunction,
@@ -18,37 +12,44 @@ import {
     EventPayload,
 } from "./EventMessage.js";
 import { EventType } from "./EventType.js";
-import { createNewGuid } from "../crypto/BrowserCrypto.js";
+import { createGuid } from "../utils/BrowserUtils.js";
 
 export class EventHandler {
     // Callback for subscribing to events
-    private eventCallbacks: Map<string, EventCallbackFunction>;
+    private eventCallbacks: Map<
+        string,
+        [EventCallbackFunction, Array<EventType>]
+    >;
     private logger: Logger;
-    private browserCrypto: ICrypto;
-    private listeningToStorageEvents: boolean;
 
-    constructor(logger: Logger, browserCrypto: ICrypto) {
+    constructor(logger?: Logger) {
         this.eventCallbacks = new Map();
-        this.logger = logger;
-        this.browserCrypto = browserCrypto;
-        this.listeningToStorageEvents = false;
-        this.handleAccountCacheChange =
-            this.handleAccountCacheChange.bind(this);
+        this.logger = logger || new Logger({});
     }
 
     /**
      * Adds event callbacks to array
-     * @param callback
+     * @param callback - callback to be invoked when an event is raised
+     * @param eventTypes - list of events that this callback will be invoked for, if not provided callback will be invoked for all events
+     * @param callbackId - Identifier for the callback, used to locate and remove the callback when no longer required
      */
-    addEventCallback(callback: EventCallbackFunction): string | null {
+    addEventCallback(
+        callback: EventCallbackFunction,
+        eventTypes?: Array<EventType>,
+        callbackId?: string
+    ): string | null {
         if (typeof window !== "undefined") {
-            const callbackId = createNewGuid();
-            this.eventCallbacks.set(callbackId, callback);
-            this.logger.verbose(
-                `Event callback registered with id: ${callbackId}`
-            );
+            const id = callbackId || createGuid();
+            if (this.eventCallbacks.has(id)) {
+                this.logger.error(
+                    `Event callback with id: ${id} is already registered. Please provide a unique id or remove the existing callback and try again.`
+                );
+                return null;
+            }
+            this.eventCallbacks.set(id, [callback, eventTypes || []]);
+            this.logger.verbose(`Event callback registered with id: ${id}`);
 
-            return callbackId;
+            return id;
         }
 
         return null;
@@ -63,43 +64,6 @@ export class EventHandler {
         this.logger.verbose(`Event callback ${callbackId} removed.`);
     }
 
-    /**
-     * Adds event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
-     */
-    enableAccountStorageEvents(): void {
-        if (typeof window === "undefined") {
-            return;
-        }
-
-        if (!this.listeningToStorageEvents) {
-            this.logger.verbose("Adding account storage listener.");
-            this.listeningToStorageEvents = true;
-            window.addEventListener("storage", this.handleAccountCacheChange);
-        } else {
-            this.logger.verbose("Account storage listener already registered.");
-        }
-    }
-
-    /**
-     * Removes event listener that emits an event when a user account is added or removed from localstorage in a different browser tab or window
-     */
-    disableAccountStorageEvents(): void {
-        if (typeof window === "undefined") {
-            return;
-        }
-
-        if (this.listeningToStorageEvents) {
-            this.logger.verbose("Removing account storage listener.");
-            window.removeEventListener(
-                "storage",
-                this.handleAccountCacheChange
-            );
-            this.listeningToStorageEvents = false;
-        } else {
-            this.logger.verbose("No account storage listener registered.");
-        }
-    }
-
     /**
      * Emits events by calling callback with event message
      * @param eventType
@@ -122,64 +86,25 @@ export class EventHandler {
                 timestamp: Date.now(),
             };
 
-            this.logger.info(`Emitting event: ${eventType}`);
-
             this.eventCallbacks.forEach(
-                (callback: EventCallbackFunction, callbackId: string) => {
-                    this.logger.verbose(
-                        `Emitting event to callback ${callbackId}: ${eventType}`
-                    );
-                    callback.apply(null, [message]);
+                (
+                    [callback, eventTypes]: [
+                        EventCallbackFunction,
+                        Array<EventType>
+                    ],
+                    callbackId: string
+                ) => {
+                    if (
+                        eventTypes.length === 0 ||
+                        eventTypes.includes(eventType)
+                    ) {
+                        this.logger.verbose(
+                            `Emitting event to callback ${callbackId}: ${eventType}`
+                        );
+                        callback.apply(null, [message]);
+                    }
                 }
             );
         }
     }
-
-    /**
-     * Emit account added/removed events when cached accounts are changed in a different tab or frame
-     */
-    private handleAccountCacheChange(e: StorageEvent): void {
-        try {
-            // Handle active account filter change
-            if (e.key?.includes(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS)) {
-                // This event has no payload, it only signals cross-tab app instances that the results of calling getActiveAccount() will have changed
-                this.emitEvent(EventType.ACTIVE_ACCOUNT_CHANGED);
-            }
-
-            // Handle account object change
-            const cacheValue = e.newValue || e.oldValue;
-            if (!cacheValue) {
-                return;
-            }
-            const parsedValue = JSON.parse(cacheValue);
-            if (
-                typeof parsedValue !== "object" ||
-                !AccountEntity.isAccountEntity(parsedValue)
-            ) {
-                return;
-            }
-            const accountEntity = CacheManager.toObject<AccountEntity>(
-                new AccountEntity(),
-                parsedValue
-            );
-            const accountInfo = accountEntity.getAccountInfo();
-            if (!e.oldValue && e.newValue) {
-                this.logger.info(
-                    "Account was added to cache in a different window"
-                );
-                this.emitEvent(EventType.ACCOUNT_ADDED, undefined, accountInfo);
-            } else if (!e.newValue && e.oldValue) {
-                this.logger.info(
-                    "Account was removed from cache in a different window"
-                );
-                this.emitEvent(
-                    EventType.ACCOUNT_REMOVED,
-                    undefined,
-                    accountInfo
-                );
-            }
-        } catch (e) {
-            return;
-        }
-    }
 }

package/src/index.ts

@@ -86,6 +86,7 @@ export {
     PopupEvent,
 } from "./event/EventMessage.js";
 export { EventType } from "./event/EventType.js";
+export { EventHandler } from "./event/EventHandler.js";
 
 export {
     SignedHttpRequest,

package/src/packageMetadata.ts

@@ -1,3 +1,3 @@
 /* eslint-disable header/header */
 export const name = "@azure/msal-browser";
-export const version = "3.25.0";
+export const version = "3.26.1";