@azure/msal-browser 3.19.1 → 3.21.0

package/package.json

@@ -10,7 +10,7 @@
     "type": "git",
     "url": "https://github.com/AzureAD/microsoft-authentication-library-for-js.git"
   },
-  "version": "3.19.1",
+  "version": "3.21.0",
   "description": "Microsoft Authentication Library for js",
   "keywords": [
     "implicit",
@@ -104,6 +104,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "@azure/msal-common": "14.13.1"
+    "@azure/msal-common": "14.14.1"
   }
 }

package/src/cache/BrowserCacheManager.ts

@@ -1552,6 +1552,9 @@ export class BrowserCacheManager extends CacheManager {
         this.removeTemporaryItem(
             this.generateCacheKey(TemporaryCacheKeys.NATIVE_REQUEST)
         );
+        this.removeTemporaryItem(
+            this.generateCacheKey(TemporaryCacheKeys.REDIRECT_REQUEST)
+        );
         this.setInteractionInProgress(false);
     }
 
@@ -1613,6 +1616,98 @@ export class BrowserCacheManager extends CacheManager {
         this.setInteractionInProgress(false);
     }
 
+    /**
+     * Create request retry key to cache retry status
+     */
+    generateRequestRetriedKey(): string {
+        return `${Constants.CACHE_PREFIX}.${TemporaryCacheKeys.REQUEST_RETRY}.${this.clientId}`;
+    }
+
+    /**
+     * Gets the request retry value from the cache
+     */
+    getRequestRetried(): number | null {
+        const requestRetriedKey = this.generateRequestRetriedKey();
+        const cachedRetryNumber = this.getTemporaryCache(requestRetriedKey);
+        if (!cachedRetryNumber) {
+            return null;
+        }
+        return parseInt(cachedRetryNumber);
+    }
+
+    /**
+     * Sets the request retry value to "retried" in the cache
+     */
+    setRequestRetried(): void {
+        this.logger.trace("BrowserCacheManager.setRequestRetried called");
+        const requestRetriedKey = this.generateRequestRetriedKey();
+        this.setTemporaryCache(requestRetriedKey, "1", false);
+    }
+
+    /**
+     * Removes all request retry values in the cache
+     */
+    removeRequestRetried(): void {
+        const requestRetriedKey = this.generateRequestRetriedKey();
+        this.removeTemporaryItem(requestRetriedKey);
+    }
+
+    /**
+     * Caches the redirectRequest in the cache
+     * @param redirectRequest
+     */
+    cacheRedirectRequest(redirectRequest: RedirectRequest): void {
+        this.logger.trace("BrowserCacheManager.cacheRedirectRequest called");
+        const { ...restParams } = redirectRequest;
+        delete restParams.onRedirectNavigate;
+        const encodedValue = JSON.stringify(restParams);
+
+        this.setTemporaryCache(
+            TemporaryCacheKeys.REDIRECT_REQUEST,
+            encodedValue,
+            true
+        );
+    }
+
+    /**
+     * Gets redirect request from the cache. Logs an error and returns undefined if nothing is found.
+     */
+    getCachedRedirectRequest(): RedirectRequest | undefined {
+        this.logger.trace(
+            "BrowserCacheManager.getCachedRedirectRequest called"
+        );
+        const cachedRedirectRequest = this.getTemporaryCache(
+            TemporaryCacheKeys.REDIRECT_REQUEST,
+            true
+        );
+        if (!cachedRedirectRequest) {
+            this.logger.error(`No cached redirect request found.`);
+        } else {
+            this.removeTemporaryItem(
+                this.generateCacheKey(TemporaryCacheKeys.REDIRECT_REQUEST)
+            );
+            let parsedRequest: RedirectRequest;
+            try {
+                parsedRequest = JSON.parse(
+                    cachedRedirectRequest
+                ) as RedirectRequest;
+            } catch (e) {
+                this.logger.errorPii(
+                    `Attempted to parse: ${cachedRedirectRequest}`
+                );
+                this.logger.error(
+                    `Parsing cached redirect request threw with error: ${e}`
+                );
+                return;
+            }
+
+            if (parsedRequest) {
+                return parsedRequest;
+            }
+        }
+        return;
+    }
+
     cacheCodeRequest(authCodeRequest: CommonAuthorizationCodeRequest): void {
         this.logger.trace("BrowserCacheManager.cacheCodeRequest called");
 

package/src/config/Configuration.ts

@@ -99,11 +99,19 @@ export type BrowserAuthOptions = {
      * @deprecated This flag is deprecated and will be removed in the next major version. createNestablePublicClientApplication should be used instead.
      */
     supportsNestedAppAuth?: boolean;
+    /**
+     * Callback that will be passed the url that MSAL will navigate to in redirect flows. Returning false in the callback will stop navigation.
+     */
+    onRedirectNavigate?: (url: string) => boolean | void;
 };
 
 /** @internal */
-export type InternalAuthOptions = Required<BrowserAuthOptions> & {
+export type InternalAuthOptions = Omit<
+    Required<BrowserAuthOptions>,
+    "onRedirectNavigate"
+> & {
     OIDCOptions: Required<OIDCOptions>;
+    onRedirectNavigate?: (url: string) => boolean | void;
 };
 
 /**

package/src/controllers/StandardController.ts

@@ -584,19 +584,37 @@ export class StandardController implements IController {
             scenarioId: request.scenarioId,
         });
 
+        // Override on request only if set, as onRedirectNavigate field is deprecated
         const onRedirectNavigateCb = request.onRedirectNavigate;
-        request.onRedirectNavigate = (url: string) => {
-            const navigate =
-                typeof onRedirectNavigateCb === "function"
-                    ? onRedirectNavigateCb(url)
-                    : undefined;
-            if (navigate !== false) {
-                atrMeasurement.end({ success: true });
-            } else {
-                atrMeasurement.discard();
-            }
-            return navigate;
-        };
+        if (onRedirectNavigateCb) {
+            request.onRedirectNavigate = (url: string) => {
+                const navigate =
+                    typeof onRedirectNavigateCb === "function"
+                        ? onRedirectNavigateCb(url)
+                        : undefined;
+                if (navigate !== false) {
+                    atrMeasurement.end({ success: true });
+                } else {
+                    atrMeasurement.discard();
+                }
+                return navigate;
+            };
+        } else {
+            const configOnRedirectNavigateCb =
+                this.config.auth.onRedirectNavigate;
+            this.config.auth.onRedirectNavigate = (url: string) => {
+                const navigate =
+                    typeof configOnRedirectNavigateCb === "function"
+                        ? configOnRedirectNavigateCb(url)
+                        : undefined;
+                if (navigate !== false) {
+                    atrMeasurement.end({ success: true });
+                } else {
+                    atrMeasurement.discard();
+                }
+                return navigate;
+            };
+        }
 
         // If logged in, emit acquire token events
         const isLoggedIn = this.getAllAccounts().length > 0;

package/src/error/BrowserAuthError.ts

@@ -92,6 +92,8 @@ export const BrowserAuthErrorMessages = {
         "Invalid base64 encoded string.",
     [BrowserAuthErrorCodes.invalidPopTokenRequest]:
         "Invalid PoP token request. The request should not have both a popKid value and signPopToken set to true.",
+    [BrowserAuthErrorCodes.failedToRetry]:
+        "Unable to retry failed auth code redemption due to usage of the onRedirectNavigate request parameter. Please set onRedirectNavigate on the PublicClientApplication configuration instead or call loginRedirect again.",
 };
 
 /**

package/src/error/BrowserAuthErrorCodes.ts

@@ -56,3 +56,4 @@ export const uninitializedPublicClientApplication =
 export const nativePromptNotSupported = "native_prompt_not_supported";
 export const invalidBase64String = "invalid_base64_string";
 export const invalidPopTokenRequest = "invalid_pop_token_request";
+export const failedToRetry = "failed_to_retry";

package/src/interaction_client/NativeInteractionClient.ts

@@ -36,6 +36,7 @@ import {
     CacheHelpers,
     buildAccountToCache,
     InProgressPerformanceEvent,
+    ServerTelemetryManager,
 } from "@azure/msal-common";
 import { BaseInteractionClient } from "./BaseInteractionClient";
 import { BrowserConfiguration } from "../config/Configuration";
@@ -50,6 +51,7 @@ import {
     ApiId,
     TemporaryCacheKeys,
     NativeConstants,
+    BrowserConstants,
 } from "../utils/BrowserConstants";
 import {
     NativeExtensionRequestBody,
@@ -72,6 +74,7 @@ import {
 import { SilentCacheClient } from "./SilentCacheClient";
 import { AuthenticationResult } from "../response/AuthenticationResult";
 import { base64Decode } from "../encode/Base64Decode";
+import { version } from "../packageMetadata";
 
 const BrokerServerParamKeys = {
     BROKER_CLIENT_ID: "brk_client_id",
@@ -84,6 +87,8 @@ export class NativeInteractionClient extends BaseInteractionClient {
     protected nativeMessageHandler: NativeMessageHandler;
     protected silentCacheClient: SilentCacheClient;
     protected nativeStorageManager: BrowserCacheManager;
+    protected skus: string;
+    protected serverTelemetryManager: ServerTelemetryManager;
 
     constructor(
         config: BrowserConfiguration,
@@ -125,6 +130,35 @@ export class NativeInteractionClient extends BaseInteractionClient {
             provider,
             correlationId
         );
+        this.serverTelemetryManager = this.initializeServerTelemetryManager(
+            this.apiId
+        );
+
+        const extensionName =
+            this.nativeMessageHandler.getExtensionId() ===
+            NativeConstants.PREFERRED_EXTENSION_ID
+                ? "chrome"
+                : this.nativeMessageHandler.getExtensionId()?.length
+                ? "unknown"
+                : undefined;
+        this.skus = ServerTelemetryManager.makeExtraSkuString({
+            libraryName: BrowserConstants.MSAL_SKU,
+            libraryVersion: version,
+            extensionName: extensionName,
+            extensionVersion: this.nativeMessageHandler.getExtensionVersion(),
+        });
+    }
+
+    /**
+     * Adds SKUs to request extra query parameters
+     * @param request {NativeTokenRequest}
+     * @private
+     */
+    private addRequestSKUs(request: NativeTokenRequest) {
+        request.extraParameters = {
+            ...request.extraParameters,
+            [AADServerParamKeys.X_CLIENT_EXTRA_SKU]: this.skus,
+        };
     }
 
     /**
@@ -147,64 +181,73 @@ export class NativeInteractionClient extends BaseInteractionClient {
         );
         const reqTimestamp = TimeUtils.nowSeconds();
 
-        // initialize native request
-        const nativeRequest = await this.initializeNativeRequest(request);
-
-        // check if the tokens can be retrieved from internal cache
         try {
-            const result = await this.acquireTokensFromCache(
-                this.accountId,
-                nativeRequest
-            );
-            nativeATMeasurement.end({
-                success: true,
-                isNativeBroker: false, // Should be true only when the result is coming directly from the broker
-                fromCache: true,
-            });
-            return result;
-        } catch (e) {
-            // continue with a native call for any and all errors
-            this.logger.info(
-                "MSAL internal Cache does not contain tokens, proceed to make a native call"
-            );
-        }
-
-        const { ...nativeTokenRequest } = nativeRequest;
-
-        // fall back to native calls
-        const messageBody: NativeExtensionRequestBody = {
-            method: NativeExtensionMethod.GetToken,
-            request: nativeTokenRequest,
-        };
-
-        const response: object = await this.nativeMessageHandler.sendMessage(
-            messageBody
-        );
-        const validatedResponse: NativeResponse =
-            this.validateNativeResponse(response);
+            // initialize native request
+            const nativeRequest = await this.initializeNativeRequest(request);
 
-        return this.handleNativeResponse(
-            validatedResponse,
-            nativeRequest,
-            reqTimestamp
-        )
-            .then((result: AuthenticationResult) => {
+            // check if the tokens can be retrieved from internal cache
+            try {
+                const result = await this.acquireTokensFromCache(
+                    this.accountId,
+                    nativeRequest
+                );
                 nativeATMeasurement.end({
                     success: true,
-                    isNativeBroker: true,
-                    requestId: result.requestId,
+                    isNativeBroker: false, // Should be true only when the result is coming directly from the broker
+                    fromCache: true,
                 });
                 return result;
-            })
-            .catch((error: AuthError) => {
-                nativeATMeasurement.end({
-                    success: false,
-                    errorCode: error.errorCode,
-                    subErrorCode: error.subError,
-                    isNativeBroker: true,
+            } catch (e) {
+                // continue with a native call for any and all errors
+                this.logger.info(
+                    "MSAL internal Cache does not contain tokens, proceed to make a native call"
+                );
+            }
+
+            const { ...nativeTokenRequest } = nativeRequest;
+
+            // fall back to native calls
+            const messageBody: NativeExtensionRequestBody = {
+                method: NativeExtensionMethod.GetToken,
+                request: nativeTokenRequest,
+            };
+
+            const response: object =
+                await this.nativeMessageHandler.sendMessage(messageBody);
+            const validatedResponse: NativeResponse =
+                this.validateNativeResponse(response);
+
+            return await this.handleNativeResponse(
+                validatedResponse,
+                nativeRequest,
+                reqTimestamp
+            )
+                .then((result: AuthenticationResult) => {
+                    nativeATMeasurement.end({
+                        success: true,
+                        isNativeBroker: true,
+                        requestId: result.requestId,
+                    });
+                    this.serverTelemetryManager.clearNativeBrokerErrorCode();
+                    return result;
+                })
+                .catch((error: AuthError) => {
+                    nativeATMeasurement.end({
+                        success: false,
+                        errorCode: error.errorCode,
+                        subErrorCode: error.subError,
+                        isNativeBroker: true,
+                    });
+                    throw error;
                 });
-                throw error;
-            });
+        } catch (e) {
+            if (e instanceof NativeAuthError) {
+                this.serverTelemetryManager.setNativeBrokerErrorCode(
+                    e.errorCode
+                );
+            }
+            throw e;
+        }
     }
 
     /**
@@ -307,8 +350,13 @@ export class NativeInteractionClient extends BaseInteractionClient {
             this.validateNativeResponse(response);
         } catch (e) {
             // Only throw fatal errors here to allow application to fallback to regular redirect. Otherwise proceed and the error will be thrown in handleRedirectPromise
-            if (e instanceof NativeAuthError && isFatalNativeAuthError(e)) {
-                throw e;
+            if (e instanceof NativeAuthError) {
+                this.serverTelemetryManager.setNativeBrokerErrorCode(
+                    e.errorCode
+                );
+                if (isFatalNativeAuthError(e)) {
+                    throw e;
+                }
             }
         }
         this.browserStorage.setTemporaryCache(
@@ -399,7 +447,9 @@ export class NativeInteractionClient extends BaseInteractionClient {
                 reqTimestamp
             );
             this.browserStorage.setInteractionInProgress(false);
-            return await result;
+            const res = await result;
+            this.serverTelemetryManager.clearNativeBrokerErrorCode();
+            return res;
         } catch (e) {
             this.browserStorage.setInteractionInProgress(false);
             throw e;
@@ -980,6 +1030,7 @@ export class NativeInteractionClient extends BaseInteractionClient {
             // SPAs require whole string to be passed to broker
             validatedRequest.reqCnf = reqCnfData;
         }
+        this.addRequestSKUs(validatedRequest);
 
         return validatedRequest;
     }