@azure/msal-common 14.0.3 → 14.1.0

package/src/response/ResponseHandler.ts

@@ -6,7 +6,10 @@
 import { ServerAuthorizationTokenResponse } from "./ServerAuthorizationTokenResponse";
 import { buildClientInfo } from "../account/ClientInfo";
 import { ICrypto } from "../crypto/ICrypto";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 import { ServerAuthorizationCodeResponse } from "./ServerAuthorizationCodeResponse";
 import { Logger } from "../logger/Logger";
 import { ServerError } from "../error/ServerError";
@@ -17,7 +20,10 @@ import { Authority } from "../authority/Authority";
 import { IdTokenEntity } from "../cache/entities/IdTokenEntity";
 import { AccessTokenEntity } from "../cache/entities/AccessTokenEntity";
 import { RefreshTokenEntity } from "../cache/entities/RefreshTokenEntity";
-import { InteractionRequiredAuthError } from "../error/InteractionRequiredAuthError";
+import {
+    InteractionRequiredAuthError,
+    isInteractionRequiredError,
+} from "../error/InteractionRequiredAuthError";
 import { CacheRecord } from "../cache/entities/CacheRecord";
 import { CacheManager } from "../cache/CacheManager";
 import { ProtocolUtils, RequestStateObject } from "../utils/ProtocolUtils";
@@ -84,8 +90,14 @@ export class ResponseHandler {
     ): void {
         if (!serverResponseHash.state || !cachedState) {
             throw serverResponseHash.state
-                ? ClientAuthError.createStateNotFoundError("Cached State")
-                : ClientAuthError.createStateNotFoundError("Server State");
+                ? createClientAuthError(
+                      ClientAuthErrorCodes.stateNotFound,
+                      "Cached State"
+                  )
+                : createClientAuthError(
+                      ClientAuthErrorCodes.stateNotFound,
+                      "Server State"
+                  );
         }
 
         let decodedServerResponseHash: string;
@@ -96,23 +108,23 @@ export class ResponseHandler {
                 serverResponseHash.state
             );
         } catch (e) {
-            throw ClientAuthError.createInvalidStateError(
-                serverResponseHash.state,
-                `Server response hash URI could not be decoded`
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidState,
+                serverResponseHash.state
             );
         }
 
         try {
             decodedCachedState = decodeURIComponent(cachedState);
         } catch (e) {
-            throw ClientAuthError.createInvalidStateError(
-                serverResponseHash.state,
-                `Cached state URI could not be decoded`
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidState,
+                serverResponseHash.state
             );
         }
 
         if (decodedServerResponseHash !== decodedCachedState) {
-            throw ClientAuthError.createStateMismatchError();
+            throw createClientAuthError(ClientAuthErrorCodes.stateMismatch);
         }
 
         // Check for error
@@ -122,7 +134,7 @@ export class ResponseHandler {
             serverResponseHash.suberror
         ) {
             if (
-                InteractionRequiredAuthError.isInteractionRequiredError(
+                isInteractionRequiredError(
                     serverResponseHash.error,
                     serverResponseHash.error_description,
                     serverResponseHash.suberror
@@ -202,7 +214,7 @@ export class ResponseHandler {
             }
 
             if (
-                InteractionRequiredAuthError.isInteractionRequiredError(
+                isInteractionRequiredError(
                     serverResponse.error,
                     serverResponse.error_description,
                     serverResponse.suberror
@@ -255,7 +267,9 @@ export class ResponseHandler {
             // token nonce check (TODO: Add a warning if no nonce is given?)
             if (authCodePayload && authCodePayload.nonce) {
                 if (idTokenClaims.nonce !== authCodePayload.nonce) {
-                    throw ClientAuthError.createNonceMismatchError();
+                    throw createClientAuthError(
+                        ClientAuthErrorCodes.nonceMismatch
+                    );
                 }
             }
 
@@ -263,7 +277,9 @@ export class ResponseHandler {
             if (request.maxAge || request.maxAge === 0) {
                 const authTime = idTokenClaims.auth_time;
                 if (!authTime) {
-                    throw ClientAuthError.createAuthTimeNotFoundError();
+                    throw createClientAuthError(
+                        ClientAuthErrorCodes.authTimeNotFound
+                    );
                 }
 
                 checkMaxAge(authTime, request.maxAge);
@@ -389,7 +405,9 @@ export class ResponseHandler {
     ): CacheRecord {
         const env = authority.getPreferredCache();
         if (!env) {
-            throw ClientAuthError.createInvalidCacheEnvironmentError();
+            throw createClientAuthError(
+                ClientAuthErrorCodes.invalidCacheEnvironment
+            );
         }
 
         // IdToken: non AAD scenarios can have empty realm
@@ -537,7 +555,9 @@ export class ResponseHandler {
                 const { secret, keyId } = cacheRecord.accessToken;
 
                 if (!keyId) {
-                    throw ClientAuthError.createKeyIdMissingError();
+                    throw createClientAuthError(
+                        ClientAuthErrorCodes.keyIdMissing
+                    );
                 }
 
                 accessToken = await popTokenGenerator.signPopToken(

package/src/telemetry/performance/PerformanceClient.ts

@@ -227,7 +227,8 @@ export abstract class PerformanceClient implements IPerformanceClient {
 
         const queueMeasurement: QueueMeasurement = {
             eventName,
-            queueTime,
+            // Always default queue time to 0 for manually completed (improperly instrumented)
+            queueTime: manuallyCompleted ? 0 : queueTime,
             manuallyCompleted,
         };
 

package/src/telemetry/performance/PerformanceEvent.ts

@@ -268,6 +268,15 @@ export const PerformanceEvents = {
      * Cache operations
      */
     ClearTokensAndKeysWithClaims: "clearTokensAndKeysWithClaims",
+
+    /**
+     * Crypto Operations
+     */
+    GeneratePkceCodes: "generatePkceCodes",
+    GenerateCodeVerifier: "generateCodeVerifier",
+    GenerateCodeChallengeFromVerifier: "generateCodeChallengeFromVerifier",
+    Sha256Digest: "sha256Digest",
+    GetRandomValues: "getRandomValues",
 } as const;
 export type PerformanceEvents =
     (typeof PerformanceEvents)[keyof typeof PerformanceEvents];

package/src/telemetry/server/ServerTelemetryManager.ts

@@ -28,7 +28,7 @@ export class ServerTelemetryManager {
     private regionUsed: string | undefined;
     private regionSource: RegionDiscoverySources | undefined;
     private regionOutcome: RegionDiscoveryOutcomes | undefined;
-    private cacheOutcome: CacheOutcome = CacheOutcome.NO_CACHE_HIT;
+    private cacheOutcome: CacheOutcome = CacheOutcome.NOT_APPLICABLE;
 
     constructor(
         telemetryRequest: ServerTelemetryRequest,

package/src/url/UrlString.ts

@@ -4,8 +4,14 @@
  */
 
 import { ServerAuthorizationCodeResponse } from "../response/ServerAuthorizationCodeResponse";
-import { ClientConfigurationError } from "../error/ClientConfigurationError";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    createClientConfigurationError,
+    ClientConfigurationErrorCodes,
+} from "../error/ClientConfigurationError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 import { StringUtils } from "../utils/StringUtils";
 import { IUri } from "./IUri";
 import {
@@ -28,7 +34,9 @@ export class UrlString {
         this._urlString = url;
         if (!this._urlString) {
             // Throws error if url is empty
-            throw ClientConfigurationError.createUrlEmptyError();
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.urlEmptyError
+            );
         }
 
         if (!this.getHash()) {
@@ -69,13 +77,15 @@ export class UrlString {
         try {
             components = this.getUrlComponents();
         } catch (e) {
-            throw ClientConfigurationError.createUrlParseError(e as string);
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.urlParseError
+            );
         }
 
         // Throw error if URI or path segments are not parseable.
         if (!components.HostNameAndPort || !components.PathSegments) {
-            throw ClientConfigurationError.createUrlParseError(
-                `Given url string: ${this.urlString}`
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.urlParseError
             );
         }
 
@@ -84,8 +94,8 @@ export class UrlString {
             !components.Protocol ||
             components.Protocol.toLowerCase() !== "https:"
         ) {
-            throw ClientConfigurationError.createInsecureAuthorityUriError(
-                this.urlString
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.authorityUriInsecure
             );
         }
     }
@@ -152,8 +162,8 @@ export class UrlString {
         // If url string does not match regEx, we throw an error
         const match = this.urlString.match(regEx);
         if (!match) {
-            throw ClientConfigurationError.createUrlParseError(
-                `Given url string: ${this.urlString}`
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.urlParseError
             );
         }
 
@@ -187,8 +197,8 @@ export class UrlString {
         const match = url.match(regEx);
 
         if (!match) {
-            throw ClientConfigurationError.createUrlParseError(
-                `Given url string: ${url}`
+            throw createClientConfigurationError(
+                ClientConfigurationErrorCodes.urlParseError
             );
         }
 
@@ -290,8 +300,8 @@ export class UrlString {
             );
         // Check if deserialization didn't work
         if (!deserializedHash) {
-            throw ClientAuthError.createHashNotDeserializedError(
-                JSON.stringify(deserializedHash)
+            throw createClientAuthError(
+                ClientAuthErrorCodes.hashNotDeserialized
             );
         }
         return deserializedHash;
@@ -316,8 +326,8 @@ export class UrlString {
             );
         // Check if deserialization didn't work
         if (!deserializedQueryString) {
-            throw ClientAuthError.createHashNotDeserializedError(
-                JSON.stringify(deserializedQueryString)
+            throw createClientAuthError(
+                ClientAuthErrorCodes.hashNotDeserialized
             );
         }
         return deserializedQueryString;

package/src/utils/Constants.ts

@@ -417,12 +417,20 @@ export const RegionDiscoveryOutcomes = {
 export type RegionDiscoveryOutcomes =
     (typeof RegionDiscoveryOutcomes)[keyof typeof RegionDiscoveryOutcomes];
 
+/**
+ * Specifies the reason for fetching the access token from the identity provider
+ */
 export const CacheOutcome = {
-    NO_CACHE_HIT: "0",
-    FORCE_REFRESH: "1",
+    // When a token is found in the cache or the cache is not supposed to be hit when making the request
+    NOT_APPLICABLE: "0",
+    // When the token request goes to the identity provider because force_refresh was set to true. Also occurs if claims were requested
+    FORCE_REFRESH_OR_CLAIMS: "1",
+    // When the token request goes to the identity provider because no cached access token exists
     NO_CACHED_ACCESS_TOKEN: "2",
+    // When the token request goes to the identity provider because cached access token expired
     CACHED_ACCESS_TOKEN_EXPIRED: "3",
-    REFRESH_CACHED_ACCESS_TOKEN: "4",
+    // When the token request goes to the identity provider because refresh_in was used and the existing token needs to be refreshed
+    PROACTIVELY_REFRESHED: "4",
 } as const;
 export type CacheOutcome = (typeof CacheOutcome)[keyof typeof CacheOutcome];
 

package/src/utils/FunctionWrappers.ts

@@ -31,7 +31,6 @@ export const invoke = <T extends Array<any>, U>(
             eventName,
             correlationId
         );
-        telemetryClient?.setPreQueueTime(eventName, correlationId);
         try {
             const result = callback(...args);
             inProgressEvent?.end({

package/src/utils/ProtocolUtils.ts

@@ -5,7 +5,10 @@
 
 import { Constants } from "./Constants";
 import { ICrypto } from "../crypto/ICrypto";
-import { ClientAuthError } from "../error/ClientAuthError";
+import {
+    ClientAuthErrorCodes,
+    createClientAuthError,
+} from "../error/ClientAuthError";
 
 /**
  * Type which defines the object that is stringified, encoded and sent in the state value.
@@ -60,9 +63,7 @@ export class ProtocolUtils {
         meta?: Record<string, string>
     ): string {
         if (!cryptoObj) {
-            throw ClientAuthError.createNoCryptoObjectError(
-                "generateLibraryState"
-            );
+            throw createClientAuthError(ClientAuthErrorCodes.noCryptoObject);
         }
 
         // Create a state object containing a unique id and the timestamp of the request creation
@@ -89,16 +90,11 @@ export class ProtocolUtils {
         state: string
     ): RequestStateObject {
         if (!cryptoObj) {
-            throw ClientAuthError.createNoCryptoObjectError(
-                "parseRequestState"
-            );
+            throw createClientAuthError(ClientAuthErrorCodes.noCryptoObject);
         }
 
         if (!state) {
-            throw ClientAuthError.createInvalidStateError(
-                state,
-                "Null, undefined or empty state"
-            );
+            throw createClientAuthError(ClientAuthErrorCodes.invalidState);
         }
 
         try {
@@ -118,7 +114,7 @@ export class ProtocolUtils {
                 libraryState: libraryStateObj,
             };
         } catch (e) {
-            throw ClientAuthError.createInvalidStateError(state, e as string);
+            throw createClientAuthError(ClientAuthErrorCodes.invalidState);
         }
     }
 }