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

package/src/cache/BrowserCacheManager.ts

@@ -25,8 +25,6 @@ import {
     ActiveAccountFilters,
     CcsCredential,
     CcsCredentialType,
-    AuthToken,
-    ValidCredentialType,
     TokenKeys,
     CredentialType,
     CacheRecord,
@@ -52,7 +50,8 @@ import {
     InMemoryCacheKeys,
     StaticCacheKeys,
 } from "../utils/BrowserConstants.js";
-import { BrowserStorage } from "./BrowserStorage.js";
+import { LocalStorage } from "./LocalStorage.js";
+import { SessionStorage } from "./SessionStorage.js";
 import { MemoryStorage } from "./MemoryStorage.js";
 import { IWindowStorage } from "./IWindowStorage.js";
 import { extractBrowserRequestState } from "../utils/BrowserProtocolUtils.js";
@@ -64,6 +63,8 @@ import { RedirectRequest } from "../request/RedirectRequest.js";
 import { PopupRequest } from "../request/PopupRequest.js";
 import { base64Decode } from "../encode/Base64Decode.js";
 import { base64Encode } from "../encode/Base64Encode.js";
+import { CookieStorage } from "./CookieStorage.js";
+import { getAccountKeys, getTokenKeys } from "./CacheHelpers.js";
 
 /**
  * This class implements the cache storage interface for MSAL through browser local or session storage.
@@ -79,14 +80,13 @@ export class BrowserCacheManager extends CacheManager {
     protected internalStorage: MemoryStorage<string>;
     // Temporary cache
     protected temporaryCacheStorage: IWindowStorage<string>;
+    // Cookie storage
+    protected cookieStorage: CookieStorage;
     // Logger instance
     protected logger: Logger;
     // Telemetry perf client
     protected performanceClient?: IPerformanceClient;
 
-    // Cookie life calculation (hours * minutes * seconds * ms)
-    protected readonly COOKIE_LIFE_MULTIPLIER = 24 * 60 * 60 * 1000;
-
     constructor(
         clientId: string,
         cacheConfig: Required<CacheOptions>,
@@ -102,20 +102,18 @@ export class BrowserCacheManager extends CacheManager {
         this.browserStorage = this.setupBrowserStorage(
             this.cacheConfig.cacheLocation
         );
-        this.temporaryCacheStorage = this.setupTemporaryCacheStorage(
-            this.cacheConfig.temporaryCacheLocation,
-            this.cacheConfig.cacheLocation
+        this.temporaryCacheStorage = this.setupBrowserStorage(
+            this.cacheConfig.temporaryCacheLocation
         );
-
-        // Migrate cache entries from older versions of MSAL.
-        if (cacheConfig.cacheMigrationEnabled) {
-            this.migrateCacheEntries();
-            this.createKeyMaps();
-        }
+        this.cookieStorage = new CookieStorage();
 
         this.performanceClient = performanceClient;
     }
 
+    async initialize(): Promise<void> {
+        await this.browserStorage.initialize();
+    }
+
     /**
      * Returns a window storage class implementing the IWindowStorage interface that corresponds to the configured cacheLocation.
      * @param cacheLocation
@@ -123,233 +121,23 @@ export class BrowserCacheManager extends CacheManager {
     protected setupBrowserStorage(
         cacheLocation: BrowserCacheLocation | string
     ): IWindowStorage<string> {
-        switch (cacheLocation) {
-            case BrowserCacheLocation.LocalStorage:
-            case BrowserCacheLocation.SessionStorage:
-                try {
-                    return new BrowserStorage(cacheLocation);
-                } catch (e) {
-                    this.logger.verbose(e as string);
+        try {
+            switch (cacheLocation) {
+                case BrowserCacheLocation.LocalStorage:
+                    return new LocalStorage(this.clientId);
+                case BrowserCacheLocation.SessionStorage:
+                    return new SessionStorage();
+                case BrowserCacheLocation.MemoryStorage:
+                default:
                     break;
-                }
-            case BrowserCacheLocation.MemoryStorage:
-            default:
-                break;
+            }
+        } catch (e) {
+            this.logger.error(e as string);
         }
         this.cacheConfig.cacheLocation = BrowserCacheLocation.MemoryStorage;
         return new MemoryStorage();
     }
 
-    /**
-     * Returns a window storage class implementing the IWindowStorage interface that corresponds to the configured temporaryCacheLocation.
-     * @param temporaryCacheLocation
-     * @param cacheLocation
-     */
-    protected setupTemporaryCacheStorage(
-        temporaryCacheLocation: BrowserCacheLocation | string,
-        cacheLocation: BrowserCacheLocation | string
-    ): IWindowStorage<string> {
-        switch (cacheLocation) {
-            case BrowserCacheLocation.LocalStorage:
-            case BrowserCacheLocation.SessionStorage:
-                try {
-                    // Temporary cache items will always be stored in session storage to mitigate problems caused by multiple tabs
-                    return new BrowserStorage(
-                        temporaryCacheLocation ||
-                            BrowserCacheLocation.SessionStorage
-                    );
-                } catch (e) {
-                    this.logger.verbose(e as string);
-                    return this.internalStorage;
-                }
-            case BrowserCacheLocation.MemoryStorage:
-            default:
-                return this.internalStorage;
-        }
-    }
-
-    /**
-     * Migrate all old cache entries to new schema. No rollback supported.
-     * @param storeAuthStateInCookie
-     */
-    protected migrateCacheEntries(): void {
-        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: string, index: number) => {
-            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
-     */
-    private createKeyMaps(): void {
-        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 as IdTokenEntity;
-                                    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 as AccessTokenEntity;
-                                    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 as RefreshTokenEntity;
-                                    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;
-                            default:
-                            // 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
@@ -371,46 +159,15 @@ export class BrowserCacheManager extends CacheManager {
         }
     }
 
-    /**
-     * fetches the entry from the browser storage based off the key
-     * @param key
-     */
-    getItem(key: string): string | null {
-        return this.browserStorage.getItem(key);
-    }
-
-    /**
-     * sets the entry in the browser storage
-     * @param key
-     * @param value
-     */
-    setItem(key: string, value: string): void {
-        this.browserStorage.setItem(key, value);
-    }
-
-    /**
-     * fetch the account entity from the platform cache
-     * @param accountKey
-     */
-    getAccount(accountKey: string, logger?: Logger): AccountEntity | null {
-        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: string): AccountEntity | null {
-        const serializedAccount = this.getItem(accountKey);
+    getAccount(accountKey: string): AccountEntity | null {
+        this.logger.trace("BrowserCacheManager.getAccount called");
+        const serializedAccount = this.browserStorage.getUserData(accountKey);
         if (!serializedAccount) {
             this.removeAccountKeyFromMap(accountKey);
             return null;
@@ -432,10 +189,10 @@ export class BrowserCacheManager extends CacheManager {
      * set account entity in the platform cache
      * @param account
      */
-    setAccount(account: AccountEntity): void {
+    async setAccount(account: AccountEntity): Promise<void> {
         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);
     }
 
@@ -444,16 +201,7 @@ export class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getAccountKeys(): Array<string> {
-        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);
     }
 
     /**
@@ -469,7 +217,7 @@ export 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(
+            this.browserStorage.setItem(
                 StaticCacheKeys.ACCOUNT_KEYS,
                 JSON.stringify(accountKeys)
             );
@@ -496,7 +244,7 @@ export class BrowserCacheManager extends CacheManager {
         const removalIndex = accountKeys.indexOf(key);
         if (removalIndex > -1) {
             accountKeys.splice(removalIndex, 1);
-            this.setItem(
+            this.browserStorage.setItem(
                 StaticCacheKeys.ACCOUNT_KEYS,
                 JSON.stringify(accountKeys)
             );
@@ -519,15 +267,6 @@ export class BrowserCacheManager extends CacheManager {
         this.removeAccountKeyFromMap(key);
     }
 
-    /**
-     * Remove account entity from the platform cache if it's outdated
-     * @param accountKey
-     */
-    removeOutdatedAccount(accountKey: string): void {
-        this.removeItem(accountKey);
-        this.removeAccountKeyFromMap(accountKey);
-    }
-
     /**
      * Removes given idToken from the cache and from the key map
      * @param key
@@ -560,35 +299,7 @@ export class BrowserCacheManager extends CacheManager {
      * @returns
      */
     getTokenKeys(): TokenKeys {
-        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 as 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);
     }
 
     /**
@@ -634,7 +345,7 @@ export class BrowserCacheManager extends CacheManager {
                 );
         }
 
-        this.setItem(
+        this.browserStorage.setItem(
             `${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`,
             JSON.stringify(tokenKeys)
         );
@@ -707,7 +418,7 @@ export class BrowserCacheManager extends CacheManager {
                 );
         }
 
-        this.setItem(
+        this.browserStorage.setItem(
             `${StaticCacheKeys.TOKEN_KEYS}.${this.clientId}`,
             JSON.stringify(tokenKeys)
         );
@@ -718,7 +429,7 @@ export class BrowserCacheManager extends CacheManager {
      * @param idTokenKey
      */
     getIdTokenCredential(idTokenKey: string): IdTokenEntity | null {
-        const value = this.getItem(idTokenKey);
+        const value = this.browserStorage.getUserData(idTokenKey);
         if (!value) {
             this.logger.trace(
                 "BrowserCacheManager.getIdTokenCredential: called, no cache hit"
@@ -746,11 +457,14 @@ export class BrowserCacheManager extends CacheManager {
      * set IdToken credential to the platform cache
      * @param idToken
      */
-    setIdTokenCredential(idToken: IdTokenEntity): void {
+    async setIdTokenCredential(idToken: IdTokenEntity): Promise<void> {
         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);
     }
@@ -760,7 +474,7 @@ export class BrowserCacheManager extends CacheManager {
      * @param key
      */
     getAccessTokenCredential(accessTokenKey: string): AccessTokenEntity | null {
-        const value = this.getItem(accessTokenKey);
+        const value = this.browserStorage.getUserData(accessTokenKey);
         if (!value) {
             this.logger.trace(
                 "BrowserCacheManager.getAccessTokenCredential: called, no cache hit"
@@ -790,12 +504,17 @@ export class BrowserCacheManager extends CacheManager {
      * set accessToken credential to the platform cache
      * @param accessToken
      */
-    setAccessTokenCredential(accessToken: AccessTokenEntity): void {
+    async setAccessTokenCredential(
+        accessToken: AccessTokenEntity
+    ): Promise<void> {
         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);
     }
@@ -807,7 +526,7 @@ export class BrowserCacheManager extends CacheManager {
     getRefreshTokenCredential(
         refreshTokenKey: string
     ): RefreshTokenEntity | null {
-        const value = this.getItem(refreshTokenKey);
+        const value = this.browserStorage.getUserData(refreshTokenKey);
         if (!value) {
             this.logger.trace(
                 "BrowserCacheManager.getRefreshTokenCredential: called, no cache hit"
@@ -837,13 +556,18 @@ export class BrowserCacheManager extends CacheManager {
      * set refreshToken credential to the platform cache
      * @param refreshToken
      */
-    setRefreshTokenCredential(refreshToken: RefreshTokenEntity): void {
+    async setRefreshTokenCredential(
+        refreshToken: RefreshTokenEntity
+    ): Promise<void> {
         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);
     }
@@ -853,7 +577,7 @@ export class BrowserCacheManager extends CacheManager {
      * @param appMetadataKey
      */
     getAppMetadata(appMetadataKey: string): AppMetadataEntity | null {
-        const value = this.getItem(appMetadataKey);
+        const value = this.browserStorage.getItem(appMetadataKey);
         if (!value) {
             this.logger.trace(
                 "BrowserCacheManager.getAppMetadata: called, no cache hit"
@@ -883,7 +607,10 @@ export class BrowserCacheManager extends CacheManager {
     setAppMetadata(appMetadata: AppMetadataEntity): void {
         this.logger.trace("BrowserCacheManager.setAppMetadata called");
         const appMetadataKey = CacheHelpers.generateAppMetadataKey(appMetadata);
-        this.setItem(appMetadataKey, JSON.stringify(appMetadata));
+        this.browserStorage.setItem(
+            appMetadataKey,
+            JSON.stringify(appMetadata)
+        );
     }
 
     /**
@@ -893,7 +620,7 @@ export class BrowserCacheManager extends CacheManager {
     getServerTelemetry(
         serverTelemetryKey: string
     ): ServerTelemetryEntity | null {
-        const value = this.getItem(serverTelemetryKey);
+        const value = this.browserStorage.getItem(serverTelemetryKey);
         if (!value) {
             this.logger.trace(
                 "BrowserCacheManager.getServerTelemetry: called, no cache hit"
@@ -928,7 +655,10 @@ export class BrowserCacheManager extends CacheManager {
         serverTelemetry: ServerTelemetryEntity
     ): void {
         this.logger.trace("BrowserCacheManager.setServerTelemetry called");
-        this.setItem(serverTelemetryKey, JSON.stringify(serverTelemetry));
+        this.browserStorage.setItem(
+            serverTelemetryKey,
+            JSON.stringify(serverTelemetry)
+        );
     }
 
     /**
@@ -1007,35 +737,13 @@ export class BrowserCacheManager extends CacheManager {
         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
+                "BrowserCacheManager.getActiveAccount: No active account filters found"
             );
-            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;
-            }
             return null;
         }
         const activeAccountValueObj = this.validateAndParseJson(
@@ -1065,9 +773,6 @@ export class BrowserCacheManager extends CacheManager {
         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: ActiveAccountFilters = {
@@ -1079,16 +784,11 @@ export class BrowserCacheManager extends CacheManager {
                 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);
         }
     }
 
@@ -1097,7 +797,7 @@ export class BrowserCacheManager extends CacheManager {
      * @param throttlingCacheKey
      */
     getThrottlingCache(throttlingCacheKey: string): ThrottlingEntity | null {
-        const value = this.getItem(throttlingCacheKey);
+        const value = this.browserStorage.getItem(throttlingCacheKey);
         if (!value) {
             this.logger.trace(
                 "BrowserCacheManager.getThrottlingCache: called, no cache hit"
@@ -1133,7 +833,10 @@ export class BrowserCacheManager extends CacheManager {
         throttlingCache: ThrottlingEntity
     ): void {
         this.logger.trace("BrowserCacheManager.setThrottlingCache called");
-        this.setItem(throttlingCacheKey, JSON.stringify(throttlingCache));
+        this.browserStorage.setItem(
+            throttlingCacheKey,
+            JSON.stringify(throttlingCache)
+        );
     }
 
     /**
@@ -1144,7 +847,7 @@ export class BrowserCacheManager extends CacheManager {
     getTemporaryCache(cacheKey: string, generateKey?: boolean): string | null {
         const key = generateKey ? this.generateCacheKey(cacheKey) : cacheKey;
         if (this.cacheConfig.storeAuthStateInCookie) {
-            const itemCookie = this.getItemCookie(key);
+            const itemCookie = this.cookieStorage.getItem(key);
             if (itemCookie) {
                 this.logger.trace(
                     "BrowserCacheManager.getTemporaryCache: storeAuthStateInCookies set to true, retrieving from cookies"
@@ -1198,7 +901,12 @@ export class BrowserCacheManager extends CacheManager {
             this.logger.trace(
                 "BrowserCacheManager.setTemporaryCache: storeAuthStateInCookie set to true, setting item cookie"
             );
-            this.setItemCookie(key, value);
+            this.cookieStorage.setItem(
+                key,
+                value,
+                undefined,
+                this.cacheConfig.secureCookies
+            );
         }
     }
 
@@ -1221,7 +929,7 @@ export class BrowserCacheManager extends CacheManager {
             this.logger.trace(
                 "BrowserCacheManager.removeItem: storeAuthStateInCookie is true, clearing item cookie"
             );
-            this.clearItemCookie(key);
+            this.cookieStorage.removeItem(key);
         }
     }
 
@@ -1301,96 +1009,6 @@ export class BrowserCacheManager extends CacheManager {
         }
     }
 
-    /**
-     * Add value to cookies
-     * @param cookieName
-     * @param cookieValue
-     * @param expires
-     * @deprecated
-     */
-    setItemCookie(
-        cookieName: string,
-        cookieValue: string,
-        expires?: number
-    ): void {
-        let cookieStr = `${encodeURIComponent(cookieName)}=${encodeURIComponent(
-            cookieValue
-        )};path=/;SameSite=Lax;`;
-        if (expires) {
-            const expireTime = this.getCookieExpirationTime(expires);
-            cookieStr += `expires=${expireTime};`;
-        }
-
-        if (this.cacheConfig.secureCookies) {
-            cookieStr += "Secure;";
-        }
-
-        document.cookie = cookieStr;
-    }
-
-    /**
-     * Get one item by key from cookies
-     * @param cookieName
-     * @deprecated
-     */
-    getItemCookie(cookieName: string): string {
-        const name = `${encodeURIComponent(cookieName)}=`;
-        const cookieList = document.cookie.split(";");
-        for (let i: number = 0; i < cookieList.length; i++) {
-            let cookie = cookieList[i];
-            while (cookie.charAt(0) === " ") {
-                cookie = cookie.substring(1);
-            }
-            if (cookie.indexOf(name) === 0) {
-                return decodeURIComponent(
-                    cookie.substring(name.length, cookie.length)
-                );
-            }
-        }
-        return Constants.EMPTY_STRING;
-    }
-
-    /**
-     * Clear all msal-related cookies currently set in the browser. Should only be used to clear temporary cache items.
-     * @deprecated
-     */
-    clearMsalCookies(): void {
-        const cookiePrefix = `${Constants.CACHE_PREFIX}.${this.clientId}`;
-        const cookieList = document.cookie.split(";");
-        cookieList.forEach((cookie: string): void => {
-            while (cookie.charAt(0) === " ") {
-                // eslint-disable-next-line no-param-reassign
-                cookie = cookie.substring(1);
-            }
-            if (cookie.indexOf(cookiePrefix) === 0) {
-                const cookieKey = cookie.split("=")[0];
-                this.clearItemCookie(cookieKey);
-            }
-        });
-    }
-
-    /**
-     * Clear an item in the cookies by key
-     * @param cookieName
-     * @deprecated
-     */
-    clearItemCookie(cookieName: string): void {
-        this.setItemCookie(cookieName, Constants.EMPTY_STRING, -1);
-    }
-
-    /**
-     * Get cookie expiration time
-     * @param cookieLifeDays
-     * @deprecated
-     */
-    getCookieExpirationTime(cookieLifeDays: number): string {
-        const today = new Date();
-        const expr = new Date(
-            today.getTime() + cookieLifeDays * this.COOKIE_LIFE_MULTIPLIER
-        );
-        return expr.toUTCString();
-    }
-
     /**
      * Prepend msal.<client-id> to each key; Skip for any JSON object as Key (defined schemas do not need the key appended: AccessToken Keys or the upcoming schema)
      * @param key
@@ -1399,10 +1017,7 @@ export class BrowserCacheManager extends CacheManager {
     generateCacheKey(key: string): string {
         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}`;
@@ -1570,7 +1185,6 @@ export class BrowserCacheManager extends CacheManager {
             );
             this.resetRequestCache(cachedState || Constants.EMPTY_STRING);
         }
-        this.clearMsalCookies();
     }
 
     /**
@@ -1609,7 +1223,6 @@ export class BrowserCacheManager extends CacheManager {
                 this.resetRequestCache(stateValue);
             }
         });
-        this.clearMsalCookies();
         this.setInteractionInProgress(false);
     }
 
@@ -1735,86 +1348,6 @@ export class BrowserCacheManager extends CacheManager {
         }
     }
 
-    /**
-     * Returns username retrieved from ADAL or MSAL v1 idToken
-     * @deprecated
-     */
-    getLegacyLoginHint(): string | null {
-        // 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: string,
-        credential: ValidCredentialType
-    ): string {
-        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