@azure/msal-browser 4.24.1 → 5.0.0-alpha.0

package/src/broker/nativeBroker/PlatformAuthProvider.ts

@@ -7,7 +7,7 @@ import {
     LoggerOptions,
     IPerformanceClient,
     Logger,
-    AuthenticationScheme,
+    Constants,
     StubPerformanceClient,
 } from "@azure/msal-common/browser";
 import { name, version } from "../../packageMetadata.js";
@@ -18,7 +18,6 @@ import {
 import { PlatformAuthExtensionHandler } from "./PlatformAuthExtensionHandler.js";
 import { IPlatformAuthHandler } from "./IPlatformAuthHandler.js";
 import { PlatformAuthDOMHandler } from "./PlatformAuthDOMHandler.js";
-import { createNewGuid } from "../../crypto/BrowserCrypto.js";
 import { BrowserCacheLocation } from "../../utils/BrowserConstants.js";
 import { PLATFORM_AUTH_DOM_SUPPORT } from "../../cache/CacheKeys.js";
 
@@ -26,6 +25,7 @@ import { PLATFORM_AUTH_DOM_SUPPORT } from "../../cache/CacheKeys.js";
  * Checks if the platform broker is available in the current environment.
  * @param loggerOptions
  * @param perfClient
+ * @param correlationId
  * @returns
  */
 export async function isPlatformBrokerAvailable(
@@ -34,21 +34,18 @@ export async function isPlatformBrokerAvailable(
     correlationId?: string
 ): Promise<boolean> {
     const logger = new Logger(loggerOptions || {}, name, version);
+    const cid = correlationId || "";
 
-    logger.trace("isPlatformBrokerAvailable called");
+    logger.trace("isPlatformBrokerAvailable called", cid);
 
     const performanceClient = perfClient || new StubPerformanceClient();
 
     if (typeof window === "undefined") {
-        logger.trace("Non-browser environment detected, returning false");
+        logger.trace("Non-browser environment detected, returning false", cid);
         return false;
     }
 
-    return !!(await getPlatformAuthProvider(
-        logger,
-        performanceClient,
-        correlationId || createNewGuid()
-    ));
+    return !!(await getPlatformAuthProvider(logger, performanceClient, cid));
 }
 
 export async function getPlatformAuthProvider(
@@ -62,8 +59,8 @@ export async function getPlatformAuthProvider(
     const enablePlatformBrokerDOMSupport = isDomEnabledForPlatformAuth();
 
     logger.trace(
-        "Has client allowed platform auth via DOM API: " +
-            enablePlatformBrokerDOMSupport
+        `Has client allowed platform auth via DOM API: '${enablePlatformBrokerDOMSupport}'`,
+        correlationId
     );
     let platformAuthProvider: IPlatformAuthHandler | undefined;
     try {
@@ -77,7 +74,8 @@ export async function getPlatformAuthProvider(
         }
         if (!platformAuthProvider) {
             logger.trace(
-                "Platform auth via DOM API not available, checking for extension"
+                "Platform auth via DOM API not available, checking for extension",
+                correlationId
             );
             /*
              * If DOM APIs are not available, check if browser extension is available.
@@ -88,7 +86,8 @@ export async function getPlatformAuthProvider(
                     logger,
                     nativeBrokerHandshakeTimeout ||
                         DEFAULT_NATIVE_BROKER_HANDSHAKE_TIMEOUT_MS,
-                    performanceClient
+                    performanceClient,
+                    correlationId
                 );
         }
     } catch (e) {
@@ -117,19 +116,22 @@ export function isDomEnabledForPlatformAuth(): boolean {
  * Returns boolean indicating whether or not the request should attempt to use native broker
  * @param logger
  * @param config
+ * @param correlationId
  * @param platformAuthProvider
  * @param authenticationScheme
  */
 export function isPlatformAuthAllowed(
     config: BrowserConfiguration,
     logger: Logger,
+    correlationId: string,
     platformAuthProvider?: IPlatformAuthHandler,
-    authenticationScheme?: AuthenticationScheme
+    authenticationScheme?: Constants.AuthenticationScheme
 ): boolean {
-    logger.trace("isPlatformAuthAllowed called");
+    logger.trace("isPlatformAuthAllowed called", correlationId);
     if (!config.system.allowPlatformBroker) {
         logger.trace(
-            "isPlatformAuthAllowed: allowPlatformBroker is not enabled, returning false"
+            "isPlatformAuthAllowed: allowPlatformBroker is not enabled, returning false",
+            correlationId
         );
         // Developer disabled WAM
         return false;
@@ -137,7 +139,8 @@ export function isPlatformAuthAllowed(
 
     if (!platformAuthProvider) {
         logger.trace(
-            "isPlatformAuthAllowed: Platform auth provider is not initialized, returning false"
+            "isPlatformAuthAllowed: Platform auth provider is not initialized, returning false",
+            correlationId
         );
         // Platform broker auth providers are not available
         return false;
@@ -145,15 +148,17 @@ export function isPlatformAuthAllowed(
 
     if (authenticationScheme) {
         switch (authenticationScheme) {
-            case AuthenticationScheme.BEARER:
-            case AuthenticationScheme.POP:
+            case Constants.AuthenticationScheme.BEARER:
+            case Constants.AuthenticationScheme.POP:
                 logger.trace(
-                    "isPlatformAuthAllowed: authenticationScheme is supported, returning true"
+                    "isPlatformAuthAllowed: authenticationScheme is supported, returning true",
+                    correlationId
                 );
                 return true;
             default:
                 logger.trace(
-                    "isPlatformAuthAllowed: authenticationScheme is not supported, returning false"
+                    "isPlatformAuthAllowed: authenticationScheme is not supported, returning false",
+                    correlationId
                 );
                 return false;
         }

package/src/cache/AccountManager.ts

@@ -18,9 +18,9 @@ export function getAllAccounts(
     correlationId: string,
     accountFilter?: AccountFilter
 ): AccountInfo[] {
-    logger.verbose("getAllAccounts called");
+    logger.verbose("getAllAccounts called", correlationId);
     return isInBrowser
-        ? browserStorage.getAllAccounts(accountFilter || {}, correlationId)
+        ? browserStorage.getAllAccounts(accountFilter, correlationId)
         : [];
 }
 
@@ -35,6 +35,12 @@ export function getAccount(
     browserStorage: BrowserCacheManager,
     correlationId: string
 ): AccountInfo | null {
+    logger.trace("getAccount called", correlationId);
+    if (Object.keys(accountFilter).length === 0) {
+        logger.warning("getAccount: No accountFilter provided", correlationId);
+        return null;
+    }
+
     const account: AccountInfo | null = browserStorage.getAccountInfoFilteredBy(
         accountFilter,
         correlationId
@@ -42,11 +48,15 @@ export function getAccount(
 
     if (account) {
         logger.verbose(
-            "getAccount: Account matching provided filter found, returning"
+            "getAccount: Account matching provided filter found, returning",
+            correlationId
         );
         return account;
     } else {
-        logger.verbose("getAccount: No matching account found, returning null");
+        logger.verbose(
+            "getAccount: No matching account found, returning null",
+            correlationId
+        );
         return null;
     }
 }
@@ -65,9 +75,12 @@ export function getAccountByUsername(
     browserStorage: BrowserCacheManager,
     correlationId: string
 ): AccountInfo | null {
-    logger.trace("getAccountByUsername called");
+    logger.trace("getAccountByUsername called", correlationId);
     if (!username) {
-        logger.warning("getAccountByUsername: No username provided");
+        logger.warning(
+            "getAccountByUsername: No username provided",
+            correlationId
+        );
         return null;
     }
 
@@ -79,15 +92,18 @@ export function getAccountByUsername(
     );
     if (account) {
         logger.verbose(
-            "getAccountByUsername: Account matching username found, returning"
+            "getAccountByUsername: Account matching username found, returning",
+            correlationId
         );
         logger.verbosePii(
-            `getAccountByUsername: Returning signed-in accounts matching username: ${username}`
+            `getAccountByUsername: Returning signed-in accounts matching username: '${username}'`,
+            correlationId
         );
         return account;
     } else {
         logger.verbose(
-            "getAccountByUsername: No matching account found, returning null"
+            "getAccountByUsername: No matching account found, returning null",
+            correlationId
         );
         return null;
     }
@@ -106,9 +122,12 @@ export function getAccountByHomeId(
     browserStorage: BrowserCacheManager,
     correlationId: string
 ): AccountInfo | null {
-    logger.trace("getAccountByHomeId called");
+    logger.trace("getAccountByHomeId called", correlationId);
     if (!homeAccountId) {
-        logger.warning("getAccountByHomeId: No homeAccountId provided");
+        logger.warning(
+            "getAccountByHomeId: No homeAccountId provided",
+            correlationId
+        );
         return null;
     }
 
@@ -120,15 +139,18 @@ export function getAccountByHomeId(
     );
     if (account) {
         logger.verbose(
-            "getAccountByHomeId: Account matching homeAccountId found, returning"
+            "getAccountByHomeId: Account matching homeAccountId found, returning",
+            correlationId
         );
         logger.verbosePii(
-            `getAccountByHomeId: Returning signed-in accounts matching homeAccountId: ${homeAccountId}`
+            `getAccountByHomeId: Returning signed-in accounts matching homeAccountId: '${homeAccountId}'`,
+            correlationId
         );
         return account;
     } else {
         logger.verbose(
-            "getAccountByHomeId: No matching account found, returning null"
+            "getAccountByHomeId: No matching account found, returning null",
+            correlationId
         );
         return null;
     }
@@ -147,9 +169,12 @@ export function getAccountByLocalId(
     browserStorage: BrowserCacheManager,
     correlationId: string
 ): AccountInfo | null {
-    logger.trace("getAccountByLocalId called");
+    logger.trace("getAccountByLocalId called", correlationId);
     if (!localAccountId) {
-        logger.warning("getAccountByLocalId: No localAccountId provided");
+        logger.warning(
+            "getAccountByLocalId: No localAccountId provided",
+            correlationId
+        );
         return null;
     }
 
@@ -161,15 +186,18 @@ export function getAccountByLocalId(
     );
     if (account) {
         logger.verbose(
-            "getAccountByLocalId: Account matching localAccountId found, returning"
+            "getAccountByLocalId: Account matching localAccountId found, returning",
+            correlationId
         );
         logger.verbosePii(
-            `getAccountByLocalId: Returning signed-in accounts matching localAccountId: ${localAccountId}`
+            `getAccountByLocalId: Returning signed-in accounts matching localAccountId: '${localAccountId}'`,
+            correlationId
         );
         return account;
     } else {
         logger.verbose(
-            "getAccountByLocalId: No matching account found, returning null"
+            "getAccountByLocalId: No matching account found, returning null",
+            correlationId
         );
         return null;
     }

package/src/cache/AsyncMemoryStorage.ts

@@ -27,13 +27,17 @@ export class AsyncMemoryStorage<T> implements IAsyncStorage<T> {
         this.logger = logger;
     }
 
-    private handleDatabaseAccessError(error: unknown): void {
+    private handleDatabaseAccessError(
+        error: unknown,
+        correlationId: string
+    ): void {
         if (
             error instanceof BrowserAuthError &&
             error.errorCode === BrowserAuthErrorCodes.databaseUnavailable
         ) {
             this.logger.error(
-                "Could not access persistent storage. This may be caused by browser privacy features which block persistent storage in third-party contexts."
+                "Could not access persistent storage. This may be caused by browser privacy features which block persistent storage in third-party contexts.",
+                correlationId
             );
         } else {
             throw error;
@@ -43,17 +47,19 @@ export class AsyncMemoryStorage<T> implements IAsyncStorage<T> {
      * Get the item matching the given key. Tries in-memory cache first, then in the asynchronous
      * storage object if item isn't found in-memory.
      * @param key
+     * @param correlationId
      */
-    async getItem(key: string): Promise<T | null> {
+    async getItem(key: string, correlationId: string): Promise<T | null> {
         const item = this.inMemoryCache.getItem(key);
         if (!item) {
             try {
                 this.logger.verbose(
-                    "Queried item not found in in-memory cache, now querying persistent storage."
+                    "Queried item not found in in-memory cache, now querying persistent storage.",
+                    correlationId
                 );
                 return await this.indexedDBCache.getItem(key);
             } catch (e) {
-                this.handleDatabaseAccessError(e);
+                this.handleDatabaseAccessError(e, correlationId);
             }
         }
         return item;
@@ -64,43 +70,47 @@ export class AsyncMemoryStorage<T> implements IAsyncStorage<T> {
      * storage object with the given key.
      * @param key
      * @param value
+     * @param correlationId
      */
-    async setItem(key: string, value: T): Promise<void> {
+    async setItem(key: string, value: T, correlationId: string): Promise<void> {
         this.inMemoryCache.setItem(key, value);
         try {
             await this.indexedDBCache.setItem(key, value);
         } catch (e) {
-            this.handleDatabaseAccessError(e);
+            this.handleDatabaseAccessError(e, correlationId);
         }
     }
 
     /**
      * Removes the item matching the key from the in-memory cache, then tries to remove it from the asynchronous storage object.
      * @param key
+     * @param correlationId
      */
-    async removeItem(key: string): Promise<void> {
+    async removeItem(key: string, correlationId: string): Promise<void> {
         this.inMemoryCache.removeItem(key);
         try {
             await this.indexedDBCache.removeItem(key);
         } catch (e) {
-            this.handleDatabaseAccessError(e);
+            this.handleDatabaseAccessError(e, correlationId);
         }
     }
 
     /**
      * Get all the keys from the in-memory cache as an iterable array of strings. If no keys are found, query the keys in the
      * asynchronous storage object.
+     * @param correlationId
      */
-    async getKeys(): Promise<string[]> {
+    async getKeys(correlationId: string): Promise<string[]> {
         const cacheKeys = this.inMemoryCache.getKeys();
         if (cacheKeys.length === 0) {
             try {
                 this.logger.verbose(
-                    "In-memory cache is empty, now querying persistent storage."
+                    "In-memory cache is empty, now querying persistent storage.",
+                    correlationId
                 );
                 return await this.indexedDBCache.getKeys();
             } catch (e) {
-                this.handleDatabaseAccessError(e);
+                this.handleDatabaseAccessError(e, correlationId);
             }
         }
         return cacheKeys;
@@ -109,17 +119,19 @@ export class AsyncMemoryStorage<T> implements IAsyncStorage<T> {
     /**
      * Returns true or false if the given key is present in the cache.
      * @param key
+     * @param correlationId
      */
-    async containsKey(key: string): Promise<boolean> {
+    async containsKey(key: string, correlationId: string): Promise<boolean> {
         const containsKey = this.inMemoryCache.containsKey(key);
         if (!containsKey) {
             try {
                 this.logger.verbose(
-                    "Key not found in in-memory cache, now querying persistent storage."
+                    "Key not found in in-memory cache, now querying persistent storage.",
+                    correlationId
                 );
                 return await this.indexedDBCache.containsKey(key);
             } catch (e) {
-                this.handleDatabaseAccessError(e);
+                this.handleDatabaseAccessError(e, correlationId);
             }
         }
         return containsKey;
@@ -127,29 +139,34 @@ export class AsyncMemoryStorage<T> implements IAsyncStorage<T> {
 
     /**
      * Clears in-memory Map
+     * @param correlationId
      */
-    clearInMemory(): void {
+    clearInMemory(correlationId: string): void {
         // InMemory cache is a Map instance, clear is straightforward
-        this.logger.verbose(`Deleting in-memory keystore`);
+        this.logger.verbose(`Deleting in-memory keystore`, correlationId);
         this.inMemoryCache.clear();
-        this.logger.verbose(`In-memory keystore deleted`);
+        this.logger.verbose(`In-memory keystore deleted`, correlationId);
     }
 
     /**
      * Tries to delete the IndexedDB database
+     * @param correlationId
      * @returns
      */
-    async clearPersistent(): Promise<boolean> {
+    async clearPersistent(correlationId: string): Promise<boolean> {
         try {
-            this.logger.verbose("Deleting persistent keystore");
+            this.logger.verbose("Deleting persistent keystore", correlationId);
             const dbDeleted = await this.indexedDBCache.deleteDatabase();
             if (dbDeleted) {
-                this.logger.verbose("Persistent keystore deleted");
+                this.logger.verbose(
+                    "Persistent keystore deleted",
+                    correlationId
+                );
             }
 
             return dbDeleted;
         } catch (e) {
-            this.handleDatabaseAccessError(e);
+            this.handleDatabaseAccessError(e, correlationId);
             return false;
         }
     }