@azure/msal-browser 5.13.0 → 5.15.0

package/src/controllers/NestedAppAuthController.ts

@@ -628,9 +628,8 @@ export class NestedAppAuthController implements IController {
      * acquireTokenRedirect flow is not supported in nested app auth
      * @param request
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     acquireTokenRedirect(request: RedirectRequest): Promise<void> {
-        throw NestedAppAuthError.createUnsupportedError();
+        throw NestedAppAuthError.createUnsupportedError(request?.correlationId);
     }
 
     /**
@@ -648,11 +647,10 @@ export class NestedAppAuthController implements IController {
      * Hybrid flow is not currently supported in nested app auth
      * @param request
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     acquireTokenByCode(
-        request: AuthorizationCodeRequest // eslint-disable-line @typescript-eslint/no-unused-vars
+        request: AuthorizationCodeRequest
     ): Promise<AuthenticationResult> {
-        throw NestedAppAuthError.createUnsupportedError();
+        throw NestedAppAuthError.createUnsupportedError(request?.correlationId);
     }
 
     /**
@@ -677,11 +675,13 @@ export class NestedAppAuthController implements IController {
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     addPerformanceCallback(callback: PerformanceCallbackFunction): string {
+        // No request context: callback registration is not per-request
         throw NestedAppAuthError.createUnsupportedError();
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     removePerformanceCallback(callbackId: string): boolean {
+        // No request context: callback registration is not per-request
         throw NestedAppAuthError.createUnsupportedError();
     }
 
@@ -756,17 +756,21 @@ export class NestedAppAuthController implements IController {
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     loginRedirect(request?: RedirectRequest | undefined): Promise<void> {
-        throw NestedAppAuthError.createUnsupportedError();
+        throw NestedAppAuthError.createUnsupportedError(request?.correlationId);
     }
     logoutRedirect(
-        logoutRequest?: EndSessionRequest | undefined // eslint-disable-line @typescript-eslint/no-unused-vars
+        logoutRequest?: EndSessionRequest | undefined
     ): Promise<void> {
-        throw NestedAppAuthError.createUnsupportedError();
+        throw NestedAppAuthError.createUnsupportedError(
+            logoutRequest?.correlationId
+        );
     }
     logoutPopup(
-        logoutRequest?: EndSessionPopupRequest | undefined // eslint-disable-line @typescript-eslint/no-unused-vars
+        logoutRequest?: EndSessionPopupRequest | undefined
     ): Promise<void> {
-        throw NestedAppAuthError.createUnsupportedError();
+        throw NestedAppAuthError.createUnsupportedError(
+            logoutRequest?.correlationId
+        );
     }
     ssoSilent(
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -829,16 +833,20 @@ export class NestedAppAuthController implements IController {
     }
 
     getPerformanceClient(): IPerformanceClient {
+        // Accessor stub with no request context
         throw NestedAppAuthError.createUnsupportedError();
     }
 
     getRedirectResponse(): Map<string, Promise<AuthenticationResult | null>> {
+        // Accessor stub with no request context
         throw NestedAppAuthError.createUnsupportedError();
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async clearCache(logoutRequest?: ClearCacheRequest): Promise<void> {
-        throw NestedAppAuthError.createUnsupportedError();
+        throw NestedAppAuthError.createUnsupportedError(
+            logoutRequest?.correlationId
+        );
     }
 
     async hydrateCache(

package/src/controllers/StandardController.ts

@@ -1307,7 +1307,8 @@ export class StandardController implements IController {
             if (request.code && request.nativeAccountId) {
                 // Throw error in case server returns both spa_code and spa_accountid in exchange for auth code.
                 throw createBrowserAuthError(
-                    BrowserAuthErrorCodes.spaCodeAndNativeAccountIdPresent
+                    BrowserAuthErrorCodes.spaCodeAndNativeAccountIdPresent,
+                    correlationId
                 );
             } else if (request.code) {
                 const hybridAuthCode = request.code;
@@ -1404,12 +1405,14 @@ export class StandardController implements IController {
                     return result;
                 } else {
                     throw createBrowserAuthError(
-                        BrowserAuthErrorCodes.unableToAcquireTokenFromNativePlatform
+                        BrowserAuthErrorCodes.unableToAcquireTokenFromNativePlatform,
+                        correlationId
                     );
                 }
             } else {
                 throw createBrowserAuthError(
-                    BrowserAuthErrorCodes.authCodeOrNativeAccountIdRequired
+                    BrowserAuthErrorCodes.authCodeOrNativeAccountIdRequired,
+                    correlationId
                 );
             }
         } catch (e) {
@@ -1505,7 +1508,8 @@ export class StandardController implements IController {
                 )(commonRequest);
             default:
                 throw createClientAuthError(
-                    ClientAuthErrorCodes.tokenRefreshRequired
+                    ClientAuthErrorCodes.tokenRefreshRequired,
+                    commonRequest.correlationId
                 );
         }
     }
@@ -1538,7 +1542,8 @@ export class StandardController implements IController {
                 )(commonRequest);
             default:
                 throw createClientAuthError(
-                    ClientAuthErrorCodes.tokenRefreshRequired
+                    ClientAuthErrorCodes.tokenRefreshRequired,
+                    commonRequest.correlationId
                 );
         }
     }
@@ -1738,6 +1743,7 @@ export class StandardController implements IController {
                     ? TimeUtils.toSecondsFromDate(result.extExpiresOn)
                     : 0,
                 base64Decode,
+                request.correlationId || "",
                 undefined, // refreshOn
                 result.tokenType as Constants.AuthenticationScheme,
                 undefined, // userAssertionHash
@@ -1784,7 +1790,8 @@ export class StandardController implements IController {
         this.logger.trace("acquireTokenNative called", correlationId);
         if (!this.platformAuthProvider) {
             throw createBrowserAuthError(
-                BrowserAuthErrorCodes.nativeConnectionNotEstablished
+                BrowserAuthErrorCodes.nativeConnectionNotEstablished,
+                correlationId
             );
         }
 
@@ -2195,7 +2202,10 @@ export class StandardController implements IController {
 
         const account = request.account || this.getActiveAccount();
         if (!account) {
-            throw createBrowserAuthError(BrowserAuthErrorCodes.noAccountError);
+            throw createBrowserAuthError(
+                BrowserAuthErrorCodes.noAccountError,
+                correlationId
+            );
         }
 
         return this.acquireTokenSilentDeduped(request, account, correlationId)
@@ -2219,7 +2229,7 @@ export class StandardController implements IController {
             .catch((error: Error) => {
                 if (error instanceof AuthError) {
                     // Ensures PWB scenarios can correctly match request to response
-                    error.setCorrelationId(correlationId);
+                    error.correlationId = correlationId;
                 }
 
                 atsMeasurement.end(
@@ -2530,7 +2540,8 @@ export class StandardController implements IController {
                     this.platformAuthProvider = undefined; // Prevent future requests from continuing to attempt
                     // Cache will not contain tokens, given that previous WAM requests succeeded. Skip cache and RT renewal and go straight to iframe renewal
                     throw createClientAuthError(
-                        ClientAuthErrorCodes.tokenRefreshRequired
+                        ClientAuthErrorCodes.tokenRefreshRequired,
+                        silentRequest.correlationId
                     );
                 }
                 throw e;

package/src/crypto/BrowserCrypto.ts

@@ -59,15 +59,20 @@ export function validateCryptoAvailable(
 ): void {
     if (!window) {
         throw createBrowserAuthError(
-            BrowserAuthErrorCodes.nonBrowserEnvironment
+            BrowserAuthErrorCodes.nonBrowserEnvironment,
+            ""
         );
     }
     if (!window.crypto) {
-        throw createBrowserAuthError(BrowserAuthErrorCodes.cryptoNonExistent);
+        throw createBrowserAuthError(
+            BrowserAuthErrorCodes.cryptoNonExistent,
+            ""
+        );
     }
     if (!skipValidateSubtleCrypto && !window.crypto.subtle) {
         throw createBrowserAuthError(
             BrowserAuthErrorCodes.cryptoNonExistent,
+            "",
             SUBTLE_SUBERROR
         );
     }
@@ -260,6 +265,7 @@ export async function decryptEarResponse(
     if (earJweParts.length !== 5) {
         throw createBrowserAuthError(
             BrowserAuthErrorCodes.failedToDecryptEarResponse,
+            "",
             "jwe_length"
         );
     }
@@ -267,6 +273,7 @@ export async function decryptEarResponse(
     const key = await importEarKey(earJwk).catch(() => {
         throw createBrowserAuthError(
             BrowserAuthErrorCodes.failedToDecryptEarResponse,
+            "",
             "import_key"
         );
     });
@@ -298,6 +305,7 @@ export async function decryptEarResponse(
     } catch (e) {
         throw createBrowserAuthError(
             BrowserAuthErrorCodes.failedToDecryptEarResponse,
+            "",
             "decrypt"
         );
     }

package/src/crypto/CryptoOps.ts

@@ -183,7 +183,8 @@ export class CryptoOps implements ICrypto {
         const keyFound = await this.cache.containsKey(kid, correlationId);
         if (keyFound) {
             throw createClientAuthError(
-                ClientAuthErrorCodes.bindingKeyNotRemoved
+                ClientAuthErrorCodes.bindingKeyNotRemoved,
+                correlationId
             );
         }
     }
@@ -242,7 +243,8 @@ export class CryptoOps implements ICrypto {
 
         if (!cachedKeyPair) {
             throw createBrowserAuthError(
-                BrowserAuthErrorCodes.cryptoKeyNotFound
+                BrowserAuthErrorCodes.cryptoKeyNotFound,
+                correlationId || ""
             );
         }
 

package/src/crypto/PkceGenerator.ts

@@ -76,7 +76,10 @@ function generateCodeVerifier(
         const pkceCodeVerifierB64: string = urlEncodeArr(buffer);
         return pkceCodeVerifierB64;
     } catch (e) {
-        throw createBrowserAuthError(BrowserAuthErrorCodes.pkceNotCreated);
+        throw createBrowserAuthError(
+            BrowserAuthErrorCodes.pkceNotCreated,
+            correlationId
+        );
     }
 }
 
@@ -102,6 +105,9 @@ async function generateCodeChallengeFromVerifier(
         // encode hash as base64
         return urlEncodeArr(new Uint8Array(pkceHashedCodeVerifier));
     } catch (e) {
-        throw createBrowserAuthError(BrowserAuthErrorCodes.pkceNotCreated);
+        throw createBrowserAuthError(
+            BrowserAuthErrorCodes.pkceNotCreated,
+            correlationId
+        );
     }
 }

package/src/custom_auth/controller/CustomAuthStandardController.ts

@@ -59,6 +59,7 @@ import { SignUpCodeRequiredState } from "../sign_up/auth_flow/state/SignUpCodeRe
 import { SignUpPasswordRequiredState } from "../sign_up/auth_flow/state/SignUpPasswordRequiredState.js";
 import { ResetPasswordCodeRequiredState } from "../reset_password/auth_flow/state/ResetPasswordCodeRequiredState.js";
 import { StandardController } from "../../controllers/StandardController.js";
+import { name } from "../../packageMetadata.js";
 
 /*
  * Controller for standard native auth operations.
@@ -95,10 +96,7 @@ export class CustomAuthStandardController
             throw new UnsupportedEnvironmentError();
         }
 
-        this.logger = this.logger.clone(
-            DefaultPackageInfo.SKU,
-            DefaultPackageInfo.VERSION
-        );
+        this.logger = this.logger.clone(name, DefaultPackageInfo.VERSION);
         this.customAuthConfig = operatingContext.getCustomAuthConfig();
 
         this.authority = new CustomAuthAuthority(

package/src/custom_auth/core/CustomAuthAuthority.ts

@@ -37,8 +37,10 @@ export class CustomAuthAuthority extends Authority {
         performanceClient: IPerformanceClient,
         private customAuthProxyDomain?: string
     ) {
-        const ciamAuthorityUrl =
-            CustomAuthAuthority.transformCIAMAuthority(authority);
+        const ciamAuthorityUrl = CustomAuthAuthority.transformCIAMAuthority(
+            authority,
+            ""
+        );
 
         const authorityOptions: AuthorityOptions = {
             protocolMode: config.system.protocolMode,

package/src/custom_auth/get_account/interaction_client/CustomAuthSilentCacheClient.ts

@@ -135,7 +135,8 @@ export class CustomAuthSilentCacheClient extends CustomAuthInteractionClientBase
         if (postLogoutRedirectUri) {
             const absoluteRedirectUri = UrlString.getAbsoluteUrl(
                 postLogoutRedirectUri,
-                getCurrentUri()
+                getCurrentUri(),
+                correlationId
             );
 
             this.logger.verbose(

package/src/encode/Base64Decode.ts

@@ -38,7 +38,8 @@ export function base64DecToArr(base64String: string): Uint8Array {
             break;
         default:
             throw createBrowserAuthError(
-                BrowserAuthErrorCodes.invalidBase64String
+                BrowserAuthErrorCodes.invalidBase64String,
+                ""
             );
     }
     const binString = atob(encodedString);

package/src/error/BrowserAuthError.ts

@@ -15,8 +15,13 @@ export function getDefaultErrorMessage(code: string): string {
  * Browser library error class thrown by the MSAL.js library for SPAs
  */
 export class BrowserAuthError extends AuthError {
-    constructor(errorCode: string, subError?: string) {
-        super(errorCode, getDefaultErrorMessage(errorCode), subError);
+    constructor(errorCode: string, correlationId: string, subError?: string) {
+        super(
+            errorCode,
+            correlationId,
+            getDefaultErrorMessage(errorCode),
+            subError
+        );
 
         Object.setPrototypeOf(this, BrowserAuthError.prototype);
         this.name = "BrowserAuthError";
@@ -25,7 +30,8 @@ export class BrowserAuthError extends AuthError {
 
 export function createBrowserAuthError(
     errorCode: string,
+    correlationId: string,
     subError?: string
 ): BrowserAuthError {
-    return new BrowserAuthError(errorCode, subError);
+    return new BrowserAuthError(errorCode, correlationId, subError);
 }

package/src/error/BrowserConfigurationAuthError.ts

@@ -11,8 +11,12 @@ export { BrowserConfigurationAuthErrorCodes };
  * Browser library error class thrown by the MSAL.js library for SPAs
  */
 export class BrowserConfigurationAuthError extends AuthError {
-    constructor(errorCode: string, errorMessage?: string) {
-        super(errorCode, errorMessage);
+    constructor(
+        errorCode: string,
+        correlationId: string,
+        errorMessage?: string
+    ) {
+        super(errorCode, correlationId, errorMessage);
         this.name = "BrowserConfigurationAuthError";
 
         Object.setPrototypeOf(this, BrowserConfigurationAuthError.prototype);
@@ -20,10 +24,12 @@ export class BrowserConfigurationAuthError extends AuthError {
 }
 
 export function createBrowserConfigurationAuthError(
-    errorCode: string
+    errorCode: string,
+    correlationId: string
 ): BrowserConfigurationAuthError {
     return new BrowserConfigurationAuthError(
         errorCode,
+        correlationId,
         getDefaultErrorMessage(errorCode)
     );
 }

package/src/error/NativeAuthError.ts

@@ -32,8 +32,17 @@ const INVALID_METHOD_ERROR = -2147186943;
 export class NativeAuthError extends AuthError {
     ext: OSError | undefined;
 
-    constructor(errorCode: string, description?: string, ext?: OSError) {
-        super(errorCode, description || getDefaultErrorMessage(errorCode));
+    constructor(
+        errorCode: string,
+        correlationId: string,
+        description?: string,
+        ext?: OSError
+    ) {
+        super(
+            errorCode,
+            correlationId,
+            description || getDefaultErrorMessage(errorCode)
+        );
 
         Object.setPrototypeOf(this, NativeAuthError.prototype);
         this.name = "NativeAuthError";
@@ -79,32 +88,56 @@ export function isFatalNativeAuthError(error: NativeAuthError): boolean {
  */
 export function createNativeAuthError(
     code: string,
+    correlationId: string,
     description?: string,
     ext?: OSError
 ): AuthError {
+    let error: AuthError;
     if (ext && ext.status) {
         switch (ext.status) {
             case NativeStatusCodes.ACCOUNT_UNAVAILABLE:
-                return createInteractionRequiredAuthError(
+                error = createInteractionRequiredAuthError(
                     InteractionRequiredAuthErrorCodes.nativeAccountUnavailable,
+                    correlationId,
                     getDefaultErrorMessage(code)
                 );
+                break;
             case NativeStatusCodes.USER_INTERACTION_REQUIRED:
-                return new InteractionRequiredAuthError(code, description);
+                error = new InteractionRequiredAuthError(
+                    code,
+                    correlationId,
+                    description
+                );
+                break;
             case NativeStatusCodes.USER_CANCEL:
-                return createBrowserAuthError(
-                    BrowserAuthErrorCodes.userCancelled
+                error = createBrowserAuthError(
+                    BrowserAuthErrorCodes.userCancelled,
+                    correlationId
                 );
+                break;
             case NativeStatusCodes.NO_NETWORK:
-                return createBrowserAuthError(
-                    BrowserAuthErrorCodes.noNetworkConnectivity
+                error = createBrowserAuthError(
+                    BrowserAuthErrorCodes.noNetworkConnectivity,
+                    correlationId
                 );
+                break;
             case NativeStatusCodes.UI_NOT_ALLOWED:
-                return createInteractionRequiredAuthError(
-                    InteractionRequiredAuthErrorCodes.uiNotAllowed
+                error = createInteractionRequiredAuthError(
+                    InteractionRequiredAuthErrorCodes.uiNotAllowed,
+                    correlationId
+                );
+                break;
+            default:
+                error = new NativeAuthError(
+                    code,
+                    correlationId,
+                    description,
+                    ext
                 );
         }
+        return error;
     }
 
-    return new NativeAuthError(code, description, ext);
+    error = new NativeAuthError(code, correlationId, description, ext);
+    return error;
 }

package/src/error/NestedAppAuthError.ts

@@ -7,14 +7,24 @@ import { AuthError } from "@azure/msal-common/browser";
 import { unsupportedMethod } from "./NativeAuthErrorCodes.js";
 
 export class NestedAppAuthError extends AuthError {
-    constructor(errorCode: string, errorMessage?: string) {
-        super(errorCode, errorMessage);
+    constructor(
+        errorCode: string,
+        correlationId: string,
+        errorMessage?: string
+    ) {
+        super(errorCode, correlationId, errorMessage);
 
         Object.setPrototypeOf(this, NestedAppAuthError.prototype);
         this.name = "NestedAppAuthError";
     }
 
-    public static createUnsupportedError(): NestedAppAuthError {
-        return new NestedAppAuthError(unsupportedMethod);
+    public static createUnsupportedError(
+        correlationId?: string
+    ): NestedAppAuthError {
+        /*
+         * Some controller stubs (perf callbacks, getPerformanceClient, getRedirectResponse)
+         * have no request param and thus no correlationId to forward
+         */
+        return new NestedAppAuthError(unsupportedMethod, correlationId || "");
     }
 }

package/src/event/EventHandler.ts

@@ -13,6 +13,7 @@ import {
 } from "./EventMessage.js";
 import { EventType } from "./EventType.js";
 import { createGuid } from "../utils/BrowserUtils.js";
+import { version, name } from "../packageMetadata.js";
 
 const BROADCAST_CHANNEL_NAME = "msal.broadcast.event";
 
@@ -27,7 +28,7 @@ export class EventHandler {
 
     constructor(logger?: Logger) {
         this.eventCallbacks = new Map();
-        this.logger = logger || new Logger({});
+        this.logger = logger || new Logger({}, name, version);
         if (typeof BroadcastChannel !== "undefined") {
             this.broadcastChannel = new BroadcastChannel(
                 BROADCAST_CHANNEL_NAME

package/src/interaction_client/BaseInteractionClient.ts

@@ -30,8 +30,7 @@ import { EndSessionRequest } from "../request/EndSessionRequest.js";
 import { RedirectRequest } from "../request/RedirectRequest.js";
 import { PopupRequest } from "../request/PopupRequest.js";
 import { SsoSilentRequest } from "../request/SsoSilentRequest.js";
-import { version } from "../packageMetadata.js";
-import { BrowserConstants } from "../utils/BrowserConstants.js";
+import { version, name } from "../packageMetadata.js";
 import * as BrowserUtils from "../utils/BrowserUtils.js";
 import { INavigationClient } from "../navigation/INavigationClient.js";
 import { AuthenticationResult } from "../response/AuthenticationResult.js";
@@ -69,7 +68,7 @@ export abstract class BaseInteractionClient {
         this.navigationClient = navigationClient;
         this.platformAuthProvider = platformAuthProvider;
         this.correlationId = correlationId;
-        this.logger = logger.clone(BrowserConstants.MSAL_SKU, version);
+        this.logger = logger.clone(name, version);
         this.performanceClient = performanceClient;
     }
 
@@ -98,7 +97,11 @@ export function getRedirectUri(
 ): string {
     logger.verbose("getRedirectUri called", correlationId);
     const redirectUri = requestRedirectUri || clientConfigRedirectUri || "";
-    return UrlString.getAbsoluteUrl(redirectUri, BrowserUtils.getCurrentUri());
+    return UrlString.getAbsoluteUrl(
+        redirectUri,
+        BrowserUtils.getCurrentUri(),
+        correlationId
+    );
 }
 
 /**
@@ -190,7 +193,7 @@ export async function getDiscoveredAuthority(
     const userAuthority =
         account && resolvedInstanceAware
             ? config.auth.authority.replace(
-                  UrlString.getDomainFromUrl(resolvedAuthority),
+                  UrlString.getDomainFromUrl(resolvedAuthority, correlationId),
                   account.environment
               )
             : resolvedAuthority;
@@ -218,7 +221,8 @@ export async function getDiscoveredAuthority(
 
     if (account && !discoveredAuthority.isAlias(account.environment)) {
         throw createClientConfigurationError(
-            ClientConfigurationErrorCodes.authorityMismatch
+            ClientConfigurationErrorCodes.authorityMismatch,
+            correlationId
         );
     }