@azure/msal-common 13.0.0 → 14.0.0-alpha.2

package/dist/client/RefreshTokenClient.js

@@ -1,9 +1,8 @@
-/*! @azure/msal-common v13.0.0 2023-05-01 */
+/*! @azure/msal-common v14.0.0-alpha.2 2023-05-17 */
 'use strict';
-import { __extends, __awaiter, __generator, __assign } from '../_virtual/_tslib.js';
 import { BaseClient } from './BaseClient.js';
 import { RequestParameterBuilder } from '../request/RequestParameterBuilder.js';
-import { AuthenticationScheme, GrantType, HeaderNames, Errors } from '../utils/Constants.js';
+import { GrantType, AuthenticationScheme, HeaderNames, Errors } from '../utils/Constants.js';
 import { ResponseHandler } from '../response/ResponseHandler.js';
 import { PopTokenGenerator } from '../crypto/PopTokenGenerator.js';
 import { StringUtils } from '../utils/StringUtils.js';
@@ -17,277 +16,245 @@ import { buildClientInfoFromHomeAccountId } from '../account/ClientInfo.js';
 import { InteractionRequiredAuthError, InteractionRequiredAuthErrorMessage } from '../error/InteractionRequiredAuthError.js';
 import { PerformanceEvents } from '../telemetry/performance/PerformanceEvent.js';
 
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-/**
- * OAuth2.0 refresh token client
- */
-var RefreshTokenClient = /** @class */ (function (_super) {
-    __extends(RefreshTokenClient, _super);
-    function RefreshTokenClient(configuration, performanceClient) {
-        return _super.call(this, configuration, performanceClient) || this;
-    }
-    RefreshTokenClient.prototype.acquireToken = function (request) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        return __awaiter(this, void 0, void 0, function () {
-            var atsMeasurement, reqTimestamp, response, httpVerToken, requestId, responseHandler;
-            var _this = this;
-            return __generator(this, function (_h) {
-                switch (_h.label) {
-                    case 0:
-                        (_a = this.performanceClient) === null || _a === void 0 ? void 0 : _a.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
-                        atsMeasurement = (_b = this.performanceClient) === null || _b === void 0 ? void 0 : _b.startMeasurement(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
-                        this.logger.verbose("RefreshTokenClientAcquireToken called", request.correlationId);
-                        reqTimestamp = TimeUtils.nowSeconds();
-                        (_c = this.performanceClient) === null || _c === void 0 ? void 0 : _c.setPreQueueTime(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
-                        return [4 /*yield*/, this.executeTokenRequest(request, this.authority)];
-                    case 1:
-                        response = _h.sent();
-                        httpVerToken = (_d = response.headers) === null || _d === void 0 ? void 0 : _d[HeaderNames.X_MS_HTTP_VERSION];
-                        atsMeasurement === null || atsMeasurement === void 0 ? void 0 : atsMeasurement.addStaticFields({
-                            refreshTokenSize: ((_e = response.body.refresh_token) === null || _e === void 0 ? void 0 : _e.length) || 0,
-                        });
-                        if (httpVerToken) {
-                            atsMeasurement === null || atsMeasurement === void 0 ? void 0 : atsMeasurement.addStaticFields({
-                                httpVerToken: httpVerToken,
-                            });
-                        }
-                        requestId = (_f = response.headers) === null || _f === void 0 ? void 0 : _f[HeaderNames.X_MS_REQUEST_ID];
-                        responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
-                        responseHandler.validateTokenResponse(response.body);
-                        (_g = this.performanceClient) === null || _g === void 0 ? void 0 : _g.setPreQueueTime(PerformanceEvents.HandleServerTokenResponse, request.correlationId);
-                        return [2 /*return*/, responseHandler.handleServerTokenResponse(response.body, this.authority, reqTimestamp, request, undefined, undefined, true, request.forceCache, requestId).then(function (result) {
-                                atsMeasurement === null || atsMeasurement === void 0 ? void 0 : atsMeasurement.endMeasurement({
-                                    success: true
-                                });
-                                return result;
-                            })
-                                .catch(function (error) {
-                                _this.logger.verbose("Error in fetching refresh token", request.correlationId);
-                                atsMeasurement === null || atsMeasurement === void 0 ? void 0 : atsMeasurement.endMeasurement({
-                                    errorCode: error.errorCode,
-                                    subErrorCode: error.subError,
-                                    success: false
-                                });
-                                throw error;
-                            })];
-                }
-            });
-        });
-    };
-    /**
-     * Gets cached refresh token and attaches to request, then calls acquireToken API
-     * @param request
-     */
-    RefreshTokenClient.prototype.acquireTokenByRefreshToken = function (request) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function () {
-            var isFOCI, noFamilyRTInCache, clientMismatchErrorWithFamilyRT;
-            return __generator(this, function (_e) {
-                // Cannot renew token if no request object is given.
-                if (!request) {
-                    throw ClientConfigurationError.createEmptyTokenRequestError();
-                }
-                (_a = this.performanceClient) === null || _a === void 0 ? void 0 : _a.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken, request.correlationId);
-                // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
-                if (!request.account) {
-                    throw ClientAuthError.createNoAccountInSilentRequestError();
-                }
-                isFOCI = this.cacheManager.isAppMetadataFOCI(request.account.environment);
-                // if the app is part of the family, retrive a Family refresh token if present and make a refreshTokenRequest
-                if (isFOCI) {
-                    try {
-                        (_b = this.performanceClient) === null || _b === void 0 ? void 0 : _b.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
-                        return [2 /*return*/, this.acquireTokenWithCachedRefreshToken(request, true)];
-                    }
-                    catch (e) {
-                        noFamilyRTInCache = e instanceof InteractionRequiredAuthError && e.errorCode === InteractionRequiredAuthErrorMessage.noTokensFoundError.code;
-                        clientMismatchErrorWithFamilyRT = e instanceof ServerError && e.errorCode === Errors.INVALID_GRANT_ERROR && e.subError === Errors.CLIENT_MISMATCH_ERROR;
-                        // if family Refresh Token (FRT) cache acquisition fails or if client_mismatch error is seen with FRT, reattempt with application Refresh Token (ART)
-                        if (noFamilyRTInCache || clientMismatchErrorWithFamilyRT) {
-                            (_c = this.performanceClient) === null || _c === void 0 ? void 0 : _c.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
-                            return [2 /*return*/, this.acquireTokenWithCachedRefreshToken(request, false)];
-                            // throw in all other cases
-                        }
-                        else {
-                            throw e;
-                        }
-                    }
-                }
-                // fall back to application refresh token acquisition
-                (_d = this.performanceClient) === null || _d === void 0 ? void 0 : _d.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
-                return [2 /*return*/, this.acquireTokenWithCachedRefreshToken(request, false)];
-            });
-        });
-    };
-    /**
-     * makes a network call to acquire tokens by exchanging RefreshToken available in userCache; throws if refresh token is not cached
-     * @param request
-     */
-    RefreshTokenClient.prototype.acquireTokenWithCachedRefreshToken = function (request, foci) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var atsMeasurement, refreshToken, refreshTokenRequest;
-            return __generator(this, function (_d) {
-                (_a = this.performanceClient) === null || _a === void 0 ? void 0 : _a.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
-                atsMeasurement = (_b = this.performanceClient) === null || _b === void 0 ? void 0 : _b.startMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
-                this.logger.verbose("RefreshTokenClientAcquireTokenWithCachedRefreshToken called", request.correlationId);
-                refreshToken = this.cacheManager.getRefreshToken(request.account, foci);
-                if (!refreshToken) {
-                    atsMeasurement === null || atsMeasurement === void 0 ? void 0 : atsMeasurement.discardMeasurement();
-                    throw InteractionRequiredAuthError.createNoTokensFoundError();
-                }
-                // attach cached RT size to the current measurement
-                atsMeasurement === null || atsMeasurement === void 0 ? void 0 : atsMeasurement.endMeasurement({
-                    success: true
-                });
-                refreshTokenRequest = __assign(__assign({}, request), { refreshToken: refreshToken.secret, authenticationScheme: request.authenticationScheme || AuthenticationScheme.BEARER, ccsCredential: {
-                        credential: request.account.homeAccountId,
-                        type: CcsCredentialType.HOME_ACCOUNT_ID
-                    } });
-                (_c = this.performanceClient) === null || _c === void 0 ? void 0 : _c.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
-                return [2 /*return*/, this.acquireToken(refreshTokenRequest)];
-            });
-        });
-    };
-    /**
-     * Constructs the network message and makes a NW call to the underlying secure token service
-     * @param request
-     * @param authority
-     */
-    RefreshTokenClient.prototype.executeTokenRequest = function (request, authority) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var acquireTokenMeasurement, queryParametersString, endpoint, requestBody, headers, thumbprint;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        (_a = this.performanceClient) === null || _a === void 0 ? void 0 : _a.addQueueMeasurement(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
-                        acquireTokenMeasurement = (_b = this.performanceClient) === null || _b === void 0 ? void 0 : _b.startMeasurement(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
-                        (_c = this.performanceClient) === null || _c === void 0 ? void 0 : _c.setPreQueueTime(PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
-                        queryParametersString = this.createTokenQueryParameters(request);
-                        endpoint = UrlString.appendQueryString(authority.tokenEndpoint, queryParametersString);
-                        return [4 /*yield*/, this.createTokenRequestBody(request)];
-                    case 1:
-                        requestBody = _d.sent();
-                        headers = this.createTokenRequestHeaders(request.ccsCredential);
-                        thumbprint = {
-                            clientId: this.config.authOptions.clientId,
-                            authority: authority.canonicalAuthority,
-                            scopes: request.scopes,
-                            claims: request.claims,
-                            authenticationScheme: request.authenticationScheme,
-                            resourceRequestMethod: request.resourceRequestMethod,
-                            resourceRequestUri: request.resourceRequestUri,
-                            shrClaims: request.shrClaims,
-                            sshKid: request.sshKid
-                        };
-                        return [2 /*return*/, this.executePostToTokenEndpoint(endpoint, requestBody, headers, thumbprint)
-                                .then(function (result) {
-                                acquireTokenMeasurement === null || acquireTokenMeasurement === void 0 ? void 0 : acquireTokenMeasurement.endMeasurement({
-                                    success: true
-                                });
-                                return result;
-                            })
-                                .catch(function (error) {
-                                acquireTokenMeasurement === null || acquireTokenMeasurement === void 0 ? void 0 : acquireTokenMeasurement.endMeasurement({
-                                    success: false
-                                });
-                                throw error;
-                            })];
-                }
-            });
-        });
-    };
-    /**
-     * Helper function to create the token request body
-     * @param request
-     */
-    RefreshTokenClient.prototype.createTokenRequestBody = function (request) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            var correlationId, acquireTokenMeasurement, parameterBuilder, clientAssertion, popTokenGenerator, reqCnfData, clientInfo;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        (_a = this.performanceClient) === null || _a === void 0 ? void 0 : _a.addQueueMeasurement(PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
-                        correlationId = request.correlationId;
-                        acquireTokenMeasurement = (_b = this.performanceClient) === null || _b === void 0 ? void 0 : _b.startMeasurement(PerformanceEvents.BaseClientCreateTokenRequestHeaders, correlationId);
-                        parameterBuilder = new RequestParameterBuilder();
-                        parameterBuilder.addClientId(this.config.authOptions.clientId);
-                        parameterBuilder.addScopes(request.scopes);
-                        parameterBuilder.addGrantType(GrantType.REFRESH_TOKEN_GRANT);
-                        parameterBuilder.addClientInfo();
-                        parameterBuilder.addLibraryInfo(this.config.libraryInfo);
-                        parameterBuilder.addApplicationTelemetry(this.config.telemetry.application);
-                        parameterBuilder.addThrottling();
-                        if (this.serverTelemetryManager) {
-                            parameterBuilder.addServerTelemetry(this.serverTelemetryManager);
-                        }
-                        parameterBuilder.addCorrelationId(correlationId);
-                        parameterBuilder.addRefreshToken(request.refreshToken);
-                        if (this.config.clientCredentials.clientSecret) {
-                            parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);
-                        }
-                        if (this.config.clientCredentials.clientAssertion) {
-                            clientAssertion = this.config.clientCredentials.clientAssertion;
-                            parameterBuilder.addClientAssertion(clientAssertion.assertion);
-                            parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
-                        }
-                        if (!(request.authenticationScheme === AuthenticationScheme.POP)) return [3 /*break*/, 2];
-                        popTokenGenerator = new PopTokenGenerator(this.cryptoUtils, this.performanceClient);
-                        (_c = this.performanceClient) === null || _c === void 0 ? void 0 : _c.setPreQueueTime(PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
-                        return [4 /*yield*/, popTokenGenerator.generateCnf(request)];
-                    case 1:
-                        reqCnfData = _d.sent();
-                        // SPA PoP requires full Base64Url encoded req_cnf string (unhashed)
-                        parameterBuilder.addPopToken(reqCnfData.reqCnfString);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        if (request.authenticationScheme === AuthenticationScheme.SSH) {
-                            if (request.sshJwk) {
-                                parameterBuilder.addSshJwk(request.sshJwk);
-                            }
-                            else {
-                                acquireTokenMeasurement === null || acquireTokenMeasurement === void 0 ? void 0 : acquireTokenMeasurement.endMeasurement({
-                                    success: false
-                                });
-                                throw ClientConfigurationError.createMissingSshJwkError();
-                            }
-                        }
-                        _d.label = 3;
-                    case 3:
-                        if (!StringUtils.isEmptyObj(request.claims) || this.config.authOptions.clientCapabilities && this.config.authOptions.clientCapabilities.length > 0) {
-                            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
-                        }
-                        if (this.config.systemOptions.preventCorsPreflight && request.ccsCredential) {
-                            switch (request.ccsCredential.type) {
-                                case CcsCredentialType.HOME_ACCOUNT_ID:
-                                    try {
-                                        clientInfo = buildClientInfoFromHomeAccountId(request.ccsCredential.credential);
-                                        parameterBuilder.addCcsOid(clientInfo);
-                                    }
-                                    catch (e) {
-                                        this.logger.verbose("Could not parse home account ID for CCS Header: " + e);
-                                    }
-                                    break;
-                                case CcsCredentialType.UPN:
-                                    parameterBuilder.addCcsUpn(request.ccsCredential.credential);
-                                    break;
-                            }
-                        }
-                        acquireTokenMeasurement === null || acquireTokenMeasurement === void 0 ? void 0 : acquireTokenMeasurement.endMeasurement({
-                            success: true
-                        });
-                        return [2 /*return*/, parameterBuilder.createQueryString()];
-                }
-            });
-        });
-    };
-    return RefreshTokenClient;
-}(BaseClient));
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+/**
+ * OAuth2.0 refresh token client
+ */
+class RefreshTokenClient extends BaseClient {
+    constructor(configuration, performanceClient) {
+        super(configuration, performanceClient);
+    }
+    async acquireToken(request) {
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
+        const atsMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
+        this.logger.verbose("RefreshTokenClientAcquireToken called", request.correlationId);
+        const reqTimestamp = TimeUtils.nowSeconds();
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
+        const response = await this.executeTokenRequest(request, this.authority);
+        const httpVerToken = response.headers?.[HeaderNames.X_MS_HTTP_VERSION];
+        atsMeasurement?.addStaticFields({
+            refreshTokenSize: response.body.refresh_token?.length || 0,
+        });
+        if (httpVerToken) {
+            atsMeasurement?.addStaticFields({
+                httpVerToken,
+            });
+        }
+        // Retrieve requestId from response headers
+        const requestId = response.headers?.[HeaderNames.X_MS_REQUEST_ID];
+        const responseHandler = new ResponseHandler(this.config.authOptions.clientId, this.cacheManager, this.cryptoUtils, this.logger, this.config.serializableCache, this.config.persistencePlugin);
+        responseHandler.validateTokenResponse(response.body);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.HandleServerTokenResponse, request.correlationId);
+        return responseHandler
+            .handleServerTokenResponse(response.body, this.authority, reqTimestamp, request, undefined, undefined, true, request.forceCache, requestId)
+            .then((result) => {
+            atsMeasurement?.endMeasurement({
+                success: true,
+            });
+            return result;
+        })
+            .catch((error) => {
+            this.logger.verbose("Error in fetching refresh token", request.correlationId);
+            atsMeasurement?.endMeasurement({
+                errorCode: error.errorCode,
+                subErrorCode: error.subError,
+                success: false,
+            });
+            throw error;
+        });
+    }
+    /**
+     * Gets cached refresh token and attaches to request, then calls acquireToken API
+     * @param request
+     */
+    async acquireTokenByRefreshToken(request) {
+        // Cannot renew token if no request object is given.
+        if (!request) {
+            throw ClientConfigurationError.createEmptyTokenRequestError();
+        }
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenByRefreshToken, request.correlationId);
+        // We currently do not support silent flow for account === null use cases; This will be revisited for confidential flow usecases
+        if (!request.account) {
+            throw ClientAuthError.createNoAccountInSilentRequestError();
+        }
+        // try checking if FOCI is enabled for the given application
+        const isFOCI = this.cacheManager.isAppMetadataFOCI(request.account.environment);
+        // if the app is part of the family, retrive a Family refresh token if present and make a refreshTokenRequest
+        if (isFOCI) {
+            try {
+                this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+                return this.acquireTokenWithCachedRefreshToken(request, true);
+            }
+            catch (e) {
+                const noFamilyRTInCache = e instanceof InteractionRequiredAuthError &&
+                    e.errorCode ===
+                        InteractionRequiredAuthErrorMessage.noTokensFoundError
+                            .code;
+                const clientMismatchErrorWithFamilyRT = e instanceof ServerError &&
+                    e.errorCode === Errors.INVALID_GRANT_ERROR &&
+                    e.subError === Errors.CLIENT_MISMATCH_ERROR;
+                // if family Refresh Token (FRT) cache acquisition fails or if client_mismatch error is seen with FRT, reattempt with application Refresh Token (ART)
+                if (noFamilyRTInCache || clientMismatchErrorWithFamilyRT) {
+                    this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+                    return this.acquireTokenWithCachedRefreshToken(request, false);
+                    // throw in all other cases
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        // fall back to application refresh token acquisition
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+        return this.acquireTokenWithCachedRefreshToken(request, false);
+    }
+    /**
+     * makes a network call to acquire tokens by exchanging RefreshToken available in userCache; throws if refresh token is not cached
+     * @param request
+     */
+    async acquireTokenWithCachedRefreshToken(request, foci) {
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+        // fetches family RT or application RT based on FOCI value
+        const atsMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.RefreshTokenClientAcquireTokenWithCachedRefreshToken, request.correlationId);
+        this.logger.verbose("RefreshTokenClientAcquireTokenWithCachedRefreshToken called", request.correlationId);
+        const refreshToken = this.cacheManager.getRefreshToken(request.account, foci);
+        if (!refreshToken) {
+            atsMeasurement?.discardMeasurement();
+            throw InteractionRequiredAuthError.createNoTokensFoundError();
+        }
+        // attach cached RT size to the current measurement
+        atsMeasurement?.endMeasurement({
+            success: true,
+        });
+        const refreshTokenRequest = {
+            ...request,
+            refreshToken: refreshToken.secret,
+            authenticationScheme: request.authenticationScheme || AuthenticationScheme.BEARER,
+            ccsCredential: {
+                credential: request.account.homeAccountId,
+                type: CcsCredentialType.HOME_ACCOUNT_ID,
+            },
+        };
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientAcquireToken, request.correlationId);
+        return this.acquireToken(refreshTokenRequest);
+    }
+    /**
+     * Constructs the network message and makes a NW call to the underlying secure token service
+     * @param request
+     * @param authority
+     */
+    async executeTokenRequest(request, authority) {
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
+        const acquireTokenMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.RefreshTokenClientExecuteTokenRequest, request.correlationId);
+        this.performanceClient?.setPreQueueTime(PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
+        const queryParametersString = this.createTokenQueryParameters(request);
+        const endpoint = UrlString.appendQueryString(authority.tokenEndpoint, queryParametersString);
+        const requestBody = await this.createTokenRequestBody(request);
+        const headers = this.createTokenRequestHeaders(request.ccsCredential);
+        const thumbprint = {
+            clientId: this.config.authOptions.clientId,
+            authority: authority.canonicalAuthority,
+            scopes: request.scopes,
+            claims: request.claims,
+            authenticationScheme: request.authenticationScheme,
+            resourceRequestMethod: request.resourceRequestMethod,
+            resourceRequestUri: request.resourceRequestUri,
+            shrClaims: request.shrClaims,
+            sshKid: request.sshKid,
+        };
+        return this.executePostToTokenEndpoint(endpoint, requestBody, headers, thumbprint)
+            .then((result) => {
+            acquireTokenMeasurement?.endMeasurement({
+                success: true,
+            });
+            return result;
+        })
+            .catch((error) => {
+            acquireTokenMeasurement?.endMeasurement({
+                success: false,
+            });
+            throw error;
+        });
+    }
+    /**
+     * Helper function to create the token request body
+     * @param request
+     */
+    async createTokenRequestBody(request) {
+        this.performanceClient?.addQueueMeasurement(PerformanceEvents.RefreshTokenClientCreateTokenRequestBody, request.correlationId);
+        const correlationId = request.correlationId;
+        const acquireTokenMeasurement = this.performanceClient?.startMeasurement(PerformanceEvents.BaseClientCreateTokenRequestHeaders, correlationId);
+        const parameterBuilder = new RequestParameterBuilder();
+        parameterBuilder.addClientId(this.config.authOptions.clientId);
+        parameterBuilder.addScopes(request.scopes);
+        parameterBuilder.addGrantType(GrantType.REFRESH_TOKEN_GRANT);
+        parameterBuilder.addClientInfo();
+        parameterBuilder.addLibraryInfo(this.config.libraryInfo);
+        parameterBuilder.addApplicationTelemetry(this.config.telemetry.application);
+        parameterBuilder.addThrottling();
+        if (this.serverTelemetryManager) {
+            parameterBuilder.addServerTelemetry(this.serverTelemetryManager);
+        }
+        parameterBuilder.addCorrelationId(correlationId);
+        parameterBuilder.addRefreshToken(request.refreshToken);
+        if (this.config.clientCredentials.clientSecret) {
+            parameterBuilder.addClientSecret(this.config.clientCredentials.clientSecret);
+        }
+        if (this.config.clientCredentials.clientAssertion) {
+            const clientAssertion = this.config.clientCredentials.clientAssertion;
+            parameterBuilder.addClientAssertion(clientAssertion.assertion);
+            parameterBuilder.addClientAssertionType(clientAssertion.assertionType);
+        }
+        if (request.authenticationScheme === AuthenticationScheme.POP) {
+            const popTokenGenerator = new PopTokenGenerator(this.cryptoUtils, this.performanceClient);
+            this.performanceClient?.setPreQueueTime(PerformanceEvents.PopTokenGenerateCnf, request.correlationId);
+            const reqCnfData = await popTokenGenerator.generateCnf(request);
+            // SPA PoP requires full Base64Url encoded req_cnf string (unhashed)
+            parameterBuilder.addPopToken(reqCnfData.reqCnfString);
+        }
+        else if (request.authenticationScheme === AuthenticationScheme.SSH) {
+            if (request.sshJwk) {
+                parameterBuilder.addSshJwk(request.sshJwk);
+            }
+            else {
+                acquireTokenMeasurement?.endMeasurement({
+                    success: false,
+                });
+                throw ClientConfigurationError.createMissingSshJwkError();
+            }
+        }
+        if (!StringUtils.isEmptyObj(request.claims) ||
+            (this.config.authOptions.clientCapabilities &&
+                this.config.authOptions.clientCapabilities.length > 0)) {
+            parameterBuilder.addClaims(request.claims, this.config.authOptions.clientCapabilities);
+        }
+        if (this.config.systemOptions.preventCorsPreflight &&
+            request.ccsCredential) {
+            switch (request.ccsCredential.type) {
+                case CcsCredentialType.HOME_ACCOUNT_ID:
+                    try {
+                        const clientInfo = buildClientInfoFromHomeAccountId(request.ccsCredential.credential);
+                        parameterBuilder.addCcsOid(clientInfo);
+                    }
+                    catch (e) {
+                        this.logger.verbose("Could not parse home account ID for CCS Header: " +
+                            e);
+                    }
+                    break;
+                case CcsCredentialType.UPN:
+                    parameterBuilder.addCcsUpn(request.ccsCredential.credential);
+                    break;
+            }
+        }
+        acquireTokenMeasurement?.endMeasurement({
+            success: true,
+        });
+        return parameterBuilder.createQueryString();
+    }
+}
 
 export { RefreshTokenClient };
 //# sourceMappingURL=RefreshTokenClient.js.map