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

package/src/interaction_client/StandardInteractionClient.ts

@@ -5,23 +5,28 @@
 
 import {
     ServerTelemetryManager,
-    Constants,
     AuthorizationCodeClient,
     ClientConfiguration,
     UrlString,
     CommonEndSessionRequest,
     ProtocolUtils,
-    ResponseMode,
     IdTokenClaims,
     AccountInfo,
     AzureCloudOptions,
-    PerformanceEvents,
     invokeAsync,
     BaseAuthRequest,
     StringDict,
     CommonAuthorizationUrlRequest,
+    ICrypto,
+    Logger,
+    IPerformanceClient,
 } from "@azure/msal-common/browser";
-import { BaseInteractionClient } from "./BaseInteractionClient.js";
+import {
+    BaseInteractionClient,
+    getDiscoveredAuthority,
+    getRedirectUri,
+} from "./BaseInteractionClient.js";
+import * as BrowserPerformanceEvents from "../telemetry/BrowserPerformanceEvents.js";
 import {
     BrowserConstants,
     InteractionType,
@@ -34,10 +39,9 @@ import { RedirectRequest } from "../request/RedirectRequest.js";
 import { PopupRequest } from "../request/PopupRequest.js";
 import { SsoSilentRequest } from "../request/SsoSilentRequest.js";
 import { createNewGuid } from "../crypto/BrowserCrypto.js";
-import {
-    initializeBaseRequest,
-    validateRequestMethod,
-} from "../request/RequestHelpers.js";
+import { initializeBaseRequest } from "../request/RequestHelpers.js";
+import { BrowserConfiguration } from "../config/Configuration.js";
+import { BrowserCacheManager } from "../cache/BrowserCacheManager.js";
 
 /**
  * Defines the class structure and helper functions used by the "standard", non-brokered auth flows (popup, redirect, silent (RT), silent (iframe))
@@ -52,11 +56,11 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
     ): CommonEndSessionRequest {
         this.logger.verbose(
             "initializeLogoutRequest called",
-            logoutRequest?.correlationId
+            this.correlationId
         );
 
         const validLogoutRequest: CommonEndSessionRequest = {
-            correlationId: this.correlationId || createNewGuid(),
+            correlationId: this.correlationId,
             ...logoutRequest,
         };
 
@@ -73,23 +77,27 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
                     );
                     if (logoutHint) {
                         this.logger.verbose(
-                            "Setting logoutHint to login_hint ID Token Claim value for the account provided"
+                            "Setting logoutHint to login_hint ID Token Claim value for the account provided",
+                            this.correlationId
                         );
                         validLogoutRequest.logoutHint = logoutHint;
                     }
                 } else {
                     this.logger.verbose(
-                        "logoutHint was not set and account was not passed into logout request, logoutHint will not be set"
+                        "logoutHint was not set and account was not passed into logout request, logoutHint will not be set",
+                        this.correlationId
                     );
                 }
             } else {
                 this.logger.verbose(
-                    "logoutHint has already been set in logoutRequest"
+                    "logoutHint has already been set in logoutRequest",
+                    this.correlationId
                 );
             }
         } else {
             this.logger.verbose(
-                "logoutHint will not be set since no logout request was configured"
+                "logoutHint will not be set since no logout request was configured",
+                this.correlationId
             );
         }
 
@@ -158,12 +166,14 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
                 return idTokenClaims.login_hint;
             } else {
                 this.logger.verbose(
-                    "The ID Token Claims tied to the provided account do not contain a login_hint claim, logoutHint will not be added to logout request"
+                    "The ID Token Claims tied to the provided account do not contain a login_hint claim, logoutHint will not be added to logout request",
+                    this.correlationId
                 );
             }
         } else {
             this.logger.verbose(
-                "The provided account does not contain ID Token Claims, logoutHint will not be added to logout request"
+                "The provided account does not contain ID Token Claims, logoutHint will not be added to logout request",
+                this.correlationId
             );
         }
 
@@ -187,14 +197,10 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
         requestExtraQueryParameters?: StringDict;
         account?: AccountInfo;
     }): Promise<AuthorizationCodeClient> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.StandardInteractionClientCreateAuthCodeClient,
-            this.correlationId
-        );
         // Create auth module.
         const clientConfig = await invokeAsync(
             this.getClientConfiguration.bind(this),
-            PerformanceEvents.StandardInteractionClientGetClientConfiguration,
+            BrowserPerformanceEvents.StandardInteractionClientGetClientConfiguration,
             this.logger,
             this.performanceClient,
             this.correlationId
@@ -231,22 +237,23 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
             account,
         } = params;
 
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.StandardInteractionClientGetClientConfiguration,
-            this.correlationId
-        );
         const discoveredAuthority = await invokeAsync(
-            this.getDiscoveredAuthority.bind(this),
-            PerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
+            getDiscoveredAuthority,
+            BrowserPerformanceEvents.StandardInteractionClientGetDiscoveredAuthority,
             this.logger,
             this.performanceClient,
             this.correlationId
-        )({
+        )(
+            this.config,
+            this.correlationId,
+            this.performanceClient,
+            this.browserStorage,
+            this.logger,
             requestAuthority,
             requestAzureCloudOptions,
             requestExtraQueryParameters,
-            account,
-        });
+            account
+        );
         const logger = this.config.system.loggerOptions;
 
         return {
@@ -267,10 +274,6 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
                 logLevel: logger.logLevel,
                 correlationId: this.correlationId,
             },
-            cacheOptions: {
-                claimsBasedCachingEnabled:
-                    this.config.cache.claimsBasedCachingEnabled,
-            },
             cryptoInterface: this.browserCrypto,
             networkInterface: this.networkClient,
             storageInterface: this.browserStorage,
@@ -278,87 +281,89 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
             libraryInfo: {
                 sku: BrowserConstants.MSAL_SKU,
                 version: version,
-                cpu: Constants.EMPTY_STRING,
-                os: Constants.EMPTY_STRING,
+                cpu: "",
+                os: "",
             },
             telemetry: this.config.telemetry,
         };
     }
+}
 
-    /**
-     * Helper to initialize required request parameters for interactive APIs and ssoSilent()
-     * @param request
-     * @param interactionType
-     */
-    protected async initializeAuthorizationRequest(
-        request: RedirectRequest | PopupRequest | SsoSilentRequest,
-        interactionType: InteractionType
-    ): Promise<CommonAuthorizationUrlRequest> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.StandardInteractionClientInitializeAuthorizationRequest,
-            this.correlationId
-        );
-
-        const redirectUri = this.getRedirectUri(request.redirectUri);
-        const browserState: BrowserStateObject = {
-            interactionType: interactionType,
-        };
-        const state = ProtocolUtils.setRequestState(
-            this.browserCrypto,
-            (request && request.state) || Constants.EMPTY_STRING,
-            browserState
-        );
-
-        const baseRequest: BaseAuthRequest = await invokeAsync(
-            initializeBaseRequest,
-            PerformanceEvents.InitializeBaseRequest,
-            this.logger,
-            this.performanceClient,
-            this.correlationId
-        )(
-            { ...request, correlationId: this.correlationId },
-            this.config,
-            this.performanceClient,
-            this.logger
-        );
-
-        const interactionRequest: CommonAuthorizationUrlRequest = {
-            ...baseRequest,
-            redirectUri: redirectUri,
-            state: state,
-            nonce: request.nonce || createNewGuid(),
-            responseMode: this.config.auth.OIDCOptions
-                .serverResponseType as ResponseMode,
-        };
-
-        const validatedRequest = {
-            ...interactionRequest,
-            httpMethod: validateRequestMethod(
-                interactionRequest,
-                this.config.auth.protocolMode
-            ),
-        };
+/**
+ * Helper to initialize required request parameters for interactive APIs and ssoSilent().
+ *
+ * @param request - The authentication request object (RedirectRequest, PopupRequest, or SsoSilentRequest).
+ * @param interactionType - The type of interaction (e.g., redirect, popup, silent).
+ * @param config - The browser configuration object.
+ * @param browserCrypto - The cryptographic interface for browser operations.
+ * @param browserStorage - The browser storage manager instance.
+ * @param logger - The logger instance for logging messages.
+ * @param performanceClient - The performance client for telemetry.
+ * @param correlationId - The correlation ID for the request.
+ * @returns A promise that resolves to a CommonAuthorizationUrlRequest object with initialized parameters.
+ */
+export async function initializeAuthorizationRequest(
+    request: RedirectRequest | PopupRequest | SsoSilentRequest,
+    interactionType: InteractionType,
+    config: BrowserConfiguration,
+    browserCrypto: ICrypto,
+    browserStorage: BrowserCacheManager,
+    logger: Logger,
+    performanceClient: IPerformanceClient,
+    correlationId: string
+): Promise<CommonAuthorizationUrlRequest> {
+    const redirectUri = getRedirectUri(
+        request.redirectUri,
+        config.auth.redirectUri,
+        logger,
+        correlationId
+    );
+    const browserState: BrowserStateObject = {
+        interactionType: interactionType,
+    };
+    const state = ProtocolUtils.setRequestState(
+        browserCrypto,
+        (request && request.state) || "",
+        browserState
+    );
 
-        // Skip active account lookup if either login hint or session id is set
-        if (request.loginHint || request.sid) {
-            return validatedRequest;
-        }
+    const baseRequest: BaseAuthRequest = await invokeAsync(
+        initializeBaseRequest,
+        BrowserPerformanceEvents.InitializeBaseRequest,
+        logger,
+        performanceClient,
+        correlationId
+    )(
+        { ...request, correlationId: correlationId },
+        config,
+        performanceClient,
+        logger,
+        correlationId
+    );
 
-        const account =
-            request.account ||
-            this.browserStorage.getActiveAccount(this.correlationId);
-        if (account) {
-            this.logger.verbose(
-                "Setting validated request account",
-                this.correlationId
-            );
-            this.logger.verbosePii(
-                `Setting validated request account: ${account.homeAccountId}`,
-                this.correlationId
-            );
-            validatedRequest.account = account;
-        }
+    const validatedRequest: CommonAuthorizationUrlRequest = {
+        ...baseRequest,
+        redirectUri: redirectUri,
+        state: state,
+        nonce: request.nonce || createNewGuid(),
+        responseMode: config.auth.OIDCOptions.responseMode,
+    };
 
+    // Skip active account lookup if either login hint or session id is set
+    if (request.loginHint || request.sid) {
         return validatedRequest;
     }
+
+    const account =
+        request.account || browserStorage.getActiveAccount(correlationId);
+    if (account) {
+        logger.verbose("Setting validated request account", correlationId);
+        logger.verbosePii(
+            `Setting validated request account: '${account.homeAccountId}'`,
+            correlationId
+        );
+        validatedRequest.account = account;
+    }
+
+    return validatedRequest;
 }

package/src/interaction_handler/InteractionHandler.ts

@@ -18,7 +18,7 @@ import {
     AuthorizeProtocol,
     CommonAuthorizationUrlRequest,
 } from "@azure/msal-common/browser";
-
+import * as BrowserPerformanceEvents from "../telemetry/BrowserPerformanceEvents.js";
 import { BrowserCacheManager } from "../cache/BrowserCacheManager.js";
 import {
     createBrowserAuthError,
@@ -58,11 +58,6 @@ export class InteractionHandler {
         response: AuthorizeResponse,
         request: CommonAuthorizationUrlRequest
     ): Promise<AuthenticationResult> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.HandleCodeResponse,
-            request.correlationId
-        );
-
         let authCodeResponse;
         try {
             authCodeResponse = AuthorizeProtocol.getAuthorizationCodePayload(
@@ -95,9 +90,8 @@ export class InteractionHandler {
     /**
      * Process auth code response from AAD
      * @param authCodeResponse
-     * @param state
-     * @param authority
-     * @param networkModule
+     * @param request
+     * @param validateNonce
      * @returns
      */
     async handleCodeResponseFromServer(
@@ -105,12 +99,9 @@ export class InteractionHandler {
         request: CommonAuthorizationUrlRequest,
         validateNonce: boolean = true
     ): Promise<AuthenticationResult> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.HandleCodeResponseFromServer,
-            request.correlationId
-        );
         this.logger.trace(
-            "InteractionHandler.handleCodeResponseFromServer called"
+            "InteractionHandler.handleCodeResponseFromServer called",
+            request.correlationId
         );
 
         // Assign code to request
@@ -120,7 +111,7 @@ export class InteractionHandler {
         if (authCodeResponse.cloud_instance_host_name) {
             await invokeAsync(
                 this.authModule.updateAuthority.bind(this.authModule),
-                PerformanceEvents.UpdateTokenEndpointAuthority,
+                BrowserPerformanceEvents.UpdateTokenEndpointAuthority,
                 this.logger,
                 this.performanceClient,
                 request.correlationId
@@ -148,7 +139,7 @@ export class InteractionHandler {
         // Acquire token with retrieved code.
         const tokenResponse = (await invokeAsync(
             this.authModule.acquireToken.bind(this.authModule),
-            PerformanceEvents.AuthClientAcquireToken,
+            BrowserPerformanceEvents.AuthClientAcquireToken,
             this.logger,
             this.performanceClient,
             request.correlationId

package/src/interaction_handler/SilentHandler.ts

@@ -6,13 +6,12 @@
 import {
     Logger,
     IPerformanceClient,
-    PerformanceEvents,
-    invokeAsync,
     invoke,
-    ServerResponseType,
+    Constants,
     Authority,
     CommonAuthorizationUrlRequest,
 } from "@azure/msal-common/browser";
+import * as BrowserPerformanceEvents from "../telemetry/BrowserPerformanceEvents.js";
 import {
     createBrowserAuthError,
     BrowserAuthErrorCodes,
@@ -21,7 +20,7 @@ import {
     BrowserConfiguration,
     DEFAULT_IFRAME_TIMEOUT_MS,
 } from "../config/Configuration.js";
-import { getCodeForm, getEARForm } from "../protocol/Authorize.js";
+import { getEARForm } from "../protocol/Authorize.js";
 
 /**
  * Creates a hidden iframe to given URL using user-requested scopes as an id.
@@ -32,60 +31,23 @@ export async function initiateCodeRequest(
     requestUrl: string,
     performanceClient: IPerformanceClient,
     logger: Logger,
-    correlationId: string,
-    navigateFrameWait?: number
+    correlationId: string
 ): Promise<HTMLIFrameElement> {
-    performanceClient.addQueueMeasurement(
-        PerformanceEvents.SilentHandlerInitiateAuthRequest,
-        correlationId
-    );
-
     if (!requestUrl) {
         // Throw error if request URL is empty.
-        logger.info("Navigate url is empty");
+        logger.info("Navigate url is empty", correlationId);
         throw createBrowserAuthError(BrowserAuthErrorCodes.emptyNavigateUri);
     }
-    if (navigateFrameWait) {
-        return invokeAsync(
-            loadFrame,
-            PerformanceEvents.SilentHandlerLoadFrame,
-            logger,
-            performanceClient,
-            correlationId
-        )(requestUrl, navigateFrameWait, performanceClient, correlationId);
-    }
+
     return invoke(
         loadFrameSync,
-        PerformanceEvents.SilentHandlerLoadFrameSync,
+        BrowserPerformanceEvents.SilentHandlerLoadFrameSync,
         logger,
         performanceClient,
         correlationId
     )(requestUrl);
 }
 
-export async function initiateCodeFlowWithPost(
-    config: BrowserConfiguration,
-    authority: Authority,
-    request: CommonAuthorizationUrlRequest,
-    logger: Logger,
-    performanceClient: IPerformanceClient
-): Promise<HTMLIFrameElement> {
-    const frame = createHiddenIframe();
-    if (!frame.contentDocument) {
-        throw "No document associated with iframe!";
-    }
-    const form = await getCodeForm(
-        frame.contentDocument,
-        config,
-        authority,
-        request,
-        logger,
-        performanceClient
-    );
-    form.submit();
-    return frame;
-}
-
 export async function initiateEarRequest(
     config: BrowserConfiguration,
     authority: Authority,
@@ -121,17 +83,13 @@ export async function monitorIframeForHash(
     performanceClient: IPerformanceClient,
     logger: Logger,
     correlationId: string,
-    responseType: ServerResponseType
+    responseType: Constants.ResponseMode
 ): Promise<string> {
-    performanceClient.addQueueMeasurement(
-        PerformanceEvents.SilentHandlerMonitorIframeForHash,
-        correlationId
-    );
-
     return new Promise<string>((resolve, reject) => {
         if (timeout < DEFAULT_IFRAME_TIMEOUT_MS) {
             logger.warning(
-                `system.loadFrameTimeout or system.iframeHashTimeout set to lower (${timeout}ms) than the default (${DEFAULT_IFRAME_TIMEOUT_MS}ms). This may result in timeouts.`
+                `system.loadFrameTimeout or system.iframeHashTimeout set to lower (${timeout}ms) than the default (${DEFAULT_IFRAME_TIMEOUT_MS}ms). This may result in timeouts.`,
+                correlationId
             );
         }
 
@@ -166,7 +124,7 @@ export async function monitorIframeForHash(
 
             let responseString = "";
             if (contentWindow) {
-                if (responseType === ServerResponseType.QUERY) {
+                if (responseType === Constants.ResponseMode.QUERY) {
                     responseString = contentWindow.location.search;
                 } else {
                     responseString = contentWindow.location.hash;
@@ -179,7 +137,7 @@ export async function monitorIframeForHash(
     }).finally(() => {
         invoke(
             removeHiddenIframe,
-            PerformanceEvents.RemoveHiddenIframe,
+            BrowserPerformanceEvents.RemoveHiddenIframe,
             logger,
             performanceClient,
             correlationId
@@ -187,43 +145,6 @@ export async function monitorIframeForHash(
     });
 }
 
-/**
- * @hidden
- * Loads iframe with authorization endpoint URL
- * @ignore
- * @deprecated
- */
-function loadFrame(
-    urlNavigate: string,
-    navigateFrameWait: number,
-    performanceClient: IPerformanceClient,
-    correlationId: string
-): Promise<HTMLIFrameElement> {
-    performanceClient.addQueueMeasurement(
-        PerformanceEvents.SilentHandlerLoadFrame,
-        correlationId
-    );
-
-    /*
-     * This trick overcomes iframe navigation in IE
-     * IE does not load the page consistently in iframe
-     */
-
-    return new Promise((resolve, reject) => {
-        const frameHandle = createHiddenIframe();
-
-        window.setTimeout(() => {
-            if (!frameHandle) {
-                reject("Unable to load iframe");
-                return;
-            }
-
-            frameHandle.src = urlNavigate;
-
-            resolve(frameHandle);
-        }, navigateFrameWait);
-    });
-}
 /**
  * @hidden
  * Loads the iframe synchronously when the navigateTimeFrame is set to `0`

package/src/naa/mapping/NestedAppAuthAdapter.ts

@@ -19,17 +19,16 @@ import {
     AuthToken,
     TokenClaims,
     ClientAuthErrorCodes,
-    AuthenticationScheme,
     RequestParameterBuilder,
     StringUtils,
     createClientAuthError,
-    OIDC_DEFAULT_SCOPES,
     AccountInfo,
     IdTokenEntity,
     AccessTokenEntity,
     TenantProfile,
     buildTenantProfile,
     TimeUtils,
+    Constants,
 } from "@azure/msal-common/browser";
 import { isBridgeError } from "../BridgeError.js";
 import { BridgeStatusCode } from "../BridgeStatusCode.js";
@@ -79,7 +78,7 @@ export class NestedAppAuthAdapter {
             request.claims,
             this.clientCapabilities
         );
-        const scopes = request.scopes || OIDC_DEFAULT_SCOPES;
+        const scopes = request.scopes || Constants.OIDC_DEFAULT_SCOPES;
         const tokenRequest: TokenRequest = {
             platformBrokerId: request.account?.homeAccountId,
             clientId: this.clientId,
@@ -89,7 +88,8 @@ export class NestedAppAuthAdapter {
             claims: !StringUtils.isEmptyObj(claims) ? claims : undefined,
             state: request.state,
             authenticationScheme:
-                request.authenticationScheme || AuthenticationScheme.BEARER,
+                request.authenticationScheme ||
+                Constants.AuthenticationScheme.BEARER,
             extraParameters: extraParams,
         };
 
@@ -132,7 +132,8 @@ export class NestedAppAuthAdapter {
             fromCache: false,
             expiresOn: expiresOn,
             tokenType:
-                request.authenticationScheme || AuthenticationScheme.BEARER,
+                request.authenticationScheme ||
+                Constants.AuthenticationScheme.BEARER,
             correlationId: request.correlationId,
             extExpiresOn: expiresOn,
             state: request.state,
@@ -314,7 +315,8 @@ export class NestedAppAuthAdapter {
                 accessToken.extendedExpiresOn
             ),
             tokenType:
-                request.authenticationScheme || AuthenticationScheme.BEARER,
+                request.authenticationScheme ||
+                Constants.AuthenticationScheme.BEARER,
             correlationId,
             state: request.state,
         };

package/src/operatingcontext/BaseOperatingContext.ts

@@ -107,8 +107,9 @@ export abstract class BaseOperatingContext {
 
     /**
      * returns a boolean indicating whether this operating context is present
+     * @param correlationId
      */
-    abstract initialize(): Promise<boolean>;
+    abstract initialize(correlationId: string): Promise<boolean>;
 
     /**
      * Return the MSAL config

package/src/operatingcontext/NestedAppOperatingContext.ts

@@ -57,9 +57,10 @@ export class NestedAppOperatingContext extends BaseOperatingContext {
     /**
      * Checks whether the operating context is available.
      * Confirms that the code is running a browser rather.  This is required.
+     * @param correlationId
      * @returns Promise<boolean> indicating whether this operating context is currently available.
      */
-    async initialize(): Promise<boolean> {
+    async initialize(correlationId: string): Promise<boolean> {
         try {
             if (typeof window !== "undefined") {
                 if (typeof window.__initializeNestedAppAuth === "function") {
@@ -78,11 +79,15 @@ export class NestedAppOperatingContext extends BaseOperatingContext {
             }
         } catch (ex) {
             this.logger.infoPii(
-                `Could not initialize Nested App Auth bridge (${ex})`
+                `Could not initialize Nested App Auth bridge ('${ex}')`,
+                correlationId
             );
         }
 
-        this.logger.info(`Nested App Auth Bridge available: ${this.available}`);
+        this.logger.info(
+            `Nested App Auth Bridge available: '${this.available}'`,
+            correlationId
+        );
         return this.available;
     }
 }

package/src/operatingcontext/StandardOperatingContext.ts

@@ -39,7 +39,8 @@ export class StandardOperatingContext extends BaseOperatingContext {
      * Confirms that the code is running a browser rather.  This is required.
      * @returns Promise<boolean> indicating whether this operating context is currently available.
      */
-    async initialize(): Promise<boolean> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async initialize(correlationId: string): Promise<boolean> {
         this.available = typeof window !== "undefined";
         return this.available;
         /*

package/src/packageMetadata.ts

@@ -1,3 +1,3 @@
 /* eslint-disable header/header */
 export const name = "@azure/msal-browser";
-export const version = "4.24.1";
+export const version = "5.0.0-alpha.0";