@azure/msal-browser 4.27.0 → 5.0.0-beta.0

package/src/interaction_client/SilentRefreshClient.ts

@@ -10,11 +10,11 @@ import {
     RefreshTokenClient,
     AuthError,
     AzureCloudOptions,
-    PerformanceEvents,
     invokeAsync,
     AccountInfo,
     StringDict,
 } from "@azure/msal-common/browser";
+import * as BrowserPerformanceEvents from "../telemetry/BrowserPerformanceEvents.js";
 import { ApiId } from "../utils/BrowserConstants.js";
 import {
     createBrowserAuthError,
@@ -22,6 +22,10 @@ import {
 } from "../error/BrowserAuthError.js";
 import { AuthenticationResult } from "../response/AuthenticationResult.js";
 import { initializeBaseRequest } from "../request/RequestHelpers.js";
+import {
+    getRedirectUri,
+    initializeServerTelemetryManager,
+} from "./BaseInteractionClient.js";
 
 export class SilentRefreshClient extends StandardInteractionClient {
     /**
@@ -31,18 +35,19 @@ export class SilentRefreshClient extends StandardInteractionClient {
     async acquireToken(
         request: CommonSilentFlowRequest
     ): Promise<AuthenticationResult> {
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.SilentRefreshClientAcquireToken,
-            request.correlationId
-        );
-
         const baseRequest = await invokeAsync(
             initializeBaseRequest,
-            PerformanceEvents.InitializeBaseRequest,
+            BrowserPerformanceEvents.InitializeBaseRequest,
             this.logger,
             this.performanceClient,
             request.correlationId
-        )(request, this.config, this.performanceClient, this.logger);
+        )(
+            request,
+            this.config,
+            this.performanceClient,
+            this.logger,
+            this.correlationId
+        );
         const silentRequest: CommonSilentFlowRequest = {
             ...request,
             ...baseRequest,
@@ -50,13 +55,20 @@ export class SilentRefreshClient extends StandardInteractionClient {
 
         if (request.redirectUri) {
             // Make sure any passed redirectUri is converted to an absolute URL - redirectUri is not a required parameter for refresh token redemption so only include if explicitly provided
-            silentRequest.redirectUri = this.getRedirectUri(
-                request.redirectUri
+            silentRequest.redirectUri = getRedirectUri(
+                request.redirectUri,
+                this.config.auth.redirectUri,
+                this.logger,
+                this.correlationId
             );
         }
 
-        const serverTelemetryManager = this.initializeServerTelemetryManager(
-            ApiId.acquireTokenSilent_silentFlow
+        const serverTelemetryManager = initializeServerTelemetryManager(
+            ApiId.acquireTokenSilent_silentFlow,
+            this.config.auth.clientId,
+            this.correlationId,
+            this.browserStorage,
+            this.logger
         );
 
         const refreshTokenClient = await this.createRefreshTokenClient({
@@ -70,7 +82,7 @@ export class SilentRefreshClient extends StandardInteractionClient {
             refreshTokenClient.acquireTokenByRefreshToken.bind(
                 refreshTokenClient
             ),
-            PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken,
+            BrowserPerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken,
             this.logger,
             this.performanceClient,
             request.correlationId
@@ -113,7 +125,7 @@ export class SilentRefreshClient extends StandardInteractionClient {
         // Create auth module.
         const clientConfig = await invokeAsync(
             this.getClientConfiguration.bind(this),
-            PerformanceEvents.StandardInteractionClientGetClientConfiguration,
+            BrowserPerformanceEvents.StandardInteractionClientGetClientConfiguration,
             this.logger,
             this.performanceClient,
             this.correlationId

package/src/interaction_client/StandardInteractionClient.ts

@@ -5,24 +5,29 @@
 
 import {
     ServerTelemetryManager,
-    Constants,
     AuthorizationCodeClient,
     ClientConfiguration,
     UrlString,
     CommonEndSessionRequest,
     ProtocolUtils,
-    ResponseMode,
     IdTokenClaims,
     AccountInfo,
     AzureCloudOptions,
-    PerformanceEvents,
     invokeAsync,
     BaseAuthRequest,
     StringDict,
     CommonAuthorizationUrlRequest,
+    ICrypto,
+    Logger,
+    IPerformanceClient,
     Authority,
 } 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,
@@ -35,6 +40,8 @@ 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 { BrowserConfiguration } from "../config/Configuration.js";
+import { BrowserCacheManager } from "../cache/BrowserCacheManager.js";
 import {
     initializeBaseRequest,
     validateRequestMethod,
@@ -53,11 +60,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,
         };
 
@@ -74,23 +81,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
             );
         }
 
@@ -159,12 +170,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
             );
         }
 
@@ -189,14 +202,10 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
         account?: AccountInfo;
         authority?: Authority;
     }): 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
@@ -234,24 +243,25 @@ export abstract class StandardInteractionClient extends BaseInteractionClient {
             account,
         } = params;
 
-        this.performanceClient.addQueueMeasurement(
-            PerformanceEvents.StandardInteractionClientGetClientConfiguration,
-            this.correlationId
-        );
         const discoveredAuthority =
             params.authority ||
             (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 {
@@ -272,10 +282,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,
@@ -283,87 +289,97 @@ 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,
-        };
+/**
+ * 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
+    );
 
-        const validatedRequest = {
-            ...interactionRequest,
-            httpMethod: validateRequestMethod(
-                interactionRequest,
-                this.config.auth.protocolMode
-            ),
-        };
+    const baseRequest: BaseAuthRequest = await invokeAsync(
+        initializeBaseRequest,
+        BrowserPerformanceEvents.InitializeBaseRequest,
+        logger,
+        performanceClient,
+        correlationId
+    )(
+        { ...request, correlationId: correlationId },
+        config,
+        performanceClient,
+        logger,
+        correlationId
+    );
 
-        // Skip active account lookup if either login hint or session id is set
-        if (request.loginHint || request.sid) {
-            return validatedRequest;
-        }
+    const interactionRequest: CommonAuthorizationUrlRequest = {
+        ...baseRequest,
+        redirectUri: redirectUri,
+        state: state,
+        nonce: request.nonce || createNewGuid(),
+        responseMode: config.auth.OIDCOptions.responseMode,
+    };
 
-        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 = {
+        ...interactionRequest,
+        httpMethod: validateRequestMethod(
+            interactionRequest,
+            config.system.protocolMode
+        ),
+    };
 
+    // 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,28 +99,14 @@ 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
         this.authCodeRequest.code = authCodeResponse.code;
 
-        // Check for new cloud instance
-        if (authCodeResponse.cloud_instance_host_name) {
-            await invokeAsync(
-                this.authModule.updateAuthority.bind(this.authModule),
-                PerformanceEvents.UpdateTokenEndpointAuthority,
-                this.logger,
-                this.performanceClient,
-                request.correlationId
-            )(authCodeResponse.cloud_instance_host_name, request.correlationId);
-        }
-
         // Nonce validation not needed when redirect not involved (e.g. hybrid spa, renewing token via rt)
         if (validateNonce) {
             // TODO: Assigning "response nonce" to "request nonce" is confusing. Refactor the function doing validation to accept request nonce directly
@@ -148,7 +128,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