@azure/msal-browser 3.28.0 → 4.0.0-alpha.0

package/dist/cache/BrowserCacheManager.mjs

@@ -1,6 +1,6 @@
-/*! @azure/msal-browser v3.28.0 2024-12-12 */
+/*! @azure/msal-browser v4.0.0-alpha.0 2024-12-18 */
 'use strict';
-import { CacheManager, CredentialType, CacheHelpers, AccountEntity, createClientAuthError, ClientAuthErrorCodes, Constants, PersistentCacheKeys, PerformanceEvents, StringUtils, ProtocolUtils, AuthToken, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CcsCredentialType } from '@azure/msal-common/browser';
+import { CacheManager, AccountEntity, CredentialType, createClientAuthError, ClientAuthErrorCodes, CacheHelpers, Constants, PersistentCacheKeys, PerformanceEvents, StringUtils, ProtocolUtils, CacheError, DEFAULT_CRYPTO_IMPLEMENTATION, CcsCredentialType } from '@azure/msal-common/browser';
 import { createBrowserAuthError } from '../error/BrowserAuthError.mjs';
 import { BrowserCacheLocation, StaticCacheKeys, InMemoryCacheKeys, TemporaryCacheKeys } from '../utils/BrowserConstants.mjs';
 import { LocalStorage } from './LocalStorage.mjs';
@@ -10,6 +10,7 @@ import { extractBrowserRequestState } from '../utils/BrowserProtocolUtils.mjs';
 import { base64Decode } from '../encode/Base64Decode.mjs';
 import { base64Encode } from '../encode/Base64Encode.mjs';
 import { CookieStorage } from './CookieStorage.mjs';
+import { getAccountKeys, getTokenKeys } from './CacheHelpers.mjs';
 import { noTokenRequestCacheError, unableToParseTokenRequestCacheError, noCachedAuthorityError, interactionInProgress } from '../error/BrowserAuthErrorCodes.mjs';
 
 /*
@@ -30,13 +31,11 @@ class BrowserCacheManager extends CacheManager {
         this.browserStorage = this.setupBrowserStorage(this.cacheConfig.cacheLocation);
         this.temporaryCacheStorage = this.setupBrowserStorage(this.cacheConfig.temporaryCacheLocation);
         this.cookieStorage = new CookieStorage();
-        // Migrate cache entries from older versions of MSAL.
-        if (cacheConfig.cacheMigrationEnabled) {
-            this.migrateCacheEntries();
-            this.createKeyMaps();
-        }
         this.performanceClient = performanceClient;
     }
+    async initialize() {
+        await this.browserStorage.initialize();
+    }
     /**
      * Returns a window storage class implementing the IWindowStorage interface that corresponds to the configured cacheLocation.
      * @param cacheLocation
@@ -45,7 +44,7 @@ class BrowserCacheManager extends CacheManager {
         try {
             switch (cacheLocation) {
                 case BrowserCacheLocation.LocalStorage:
-                    return new LocalStorage();
+                    return new LocalStorage(this.clientId);
                 case BrowserCacheLocation.SessionStorage:
                     return new SessionStorage();
                 case BrowserCacheLocation.MemoryStorage:
@@ -59,123 +58,6 @@ class BrowserCacheManager extends CacheManager {
         this.cacheConfig.cacheLocation = BrowserCacheLocation.MemoryStorage;
         return new MemoryStorage();
     }
-    /**
-     * Migrate all old cache entries to new schema. No rollback supported.
-     * @param storeAuthStateInCookie
-     */
-    migrateCacheEntries() {
-        const idTokenKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ID_TOKEN}`;
-        const clientInfoKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.CLIENT_INFO}`;
-        const errorKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ERROR}`;
-        const errorDescKey = `${Constants.CACHE_PREFIX}.${PersistentCacheKeys.ERROR_DESC}`;
-        const idTokenValue = this.browserStorage.getItem(idTokenKey);
-        const clientInfoValue = this.browserStorage.getItem(clientInfoKey);
-        const errorValue = this.browserStorage.getItem(errorKey);
-        const errorDescValue = this.browserStorage.getItem(errorDescKey);
-        const values = [
-            idTokenValue,
-            clientInfoValue,
-            errorValue,
-            errorDescValue,
-        ];
-        const keysToMigrate = [
-            PersistentCacheKeys.ID_TOKEN,
-            PersistentCacheKeys.CLIENT_INFO,
-            PersistentCacheKeys.ERROR,
-            PersistentCacheKeys.ERROR_DESC,
-        ];
-        keysToMigrate.forEach((cacheKey, index) => {
-            const value = values[index];
-            if (value) {
-                this.setTemporaryCache(cacheKey, value, true);
-            }
-        });
-    }
-    /**
-     * Searches all cache entries for MSAL accounts and creates the account key map
-     * This is used to migrate users from older versions of MSAL which did not create the map.
-     * @returns
-     */
-    createKeyMaps() {
-        this.logger.trace("BrowserCacheManager - createKeyMaps called.");
-        const accountKeys = this.getItem(StaticCacheKeys.ACCOUNT_KEYS);
-        const tokenKeys = this.getItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`);
-        if (accountKeys && tokenKeys) {
-            this.logger.verbose("BrowserCacheManager:createKeyMaps - account and token key maps already exist, skipping migration.");
-            // Key maps already exist, no need to iterate through cache
-            return;
-        }
-        const allKeys = this.browserStorage.getKeys();
-        allKeys.forEach((key) => {
-            if (this.isCredentialKey(key)) {
-                // Get item, parse, validate and write key to map
-                const value = this.getItem(key);
-                if (value) {
-                    const credObj = this.validateAndParseJson(value);
-                    if (credObj && credObj.hasOwnProperty("credentialType")) {
-                        switch (credObj["credentialType"]) {
-                            case CredentialType.ID_TOKEN:
-                                if (CacheHelpers.isIdTokenEntity(credObj)) {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - idToken found, saving key to token key map");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - idToken with key: ${key} found, saving key to token key map`);
-                                    const idTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, idTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.ID_TOKEN);
-                                    return;
-                                }
-                                else {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - key found matching idToken schema with value containing idToken credentialType field but value failed IdTokenEntity validation, skipping.");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - failed idToken validation on key: ${key}`);
-                                }
-                                break;
-                            case CredentialType.ACCESS_TOKEN:
-                            case CredentialType.ACCESS_TOKEN_WITH_AUTH_SCHEME:
-                                if (CacheHelpers.isAccessTokenEntity(credObj)) {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - accessToken found, saving key to token key map");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - accessToken with key: ${key} found, saving key to token key map`);
-                                    const accessTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, accessTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.ACCESS_TOKEN);
-                                    return;
-                                }
-                                else {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - key found matching accessToken schema with value containing accessToken credentialType field but value failed AccessTokenEntity validation, skipping.");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - failed accessToken validation on key: ${key}`);
-                                }
-                                break;
-                            case CredentialType.REFRESH_TOKEN:
-                                if (CacheHelpers.isRefreshTokenEntity(credObj)) {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - refreshToken found, saving key to token key map");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - refreshToken with key: ${key} found, saving key to token key map`);
-                                    const refreshTokenEntity = credObj;
-                                    const newKey = this.updateCredentialCacheKey(key, refreshTokenEntity);
-                                    this.addTokenKey(newKey, CredentialType.REFRESH_TOKEN);
-                                    return;
-                                }
-                                else {
-                                    this.logger.trace("BrowserCacheManager:createKeyMaps - key found matching refreshToken schema with value containing refreshToken credentialType field but value failed RefreshTokenEntity validation, skipping.");
-                                    this.logger.tracePii(`BrowserCacheManager:createKeyMaps - failed refreshToken validation on key: ${key}`);
-                                }
-                                break;
-                            // If credentialType isn't one of our predefined ones, it may not be an MSAL cache value. Ignore.
-                        }
-                    }
-                }
-            }
-            if (this.isAccountKey(key)) {
-                const value = this.getItem(key);
-                if (value) {
-                    const accountObj = this.validateAndParseJson(value);
-                    if (accountObj &&
-                        AccountEntity.isAccountEntity(accountObj)) {
-                        this.logger.trace("BrowserCacheManager:createKeyMaps - account found, saving key to account key map");
-                        this.logger.tracePii(`BrowserCacheManager:createKeyMaps - account with key: ${key} found, saving key to account key map`);
-                        this.addAccountKeyToMap(key);
-                    }
-                }
-            }
-        });
-    }
     /**
      * Parses passed value as JSON object, JSON.parse() will throw an error.
      * @param input
@@ -197,38 +79,15 @@ class BrowserCacheManager extends CacheManager {
             return null;
         }
     }
-    /**
-     * fetches the entry from the browser storage based off the key
-     * @param key
-     */
-    getItem(key) {
-        return this.browserStorage.getItem(key);
-    }
-    /**
-     * sets the entry in the browser storage
-     * @param key
-     * @param value
-     */
-    setItem(key, value) {
-        this.browserStorage.setItem(key, value);
-    }
-    /**
-     * fetch the account entity from the platform cache
-     * @param accountKey
-     */
-    getAccount(accountKey, logger) {
-        this.logger.trace("BrowserCacheManager.getAccount called");
-        const accountEntity = this.getCachedAccountEntity(accountKey);
-        return this.updateOutdatedCachedAccount(accountKey, accountEntity, logger);
-    }
     /**
      * Reads account from cache, deserializes it into an account entity and returns it.
      * If account is not found from the key, returns null and removes key from map.
      * @param accountKey
      * @returns
      */
-    getCachedAccountEntity(accountKey) {
-        const serializedAccount = this.getItem(accountKey);
+    getAccount(accountKey) {
+        this.logger.trace("BrowserCacheManager.getAccount called");
+        const serializedAccount = this.browserStorage.getUserData(accountKey);
         if (!serializedAccount) {
             this.removeAccountKeyFromMap(accountKey);
             return null;
@@ -244,10 +103,10 @@ class BrowserCacheManager extends CacheManager {
      * set account entity in the platform cache
      * @param account
      */
-    setAccount(account) {
+    async setAccount(account) {
         this.logger.trace("BrowserCacheManager.setAccount called");
         const key = account.generateAccountKey();
-        this.setItem(key, JSON.stringify(account));
+        await this.browserStorage.setUserData(key, JSON.stringify(account));
         this.addAccountKeyToMap(key);
     }
     /**
@@ -255,13 +114,7 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getAccountKeys() {
-        this.logger.trace("BrowserCacheManager.getAccountKeys called");
-        const accountKeys = this.getItem(StaticCacheKeys.ACCOUNT_KEYS);
-        if (accountKeys) {
-            return JSON.parse(accountKeys);
-        }
-        this.logger.verbose("BrowserCacheManager.getAccountKeys - No account keys found");
-        return [];
+        return getAccountKeys(this.browserStorage);
     }
     /**
      * Add a new account to the key map
@@ -274,7 +127,7 @@ class BrowserCacheManager extends CacheManager {
         if (accountKeys.indexOf(key) === -1) {
             // Only add key if it does not already exist in the map
             accountKeys.push(key);
-            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
+            this.browserStorage.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
             this.logger.verbose("BrowserCacheManager.addAccountKeyToMap account key added");
         }
         else {
@@ -292,7 +145,7 @@ class BrowserCacheManager extends CacheManager {
         const removalIndex = accountKeys.indexOf(key);
         if (removalIndex > -1) {
             accountKeys.splice(removalIndex, 1);
-            this.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
+            this.browserStorage.setItem(StaticCacheKeys.ACCOUNT_KEYS, JSON.stringify(accountKeys));
             this.logger.trace("BrowserCacheManager.removeAccountKeyFromMap account key removed");
         }
         else {
@@ -307,14 +160,6 @@ class BrowserCacheManager extends CacheManager {
         void super.removeAccount(key);
         this.removeAccountKeyFromMap(key);
     }
-    /**
-     * Remove account entity from the platform cache if it's outdated
-     * @param accountKey
-     */
-    removeOutdatedAccount(accountKey) {
-        this.removeItem(accountKey);
-        this.removeAccountKeyFromMap(accountKey);
-    }
     /**
      * Removes given idToken from the cache and from the key map
      * @param key
@@ -344,28 +189,7 @@ class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getTokenKeys() {
-        this.logger.trace("BrowserCacheManager.getTokenKeys called");
-        const item = this.getItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`);
-        if (item) {
-            const tokenKeys = this.validateAndParseJson(item);
-            if (tokenKeys &&
-                tokenKeys.hasOwnProperty("idToken") &&
-                tokenKeys.hasOwnProperty("accessToken") &&
-                tokenKeys.hasOwnProperty("refreshToken")) {
-                return tokenKeys;
-            }
-            else {
-                this.logger.error("BrowserCacheManager.getTokenKeys - Token keys found but in an unknown format. Returning empty key map.");
-            }
-        }
-        else {
-            this.logger.verbose("BrowserCacheManager.getTokenKeys - No token keys found");
-        }
-        return {
-            idToken: [],
-            accessToken: [],
-            refreshToken: [],
-        };
+        return getTokenKeys(this.clientId, this.browserStorage);
     }
     /**
      * Adds the given key to the token key map
@@ -398,7 +222,7 @@ class BrowserCacheManager extends CacheManager {
                 this.logger.error(`BrowserCacheManager:addTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
                 throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
         }
-        this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
+        this.browserStorage.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
     }
     /**
      * Removes the given key from the token key map
@@ -446,14 +270,14 @@ class BrowserCacheManager extends CacheManager {
                 this.logger.error(`BrowserCacheManager:removeTokenKey - CredentialType provided invalid. CredentialType: ${type}`);
                 throw createClientAuthError(ClientAuthErrorCodes.unexpectedCredentialType);
         }
-        this.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
+        this.browserStorage.setItem(`${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`, JSON.stringify(tokenKeys));
     }
     /**
      * generates idToken entity from a string
      * @param idTokenKey
      */
     getIdTokenCredential(idTokenKey) {
-        const value = this.getItem(idTokenKey);
+        const value = this.browserStorage.getUserData(idTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getIdTokenCredential: called, no cache hit");
             this.removeTokenKey(idTokenKey, CredentialType.ID_TOKEN);
@@ -472,10 +296,10 @@ class BrowserCacheManager extends CacheManager {
      * set IdToken credential to the platform cache
      * @param idToken
      */
-    setIdTokenCredential(idToken) {
+    async setIdTokenCredential(idToken) {
         this.logger.trace("BrowserCacheManager.setIdTokenCredential called");
         const idTokenKey = CacheHelpers.generateCredentialKey(idToken);
-        this.setItem(idTokenKey, JSON.stringify(idToken));
+        await this.browserStorage.setUserData(idTokenKey, JSON.stringify(idToken));
         this.addTokenKey(idTokenKey, CredentialType.ID_TOKEN);
     }
     /**
@@ -483,7 +307,7 @@ class BrowserCacheManager extends CacheManager {
      * @param key
      */
     getAccessTokenCredential(accessTokenKey) {
-        const value = this.getItem(accessTokenKey);
+        const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getAccessTokenCredential: called, no cache hit");
             this.removeTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
@@ -503,10 +327,10 @@ class BrowserCacheManager extends CacheManager {
      * set accessToken credential to the platform cache
      * @param accessToken
      */
-    setAccessTokenCredential(accessToken) {
+    async setAccessTokenCredential(accessToken) {
         this.logger.trace("BrowserCacheManager.setAccessTokenCredential called");
         const accessTokenKey = CacheHelpers.generateCredentialKey(accessToken);
-        this.setItem(accessTokenKey, JSON.stringify(accessToken));
+        await this.browserStorage.setUserData(accessTokenKey, JSON.stringify(accessToken));
         this.addTokenKey(accessTokenKey, CredentialType.ACCESS_TOKEN);
     }
     /**
@@ -514,7 +338,7 @@ class BrowserCacheManager extends CacheManager {
      * @param refreshTokenKey
      */
     getRefreshTokenCredential(refreshTokenKey) {
-        const value = this.getItem(refreshTokenKey);
+        const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getRefreshTokenCredential: called, no cache hit");
             this.removeTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
@@ -534,10 +358,10 @@ class BrowserCacheManager extends CacheManager {
      * set refreshToken credential to the platform cache
      * @param refreshToken
      */
-    setRefreshTokenCredential(refreshToken) {
+    async setRefreshTokenCredential(refreshToken) {
         this.logger.trace("BrowserCacheManager.setRefreshTokenCredential called");
         const refreshTokenKey = CacheHelpers.generateCredentialKey(refreshToken);
-        this.setItem(refreshTokenKey, JSON.stringify(refreshToken));
+        await this.browserStorage.setUserData(refreshTokenKey, JSON.stringify(refreshToken));
         this.addTokenKey(refreshTokenKey, CredentialType.REFRESH_TOKEN);
     }
     /**
@@ -545,7 +369,7 @@ class BrowserCacheManager extends CacheManager {
      * @param appMetadataKey
      */
     getAppMetadata(appMetadataKey) {
-        const value = this.getItem(appMetadataKey);
+        const value = this.browserStorage.getItem(appMetadataKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getAppMetadata: called, no cache hit");
             return null;
@@ -566,14 +390,14 @@ class BrowserCacheManager extends CacheManager {
     setAppMetadata(appMetadata) {
         this.logger.trace("BrowserCacheManager.setAppMetadata called");
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
-        this.setItem(appMetadataKey, JSON.stringify(appMetadata));
+        this.browserStorage.setItem(appMetadataKey, JSON.stringify(appMetadata));
     }
     /**
      * fetch server telemetry entity from the platform cache
      * @param serverTelemetryKey
      */
     getServerTelemetry(serverTelemetryKey) {
-        const value = this.getItem(serverTelemetryKey);
+        const value = this.browserStorage.getItem(serverTelemetryKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getServerTelemetry: called, no cache hit");
             return null;
@@ -594,7 +418,7 @@ class BrowserCacheManager extends CacheManager {
      */
     setServerTelemetry(serverTelemetryKey, serverTelemetry) {
         this.logger.trace("BrowserCacheManager.setServerTelemetry called");
-        this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
+        this.browserStorage.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
     }
     /**
      *
@@ -654,25 +478,9 @@ class BrowserCacheManager extends CacheManager {
      */
     getActiveAccount() {
         const activeAccountKeyFilters = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
-        const activeAccountValueFilters = this.getItem(activeAccountKeyFilters);
+        const activeAccountValueFilters = this.browserStorage.getItem(activeAccountKeyFilters);
         if (!activeAccountValueFilters) {
-            // if new active account cache type isn't found, it's an old version, so look for that instead
-            this.logger.trace("BrowserCacheManager.getActiveAccount: No active account filters cache schema found, looking for legacy schema");
-            const activeAccountKeyLocal = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT);
-            const activeAccountValueLocal = this.getItem(activeAccountKeyLocal);
-            if (!activeAccountValueLocal) {
-                this.logger.trace("BrowserCacheManager.getActiveAccount: No active account found");
-                return null;
-            }
-            const activeAccount = this.getAccountInfoFilteredBy({
-                localAccountId: activeAccountValueLocal,
-            });
-            if (activeAccount) {
-                this.logger.trace("BrowserCacheManager.getActiveAccount: Legacy active account cache schema found");
-                this.logger.trace("BrowserCacheManager.getActiveAccount: Adding active account filters cache schema");
-                this.setActiveAccount(activeAccount);
-                return activeAccount;
-            }
+            this.logger.trace("BrowserCacheManager.getActiveAccount: No active account filters found");
             return null;
         }
         const activeAccountValueObj = this.validateAndParseJson(activeAccountValueFilters);
@@ -693,7 +501,6 @@ class BrowserCacheManager extends CacheManager {
      */
     setActiveAccount(account) {
         const activeAccountKey = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT_FILTERS);
-        const activeAccountKeyLocal = this.generateCacheKey(PersistentCacheKeys.ACTIVE_ACCOUNT);
         if (account) {
             this.logger.verbose("setActiveAccount: Active account set");
             const activeAccountValue = {
@@ -702,12 +509,10 @@ class BrowserCacheManager extends CacheManager {
                 tenantId: account.tenantId,
             };
             this.browserStorage.setItem(activeAccountKey, JSON.stringify(activeAccountValue));
-            this.browserStorage.setItem(activeAccountKeyLocal, account.localAccountId);
         }
         else {
             this.logger.verbose("setActiveAccount: No account passed, active account not set");
             this.browserStorage.removeItem(activeAccountKey);
-            this.browserStorage.removeItem(activeAccountKeyLocal);
         }
     }
     /**
@@ -715,7 +520,7 @@ class BrowserCacheManager extends CacheManager {
      * @param throttlingCacheKey
      */
     getThrottlingCache(throttlingCacheKey) {
-        const value = this.getItem(throttlingCacheKey);
+        const value = this.browserStorage.getItem(throttlingCacheKey);
         if (!value) {
             this.logger.trace("BrowserCacheManager.getThrottlingCache: called, no cache hit");
             return null;
@@ -736,7 +541,7 @@ class BrowserCacheManager extends CacheManager {
      */
     setThrottlingCache(throttlingCacheKey, throttlingCache) {
         this.logger.trace("BrowserCacheManager.setThrottlingCache called");
-        this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
+        this.browserStorage.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
     }
     /**
      * Gets cache item with given key.
@@ -864,8 +669,7 @@ class BrowserCacheManager extends CacheManager {
     generateCacheKey(key) {
         const generatedKey = this.validateAndParseJson(key);
         if (!generatedKey) {
-            if (StringUtils.startsWith(key, Constants.CACHE_PREFIX) ||
-                StringUtils.startsWith(key, PersistentCacheKeys.ADAL_ID_TOKEN)) {
+            if (StringUtils.startsWith(key, Constants.CACHE_PREFIX)) {
                 return key;
             }
             return `${Constants.CACHE_PREFIX}.${this.clientId}.${key}`;
@@ -1091,59 +895,6 @@ class BrowserCacheManager extends CacheManager {
             this.removeTemporaryItem(key);
         }
     }
-    /**
-     * Returns username retrieved from ADAL or MSAL v1 idToken
-     * @deprecated
-     */
-    getLegacyLoginHint() {
-        // Only check for adal/msal token if no SSO params are being used
-        const adalIdTokenString = this.getTemporaryCache(PersistentCacheKeys.ADAL_ID_TOKEN);
-        if (adalIdTokenString) {
-            this.browserStorage.removeItem(PersistentCacheKeys.ADAL_ID_TOKEN);
-            this.logger.verbose("Cached ADAL id token retrieved.");
-        }
-        // Check for cached MSAL v1 id token
-        const msalIdTokenString = this.getTemporaryCache(PersistentCacheKeys.ID_TOKEN, true);
-        if (msalIdTokenString) {
-            this.browserStorage.removeItem(this.generateCacheKey(PersistentCacheKeys.ID_TOKEN));
-            this.logger.verbose("Cached MSAL.js v1 id token retrieved");
-        }
-        const cachedIdTokenString = msalIdTokenString || adalIdTokenString;
-        if (cachedIdTokenString) {
-            const idTokenClaims = AuthToken.extractTokenClaims(cachedIdTokenString, base64Decode);
-            if (idTokenClaims.preferred_username) {
-                this.logger.verbose("No SSO params used and ADAL/MSAL v1 token retrieved, setting ADAL/MSAL v1 preferred_username as loginHint");
-                return idTokenClaims.preferred_username;
-            }
-            else if (idTokenClaims.upn) {
-                this.logger.verbose("No SSO params used and ADAL/MSAL v1 token retrieved, setting ADAL/MSAL v1 upn as loginHint");
-                return idTokenClaims.upn;
-            }
-            else {
-                this.logger.verbose("No SSO params used and ADAL/MSAL v1 token retrieved, however, no account hint claim found. Enable preferred_username or upn id token claim to get SSO.");
-            }
-        }
-        return null;
-    }
-    /**
-     * Updates a credential's cache key if the current cache key is outdated
-     */
-    updateCredentialCacheKey(currentCacheKey, credential) {
-        const updatedCacheKey = CacheHelpers.generateCredentialKey(credential);
-        if (currentCacheKey !== updatedCacheKey) {
-            const cacheItem = this.getItem(currentCacheKey);
-            if (cacheItem) {
-                this.browserStorage.removeItem(currentCacheKey);
-                this.setItem(updatedCacheKey, cacheItem);
-                this.logger.verbose(`Updated an outdated ${credential.credentialType} cache key`);
-                return updatedCacheKey;
-            }
-            else {
-                this.logger.error(`Attempted to update an outdated ${credential.credentialType} cache key but no item matching the outdated key was found in storage`);
-            }
-        }
-        return currentCacheKey;
-    }
     /**
      * Builds credential entities from AuthenticationResult object and saves the resulting credentials to the cache
      * @param result