plugin-data-source-mssql 2.0.3 → 2.0.4

package/dist/tedious/node_modules/@azure/msal-browser/src/cache/BrowserCacheManager.ts

@@ -6,10 +6,10 @@
 import {
     AccessTokenEntity,
     AccountEntity,
+    AccountEntityUtils,
     AccountInfo,
     ActiveAccountFilters,
     AppMetadataEntity,
-    AuthenticationScheme,
     AuthorityMetadataEntity,
     CacheError,
     CacheErrorCodes,
@@ -26,7 +26,6 @@ import {
     IPerformanceClient,
     Logger,
     PerformanceEvents,
-    PersistentCacheKeys,
     RefreshTokenEntity,
     ServerTelemetryEntity,
     StaticAuthorityOptions,
@@ -36,8 +35,6 @@ import {
     TimeUtils,
     TokenKeys,
     CredentialEntity,
-    CredentialType,
-    DEFAULT_TOKEN_RENEWAL_OFFSET_SEC,
     AuthToken,
     getTenantIdFromIdTokenClaims,
     buildTenantProfile,
@@ -48,12 +45,12 @@ import {
     createBrowserAuthError,
 } from "../error/BrowserAuthError.js";
 import {
-    ApiId,
-    apiIdToName,
     BrowserCacheLocation,
     InMemoryCacheKeys,
     INTERACTION_TYPE,
     TemporaryCacheKeys,
+    ApiId,
+    apiIdToName,
 } from "../utils/BrowserConstants.js";
 import * as CacheKeys from "./CacheKeys.js";
 import { LocalStorage } from "./LocalStorage.js";
@@ -71,6 +68,7 @@ import { base64Encode } from "../encode/Base64Encode.js";
 import { CookieStorage } from "./CookieStorage.js";
 import { getAccountKeys, getTokenKeys } from "./CacheHelpers.js";
 import { EventType } from "../event/EventType.js";
+import * as BrowserUtils from "../utils/BrowserUtils.js";
 import { EventHandler } from "../event/EventHandler.js";
 import { clearHash } from "../utils/BrowserUtils.js";
 import { version } from "../packageMetadata.js";
@@ -81,8 +79,6 @@ type KmsiMap = { [homeAccountId: string]: boolean };
 
 /**
  * This class implements the cache storage interface for MSAL through browser local or session storage.
- * Cookies are only used if storeAuthStateInCookie is true, and are only used for
- * parameters such as state and nonce, generally.
  */
 export class BrowserCacheManager extends CacheManager {
     // Cache configuration, either set by user or default values.
@@ -127,11 +123,12 @@ export class BrowserCacheManager extends CacheManager {
         );
         this.temporaryCacheStorage = getStorageImplementation(
             clientId,
-            cacheConfig.temporaryCacheLocation,
+            BrowserCacheLocation.SessionStorage,
             logger,
             performanceClient
         );
         this.cookieStorage = new CookieStorage();
+
         this.eventHandler = eventHandler;
     }
 
@@ -252,7 +249,7 @@ export class BrowserCacheManager extends CacheManager {
             decryptedData.expiresOn &&
             TimeUtils.isTokenExpired(
                 decryptedData.expiresOn,
-                DEFAULT_TOKEN_RENEWAL_OFFSET_SEC
+                Constants.DEFAULT_TOKEN_RENEWAL_OFFSET_SEC
             )
         ) {
             this.browserStorage.removeItem(key);
@@ -542,7 +539,7 @@ export class BrowserCacheManager extends CacheManager {
                 }
                 account.tenantProfiles = tenantProfiles;
                 const newAccountKey = this.generateAccountKey(
-                    AccountEntity.getAccountInfo(account)
+                    AccountEntityUtils.getAccountInfo(account)
                 );
                 const kmsi = AuthToken.isKmsi(claims);
                 await this.setUserData(
@@ -624,7 +621,7 @@ export class BrowserCacheManager extends CacheManager {
                 continue;
             }
 
-            if (!Object.keys(kmsiMap).includes(oldSchemaData.homeAccountId)) {
+            if (!(oldSchemaData.homeAccountId in kmsiMap)) {
                 // Don't migrate tokens if we don't have an idToken for them
                 this.performanceClient.incrementFields(
                     { skipATMigrateCount: 1 },
@@ -728,7 +725,7 @@ export class BrowserCacheManager extends CacheManager {
                 continue;
             }
 
-            if (!Object.keys(kmsiMap).includes(oldSchemaData.homeAccountId)) {
+            if (!(oldSchemaData.homeAccountId in kmsiMap)) {
                 // Don't migrate tokens if we don't have an idToken for them
                 this.performanceClient.incrementFields(
                     { skipRTMigrateCount: 1 },
@@ -794,7 +791,8 @@ export class BrowserCacheManager extends CacheManager {
         );
         if (previousVersion) {
             this.logger.info(
-                `MSAL.js was last initialized by version: ${previousVersion}`
+                `MSAL.js was last initialized by version: '${previousVersion}'`,
+                correlationId
             );
             this.performanceClient.addFields(
                 { previousLibraryVersion: previousVersion },
@@ -953,7 +951,8 @@ export class BrowserCacheManager extends CacheManager {
                     this.browserStorage.setUserData.bind(this.browserStorage),
                     PerformanceEvents.SetUserData,
                     this.logger,
-                    this.performanceClient
+                    this.performanceClient,
+                    correlationId
                 )(key, value, correlationId, timestamp, kmsi);
                 if (i > 0) {
                     // If any tokens were removed in order to store this item update the token keys array with the tokens removed
@@ -1035,7 +1034,10 @@ export class BrowserCacheManager extends CacheManager {
         accountKey: string,
         correlationId: string
     ): AccountEntity | null {
-        this.logger.trace("BrowserCacheManager.getAccount called");
+        this.logger.trace(
+            "BrowserCacheManager.getAccount called",
+            correlationId
+        );
         const serializedAccount = this.browserStorage.getUserData(accountKey);
         if (!serializedAccount) {
             this.removeAccountKeyFromMap(accountKey, correlationId);
@@ -1043,21 +1045,26 @@ export class BrowserCacheManager extends CacheManager {
         }
 
         const parsedAccount = this.validateAndParseJson(serializedAccount);
-        if (!parsedAccount || !AccountEntity.isAccountEntity(parsedAccount)) {
+        if (
+            !parsedAccount ||
+            !AccountEntityUtils.isAccountEntity(parsedAccount)
+        ) {
             return null;
         }
 
+        const account = CacheManager.toObject<AccountEntity>(
+            {} as AccountEntity,
+            parsedAccount
+        );
+
         this.performanceClient.addFields(
             {
-                accountCachedBy: apiIdToName(parsedAccount.cachedByApiId),
+                accountCachedBy: apiIdToName(account.cachedByApiId),
             },
             correlationId
         );
 
-        return CacheManager.toObject<AccountEntity>(
-            new AccountEntity(),
-            parsedAccount
-        );
+        return account;
     }
 
     /**
@@ -1070,9 +1077,12 @@ export class BrowserCacheManager extends CacheManager {
         kmsi: boolean,
         apiId: number
     ): Promise<void> {
-        this.logger.trace("BrowserCacheManager.setAccount called");
+        this.logger.trace(
+            "BrowserCacheManager.setAccount called",
+            correlationId
+        );
         const key = this.generateAccountKey(
-            AccountEntity.getAccountInfo(account)
+            AccountEntityUtils.getAccountInfo(account)
         );
         const timestamp = Date.now().toString();
         account.lastUpdatedAt = timestamp;
@@ -1084,31 +1094,8 @@ export class BrowserCacheManager extends CacheManager {
             timestamp,
             kmsi
         );
-        const wasAdded = this.addAccountKeyToMap(key, correlationId);
+        this.addAccountKeyToMap(key, correlationId);
         this.performanceClient.addFields({ kmsi: kmsi }, correlationId);
-
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGIN event
-         */
-        if (
-            this.cacheConfig.cacheLocation ===
-                BrowserCacheLocation.LocalStorage &&
-            wasAdded
-        ) {
-            this.eventHandler.emitEvent(
-                EventType.ACCOUNT_ADDED,
-                undefined,
-                AccountEntity.getAccountInfo(account)
-            );
-        }
-    }
-
-    /**
-     * Returns the array of account keys currently cached
-     * @returns
-     */
-    getAccountKeys(): Array<string> {
-        return getAccountKeys(this.browserStorage);
     }
 
     setAccountKeys(
@@ -1127,14 +1114,26 @@ export class BrowserCacheManager extends CacheManager {
         }
     }
 
+    /**
+     * Returns the array of account keys currently cached
+     * @returns
+     */
+    getAccountKeys(): Array<string> {
+        return getAccountKeys(this.browserStorage);
+    }
+
     /**
      * Add a new account to the key map
      * @param key
      */
     addAccountKeyToMap(key: string, correlationId: string): boolean {
-        this.logger.trace("BrowserCacheManager.addAccountKeyToMap called");
+        this.logger.trace(
+            "BrowserCacheManager.addAccountKeyToMap called",
+            correlationId
+        );
         this.logger.tracePii(
-            `BrowserCacheManager.addAccountKeyToMap called with key: ${key}`
+            `BrowserCacheManager.addAccountKeyToMap called with key: '${key}'`,
+            correlationId
         );
         const accountKeys = this.getAccountKeys();
         if (accountKeys.indexOf(key) === -1) {
@@ -1146,12 +1145,14 @@ export class BrowserCacheManager extends CacheManager {
                 correlationId
             );
             this.logger.verbose(
-                "BrowserCacheManager.addAccountKeyToMap account key added"
+                "BrowserCacheManager.addAccountKeyToMap account key added",
+                correlationId
             );
             return true;
         } else {
             this.logger.verbose(
-                "BrowserCacheManager.addAccountKeyToMap account key already exists in map"
+                "BrowserCacheManager.addAccountKeyToMap account key already exists in map",
+                correlationId
             );
             return false;
         }
@@ -1162,21 +1163,23 @@ export class BrowserCacheManager extends CacheManager {
      * @param key
      */
     removeAccountKeyFromMap(key: string, correlationId: string): void {
-        this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap called");
+        this.logger.trace(
+            "BrowserCacheManager.removeAccountKeyFromMap called",
+            correlationId
+        );
         this.logger.tracePii(
-            `BrowserCacheManager.removeAccountKeyFromMap called with key: ${key}`
+            `BrowserCacheManager.removeAccountKeyFromMap called with key: '${key}'`,
+            correlationId
         );
         const accountKeys = this.getAccountKeys();
         const removalIndex = accountKeys.indexOf(key);
         if (removalIndex > -1) {
             accountKeys.splice(removalIndex, 1);
             this.setAccountKeys(accountKeys, correlationId);
-            this.logger.trace(
-                "BrowserCacheManager.removeAccountKeyFromMap account key removed"
-            );
         } else {
             this.logger.trace(
-                "BrowserCacheManager.removeAccountKeyFromMap key not found in existing map"
+                "BrowserCacheManager.removeAccountKeyFromMap key not found in existing map",
+                correlationId
             );
         }
     }
@@ -1209,19 +1212,6 @@ export class BrowserCacheManager extends CacheManager {
                 this.browserStorage.removeItem(key);
             }
         });
-
-        /**
-         * @deprecated - Remove this in next major version in favor of more consistent LOGOUT event
-         */
-        if (
-            this.cacheConfig.cacheLocation === BrowserCacheLocation.LocalStorage
-        ) {
-            this.eventHandler.emitEvent(
-                EventType.ACCOUNT_REMOVED,
-                undefined,
-                account
-            );
-        }
     }
 
     /**
@@ -1233,7 +1223,10 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const idRemoval = tokenKeys.idToken.indexOf(key);
         if (idRemoval > -1) {
-            this.logger.info("idToken removed from tokenKeys map");
+            this.logger.info(
+                "idToken removed from tokenKeys map",
+                correlationId
+            );
             tokenKeys.idToken.splice(idRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -1263,7 +1256,7 @@ export class BrowserCacheManager extends CacheManager {
         correlationId: string,
         schemaVersion: number = CacheKeys.CREDENTIAL_SCHEMA_VERSION
     ): void {
-        this.logger.trace("removeAccessTokenKey called");
+        this.logger.trace("removeAccessTokenKey called", correlationId);
         const tokenKeys = this.getTokenKeys(schemaVersion);
         let keysRemoved = 0;
         keys.forEach((key) => {
@@ -1276,7 +1269,8 @@ export class BrowserCacheManager extends CacheManager {
 
         if (keysRemoved > 0) {
             this.logger.info(
-                `removed ${keysRemoved} accessToken keys from tokenKeys map`
+                `removed '${keysRemoved}' accessToken keys from tokenKeys map`,
+                correlationId
             );
             this.setTokenKeys(tokenKeys, correlationId, schemaVersion);
             return;
@@ -1292,7 +1286,10 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         const refreshRemoval = tokenKeys.refreshToken.indexOf(key);
         if (refreshRemoval > -1) {
-            this.logger.info("refreshToken removed from tokenKeys map");
+            this.logger.info(
+                "refreshToken removed from tokenKeys map",
+                correlationId
+            );
             tokenKeys.refreshToken.splice(refreshRemoval, 1);
             this.setTokenKeys(tokenKeys, correlationId);
         }
@@ -1309,7 +1306,7 @@ export class BrowserCacheManager extends CacheManager {
     }
 
     /**
-     * Stores the token keys in the cache
+     * Sets the token keys in the cache
      * @param tokenKeys
      * @param correlationId
      * @returns
@@ -1349,7 +1346,8 @@ export class BrowserCacheManager extends CacheManager {
         const value = this.browserStorage.getUserData(idTokenKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getIdTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getIdTokenCredential: called, no cache hit",
+                correlationId
             );
             this.removeIdToken(idTokenKey, correlationId);
             return null;
@@ -1358,13 +1356,15 @@ export class BrowserCacheManager extends CacheManager {
         const parsedIdToken = this.validateAndParseJson(value);
         if (!parsedIdToken || !CacheHelpers.isIdTokenEntity(parsedIdToken)) {
             this.logger.trace(
-                "BrowserCacheManager.getIdTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getIdTokenCredential: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
         this.logger.trace(
-            "BrowserCacheManager.getIdTokenCredential: cache hit"
+            "BrowserCacheManager.getIdTokenCredential: cache hit",
+            correlationId
         );
         return parsedIdToken as IdTokenEntity;
     }
@@ -1378,7 +1378,10 @@ export class BrowserCacheManager extends CacheManager {
         correlationId: string,
         kmsi: boolean
     ): Promise<void> {
-        this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
+        this.logger.trace(
+            "BrowserCacheManager.setIdTokenCredential called",
+            correlationId
+        );
         const idTokenKey = this.generateCredentialKey(idToken);
         const timestamp = Date.now().toString();
         idToken.lastUpdatedAt = timestamp;
@@ -1394,7 +1397,8 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.idToken.indexOf(idTokenKey) === -1) {
             this.logger.info(
-                "BrowserCacheManager: addTokenKey - idToken added to map"
+                "BrowserCacheManager: addTokenKey - idToken added to map",
+                correlationId
             );
             tokenKeys.idToken.push(idTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
@@ -1412,7 +1416,8 @@ export class BrowserCacheManager extends CacheManager {
         const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit",
+                correlationId
             );
             this.removeAccessTokenKeys([accessTokenKey], correlationId);
             return null;
@@ -1423,13 +1428,15 @@ export class BrowserCacheManager extends CacheManager {
             !CacheHelpers.isAccessTokenEntity(parsedAccessToken)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getAccessTokenCredential: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
         this.logger.trace(
-            "BrowserCacheManager.getAccessTokenCredential: cache hit"
+            "BrowserCacheManager.getAccessTokenCredential: cache hit",
+            correlationId
         );
         return parsedAccessToken as AccessTokenEntity;
     }
@@ -1444,7 +1451,8 @@ export class BrowserCacheManager extends CacheManager {
         kmsi: boolean
     ): Promise<void> {
         this.logger.trace(
-            "BrowserCacheManager.setAccessTokenCredential called"
+            "BrowserCacheManager.setAccessTokenCredential called",
+            correlationId
         );
         const accessTokenKey = this.generateCredentialKey(accessToken);
         const timestamp = Date.now().toString();
@@ -1464,7 +1472,8 @@ export class BrowserCacheManager extends CacheManager {
             tokenKeys.accessToken.splice(index, 1); // Remove existing key before pushing to the end
         }
         this.logger.trace(
-            `access token ${index === -1 ? "added to" : "updated in"} map`
+            `access token '${index === -1 ? "added to" : "updated in"}' map`,
+            correlationId
         );
         tokenKeys.accessToken.push(accessTokenKey);
         this.setTokenKeys(tokenKeys, correlationId);
@@ -1481,7 +1490,8 @@ export class BrowserCacheManager extends CacheManager {
         const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit",
+                correlationId
             );
             this.removeRefreshToken(refreshTokenKey, correlationId);
             return null;
@@ -1492,13 +1502,15 @@ export class BrowserCacheManager extends CacheManager {
             !CacheHelpers.isRefreshTokenEntity(parsedRefreshToken)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit"
+                "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
         this.logger.trace(
-            "BrowserCacheManager.getRefreshTokenCredential: cache hit"
+            "BrowserCacheManager.getRefreshTokenCredential: cache hit",
+            correlationId
         );
         return parsedRefreshToken as RefreshTokenEntity;
     }
@@ -1513,7 +1525,8 @@ export class BrowserCacheManager extends CacheManager {
         kmsi: boolean
     ): Promise<void> {
         this.logger.trace(
-            "BrowserCacheManager.setRefreshTokenCredential called"
+            "BrowserCacheManager.setRefreshTokenCredential called",
+            correlationId
         );
         const refreshTokenKey = this.generateCredentialKey(refreshToken);
         const timestamp = Date.now().toString();
@@ -1530,7 +1543,8 @@ export class BrowserCacheManager extends CacheManager {
         const tokenKeys = this.getTokenKeys();
         if (tokenKeys.refreshToken.indexOf(refreshTokenKey) === -1) {
             this.logger.info(
-                "BrowserCacheManager: addTokenKey - refreshToken added to map"
+                "BrowserCacheManager: addTokenKey - refreshToken added to map",
+                correlationId
             );
             tokenKeys.refreshToken.push(refreshTokenKey);
             this.setTokenKeys(tokenKeys, correlationId);
@@ -1540,12 +1554,17 @@ export class BrowserCacheManager extends CacheManager {
     /**
      * fetch appMetadata entity from the platform cache
      * @param appMetadataKey
+     * @param correlationId
      */
-    getAppMetadata(appMetadataKey: string): AppMetadataEntity | null {
+    getAppMetadata(
+        appMetadataKey: string,
+        correlationId: string
+    ): AppMetadataEntity | null {
         const value = this.browserStorage.getItem(appMetadataKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getAppMetadata: called, no cache hit"
+                "BrowserCacheManager.getAppMetadata: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1556,24 +1575,32 @@ export class BrowserCacheManager extends CacheManager {
             !CacheHelpers.isAppMetadataEntity(appMetadataKey, parsedMetadata)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getAppMetadata: called, no cache hit"
+                "BrowserCacheManager.getAppMetadata: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
-        this.logger.trace("BrowserCacheManager.getAppMetadata: cache hit");
+        this.logger.trace(
+            "BrowserCacheManager.getAppMetadata: cache hit",
+            correlationId
+        );
         return parsedMetadata as AppMetadataEntity;
     }
 
     /**
      * set appMetadata entity to the platform cache
      * @param appMetadata
+     * @param correlationId
      */
     setAppMetadata(
         appMetadata: AppMetadataEntity,
         correlationId: string
     ): void {
-        this.logger.trace("BrowserCacheManager.setAppMetadata called");
+        this.logger.trace(
+            "BrowserCacheManager.setAppMetadata called",
+            correlationId
+        );
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
         this.setItem(
             appMetadataKey,
@@ -1585,14 +1612,17 @@ export class BrowserCacheManager extends CacheManager {
     /**
      * fetch server telemetry entity from the platform cache
      * @param serverTelemetryKey
+     * @param correlationId
      */
     getServerTelemetry(
-        serverTelemetryKey: string
+        serverTelemetryKey: string,
+        correlationId: string
     ): ServerTelemetryEntity | null {
         const value = this.browserStorage.getItem(serverTelemetryKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getServerTelemetry: called, no cache hit"
+                "BrowserCacheManager.getServerTelemetry: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1605,12 +1635,16 @@ export class BrowserCacheManager extends CacheManager {
             )
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getServerTelemetry: called, no cache hit"
+                "BrowserCacheManager.getServerTelemetry: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
-        this.logger.trace("BrowserCacheManager.getServerTelemetry: cache hit");
+        this.logger.trace(
+            "BrowserCacheManager.getServerTelemetry: cache hit",
+            correlationId
+        );
         return parsedEntity as ServerTelemetryEntity;
     }
 
@@ -1624,7 +1658,10 @@ export class BrowserCacheManager extends CacheManager {
         serverTelemetry: ServerTelemetryEntity,
         correlationId: string
     ): void {
-        this.logger.trace("BrowserCacheManager.setServerTelemetry called");
+        this.logger.trace(
+            "BrowserCacheManager.setServerTelemetry called",
+            correlationId
+        );
         this.setItem(
             serverTelemetryKey,
             JSON.stringify(serverTelemetry),
@@ -1635,11 +1672,15 @@ export class BrowserCacheManager extends CacheManager {
     /**
      *
      */
-    getAuthorityMetadata(key: string): AuthorityMetadataEntity | null {
+    getAuthorityMetadata(
+        key: string,
+        correlationId: string
+    ): AuthorityMetadataEntity | null {
         const value = this.internalStorage.getItem(key);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getAuthorityMetadata: called, no cache hit"
+                "BrowserCacheManager.getAuthorityMetadata: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1649,7 +1690,8 @@ export class BrowserCacheManager extends CacheManager {
             CacheHelpers.isAuthorityMetadataEntity(key, parsedMetadata)
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getAuthorityMetadata: cache hit"
+                "BrowserCacheManager.getAuthorityMetadata: cache hit",
+                correlationId
             );
             return parsedMetadata as AuthorityMetadataEntity;
         }
@@ -1684,20 +1726,27 @@ export class BrowserCacheManager extends CacheManager {
      */
     getWrapperMetadata(): [string, string] {
         const sku =
-            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) ||
-            Constants.EMPTY_STRING;
+            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_SKU) || "";
         const version =
-            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) ||
-            Constants.EMPTY_STRING;
+            this.internalStorage.getItem(InMemoryCacheKeys.WRAPPER_VER) || "";
         return [sku, version];
     }
 
     /**
      *
+     * @param key
      * @param entity
+     * @param correlationId
      */
-    setAuthorityMetadata(key: string, entity: AuthorityMetadataEntity): void {
-        this.logger.trace("BrowserCacheManager.setAuthorityMetadata called");
+    setAuthorityMetadata(
+        key: string,
+        entity: AuthorityMetadataEntity,
+        correlationId: string
+    ): void {
+        this.logger.trace(
+            "BrowserCacheManager.setAuthorityMetadata called",
+            correlationId
+        );
         this.internalStorage.setItem(key, JSON.stringify(entity));
     }
 
@@ -1706,14 +1755,15 @@ export class BrowserCacheManager extends CacheManager {
      */
     getActiveAccount(correlationId: string): AccountInfo | null {
         const activeAccountKeyFilters = this.generateCacheKey(
-            PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
+            Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
         );
         const activeAccountValueFilters = this.browserStorage.getItem(
             activeAccountKeyFilters
         );
         if (!activeAccountValueFilters) {
             this.logger.trace(
-                "BrowserCacheManager.getActiveAccount: No active account filters found"
+                "BrowserCacheManager.getActiveAccount: No active account filters found",
+                correlationId
             );
             return null;
         }
@@ -1722,7 +1772,8 @@ export class BrowserCacheManager extends CacheManager {
         ) as AccountInfo;
         if (activeAccountValueObj) {
             this.logger.trace(
-                "BrowserCacheManager.getActiveAccount: Active account filters schema found"
+                "BrowserCacheManager.getActiveAccount: Active account filters schema found",
+                correlationId
             );
             return this.getAccountInfoFilteredBy(
                 {
@@ -1734,7 +1785,8 @@ export class BrowserCacheManager extends CacheManager {
             );
         }
         this.logger.trace(
-            "BrowserCacheManager.getActiveAccount: No active account found"
+            "BrowserCacheManager.getActiveAccount: No active account found",
+            correlationId
         );
         return null;
     }
@@ -1745,15 +1797,17 @@ export class BrowserCacheManager extends CacheManager {
      */
     setActiveAccount(account: AccountInfo | null, correlationId: string): void {
         const activeAccountKey = this.generateCacheKey(
-            PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
+            Constants.PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS
         );
         if (account) {
-            this.logger.verbose("setActiveAccount: Active account set");
+            this.logger.verbose(
+                "setActiveAccount: Active account set",
+                correlationId
+            );
             const activeAccountValue: ActiveAccountFilters = {
                 homeAccountId: account.homeAccountId,
                 localAccountId: account.localAccountId,
                 tenantId: account.tenantId,
-                lastUpdatedAt: TimeUtils.nowSeconds().toString(),
             };
             this.setItem(
                 activeAccountKey,
@@ -1762,22 +1816,31 @@ export class BrowserCacheManager extends CacheManager {
             );
         } else {
             this.logger.verbose(
-                "setActiveAccount: No account passed, active account not set"
+                "setActiveAccount: No account passed, active account not set",
+                correlationId
             );
             this.browserStorage.removeItem(activeAccountKey);
         }
-        this.eventHandler.emitEvent(EventType.ACTIVE_ACCOUNT_CHANGED);
+        this.eventHandler.emitEvent(
+            EventType.ACTIVE_ACCOUNT_CHANGED,
+            correlationId
+        );
     }
 
     /**
      * fetch throttling entity from the platform cache
      * @param throttlingCacheKey
+     * @param correlationId
      */
-    getThrottlingCache(throttlingCacheKey: string): ThrottlingEntity | null {
+    getThrottlingCache(
+        throttlingCacheKey: string,
+        correlationId: string
+    ): ThrottlingEntity | null {
         const value = this.browserStorage.getItem(throttlingCacheKey);
         if (!value) {
             this.logger.trace(
-                "BrowserCacheManager.getThrottlingCache: called, no cache hit"
+                "BrowserCacheManager.getThrottlingCache: called, no cache hit",
+                correlationId
             );
             return null;
         }
@@ -1791,12 +1854,16 @@ export class BrowserCacheManager extends CacheManager {
             )
         ) {
             this.logger.trace(
-                "BrowserCacheManager.getThrottlingCache: called, no cache hit"
+                "BrowserCacheManager.getThrottlingCache: called, no cache hit",
+                correlationId
             );
             return null;
         }
 
-        this.logger.trace("BrowserCacheManager.getThrottlingCache: cache hit");
+        this.logger.trace(
+            "BrowserCacheManager.getThrottlingCache: cache hit",
+            correlationId
+        );
         return parsedThrottlingCache as ThrottlingEntity;
     }
 
@@ -1810,7 +1877,10 @@ export class BrowserCacheManager extends CacheManager {
         throttlingCache: ThrottlingEntity,
         correlationId: string
     ): void {
-        this.logger.trace("BrowserCacheManager.setThrottlingCache called");
+        this.logger.trace(
+            "BrowserCacheManager.setThrottlingCache called",
+            correlationId
+        );
         this.setItem(
             throttlingCacheKey,
             JSON.stringify(throttlingCache),
@@ -1820,21 +1890,16 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Gets cache item with given key.
-     * Will retrieve from cookies if storeAuthStateInCookie is set to true.
-     * @param key
+     * @param cacheKey
+     * @param correlationId
+     * @param generateKey
      */
-    getTemporaryCache(cacheKey: string, generateKey?: boolean): string | null {
+    getTemporaryCache(
+        cacheKey: string,
+        correlationId: string,
+        generateKey?: boolean
+    ): string | null {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            const itemCookie = this.cookieStorage.getItem(key);
-            if (itemCookie) {
-                this.logger.trace(
-                    "BrowserCacheManager.getTemporaryCache: storeAuthStateInCookies set to true, retrieving from cookies"
-                );
-                return itemCookie;
-            }
-        }
-
         const value = this.temporaryCacheStorage.getItem(key);
         if (!value) {
             // If temp cache item not found in session/memory, check local storage for items set by old versions
@@ -1845,26 +1910,23 @@ export class BrowserCacheManager extends CacheManager {
                 const item = this.browserStorage.getItem(key);
                 if (item) {
                     this.logger.trace(
-                        "BrowserCacheManager.getTemporaryCache: Temporary cache item found in local storage"
+                        "BrowserCacheManager.getTemporaryCache: Temporary cache item found in local storage",
+                        correlationId
                     );
                     return item;
                 }
             }
             this.logger.trace(
-                "BrowserCacheManager.getTemporaryCache: No cache item found in local storage"
+                "BrowserCacheManager.getTemporaryCache: No cache item found in local storage",
+                correlationId
             );
             return null;
         }
-        this.logger.trace(
-            "BrowserCacheManager.getTemporaryCache: Temporary cache item returned"
-        );
         return value;
     }
 
     /**
      * Sets the cache item with the key and value given.
-     * Stores in cookie if storeAuthStateInCookie is set to true.
-     * This can cause cookie overflow if used incorrectly.
      * @param key
      * @param value
      */
@@ -1874,19 +1936,7 @@ export class BrowserCacheManager extends CacheManager {
         generateKey?: boolean
     ): void {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
-
         this.temporaryCacheStorage.setItem(key, value);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace(
-                "BrowserCacheManager.setTemporaryCache: storeAuthStateInCookie set to true, setting item cookie"
-            );
-            this.cookieStorage.setItem(
-                key,
-                value,
-                undefined,
-                this.cacheConfig.secureCookies
-            );
-        }
     }
 
     /**
@@ -1899,17 +1949,10 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Removes the temporary cache item with the given key.
-     * Will also clear the cookie item if storeAuthStateInCookie is set to true.
      * @param key
      */
     removeTemporaryItem(key: string): void {
         this.temporaryCacheStorage.removeItem(key);
-        if (this.cacheConfig.storeAuthStateInCookie) {
-            this.logger.trace(
-                "BrowserCacheManager.removeItem: storeAuthStateInCookie is true, clearing item cookie"
-            );
-            this.cookieStorage.removeItem(key);
-        }
     }
 
     /**
@@ -1950,43 +1993,6 @@ export class BrowserCacheManager extends CacheManager {
         this.internalStorage.clear();
     }
 
-    /**
-     * Clears all access tokes that have claims prior to saving the current one
-     * @param performanceClient {IPerformanceClient}
-     * @param correlationId {string} correlation id
-     * @returns
-     */
-    clearTokensAndKeysWithClaims(correlationId: string): void {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.ClearTokensAndKeysWithClaims,
-            correlationId
-        );
-
-        const tokenKeys = this.getTokenKeys();
-        let removedAccessTokens = 0;
-        tokenKeys.accessToken.forEach((key: string) => {
-            // if the access token has claims in its key, remove the token key and the token
-            const credential = this.getAccessTokenCredential(
-                key,
-                correlationId
-            );
-            if (
-                credential?.requestedClaimsHash &&
-                key.includes(credential.requestedClaimsHash.toLowerCase())
-            ) {
-                this.removeAccessToken(key, correlationId);
-                removedAccessTokens++;
-            }
-        });
-
-        // warn if any access tokens are removed
-        if (removedAccessTokens > 0) {
-            this.logger.warning(
-                `${removedAccessTokens} access tokens with claims in the cache keys have been removed from the cache.`
-            );
-        }
-    }
-
     /**
      * Prepend msal.<client-id> to each key
      * @param key
@@ -2009,13 +2015,14 @@ export class BrowserCacheManager extends CacheManager {
      */
     generateCredentialKey(credential: CredentialEntity): string {
         const familyId =
-            (credential.credentialType === CredentialType.REFRESH_TOKEN &&
+            (credential.credentialType ===
+                Constants.CredentialType.REFRESH_TOKEN &&
                 credential.familyId) ||
             credential.clientId;
         const scheme =
             credential.tokenType &&
             credential.tokenType.toLowerCase() !==
-                AuthenticationScheme.BEARER.toLowerCase()
+                Constants.AuthenticationScheme.BEARER.toLowerCase()
                 ? credential.tokenType.toLowerCase()
                 : "";
         const credentialKey = [
@@ -2026,7 +2033,6 @@ export class BrowserCacheManager extends CacheManager {
             familyId,
             credential.realm || "",
             credential.target || "",
-            credential.requestedClaimsHash || "",
             scheme,
         ];
 
@@ -2052,10 +2058,13 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Reset all temporary cache items
-     * @param state
+     * @param correlationId
      */
-    resetRequestCache(): void {
-        this.logger.trace("BrowserCacheManager.resetRequestCache called");
+    resetRequestCache(correlationId: string): void {
+        this.logger.trace(
+            "BrowserCacheManager.resetRequestCache called",
+            correlationId
+        );
 
         this.removeTemporaryItem(
             this.generateCacheKey(TemporaryCacheKeys.REQUEST_PARAMS)
@@ -2072,14 +2081,18 @@ export class BrowserCacheManager extends CacheManager {
         this.removeTemporaryItem(
             this.generateCacheKey(TemporaryCacheKeys.NATIVE_REQUEST)
         );
-        this.setInteractionInProgress(false);
+        this.setInteractionInProgress(false, undefined);
     }
 
     cacheAuthorizeRequest(
         authCodeRequest: CommonAuthorizationUrlRequest,
+        correlationId: string,
         codeVerifier?: string
     ): void {
-        this.logger.trace("BrowserCacheManager.cacheAuthorizeRequest called");
+        this.logger.trace(
+            "BrowserCacheManager.cacheAuthorizeRequest called",
+            correlationId
+        );
 
         const encodedValue = base64Encode(JSON.stringify(authCodeRequest));
         this.setTemporaryCache(
@@ -2100,12 +2113,19 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Gets the token exchange parameters from the cache. Throws an error if nothing is found.
+     * @param correlationId
      */
-    getCachedRequest(): [CommonAuthorizationUrlRequest, string] {
-        this.logger.trace("BrowserCacheManager.getCachedRequest called");
+    getCachedRequest(
+        correlationId: string
+    ): [CommonAuthorizationUrlRequest, string] {
+        this.logger.trace(
+            "BrowserCacheManager.getCachedRequest called",
+            correlationId
+        );
         // Get token request from cache and parse as TokenExchangeParameters.
         const encodedTokenRequest = this.getTemporaryCache(
             TemporaryCacheKeys.REQUEST_PARAMS,
+            correlationId,
             true
         );
         if (!encodedTokenRequest) {
@@ -2115,6 +2135,7 @@ export class BrowserCacheManager extends CacheManager {
         }
         const encodedVerifier = this.getTemporaryCache(
             TemporaryCacheKeys.VERIFIER,
+            correlationId,
             true
         );
 
@@ -2126,9 +2147,13 @@ export class BrowserCacheManager extends CacheManager {
                 verifier = base64Decode(encodedVerifier);
             }
         } catch (e) {
-            this.logger.errorPii(`Attempted to parse: ${encodedTokenRequest}`);
+            this.logger.errorPii(
+                `Attempted to parse: '${encodedTokenRequest}'`,
+                correlationId
+            );
             this.logger.error(
-                `Parsing cached token request threw with error: ${e}`
+                `Parsing cached token request threw with error: '${e}'`,
+                correlationId
             );
             throw createBrowserAuthError(
                 BrowserAuthErrorCodes.unableToParseTokenRequestCacheError
@@ -2140,16 +2165,22 @@ export class BrowserCacheManager extends CacheManager {
 
     /**
      * Gets cached native request for redirect flows
+     * @param correlationId
      */
     getCachedNativeRequest(): PlatformAuthRequest | null {
-        this.logger.trace("BrowserCacheManager.getCachedNativeRequest called");
+        this.logger.trace(
+            "BrowserCacheManager.getCachedNativeRequest called",
+            ""
+        );
         const cachedRequest = this.getTemporaryCache(
             TemporaryCacheKeys.NATIVE_REQUEST,
+            "",
             true
         );
         if (!cachedRequest) {
             this.logger.trace(
-                "BrowserCacheManager.getCachedNativeRequest: No cached native request found"
+                "BrowserCacheManager.getCachedNativeRequest: No cached native request found",
+                ""
             );
             return null;
         }
@@ -2159,7 +2190,8 @@ export class BrowserCacheManager extends CacheManager {
         ) as PlatformAuthRequest;
         if (!parsedRequest) {
             this.logger.error(
-                "BrowserCacheManager.getCachedNativeRequest: Unable to parse native request"
+                "BrowserCacheManager.getCachedNativeRequest: Unable to parse native request",
+                ""
             );
             return null;
         }
@@ -2182,16 +2214,17 @@ export class BrowserCacheManager extends CacheManager {
         type: INTERACTION_TYPE;
     } | null {
         const key = `${CacheKeys.PREFIX}.${TemporaryCacheKeys.INTERACTION_STATUS_KEY}`;
-        const value = this.getTemporaryCache(key, false);
+        const value = this.getTemporaryCache(key, "", false);
         try {
             return value ? JSON.parse(value) : null;
         } catch (e) {
             // Remove interaction and other temp keys if interaction status can't be parsed
             this.logger.error(
-                `Cannot parse interaction status. Removing temporary cache items and clearing url hash. Retrying interaction should fix the error`
+                `Cannot parse interaction status. Removing temporary cache items and clearing url hash. Retrying interaction should fix the error`,
+                ""
             );
             this.removeTemporaryItem(key);
-            this.resetRequestCache();
+            this.resetRequestCache("");
             clearHash(window);
             return null;
         }
@@ -2199,23 +2232,41 @@ export class BrowserCacheManager extends CacheManager {
 
     setInteractionInProgress(
         inProgress: boolean,
-        type: INTERACTION_TYPE = INTERACTION_TYPE.SIGNIN
+        type: INTERACTION_TYPE = INTERACTION_TYPE.SIGNIN,
+        allowOverride: boolean = false,
+        correlationId: string = ""
     ): void {
         // Ensure we don't overwrite interaction in progress for a different clientId
         const key = `${CacheKeys.PREFIX}.${TemporaryCacheKeys.INTERACTION_STATUS_KEY}`;
         if (inProgress) {
-            if (this.getInteractionInProgress()) {
-                throw createBrowserAuthError(
-                    BrowserAuthErrorCodes.interactionInProgress
-                );
-            } else {
-                // No interaction is in progress
-                this.setTemporaryCache(
-                    key,
-                    JSON.stringify({ clientId: this.clientId, type }),
-                    false
-                );
+            const existingInteraction = this.getInteractionInProgress();
+            if (existingInteraction) {
+                if (allowOverride) {
+                    this.logger.warning(
+                        `Overriding existing interaction_in_progress for clientId: ${existingInteraction.clientId}, type: ${existingInteraction.type}`,
+                        correlationId
+                    );
+
+                    // Cancel any active bridge monitor from the previous interaction
+                    BrowserUtils.cancelPendingBridgeResponse(
+                        this.logger,
+                        correlationId
+                    );
+
+                    // Clear existing interaction to allow new one
+                    this.removeTemporaryItem(key);
+                } else {
+                    throw createBrowserAuthError(
+                        BrowserAuthErrorCodes.interactionInProgress
+                    );
+                }
             }
+            // Set new interaction
+            this.setTemporaryCache(
+                key,
+                JSON.stringify({ clientId: this.clientId, type }),
+                false
+            );
         } else if (
             !inProgress &&
             this.getInteractionInProgress()?.clientId === this.clientId
@@ -2245,11 +2296,6 @@ export class BrowserCacheManager extends CacheManager {
             result.tenantId
         );
 
-        let claimsHash;
-        if (request.claims) {
-            claimsHash = await this.cryptoImpl.hashString(request.claims);
-        }
-
         /**
          * meta data for cache stores time in seconds from epoch
          * AuthenticationResult returns expiresOn and extExpiresOn in milliseconds (as a Date object which is in ms)
@@ -2274,13 +2320,15 @@ export class BrowserCacheManager extends CacheManager {
                 : 0,
             base64Decode,
             undefined, // refreshOn
-            result.tokenType as AuthenticationScheme,
+            result.tokenType as Constants.AuthenticationScheme,
             undefined, // userAssertionHash
-            request.sshKid,
-            request.claims,
-            claimsHash
+            request.sshKid
         );
 
+        if (request.resource) {
+            accessTokenEntity.resource = request.resource;
+        }
+
         const cacheRecord = {
             idToken: idTokenEntity,
             accessToken: accessTokenEntity,
@@ -2305,7 +2353,7 @@ export class BrowserCacheManager extends CacheManager {
         cacheRecord: CacheRecord,
         correlationId: string,
         kmsi: boolean,
-        apiId: ApiId,
+        apiId: number,
         storeInCache?: StoreInCache
     ): Promise<void> {
         try {
@@ -2362,7 +2410,7 @@ function getStorageImplementation(
                 break;
         }
     } catch (e) {
-        logger.error(e as string);
+        logger.error(e as string, "");
     }
 
     return new MemoryStorage();
@@ -2377,11 +2425,6 @@ export const DEFAULT_BROWSER_CACHE_MANAGER = (
     const cacheOptions: Required<CacheOptions> = {
         cacheLocation: BrowserCacheLocation.MemoryStorage,
         cacheRetentionDays: 5,
-        temporaryCacheLocation: BrowserCacheLocation.MemoryStorage,
-        storeAuthStateInCookie: false,
-        secureCookies: false,
-        cacheMigrationEnabled: false,
-        claimsBasedCachingEnabled: false,
     };
     return new BrowserCacheManager(
         clientId,