@azure/msal-common 15.13.3 → 16.0.0-beta.0

package/src/response/ResponseHandler.ts

@@ -24,13 +24,8 @@ import {
 } from "../error/InteractionRequiredAuthError.js";
 import { CacheRecord } from "../cache/entities/CacheRecord.js";
 import { CacheManager } from "../cache/CacheManager.js";
-import { ProtocolUtils, RequestStateObject } from "../utils/ProtocolUtils.js";
-import {
-    AuthenticationScheme,
-    Constants,
-    THE_FAMILY_ID,
-    HttpStatus,
-} from "../utils/Constants.js";
+import * as ProtocolUtils from "../utils/ProtocolUtils.js";
+import * as Constants from "../utils/Constants.js";
 import { PopTokenGenerator } from "../crypto/PopTokenGenerator.js";
 import { AppMetadataEntity } from "../cache/entities/AppMetadataEntity.js";
 import { ICachePlugin } from "../cache/interface/ICachePlugin.js";
@@ -38,8 +33,6 @@ import { TokenCacheContext } from "../cache/persistence/TokenCacheContext.js";
 import { ISerializableTokenCache } from "../cache/interface/ISerializableTokenCache.js";
 import { AuthorizationCodePayload } from "./AuthorizationCodePayload.js";
 import { BaseAuthRequest } from "../request/BaseAuthRequest.js";
-import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient.js";
-import { PerformanceEvents } from "../telemetry/performance/PerformanceEvent.js";
 import {
     checkMaxAge,
     extractTokenClaims,
@@ -56,6 +49,9 @@ import {
 } from "../account/AccountInfo.js";
 import * as CacheHelpers from "../cache/utils/CacheHelpers.js";
 import * as TimeUtils from "../utils/TimeUtils.js";
+import * as AccountEntityUtils from "../cache/utils/AccountEntityUtils.js";
+import { IPerformanceClient } from "../telemetry/performance/IPerformanceClient.js";
+import { RequestStateObject } from "../utils/StateTypes.js";
 
 /**
  * Class that handles response parsing.
@@ -67,35 +63,37 @@ export class ResponseHandler {
     private cryptoObj: ICrypto;
     private logger: Logger;
     private homeAccountIdentifier: string;
+    private performanceClient: IPerformanceClient;
     private serializableCache: ISerializableTokenCache | null;
     private persistencePlugin: ICachePlugin | null;
-    private performanceClient?: IPerformanceClient;
 
     constructor(
         clientId: string,
         cacheStorage: CacheManager,
         cryptoObj: ICrypto,
         logger: Logger,
+        performanceClient: IPerformanceClient,
         serializableCache: ISerializableTokenCache | null,
-        persistencePlugin: ICachePlugin | null,
-        performanceClient?: IPerformanceClient
+        persistencePlugin: ICachePlugin | null
     ) {
         this.clientId = clientId;
         this.cacheStorage = cacheStorage;
         this.cryptoObj = cryptoObj;
         this.logger = logger;
+        this.performanceClient = performanceClient;
         this.serializableCache = serializableCache;
         this.persistencePlugin = persistencePlugin;
-        this.performanceClient = performanceClient;
     }
 
     /**
      * Function which validates server authorization token response.
      * @param serverResponse
+     * @param correlationId
      * @param refreshAccessToken
      */
     validateTokenResponse(
         serverResponse: ServerAuthorizationTokenResponse,
+        correlationId: string,
         refreshAccessToken?: boolean
     ): void {
         // Check for error
@@ -130,11 +128,13 @@ export class ResponseHandler {
             if (
                 refreshAccessToken &&
                 serverResponse.status &&
-                serverResponse.status >= HttpStatus.SERVER_ERROR_RANGE_START &&
-                serverResponse.status <= HttpStatus.SERVER_ERROR_RANGE_END
+                serverResponse.status >=
+                    Constants.HTTP_SERVER_ERROR_RANGE_START &&
+                serverResponse.status <= Constants.HTTP_SERVER_ERROR_RANGE_END
             ) {
                 this.logger.warning(
-                    `executeTokenRequest:validateTokenResponse - AAD is currently unavailable and the access token is unable to be refreshed.\n${serverError}`
+                    `executeTokenRequest:validateTokenResponse - AAD is currently unavailable and the access token is unable to be refreshed.\n${serverError}`,
+                    correlationId
                 );
 
                 // don't throw an exception, but alert the user via a log that the token was unable to be refreshed
@@ -143,11 +143,13 @@ export class ResponseHandler {
             } else if (
                 refreshAccessToken &&
                 serverResponse.status &&
-                serverResponse.status >= HttpStatus.CLIENT_ERROR_RANGE_START &&
-                serverResponse.status <= HttpStatus.CLIENT_ERROR_RANGE_END
+                serverResponse.status >=
+                    Constants.HTTP_CLIENT_ERROR_RANGE_START &&
+                serverResponse.status <= Constants.HTTP_CLIENT_ERROR_RANGE_END
             ) {
                 this.logger.warning(
-                    `executeTokenRequest:validateTokenResponse - AAD is currently available but is unable to refresh the access token.\n${serverError}`
+                    `executeTokenRequest:validateTokenResponse - AAD is currently available but is unable to refresh the access token.\n${serverError}`,
+                    correlationId
                 );
 
                 // don't throw an exception, but alert the user via a log that the token was unable to be refreshed
@@ -165,10 +167,10 @@ export class ResponseHandler {
                     serverResponse.error,
                     serverResponse.error_description,
                     serverResponse.suberror,
-                    serverResponse.timestamp || Constants.EMPTY_STRING,
-                    serverResponse.trace_id || Constants.EMPTY_STRING,
-                    serverResponse.correlation_id || Constants.EMPTY_STRING,
-                    serverResponse.claims || Constants.EMPTY_STRING,
+                    serverResponse.timestamp || "",
+                    serverResponse.trace_id || "",
+                    serverResponse.correlation_id || "",
+                    serverResponse.claims || "",
                     serverErrorNo
                 );
             }
@@ -193,16 +195,11 @@ export class ResponseHandler {
         forceCacheRefreshTokenResponse?: boolean,
         serverRequestId?: string
     ): Promise<AuthenticationResult> {
-        this.performanceClient?.addQueueMeasurement(
-            PerformanceEvents.HandleServerTokenResponse,
-            serverTokenResponse.correlation_id
-        );
-
         // create an idToken object (not entity)
         let idTokenClaims: TokenClaims | undefined;
         if (serverTokenResponse.id_token) {
             idTokenClaims = extractTokenClaims(
-                serverTokenResponse.id_token || Constants.EMPTY_STRING,
+                serverTokenResponse.id_token || "",
                 this.cryptoObj.base64Decode
             );
 
@@ -229,11 +226,12 @@ export class ResponseHandler {
         }
 
         // generate homeAccountId
-        this.homeAccountIdentifier = AccountEntity.generateHomeAccountId(
-            serverTokenResponse.client_info || Constants.EMPTY_STRING,
+        this.homeAccountIdentifier = AccountEntityUtils.generateHomeAccountId(
+            serverTokenResponse.client_info || "",
             authority.authorityType,
             this.logger,
             this.cryptoObj,
+            request.correlationId,
             idTokenClaims
         );
 
@@ -241,7 +239,7 @@ export class ResponseHandler {
         let requestStateObj: RequestStateObject | undefined;
         if (!!authCodePayload && !!authCodePayload.state) {
             requestStateObj = ProtocolUtils.parseRequestState(
-                this.cryptoObj,
+                this.cryptoObj.base64Decode,
                 authCodePayload.state
             );
         }
@@ -263,7 +261,8 @@ export class ResponseHandler {
         try {
             if (this.persistencePlugin && this.serializableCache) {
                 this.logger.verbose(
-                    "Persistence enabled, calling beforeCacheAccess"
+                    "Persistence enabled, calling beforeCacheAccess",
+                    request.correlationId
                 );
                 cacheContext = new TokenCacheContext(
                     this.serializableCache,
@@ -283,7 +282,7 @@ export class ResponseHandler {
                 cacheRecord.account
             ) {
                 const key = this.cacheStorage.generateAccountKey(
-                    AccountEntity.getAccountInfo(cacheRecord.account)
+                    AccountEntityUtils.getAccountInfo(cacheRecord.account)
                 );
                 const account = this.cacheStorage.getAccount(
                     key,
@@ -291,7 +290,8 @@ export class ResponseHandler {
                 );
                 if (!account) {
                     this.logger.warning(
-                        "Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache"
+                        "Account used to refresh tokens not in persistence, refreshed tokens will not be stored in the cache",
+                        request.correlationId
                     );
                     return await ResponseHandler.generateAuthenticationResult(
                         this.cryptoObj,
@@ -299,6 +299,7 @@ export class ResponseHandler {
                         cacheRecord,
                         false,
                         request,
+                        this.performanceClient,
                         idTokenClaims,
                         requestStateObj,
                         undefined,
@@ -319,7 +320,8 @@ export class ResponseHandler {
                 cacheContext
             ) {
                 this.logger.verbose(
-                    "Persistence enabled, calling afterCacheAccess"
+                    "Persistence enabled, calling afterCacheAccess",
+                    request.correlationId
                 );
                 await this.persistencePlugin.afterCacheAccess(cacheContext);
             }
@@ -331,6 +333,7 @@ export class ResponseHandler {
             cacheRecord,
             false,
             request,
+            this.performanceClient,
             idTokenClaims,
             requestStateObj,
             serverTokenResponse,
@@ -436,9 +439,7 @@ export class ResponseHandler {
                 refreshOnSeconds,
                 serverTokenResponse.token_type,
                 userAssertionHash,
-                serverTokenResponse.key_id,
-                request.claims,
-                request.requestedClaimsHash
+                serverTokenResponse.key_id
             );
         }
 
@@ -503,17 +504,18 @@ export class ResponseHandler {
         cacheRecord: CacheRecord,
         fromTokenCache: boolean,
         request: BaseAuthRequest,
+        performanceClient: IPerformanceClient,
         idTokenClaims?: TokenClaims,
         requestState?: RequestStateObject,
         serverTokenResponse?: ServerAuthorizationTokenResponse,
         requestId?: string
     ): Promise<AuthenticationResult> {
-        let accessToken: string = Constants.EMPTY_STRING;
+        let accessToken: string = "";
         let responseScopes: Array<string> = [];
         let expiresOn: Date | null = null;
         let extExpiresOn: Date | undefined;
         let refreshOn: Date | undefined;
-        let familyId: string = Constants.EMPTY_STRING;
+        let familyId: string = "";
 
         if (cacheRecord.accessToken) {
             /*
@@ -522,11 +524,11 @@ export class ResponseHandler {
              */
             if (
                 cacheRecord.accessToken.tokenType ===
-                    AuthenticationScheme.POP &&
+                    Constants.AuthenticationScheme.POP &&
                 !request.popKid
             ) {
                 const popTokenGenerator: PopTokenGenerator =
-                    new PopTokenGenerator(cryptoObj);
+                    new PopTokenGenerator(cryptoObj, performanceClient);
                 const { secret, keyId } = cacheRecord.accessToken;
 
                 if (!keyId) {
@@ -562,8 +564,8 @@ export class ResponseHandler {
 
         if (cacheRecord.appMetadata) {
             familyId =
-                cacheRecord.appMetadata.familyId === THE_FAMILY_ID
-                    ? THE_FAMILY_ID
+                cacheRecord.appMetadata.familyId === Constants.THE_FAMILY_ID
+                    ? Constants.THE_FAMILY_ID
                     : "";
         }
         const uid = idTokenClaims?.oid || idTokenClaims?.sub || "";
@@ -577,7 +579,7 @@ export class ResponseHandler {
 
         const accountInfo: AccountInfo | null = cacheRecord.account
             ? updateAccountTenantProfileData(
-                  AccountEntity.getAccountInfo(cacheRecord.account),
+                  AccountEntityUtils.getAccountInfo(cacheRecord.account),
                   undefined, // tenantProfile optional
                   idTokenClaims,
                   cacheRecord.idToken?.secret
@@ -598,20 +600,14 @@ export class ResponseHandler {
             extExpiresOn: extExpiresOn,
             refreshOn: refreshOn,
             correlationId: request.correlationId,
-            requestId: requestId || Constants.EMPTY_STRING,
+            requestId: requestId || "",
             familyId: familyId,
-            tokenType:
-                cacheRecord.accessToken?.tokenType || Constants.EMPTY_STRING,
-            state: requestState
-                ? requestState.userRequestState
-                : Constants.EMPTY_STRING,
-            cloudGraphHostName:
-                cacheRecord.account?.cloudGraphHostName ||
-                Constants.EMPTY_STRING,
-            msGraphHost:
-                cacheRecord.account?.msGraphHost || Constants.EMPTY_STRING,
+            tokenType: cacheRecord.accessToken?.tokenType || "",
+            state: requestState ? requestState.userRequestState : "",
+            cloudGraphHostName: cacheRecord.account?.cloudGraphHostName || "",
+            msGraphHost: cacheRecord.account?.msGraphHost || "",
             code: serverTokenResponse?.spa_code,
-            fromNativeBroker: false,
+            fromPlatformBroker: false,
         };
     }
 }
@@ -630,7 +626,7 @@ export function buildAccountToCache(
     nativeAccountId?: string,
     logger?: Logger
 ): AccountEntity {
-    logger?.verbose("setCachedAccount called");
+    logger?.verbose("setCachedAccount called", correlationId);
 
     // Check if base account is already cached
     const accountKeys = cacheStorage.getAccountKeys();
@@ -645,7 +641,7 @@ export function buildAccountToCache(
 
     const baseAccount =
         cachedAccount ||
-        AccountEntity.createAccount(
+        AccountEntityUtils.createAccountEntity(
             {
                 homeAccountId,
                 idTokenClaims,

package/src/telemetry/performance/IPerformanceClient.ts

@@ -4,7 +4,6 @@
  */
 
 import { PerformanceEvent } from "./PerformanceEvent.js";
-import { IPerformanceMeasurement } from "./IPerformanceMeasurement.js";
 import { AccountInfo } from "../../account/AccountInfo.js";
 
 export type PerformanceCallbackFunction = (events: PerformanceEvent[]) => void;
@@ -19,10 +18,6 @@ export type InProgressPerformanceEvent = {
     add: (fields: { [key: string]: {} | undefined }) => void;
     increment: (fields: { [key: string]: number | undefined }) => void;
     event: PerformanceEvent;
-    /**
-     * @deprecated This attribute will be removed in the next major version
-     */
-    measurement: IPerformanceMeasurement;
 };
 
 export interface IPerformanceClient {
@@ -43,40 +38,5 @@ export interface IPerformanceClient {
     removePerformanceCallback(callbackId: string): boolean;
     addPerformanceCallback(callback: PerformanceCallbackFunction): string;
     emitEvents(events: PerformanceEvent[], correlationId: string): void;
-    /**
-     * @deprecated This method will be removed in the next major version
-     */
-    startPerformanceMeasurement(
-        measureName: string,
-        correlationId: string
-    ): IPerformanceMeasurement;
     generateId(): string;
-    calculateQueuedTime(preQueueTime: number, currentTime: number): number;
-    addQueueMeasurement(
-        eventName: string,
-        correlationId?: string,
-        queueTime?: number,
-        manuallyCompleted?: boolean
-    ): void;
-    setPreQueueTime(eventName: string, correlationId?: string): void;
 }
-
-/**
- * Queue measurement type
- */
-export type QueueMeasurement = {
-    /**
-     * Name of performance event
-     */
-    eventName: string;
-
-    /**
-     * Time spent in JS queue
-     */
-    queueTime: number;
-
-    /**
-     * Incomplete pre-queue events are instrumentation bugs that should be fixed.
-     */
-    manuallyCompleted?: boolean;
-};