var __defProp = Object.defineProperty;
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
var __export = (target, all) => {
|
for (var name in all)
|
__defProp(target, name, { get: all[name], enumerable: true });
|
};
|
var __copyProps = (to, from, except, desc) => {
|
if (from && typeof from === "object" || typeof from === "function") {
|
for (let key of __getOwnPropNames(from))
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
}
|
return to;
|
};
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
var tokenCycler_exports = {};
|
__export(tokenCycler_exports, {
|
DEFAULT_CYCLER_OPTIONS: () => DEFAULT_CYCLER_OPTIONS,
|
createTokenCycler: () => createTokenCycler
|
});
|
module.exports = __toCommonJS(tokenCycler_exports);
|
var import_core_util = require("@azure/core-util");
|
const DEFAULT_CYCLER_OPTIONS = {
|
forcedRefreshWindowInMs: 1e3,
|
// Force waiting for a refresh 1s before the token expires
|
retryIntervalInMs: 3e3,
|
// Allow refresh attempts every 3s
|
refreshWindowInMs: 1e3 * 60 * 2
|
// Start refreshing 2m before expiry
|
};
|
async function beginRefresh(getAccessToken, retryIntervalInMs, refreshTimeout) {
|
async function tryGetAccessToken() {
|
if (Date.now() < refreshTimeout) {
|
try {
|
return await getAccessToken();
|
} catch {
|
return null;
|
}
|
} else {
|
const finalToken = await getAccessToken();
|
if (finalToken === null) {
|
throw new Error("Failed to refresh access token.");
|
}
|
return finalToken;
|
}
|
}
|
let token = await tryGetAccessToken();
|
while (token === null) {
|
await (0, import_core_util.delay)(retryIntervalInMs);
|
token = await tryGetAccessToken();
|
}
|
return token;
|
}
|
function createTokenCycler(credential, tokenCyclerOptions) {
|
let refreshWorker = null;
|
let token = null;
|
let tenantId;
|
const options = {
|
...DEFAULT_CYCLER_OPTIONS,
|
...tokenCyclerOptions
|
};
|
const cycler = {
|
/**
|
* Produces true if a refresh job is currently in progress.
|
*/
|
get isRefreshing() {
|
return refreshWorker !== null;
|
},
|
/**
|
* Produces true if the cycler SHOULD refresh (we are within the refresh
|
* window and not already refreshing)
|
*/
|
get shouldRefresh() {
|
if (cycler.isRefreshing) {
|
return false;
|
}
|
if (token?.refreshAfterTimestamp && token.refreshAfterTimestamp < Date.now()) {
|
return true;
|
}
|
return (token?.expiresOnTimestamp ?? 0) - options.refreshWindowInMs < Date.now();
|
},
|
/**
|
* Produces true if the cycler MUST refresh (null or nearly-expired
|
* token).
|
*/
|
get mustRefresh() {
|
return token === null || token.expiresOnTimestamp - options.forcedRefreshWindowInMs < Date.now();
|
}
|
};
|
function refresh(scopes, getTokenOptions) {
|
if (!cycler.isRefreshing) {
|
const tryGetAccessToken = () => credential.getToken(scopes, getTokenOptions);
|
refreshWorker = beginRefresh(
|
tryGetAccessToken,
|
options.retryIntervalInMs,
|
// If we don't have a token, then we should timeout immediately
|
token?.expiresOnTimestamp ?? Date.now()
|
).then((_token) => {
|
refreshWorker = null;
|
token = _token;
|
tenantId = getTokenOptions.tenantId;
|
return token;
|
}).catch((reason) => {
|
refreshWorker = null;
|
token = null;
|
tenantId = void 0;
|
throw reason;
|
});
|
}
|
return refreshWorker;
|
}
|
return async (scopes, tokenOptions) => {
|
const hasClaimChallenge = Boolean(tokenOptions.claims);
|
const tenantIdChanged = tenantId !== tokenOptions.tenantId;
|
if (hasClaimChallenge) {
|
token = null;
|
}
|
const mustRefresh = tenantIdChanged || hasClaimChallenge || cycler.mustRefresh;
|
if (mustRefresh) {
|
return refresh(scopes, tokenOptions);
|
}
|
if (cycler.shouldRefresh) {
|
refresh(scopes, tokenOptions);
|
}
|
return token;
|
};
|
}
|
// Annotate the CommonJS export names for ESM import in node:
|
0 && (module.exports = {
|
DEFAULT_CYCLER_OPTIONS,
|
createTokenCycler
|
});
|
