@rushstack/rush-http-build-cache-plugin 5.97.1-pr3481.18 → 5.97.1

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/{c2/Async_c2ea5cc2edc0a460dcf394ef8277e88e → b4/Async_b43c9d64ab6a035dbce65b9f1a28e166}

@@ -1,9 +1,21 @@
-3817be9a4649c6145c8368590b85d811
+6d4790c8d0cbba844fa0570935749f81
 "use strict";
 // Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
 // See LICENSE in the project root for license information.
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Async = void 0;
+exports.AsyncQueue = exports.Async = void 0;
 /**
  * Utilities for parallel asynchronous operations, for use with the system `Promise` APIs.
  *
@@ -139,4 +151,68 @@ class Async {
     }
 }
 exports.Async = Async;
+function getSignal() {
+    let resolver;
+    const promise = new Promise((resolve) => {
+        resolver = resolve;
+    });
+    return [promise, resolver];
+}
+/**
+ * A queue that allows for asynchronous iteration. During iteration, the queue will wait until
+ * the next item is pushed into the queue before yielding. If instead all queue items are consumed
+ * and all callbacks have been called, the queue will return.
+ *
+ * @public
+ */
+class AsyncQueue {
+    constructor(iterable) {
+        this._queue = iterable ? Array.from(iterable) : [];
+        const [promise, resolver] = getSignal();
+        this._onPushSignal = promise;
+        this._onPushResolve = resolver;
+    }
+    [Symbol.asyncIterator]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            let activeIterations = 0;
+            let [callbackSignal, callbackResolve] = getSignal();
+            const callback = () => {
+                if (--activeIterations === 0) {
+                    // Resolve whatever the latest callback promise is and create a new one
+                    callbackResolve();
+                    const [newCallbackSignal, newCallbackResolve] = getSignal();
+                    callbackSignal = newCallbackSignal;
+                    callbackResolve = newCallbackResolve;
+                }
+            };
+            let position = 0;
+            while (this._queue.length > position || activeIterations > 0) {
+                if (this._queue.length > position) {
+                    activeIterations++;
+                    yield yield __await([this._queue[position++], callback]);
+                }
+                else {
+                    // On push, the item will be added to the queue and the onPushSignal will be resolved.
+                    // On calling the callback, active iterations will be decremented by the callback and the
+                    // callbackSignal will be resolved. This means that the loop will continue if there are
+                    // active iterations or if there are items in the queue that haven't been yielded yet.
+                    yield __await(Promise.race([this._onPushSignal, callbackSignal]));
+                }
+            }
+        });
+    }
+    /**
+     * Adds an item to the queue.
+     *
+     * @param item - The item to push into the queue.
+     */
+    push(item) {
+        this._queue.push(item);
+        this._onPushResolve();
+        const [onPushSignal, onPushResolve] = getSignal();
+        this._onPushSignal = onPushSignal;
+        this._onPushResolve = onPushResolve;
+    }
+}
+exports.AsyncQueue = AsyncQueue;
 //# sourceMappingURL=Async.js.map

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/ce/index_ce3464019fb882539ee9a6f3e36e615a

@@ -1,4 +1,4 @@
-b17dd527c7bfa2e203f014e0eacadd6a
+5e06840b02f85d94fa67df91677c70ce
 "use strict";
 
 /* istanbul ignore next */
@@ -85,4 +85,4 @@ const RushHttpBuildCachePlugin_1 =
 /* istanbul ignore next */
 cov_1ufkhiak5h().s[2]++;
 exports.default = RushHttpBuildCachePlugin_1.RushHttpBuildCachePlugin;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBc0U7QUFBQUE7QUFFdEVDLGtCQUFlQyxtREFBd0IiLCJuYW1lcyI6WyJjb3ZfMXVma2hpYWs1aCIsImV4cG9ydHMiLCJSdXNoSHR0cEJ1aWxkQ2FjaGVQbHVnaW5fMSJdLCJzb3VyY2VzIjpbIi9ob21lL3ZzdHMvd29yay8xL3MvcnVzaC1wbHVnaW5zL3J1c2gtaHR0cC1idWlsZC1jYWNoZS1wbHVnaW4vc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJ1c2hIdHRwQnVpbGRDYWNoZVBsdWdpbiB9IGZyb20gJy4vUnVzaEh0dHBCdWlsZENhY2hlUGx1Z2luJztcblxuZXhwb3J0IGRlZmF1bHQgUnVzaEh0dHBCdWlsZENhY2hlUGx1Z2luO1xuZXhwb3J0IHsgSUh0dHBCdWlsZENhY2hlUHJvdmlkZXJPcHRpb25zIH0gZnJvbSAnLi9IdHRwQnVpbGRDYWNoZVByb3ZpZGVyJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBc0U7QUFBQTtBQUV0RUEsa0JBQWVDLG1EQUF3QiIsIm5hbWVzIjpbImV4cG9ydHMiLCJSdXNoSHR0cEJ1aWxkQ2FjaGVQbHVnaW5fMSJdLCJzb3VyY2VzIjpbIi9ob21lL3ZzdHMvd29yay8xL3MvcnVzaC1wbHVnaW5zL3J1c2gtaHR0cC1idWlsZC1jYWNoZS1wbHVnaW4vc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJ1c2hIdHRwQnVpbGRDYWNoZVBsdWdpbiB9IGZyb20gJy4vUnVzaEh0dHBCdWlsZENhY2hlUGx1Z2luJztcblxuZXhwb3J0IGRlZmF1bHQgUnVzaEh0dHBCdWlsZENhY2hlUGx1Z2luO1xuZXhwb3J0IHsgSUh0dHBCdWlsZENhY2hlUHJvdmlkZXJPcHRpb25zIH0gZnJvbSAnLi9IdHRwQnVpbGRDYWNoZVByb3ZpZGVyJztcbiJdfQ==

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/ce/index_ce3464019fb882539ee9a6f3e36e615a.map

@@ -1 +1 @@
-{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAsE;AAAAA;AAEtEC,kBAAeC,mDAAwB","names":["cov_1ufkhiak5h","exports","RushHttpBuildCachePlugin_1"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/index.ts"],"sourcesContent":["import { RushHttpBuildCachePlugin } from './RushHttpBuildCachePlugin';\n\nexport default RushHttpBuildCachePlugin;\nexport { IHttpBuildCacheProviderOptions } from './HttpBuildCacheProvider';\n"]}
+{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAsE;AAAA;AAEtEA,kBAAeC,mDAAwB","names":["exports","RushHttpBuildCachePlugin_1"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/index.ts"],"sourcesContent":["import { RushHttpBuildCachePlugin } from './RushHttpBuildCachePlugin';\n\nexport default RushHttpBuildCachePlugin;\nexport { IHttpBuildCacheProviderOptions } from './HttpBuildCacheProvider';\n"]}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e5/HttpBuildCacheProvider_e53bd002cf44ae62693f20b8c4682941

@@ -1,4 +1,4 @@
-4b020c56bd52a480c10554d0bf7825f9
+63b3387b13c32b9461b83c75e22b0d01
 "use strict";
 
 /* istanbul ignore next */
@@ -4364,4 +4364,4 @@ class HttpBuildCacheProvider {
 /* istanbul ignore next */
 cov_ms2xfswbr().s[121]++;
 exports.HttpBuildCacheProvider = HttpBuildCacheProvider;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBK;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","names":["cov_ms2xfswbr","CredentialsOptions","FailureType","HttpBuildCacheProvider","constructor","options","rushSession","_pluginName","pluginName","_rushSession","_rushProjectRoot","rushProjectRoot","_environmentCredential","rush_sdk_1","buildCacheCredential","_isCacheWriteAllowedByConfiguration","isCacheWriteAllowed","_url","URL","url","endsWith","_uploadMethod","uploadMethod","_headers","headers","_tokenHandler","tokenHandler","_cacheKeyPrefix","cacheKeyPrefix","buildCacheWriteAllowed","tryGetCacheEntryBufferByIdAsync","terminal","cacheId","result","_http","relUrl","method","body","undefined","warningText","readBody","Buffer","isBuffer","e","writeWarningLine","trySetCacheEntryBufferAsync","objectBuffer","writeErrorLine","writeDebugLine","updateCachedCredentialAsync","credential","usingAsync","supportEditing","credentialsCache","setCacheEntry","_credentialCacheId","saveIfModifiedAsync","updateCachedCredentialInteractiveAsync","Error","href","cmd","exec","args","join","writeVerboseLine","node_core_library_1","spawnSync","stderr","error","stdout","trim","writeLine","deleteCachedCredentialsAsync","deleteCacheEntry","__credentialCacheId","cacheIdParts","push","credentialOptions","safeCredentialOptions","Optional","credentials","_tryGetCredentials","Authorization","key","value","Object","entries","bodyLength","length","response","redirect","ok","Required","_reportFailure","from","arrayBuffer","status","Omit","_tryGetCredentialsFromCache","cacheEntry","tryGetCacheEntry","expirationTime","expires","getTime","Date","now","_getFailureType","requestMethod","isRedirect","None","Informational","redirected","Authentication","Warning","message","statusText","exports"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.ts"],"sourcesContent":["import { ITerminal, Executable } from '@rushstack/node-core-library';\nimport {\n  ICloudBuildCacheProvider,\n  ICredentialCacheEntry,\n  CredentialCache,\n  RushSession,\n  EnvironmentConfiguration\n} from '@rushstack/rush-sdk';\nimport fetch, { BodyInit, Response } from 'node-fetch';\n\nenum CredentialsOptions {\n  Optional,\n  Required,\n  Omit\n}\n\nenum FailureType {\n  None,\n  Informational,\n  Warning,\n  Error,\n  Authentication\n}\n\nexport interface IHttpBuildCacheTokenHandler {\n  exec: string;\n  args?: string[];\n}\n\n/**\n * @public\n */\nexport interface IHttpBuildCacheProviderOptions {\n  url: string;\n  tokenHandler?: IHttpBuildCacheTokenHandler;\n  uploadMethod?: string;\n  headers?: Record<string, string>;\n  cacheKeyPrefix?: string;\n  isCacheWriteAllowed: boolean;\n  pluginName: string;\n  rushProjectRoot: string;\n}\n\nexport class HttpBuildCacheProvider implements ICloudBuildCacheProvider {\n  private readonly _pluginName: string;\n  private readonly _rushSession: RushSession;\n  private readonly _rushProjectRoot: string;\n  private readonly _environmentCredential: string | undefined;\n  private readonly _isCacheWriteAllowedByConfiguration: boolean;\n  private readonly _url: URL;\n  private readonly _uploadMethod: string;\n  private readonly _headers: Record<string, string>;\n  private readonly _cacheKeyPrefix: string;\n  private readonly _tokenHandler: IHttpBuildCacheTokenHandler | undefined;\n  private __credentialCacheId: string | undefined;\n\n  public get isCacheWriteAllowed(): boolean {\n    return EnvironmentConfiguration.buildCacheWriteAllowed ?? this._isCacheWriteAllowedByConfiguration;\n  }\n\n  public constructor(options: IHttpBuildCacheProviderOptions, rushSession: RushSession) {\n    this._pluginName = options.pluginName;\n    this._rushSession = rushSession;\n    this._rushProjectRoot = options.rushProjectRoot;\n\n    this._environmentCredential = EnvironmentConfiguration.buildCacheCredential;\n    this._isCacheWriteAllowedByConfiguration = options.isCacheWriteAllowed;\n    this._url = new URL(options.url.endsWith('/') ? options.url : options.url + '/');\n    this._uploadMethod = options.uploadMethod ?? 'PUT';\n    this._headers = options.headers ?? {};\n    this._tokenHandler = options.tokenHandler;\n    this._cacheKeyPrefix = options.cacheKeyPrefix ?? '';\n  }\n\n  public async tryGetCacheEntryBufferByIdAsync(\n    terminal: ITerminal,\n    cacheId: string\n  ): Promise<Buffer | undefined> {\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: 'GET',\n        body: undefined,\n        warningText: 'Could not get cache entry',\n        readBody: true\n      });\n\n      return Buffer.isBuffer(result) ? result : undefined;\n    } catch (e) {\n      terminal.writeWarningLine(`Error getting cache entry: ${e}`);\n      return undefined;\n    }\n  }\n\n  public async trySetCacheEntryBufferAsync(\n    terminal: ITerminal,\n    cacheId: string,\n    objectBuffer: Buffer\n  ): Promise<boolean> {\n    if (!this.isCacheWriteAllowed) {\n      terminal.writeErrorLine('Writing to cache is not allowed in the current configuration.');\n      return false;\n    }\n\n    terminal.writeDebugLine('Uploading object with cacheId: ', cacheId);\n\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: this._uploadMethod,\n        body: objectBuffer,\n        warningText: 'Could not write cache entry',\n        readBody: false\n      });\n\n      return result !== false;\n    } catch (e) {\n      terminal.writeWarningLine(`Error uploading cache entry: ${e}`);\n      return false;\n    }\n  }\n\n  public async updateCachedCredentialAsync(terminal: ITerminal, credential: string): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.setCacheEntry(this._credentialCacheId, {\n          credential: credential\n        });\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  public async updateCachedCredentialInteractiveAsync(terminal: ITerminal): Promise<void> {\n    if (!this._tokenHandler) {\n      throw new Error(\n        `The interactive cloud credentials flow is not configured.\\n` +\n          `Set the 'tokenHandler' setting in 'common/config/rush-plugins/${this._pluginName}.json' to a command that writes your credentials to standard output and exits with code 0 ` +\n          `or provide your credentials to rush using the --credential flag instead. Credentials must be the ` +\n          `'Authorization' header expected by ${this._url.href}`\n      );\n    }\n\n    const cmd: string = `${this._tokenHandler.exec} ${(this._tokenHandler.args || []).join(' ')}`;\n    terminal.writeVerboseLine(`Running '${cmd}' to get credentials`);\n    const result = Executable.spawnSync(this._tokenHandler.exec, this._tokenHandler.args || []);\n\n    terminal.writeErrorLine(result.stderr);\n\n    if (result.error) {\n      throw new Error(`Could not obtain credentials. The command '${cmd}' failed.`);\n    }\n\n    const credential = result.stdout.trim();\n    terminal.writeVerboseLine('Got credentials');\n\n    await this.updateCachedCredentialAsync(terminal, credential);\n\n    terminal.writeLine('Updated credentials cache');\n  }\n\n  public async deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.deleteCacheEntry(this._credentialCacheId);\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  private get _credentialCacheId(): string {\n    if (!this.__credentialCacheId) {\n      const cacheIdParts: string[] = [this._url.href];\n\n      if (this._isCacheWriteAllowedByConfiguration) {\n        cacheIdParts.push('cacheWriteAllowed');\n      }\n\n      this.__credentialCacheId = cacheIdParts.join('|');\n    }\n\n    return this.__credentialCacheId;\n  }\n\n  private async _http(options: {\n    terminal: ITerminal;\n    relUrl: string;\n    method: string;\n    body: BodyInit | undefined;\n    warningText: string;\n    readBody: boolean;\n    credentialOptions?: CredentialsOptions;\n  }): Promise<Buffer | boolean> {\n    const { terminal, relUrl, method, body, warningText, readBody, credentialOptions } = options;\n    const safeCredentialOptions = credentialOptions ?? CredentialsOptions.Optional;\n    const credentials = await this._tryGetCredentials(safeCredentialOptions);\n    const url = new URL(relUrl, this._url).href;\n\n    const headers: Record<string, string> = {};\n    if (typeof credentials === 'string') {\n      headers.Authorization = credentials;\n    }\n\n    for (const [key, value] of Object.entries(this._headers)) {\n      if (typeof value === 'string') {\n        headers[key] = value;\n      }\n    }\n\n    const bodyLength = (body as { length: number })?.length || 'unknown';\n\n    terminal.writeDebugLine(`[http-build-cache] request: ${method} ${url} ${bodyLength} bytes`);\n\n    const response = await fetch(url, {\n      method: method,\n      headers: headers,\n      body: body,\n      redirect: 'follow'\n    });\n\n    if (!response.ok) {\n      if (typeof credentials !== 'string' && safeCredentialOptions === CredentialsOptions.Optional) {\n        // We tried fetching the resource without credentials and that did not work out\n        // Try again but require credentials this time\n        // This will trigger the provider to request credentials\n        return await this._http({ ...options, credentialOptions: CredentialsOptions.Required });\n      }\n\n      this._reportFailure(terminal, method, response, false, warningText);\n      return false;\n    }\n\n    const result: Buffer | boolean = readBody ? Buffer.from(await response.arrayBuffer()) : true;\n\n    terminal.writeDebugLine(\n      `[http-build-cache] actual response: ${response.status} ${url} ${\n        result === true ? 'true' : result.length\n      } bytes`\n    );\n\n    return result;\n  }\n\n  private async _tryGetCredentials(options: CredentialsOptions.Required): Promise<string>;\n  private async _tryGetCredentials(options: CredentialsOptions.Optional): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions.Omit): Promise<undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined> {\n    if (options === CredentialsOptions.Omit) {\n      return;\n    }\n\n    let credentials: string | undefined = this._environmentCredential;\n\n    if (credentials === undefined) {\n      credentials = await this._tryGetCredentialsFromCache();\n    }\n\n    if (typeof credentials !== 'string' && options === CredentialsOptions.Required) {\n      throw new Error(\n        [\n          `Credentials for ${this._url.href} have not been provided.`,\n          `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n          ``,\n          `For local developers, run:`,\n          ``,\n          `    rush update-cloud-credentials --interactive`,\n          ``\n        ].join('\\n')\n      );\n    }\n\n    return credentials;\n  }\n\n  private async _tryGetCredentialsFromCache(): Promise<string | undefined> {\n    let cacheEntry: ICredentialCacheEntry | undefined;\n\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: false\n      },\n      (credentialsCache: CredentialCache) => {\n        cacheEntry = credentialsCache.tryGetCacheEntry(this._credentialCacheId);\n      }\n    );\n\n    if (cacheEntry) {\n      const expirationTime: number | undefined = cacheEntry.expires?.getTime();\n      if (!expirationTime || expirationTime >= Date.now()) {\n        return cacheEntry.credential;\n      }\n    }\n  }\n\n  private _getFailureType(requestMethod: string, response: Response, isRedirect: boolean): FailureType {\n    if (response.ok) {\n      return FailureType.None;\n    }\n\n    switch (response.status) {\n      case 503: {\n        // We select 503 specifically because this represents \"service unavailable\" and\n        // \"rate limit throttle\" errors, which are transient issues.\n        //\n        // There are other 5xx errors, such as 501, that can occur if the request is\n        // malformed, so as a general rule we want to let through other 5xx errors\n        // so the user can troubleshoot.\n\n        // Don't fail production builds with warnings for transient issues\n        return FailureType.Informational;\n      }\n\n      case 401:\n      case 403:\n      case 407: {\n        if (requestMethod === 'GET' && (isRedirect || response.redirected)) {\n          // Cache misses for GET requests are not errors\n          // This is a workaround behavior where a server can issue a redirect and we fail to authenticate at the new location.\n          // We do not want to signal this as an authentication failure because the authorization header is not passed on to redirects.\n          // i.e The authentication header was accepted for the first request and therefore subsequent failures\n          // where it was not present should not be attributed to the header.\n          // This scenario usually comes up with services that redirect to pre-signed URLS that don't actually exist.\n          // Those services then usually treat the 404 as a 403 to prevent leaking information.\n          return FailureType.None;\n        }\n\n        return FailureType.Authentication;\n      }\n\n      case 404: {\n        if (requestMethod === 'GET') {\n          // Cache misses for GET requests are not errors\n          return FailureType.None;\n        }\n      }\n    }\n\n    // Let dev builds succeed, let Prod builds fail\n    return FailureType.Warning;\n  }\n\n  private _reportFailure(\n    terminal: ITerminal,\n    requestMethod: string,\n    response: Response,\n    isRedirect: boolean,\n    message: string\n  ): void {\n    switch (this._getFailureType(requestMethod, response, isRedirect)) {\n      default: {\n        terminal.writeErrorLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Warning: {\n        terminal.writeWarningLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Informational: {\n        terminal.writeLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.None: {\n        terminal.writeDebugLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Authentication: {\n        throw new Error(\n          [\n            `${this._url.href} responded with ${response.status}: ${response.statusText}.`,\n            `Credentials may be misconfigured or have expired.`,\n            `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n            ``,\n            `For local developers, run:`,\n            ``,\n            `    rush update-cloud-credentials --interactive`,\n            ``\n          ].join('\\n')\n        );\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBK;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","names":["CredentialsOptions","FailureType","HttpBuildCacheProvider","constructor","options","rushSession","_pluginName","pluginName","_rushSession","_rushProjectRoot","rushProjectRoot","_environmentCredential","rush_sdk_1","buildCacheCredential","_isCacheWriteAllowedByConfiguration","isCacheWriteAllowed","_url","URL","url","endsWith","_uploadMethod","uploadMethod","_headers","headers","_tokenHandler","tokenHandler","_cacheKeyPrefix","cacheKeyPrefix","buildCacheWriteAllowed","tryGetCacheEntryBufferByIdAsync","terminal","cacheId","result","_http","relUrl","method","body","undefined","warningText","readBody","Buffer","isBuffer","e","writeWarningLine","trySetCacheEntryBufferAsync","objectBuffer","writeErrorLine","writeDebugLine","updateCachedCredentialAsync","credential","usingAsync","supportEditing","credentialsCache","setCacheEntry","_credentialCacheId","saveIfModifiedAsync","updateCachedCredentialInteractiveAsync","Error","href","cmd","exec","args","join","writeVerboseLine","node_core_library_1","spawnSync","stderr","error","stdout","trim","writeLine","deleteCachedCredentialsAsync","deleteCacheEntry","__credentialCacheId","cacheIdParts","push","credentialOptions","safeCredentialOptions","Optional","credentials","_tryGetCredentials","Authorization","key","value","Object","entries","bodyLength","length","response","redirect","ok","Required","_reportFailure","from","arrayBuffer","status","Omit","_tryGetCredentialsFromCache","cacheEntry","tryGetCacheEntry","expirationTime","expires","getTime","Date","now","_getFailureType","requestMethod","isRedirect","None","Informational","redirected","Authentication","Warning","message","statusText","exports"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.ts"],"sourcesContent":["import { ITerminal, Executable } from '@rushstack/node-core-library';\nimport {\n  ICloudBuildCacheProvider,\n  ICredentialCacheEntry,\n  CredentialCache,\n  RushSession,\n  EnvironmentConfiguration\n} from '@rushstack/rush-sdk';\nimport fetch, { BodyInit, Response } from 'node-fetch';\n\nenum CredentialsOptions {\n  Optional,\n  Required,\n  Omit\n}\n\nenum FailureType {\n  None,\n  Informational,\n  Warning,\n  Error,\n  Authentication\n}\n\nexport interface IHttpBuildCacheTokenHandler {\n  exec: string;\n  args?: string[];\n}\n\n/**\n * @public\n */\nexport interface IHttpBuildCacheProviderOptions {\n  url: string;\n  tokenHandler?: IHttpBuildCacheTokenHandler;\n  uploadMethod?: string;\n  headers?: Record<string, string>;\n  cacheKeyPrefix?: string;\n  isCacheWriteAllowed: boolean;\n  pluginName: string;\n  rushProjectRoot: string;\n}\n\nexport class HttpBuildCacheProvider implements ICloudBuildCacheProvider {\n  private readonly _pluginName: string;\n  private readonly _rushSession: RushSession;\n  private readonly _rushProjectRoot: string;\n  private readonly _environmentCredential: string | undefined;\n  private readonly _isCacheWriteAllowedByConfiguration: boolean;\n  private readonly _url: URL;\n  private readonly _uploadMethod: string;\n  private readonly _headers: Record<string, string>;\n  private readonly _cacheKeyPrefix: string;\n  private readonly _tokenHandler: IHttpBuildCacheTokenHandler | undefined;\n  private __credentialCacheId: string | undefined;\n\n  public get isCacheWriteAllowed(): boolean {\n    return EnvironmentConfiguration.buildCacheWriteAllowed ?? this._isCacheWriteAllowedByConfiguration;\n  }\n\n  public constructor(options: IHttpBuildCacheProviderOptions, rushSession: RushSession) {\n    this._pluginName = options.pluginName;\n    this._rushSession = rushSession;\n    this._rushProjectRoot = options.rushProjectRoot;\n\n    this._environmentCredential = EnvironmentConfiguration.buildCacheCredential;\n    this._isCacheWriteAllowedByConfiguration = options.isCacheWriteAllowed;\n    this._url = new URL(options.url.endsWith('/') ? options.url : options.url + '/');\n    this._uploadMethod = options.uploadMethod ?? 'PUT';\n    this._headers = options.headers ?? {};\n    this._tokenHandler = options.tokenHandler;\n    this._cacheKeyPrefix = options.cacheKeyPrefix ?? '';\n  }\n\n  public async tryGetCacheEntryBufferByIdAsync(\n    terminal: ITerminal,\n    cacheId: string\n  ): Promise<Buffer | undefined> {\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: 'GET',\n        body: undefined,\n        warningText: 'Could not get cache entry',\n        readBody: true\n      });\n\n      return Buffer.isBuffer(result) ? result : undefined;\n    } catch (e) {\n      terminal.writeWarningLine(`Error getting cache entry: ${e}`);\n      return undefined;\n    }\n  }\n\n  public async trySetCacheEntryBufferAsync(\n    terminal: ITerminal,\n    cacheId: string,\n    objectBuffer: Buffer\n  ): Promise<boolean> {\n    if (!this.isCacheWriteAllowed) {\n      terminal.writeErrorLine('Writing to cache is not allowed in the current configuration.');\n      return false;\n    }\n\n    terminal.writeDebugLine('Uploading object with cacheId: ', cacheId);\n\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: this._uploadMethod,\n        body: objectBuffer,\n        warningText: 'Could not write cache entry',\n        readBody: false\n      });\n\n      return result !== false;\n    } catch (e) {\n      terminal.writeWarningLine(`Error uploading cache entry: ${e}`);\n      return false;\n    }\n  }\n\n  public async updateCachedCredentialAsync(terminal: ITerminal, credential: string): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.setCacheEntry(this._credentialCacheId, {\n          credential: credential\n        });\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  public async updateCachedCredentialInteractiveAsync(terminal: ITerminal): Promise<void> {\n    if (!this._tokenHandler) {\n      throw new Error(\n        `The interactive cloud credentials flow is not configured.\\n` +\n          `Set the 'tokenHandler' setting in 'common/config/rush-plugins/${this._pluginName}.json' to a command that writes your credentials to standard output and exits with code 0 ` +\n          `or provide your credentials to rush using the --credential flag instead. Credentials must be the ` +\n          `'Authorization' header expected by ${this._url.href}`\n      );\n    }\n\n    const cmd: string = `${this._tokenHandler.exec} ${(this._tokenHandler.args || []).join(' ')}`;\n    terminal.writeVerboseLine(`Running '${cmd}' to get credentials`);\n    const result = Executable.spawnSync(this._tokenHandler.exec, this._tokenHandler.args || []);\n\n    terminal.writeErrorLine(result.stderr);\n\n    if (result.error) {\n      throw new Error(`Could not obtain credentials. The command '${cmd}' failed.`);\n    }\n\n    const credential = result.stdout.trim();\n    terminal.writeVerboseLine('Got credentials');\n\n    await this.updateCachedCredentialAsync(terminal, credential);\n\n    terminal.writeLine('Updated credentials cache');\n  }\n\n  public async deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.deleteCacheEntry(this._credentialCacheId);\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  private get _credentialCacheId(): string {\n    if (!this.__credentialCacheId) {\n      const cacheIdParts: string[] = [this._url.href];\n\n      if (this._isCacheWriteAllowedByConfiguration) {\n        cacheIdParts.push('cacheWriteAllowed');\n      }\n\n      this.__credentialCacheId = cacheIdParts.join('|');\n    }\n\n    return this.__credentialCacheId;\n  }\n\n  private async _http(options: {\n    terminal: ITerminal;\n    relUrl: string;\n    method: string;\n    body: BodyInit | undefined;\n    warningText: string;\n    readBody: boolean;\n    credentialOptions?: CredentialsOptions;\n  }): Promise<Buffer | boolean> {\n    const { terminal, relUrl, method, body, warningText, readBody, credentialOptions } = options;\n    const safeCredentialOptions = credentialOptions ?? CredentialsOptions.Optional;\n    const credentials = await this._tryGetCredentials(safeCredentialOptions);\n    const url = new URL(relUrl, this._url).href;\n\n    const headers: Record<string, string> = {};\n    if (typeof credentials === 'string') {\n      headers.Authorization = credentials;\n    }\n\n    for (const [key, value] of Object.entries(this._headers)) {\n      if (typeof value === 'string') {\n        headers[key] = value;\n      }\n    }\n\n    const bodyLength = (body as { length: number })?.length || 'unknown';\n\n    terminal.writeDebugLine(`[http-build-cache] request: ${method} ${url} ${bodyLength} bytes`);\n\n    const response = await fetch(url, {\n      method: method,\n      headers: headers,\n      body: body,\n      redirect: 'follow'\n    });\n\n    if (!response.ok) {\n      if (typeof credentials !== 'string' && safeCredentialOptions === CredentialsOptions.Optional) {\n        // We tried fetching the resource without credentials and that did not work out\n        // Try again but require credentials this time\n        // This will trigger the provider to request credentials\n        return await this._http({ ...options, credentialOptions: CredentialsOptions.Required });\n      }\n\n      this._reportFailure(terminal, method, response, false, warningText);\n      return false;\n    }\n\n    const result: Buffer | boolean = readBody ? Buffer.from(await response.arrayBuffer()) : true;\n\n    terminal.writeDebugLine(\n      `[http-build-cache] actual response: ${response.status} ${url} ${\n        result === true ? 'true' : result.length\n      } bytes`\n    );\n\n    return result;\n  }\n\n  private async _tryGetCredentials(options: CredentialsOptions.Required): Promise<string>;\n  private async _tryGetCredentials(options: CredentialsOptions.Optional): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions.Omit): Promise<undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined> {\n    if (options === CredentialsOptions.Omit) {\n      return;\n    }\n\n    let credentials: string | undefined = this._environmentCredential;\n\n    if (credentials === undefined) {\n      credentials = await this._tryGetCredentialsFromCache();\n    }\n\n    if (typeof credentials !== 'string' && options === CredentialsOptions.Required) {\n      throw new Error(\n        [\n          `Credentials for ${this._url.href} have not been provided.`,\n          `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n          ``,\n          `For local developers, run:`,\n          ``,\n          `    rush update-cloud-credentials --interactive`,\n          ``\n        ].join('\\n')\n      );\n    }\n\n    return credentials;\n  }\n\n  private async _tryGetCredentialsFromCache(): Promise<string | undefined> {\n    let cacheEntry: ICredentialCacheEntry | undefined;\n\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: false\n      },\n      (credentialsCache: CredentialCache) => {\n        cacheEntry = credentialsCache.tryGetCacheEntry(this._credentialCacheId);\n      }\n    );\n\n    if (cacheEntry) {\n      const expirationTime: number | undefined = cacheEntry.expires?.getTime();\n      if (!expirationTime || expirationTime >= Date.now()) {\n        return cacheEntry.credential;\n      }\n    }\n  }\n\n  private _getFailureType(requestMethod: string, response: Response, isRedirect: boolean): FailureType {\n    if (response.ok) {\n      return FailureType.None;\n    }\n\n    switch (response.status) {\n      case 503: {\n        // We select 503 specifically because this represents \"service unavailable\" and\n        // \"rate limit throttle\" errors, which are transient issues.\n        //\n        // There are other 5xx errors, such as 501, that can occur if the request is\n        // malformed, so as a general rule we want to let through other 5xx errors\n        // so the user can troubleshoot.\n\n        // Don't fail production builds with warnings for transient issues\n        return FailureType.Informational;\n      }\n\n      case 401:\n      case 403:\n      case 407: {\n        if (requestMethod === 'GET' && (isRedirect || response.redirected)) {\n          // Cache misses for GET requests are not errors\n          // This is a workaround behavior where a server can issue a redirect and we fail to authenticate at the new location.\n          // We do not want to signal this as an authentication failure because the authorization header is not passed on to redirects.\n          // i.e The authentication header was accepted for the first request and therefore subsequent failures\n          // where it was not present should not be attributed to the header.\n          // This scenario usually comes up with services that redirect to pre-signed URLS that don't actually exist.\n          // Those services then usually treat the 404 as a 403 to prevent leaking information.\n          return FailureType.None;\n        }\n\n        return FailureType.Authentication;\n      }\n\n      case 404: {\n        if (requestMethod === 'GET') {\n          // Cache misses for GET requests are not errors\n          return FailureType.None;\n        }\n      }\n    }\n\n    // Let dev builds succeed, let Prod builds fail\n    return FailureType.Warning;\n  }\n\n  private _reportFailure(\n    terminal: ITerminal,\n    requestMethod: string,\n    response: Response,\n    isRedirect: boolean,\n    message: string\n  ): void {\n    switch (this._getFailureType(requestMethod, response, isRedirect)) {\n      default: {\n        terminal.writeErrorLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Warning: {\n        terminal.writeWarningLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Informational: {\n        terminal.writeLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.None: {\n        terminal.writeDebugLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Authentication: {\n        throw new Error(\n          [\n            `${this._url.href} responded with ${response.status}: ${response.statusText}.`,\n            `Credentials may be misconfigured or have expired.`,\n            `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n            ``,\n            `For local developers, run:`,\n            ``,\n            `    rush update-cloud-credentials --interactive`,\n            ``\n          ].join('\\n')\n        );\n      }\n    }\n  }\n}\n"]}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e5/HttpBuildCacheProvider_e53bd002cf44ae62693f20b8c4682941.map

@@ -1 +1 @@
-{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBK;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","names":["cov_ms2xfswbr","CredentialsOptions","FailureType","HttpBuildCacheProvider","constructor","options","rushSession","_pluginName","pluginName","_rushSession","_rushProjectRoot","rushProjectRoot","_environmentCredential","rush_sdk_1","buildCacheCredential","_isCacheWriteAllowedByConfiguration","isCacheWriteAllowed","_url","URL","url","endsWith","_uploadMethod","uploadMethod","_headers","headers","_tokenHandler","tokenHandler","_cacheKeyPrefix","cacheKeyPrefix","buildCacheWriteAllowed","tryGetCacheEntryBufferByIdAsync","terminal","cacheId","result","_http","relUrl","method","body","undefined","warningText","readBody","Buffer","isBuffer","e","writeWarningLine","trySetCacheEntryBufferAsync","objectBuffer","writeErrorLine","writeDebugLine","updateCachedCredentialAsync","credential","usingAsync","supportEditing","credentialsCache","setCacheEntry","_credentialCacheId","saveIfModifiedAsync","updateCachedCredentialInteractiveAsync","Error","href","cmd","exec","args","join","writeVerboseLine","node_core_library_1","spawnSync","stderr","error","stdout","trim","writeLine","deleteCachedCredentialsAsync","deleteCacheEntry","__credentialCacheId","cacheIdParts","push","credentialOptions","safeCredentialOptions","Optional","credentials","_tryGetCredentials","Authorization","key","value","Object","entries","bodyLength","length","response","redirect","ok","Required","_reportFailure","from","arrayBuffer","status","Omit","_tryGetCredentialsFromCache","cacheEntry","tryGetCacheEntry","expirationTime","expires","getTime","Date","now","_getFailureType","requestMethod","isRedirect","None","Informational","redirected","Authentication","Warning","message","statusText","exports"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.ts"],"sourcesContent":["import { ITerminal, Executable } from '@rushstack/node-core-library';\nimport {\n  ICloudBuildCacheProvider,\n  ICredentialCacheEntry,\n  CredentialCache,\n  RushSession,\n  EnvironmentConfiguration\n} from '@rushstack/rush-sdk';\nimport fetch, { BodyInit, Response } from 'node-fetch';\n\nenum CredentialsOptions {\n  Optional,\n  Required,\n  Omit\n}\n\nenum FailureType {\n  None,\n  Informational,\n  Warning,\n  Error,\n  Authentication\n}\n\nexport interface IHttpBuildCacheTokenHandler {\n  exec: string;\n  args?: string[];\n}\n\n/**\n * @public\n */\nexport interface IHttpBuildCacheProviderOptions {\n  url: string;\n  tokenHandler?: IHttpBuildCacheTokenHandler;\n  uploadMethod?: string;\n  headers?: Record<string, string>;\n  cacheKeyPrefix?: string;\n  isCacheWriteAllowed: boolean;\n  pluginName: string;\n  rushProjectRoot: string;\n}\n\nexport class HttpBuildCacheProvider implements ICloudBuildCacheProvider {\n  private readonly _pluginName: string;\n  private readonly _rushSession: RushSession;\n  private readonly _rushProjectRoot: string;\n  private readonly _environmentCredential: string | undefined;\n  private readonly _isCacheWriteAllowedByConfiguration: boolean;\n  private readonly _url: URL;\n  private readonly _uploadMethod: string;\n  private readonly _headers: Record<string, string>;\n  private readonly _cacheKeyPrefix: string;\n  private readonly _tokenHandler: IHttpBuildCacheTokenHandler | undefined;\n  private __credentialCacheId: string | undefined;\n\n  public get isCacheWriteAllowed(): boolean {\n    return EnvironmentConfiguration.buildCacheWriteAllowed ?? this._isCacheWriteAllowedByConfiguration;\n  }\n\n  public constructor(options: IHttpBuildCacheProviderOptions, rushSession: RushSession) {\n    this._pluginName = options.pluginName;\n    this._rushSession = rushSession;\n    this._rushProjectRoot = options.rushProjectRoot;\n\n    this._environmentCredential = EnvironmentConfiguration.buildCacheCredential;\n    this._isCacheWriteAllowedByConfiguration = options.isCacheWriteAllowed;\n    this._url = new URL(options.url.endsWith('/') ? options.url : options.url + '/');\n    this._uploadMethod = options.uploadMethod ?? 'PUT';\n    this._headers = options.headers ?? {};\n    this._tokenHandler = options.tokenHandler;\n    this._cacheKeyPrefix = options.cacheKeyPrefix ?? '';\n  }\n\n  public async tryGetCacheEntryBufferByIdAsync(\n    terminal: ITerminal,\n    cacheId: string\n  ): Promise<Buffer | undefined> {\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: 'GET',\n        body: undefined,\n        warningText: 'Could not get cache entry',\n        readBody: true\n      });\n\n      return Buffer.isBuffer(result) ? result : undefined;\n    } catch (e) {\n      terminal.writeWarningLine(`Error getting cache entry: ${e}`);\n      return undefined;\n    }\n  }\n\n  public async trySetCacheEntryBufferAsync(\n    terminal: ITerminal,\n    cacheId: string,\n    objectBuffer: Buffer\n  ): Promise<boolean> {\n    if (!this.isCacheWriteAllowed) {\n      terminal.writeErrorLine('Writing to cache is not allowed in the current configuration.');\n      return false;\n    }\n\n    terminal.writeDebugLine('Uploading object with cacheId: ', cacheId);\n\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: this._uploadMethod,\n        body: objectBuffer,\n        warningText: 'Could not write cache entry',\n        readBody: false\n      });\n\n      return result !== false;\n    } catch (e) {\n      terminal.writeWarningLine(`Error uploading cache entry: ${e}`);\n      return false;\n    }\n  }\n\n  public async updateCachedCredentialAsync(terminal: ITerminal, credential: string): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.setCacheEntry(this._credentialCacheId, {\n          credential: credential\n        });\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  public async updateCachedCredentialInteractiveAsync(terminal: ITerminal): Promise<void> {\n    if (!this._tokenHandler) {\n      throw new Error(\n        `The interactive cloud credentials flow is not configured.\\n` +\n          `Set the 'tokenHandler' setting in 'common/config/rush-plugins/${this._pluginName}.json' to a command that writes your credentials to standard output and exits with code 0 ` +\n          `or provide your credentials to rush using the --credential flag instead. Credentials must be the ` +\n          `'Authorization' header expected by ${this._url.href}`\n      );\n    }\n\n    const cmd: string = `${this._tokenHandler.exec} ${(this._tokenHandler.args || []).join(' ')}`;\n    terminal.writeVerboseLine(`Running '${cmd}' to get credentials`);\n    const result = Executable.spawnSync(this._tokenHandler.exec, this._tokenHandler.args || []);\n\n    terminal.writeErrorLine(result.stderr);\n\n    if (result.error) {\n      throw new Error(`Could not obtain credentials. The command '${cmd}' failed.`);\n    }\n\n    const credential = result.stdout.trim();\n    terminal.writeVerboseLine('Got credentials');\n\n    await this.updateCachedCredentialAsync(terminal, credential);\n\n    terminal.writeLine('Updated credentials cache');\n  }\n\n  public async deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.deleteCacheEntry(this._credentialCacheId);\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  private get _credentialCacheId(): string {\n    if (!this.__credentialCacheId) {\n      const cacheIdParts: string[] = [this._url.href];\n\n      if (this._isCacheWriteAllowedByConfiguration) {\n        cacheIdParts.push('cacheWriteAllowed');\n      }\n\n      this.__credentialCacheId = cacheIdParts.join('|');\n    }\n\n    return this.__credentialCacheId;\n  }\n\n  private async _http(options: {\n    terminal: ITerminal;\n    relUrl: string;\n    method: string;\n    body: BodyInit | undefined;\n    warningText: string;\n    readBody: boolean;\n    credentialOptions?: CredentialsOptions;\n  }): Promise<Buffer | boolean> {\n    const { terminal, relUrl, method, body, warningText, readBody, credentialOptions } = options;\n    const safeCredentialOptions = credentialOptions ?? CredentialsOptions.Optional;\n    const credentials = await this._tryGetCredentials(safeCredentialOptions);\n    const url = new URL(relUrl, this._url).href;\n\n    const headers: Record<string, string> = {};\n    if (typeof credentials === 'string') {\n      headers.Authorization = credentials;\n    }\n\n    for (const [key, value] of Object.entries(this._headers)) {\n      if (typeof value === 'string') {\n        headers[key] = value;\n      }\n    }\n\n    const bodyLength = (body as { length: number })?.length || 'unknown';\n\n    terminal.writeDebugLine(`[http-build-cache] request: ${method} ${url} ${bodyLength} bytes`);\n\n    const response = await fetch(url, {\n      method: method,\n      headers: headers,\n      body: body,\n      redirect: 'follow'\n    });\n\n    if (!response.ok) {\n      if (typeof credentials !== 'string' && safeCredentialOptions === CredentialsOptions.Optional) {\n        // We tried fetching the resource without credentials and that did not work out\n        // Try again but require credentials this time\n        // This will trigger the provider to request credentials\n        return await this._http({ ...options, credentialOptions: CredentialsOptions.Required });\n      }\n\n      this._reportFailure(terminal, method, response, false, warningText);\n      return false;\n    }\n\n    const result: Buffer | boolean = readBody ? Buffer.from(await response.arrayBuffer()) : true;\n\n    terminal.writeDebugLine(\n      `[http-build-cache] actual response: ${response.status} ${url} ${\n        result === true ? 'true' : result.length\n      } bytes`\n    );\n\n    return result;\n  }\n\n  private async _tryGetCredentials(options: CredentialsOptions.Required): Promise<string>;\n  private async _tryGetCredentials(options: CredentialsOptions.Optional): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions.Omit): Promise<undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined> {\n    if (options === CredentialsOptions.Omit) {\n      return;\n    }\n\n    let credentials: string | undefined = this._environmentCredential;\n\n    if (credentials === undefined) {\n      credentials = await this._tryGetCredentialsFromCache();\n    }\n\n    if (typeof credentials !== 'string' && options === CredentialsOptions.Required) {\n      throw new Error(\n        [\n          `Credentials for ${this._url.href} have not been provided.`,\n          `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n          ``,\n          `For local developers, run:`,\n          ``,\n          `    rush update-cloud-credentials --interactive`,\n          ``\n        ].join('\\n')\n      );\n    }\n\n    return credentials;\n  }\n\n  private async _tryGetCredentialsFromCache(): Promise<string | undefined> {\n    let cacheEntry: ICredentialCacheEntry | undefined;\n\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: false\n      },\n      (credentialsCache: CredentialCache) => {\n        cacheEntry = credentialsCache.tryGetCacheEntry(this._credentialCacheId);\n      }\n    );\n\n    if (cacheEntry) {\n      const expirationTime: number | undefined = cacheEntry.expires?.getTime();\n      if (!expirationTime || expirationTime >= Date.now()) {\n        return cacheEntry.credential;\n      }\n    }\n  }\n\n  private _getFailureType(requestMethod: string, response: Response, isRedirect: boolean): FailureType {\n    if (response.ok) {\n      return FailureType.None;\n    }\n\n    switch (response.status) {\n      case 503: {\n        // We select 503 specifically because this represents \"service unavailable\" and\n        // \"rate limit throttle\" errors, which are transient issues.\n        //\n        // There are other 5xx errors, such as 501, that can occur if the request is\n        // malformed, so as a general rule we want to let through other 5xx errors\n        // so the user can troubleshoot.\n\n        // Don't fail production builds with warnings for transient issues\n        return FailureType.Informational;\n      }\n\n      case 401:\n      case 403:\n      case 407: {\n        if (requestMethod === 'GET' && (isRedirect || response.redirected)) {\n          // Cache misses for GET requests are not errors\n          // This is a workaround behavior where a server can issue a redirect and we fail to authenticate at the new location.\n          // We do not want to signal this as an authentication failure because the authorization header is not passed on to redirects.\n          // i.e The authentication header was accepted for the first request and therefore subsequent failures\n          // where it was not present should not be attributed to the header.\n          // This scenario usually comes up with services that redirect to pre-signed URLS that don't actually exist.\n          // Those services then usually treat the 404 as a 403 to prevent leaking information.\n          return FailureType.None;\n        }\n\n        return FailureType.Authentication;\n      }\n\n      case 404: {\n        if (requestMethod === 'GET') {\n          // Cache misses for GET requests are not errors\n          return FailureType.None;\n        }\n      }\n    }\n\n    // Let dev builds succeed, let Prod builds fail\n    return FailureType.Warning;\n  }\n\n  private _reportFailure(\n    terminal: ITerminal,\n    requestMethod: string,\n    response: Response,\n    isRedirect: boolean,\n    message: string\n  ): void {\n    switch (this._getFailureType(requestMethod, response, isRedirect)) {\n      default: {\n        terminal.writeErrorLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Warning: {\n        terminal.writeWarningLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Informational: {\n        terminal.writeLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.None: {\n        terminal.writeDebugLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Authentication: {\n        throw new Error(\n          [\n            `${this._url.href} responded with ${response.status}: ${response.statusText}.`,\n            `Credentials may be misconfigured or have expired.`,\n            `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n            ``,\n            `For local developers, run:`,\n            ``,\n            `    rush update-cloud-credentials --interactive`,\n            ``\n          ].join('\\n')\n        );\n      }\n    }\n  }\n}\n"]}
+{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgBK;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","names":["CredentialsOptions","FailureType","HttpBuildCacheProvider","constructor","options","rushSession","_pluginName","pluginName","_rushSession","_rushProjectRoot","rushProjectRoot","_environmentCredential","rush_sdk_1","buildCacheCredential","_isCacheWriteAllowedByConfiguration","isCacheWriteAllowed","_url","URL","url","endsWith","_uploadMethod","uploadMethod","_headers","headers","_tokenHandler","tokenHandler","_cacheKeyPrefix","cacheKeyPrefix","buildCacheWriteAllowed","tryGetCacheEntryBufferByIdAsync","terminal","cacheId","result","_http","relUrl","method","body","undefined","warningText","readBody","Buffer","isBuffer","e","writeWarningLine","trySetCacheEntryBufferAsync","objectBuffer","writeErrorLine","writeDebugLine","updateCachedCredentialAsync","credential","usingAsync","supportEditing","credentialsCache","setCacheEntry","_credentialCacheId","saveIfModifiedAsync","updateCachedCredentialInteractiveAsync","Error","href","cmd","exec","args","join","writeVerboseLine","node_core_library_1","spawnSync","stderr","error","stdout","trim","writeLine","deleteCachedCredentialsAsync","deleteCacheEntry","__credentialCacheId","cacheIdParts","push","credentialOptions","safeCredentialOptions","Optional","credentials","_tryGetCredentials","Authorization","key","value","Object","entries","bodyLength","length","response","redirect","ok","Required","_reportFailure","from","arrayBuffer","status","Omit","_tryGetCredentialsFromCache","cacheEntry","tryGetCacheEntry","expirationTime","expires","getTime","Date","now","_getFailureType","requestMethod","isRedirect","None","Informational","redirected","Authentication","Warning","message","statusText","exports"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.ts"],"sourcesContent":["import { ITerminal, Executable } from '@rushstack/node-core-library';\nimport {\n  ICloudBuildCacheProvider,\n  ICredentialCacheEntry,\n  CredentialCache,\n  RushSession,\n  EnvironmentConfiguration\n} from '@rushstack/rush-sdk';\nimport fetch, { BodyInit, Response } from 'node-fetch';\n\nenum CredentialsOptions {\n  Optional,\n  Required,\n  Omit\n}\n\nenum FailureType {\n  None,\n  Informational,\n  Warning,\n  Error,\n  Authentication\n}\n\nexport interface IHttpBuildCacheTokenHandler {\n  exec: string;\n  args?: string[];\n}\n\n/**\n * @public\n */\nexport interface IHttpBuildCacheProviderOptions {\n  url: string;\n  tokenHandler?: IHttpBuildCacheTokenHandler;\n  uploadMethod?: string;\n  headers?: Record<string, string>;\n  cacheKeyPrefix?: string;\n  isCacheWriteAllowed: boolean;\n  pluginName: string;\n  rushProjectRoot: string;\n}\n\nexport class HttpBuildCacheProvider implements ICloudBuildCacheProvider {\n  private readonly _pluginName: string;\n  private readonly _rushSession: RushSession;\n  private readonly _rushProjectRoot: string;\n  private readonly _environmentCredential: string | undefined;\n  private readonly _isCacheWriteAllowedByConfiguration: boolean;\n  private readonly _url: URL;\n  private readonly _uploadMethod: string;\n  private readonly _headers: Record<string, string>;\n  private readonly _cacheKeyPrefix: string;\n  private readonly _tokenHandler: IHttpBuildCacheTokenHandler | undefined;\n  private __credentialCacheId: string | undefined;\n\n  public get isCacheWriteAllowed(): boolean {\n    return EnvironmentConfiguration.buildCacheWriteAllowed ?? this._isCacheWriteAllowedByConfiguration;\n  }\n\n  public constructor(options: IHttpBuildCacheProviderOptions, rushSession: RushSession) {\n    this._pluginName = options.pluginName;\n    this._rushSession = rushSession;\n    this._rushProjectRoot = options.rushProjectRoot;\n\n    this._environmentCredential = EnvironmentConfiguration.buildCacheCredential;\n    this._isCacheWriteAllowedByConfiguration = options.isCacheWriteAllowed;\n    this._url = new URL(options.url.endsWith('/') ? options.url : options.url + '/');\n    this._uploadMethod = options.uploadMethod ?? 'PUT';\n    this._headers = options.headers ?? {};\n    this._tokenHandler = options.tokenHandler;\n    this._cacheKeyPrefix = options.cacheKeyPrefix ?? '';\n  }\n\n  public async tryGetCacheEntryBufferByIdAsync(\n    terminal: ITerminal,\n    cacheId: string\n  ): Promise<Buffer | undefined> {\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: 'GET',\n        body: undefined,\n        warningText: 'Could not get cache entry',\n        readBody: true\n      });\n\n      return Buffer.isBuffer(result) ? result : undefined;\n    } catch (e) {\n      terminal.writeWarningLine(`Error getting cache entry: ${e}`);\n      return undefined;\n    }\n  }\n\n  public async trySetCacheEntryBufferAsync(\n    terminal: ITerminal,\n    cacheId: string,\n    objectBuffer: Buffer\n  ): Promise<boolean> {\n    if (!this.isCacheWriteAllowed) {\n      terminal.writeErrorLine('Writing to cache is not allowed in the current configuration.');\n      return false;\n    }\n\n    terminal.writeDebugLine('Uploading object with cacheId: ', cacheId);\n\n    try {\n      const result = await this._http({\n        terminal: terminal,\n        relUrl: `${this._cacheKeyPrefix}${cacheId}`,\n        method: this._uploadMethod,\n        body: objectBuffer,\n        warningText: 'Could not write cache entry',\n        readBody: false\n      });\n\n      return result !== false;\n    } catch (e) {\n      terminal.writeWarningLine(`Error uploading cache entry: ${e}`);\n      return false;\n    }\n  }\n\n  public async updateCachedCredentialAsync(terminal: ITerminal, credential: string): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.setCacheEntry(this._credentialCacheId, {\n          credential: credential\n        });\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  public async updateCachedCredentialInteractiveAsync(terminal: ITerminal): Promise<void> {\n    if (!this._tokenHandler) {\n      throw new Error(\n        `The interactive cloud credentials flow is not configured.\\n` +\n          `Set the 'tokenHandler' setting in 'common/config/rush-plugins/${this._pluginName}.json' to a command that writes your credentials to standard output and exits with code 0 ` +\n          `or provide your credentials to rush using the --credential flag instead. Credentials must be the ` +\n          `'Authorization' header expected by ${this._url.href}`\n      );\n    }\n\n    const cmd: string = `${this._tokenHandler.exec} ${(this._tokenHandler.args || []).join(' ')}`;\n    terminal.writeVerboseLine(`Running '${cmd}' to get credentials`);\n    const result = Executable.spawnSync(this._tokenHandler.exec, this._tokenHandler.args || []);\n\n    terminal.writeErrorLine(result.stderr);\n\n    if (result.error) {\n      throw new Error(`Could not obtain credentials. The command '${cmd}' failed.`);\n    }\n\n    const credential = result.stdout.trim();\n    terminal.writeVerboseLine('Got credentials');\n\n    await this.updateCachedCredentialAsync(terminal, credential);\n\n    terminal.writeLine('Updated credentials cache');\n  }\n\n  public async deleteCachedCredentialsAsync(terminal: ITerminal): Promise<void> {\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: true\n      },\n      async (credentialsCache: CredentialCache) => {\n        credentialsCache.deleteCacheEntry(this._credentialCacheId);\n        await credentialsCache.saveIfModifiedAsync();\n      }\n    );\n  }\n\n  private get _credentialCacheId(): string {\n    if (!this.__credentialCacheId) {\n      const cacheIdParts: string[] = [this._url.href];\n\n      if (this._isCacheWriteAllowedByConfiguration) {\n        cacheIdParts.push('cacheWriteAllowed');\n      }\n\n      this.__credentialCacheId = cacheIdParts.join('|');\n    }\n\n    return this.__credentialCacheId;\n  }\n\n  private async _http(options: {\n    terminal: ITerminal;\n    relUrl: string;\n    method: string;\n    body: BodyInit | undefined;\n    warningText: string;\n    readBody: boolean;\n    credentialOptions?: CredentialsOptions;\n  }): Promise<Buffer | boolean> {\n    const { terminal, relUrl, method, body, warningText, readBody, credentialOptions } = options;\n    const safeCredentialOptions = credentialOptions ?? CredentialsOptions.Optional;\n    const credentials = await this._tryGetCredentials(safeCredentialOptions);\n    const url = new URL(relUrl, this._url).href;\n\n    const headers: Record<string, string> = {};\n    if (typeof credentials === 'string') {\n      headers.Authorization = credentials;\n    }\n\n    for (const [key, value] of Object.entries(this._headers)) {\n      if (typeof value === 'string') {\n        headers[key] = value;\n      }\n    }\n\n    const bodyLength = (body as { length: number })?.length || 'unknown';\n\n    terminal.writeDebugLine(`[http-build-cache] request: ${method} ${url} ${bodyLength} bytes`);\n\n    const response = await fetch(url, {\n      method: method,\n      headers: headers,\n      body: body,\n      redirect: 'follow'\n    });\n\n    if (!response.ok) {\n      if (typeof credentials !== 'string' && safeCredentialOptions === CredentialsOptions.Optional) {\n        // We tried fetching the resource without credentials and that did not work out\n        // Try again but require credentials this time\n        // This will trigger the provider to request credentials\n        return await this._http({ ...options, credentialOptions: CredentialsOptions.Required });\n      }\n\n      this._reportFailure(terminal, method, response, false, warningText);\n      return false;\n    }\n\n    const result: Buffer | boolean = readBody ? Buffer.from(await response.arrayBuffer()) : true;\n\n    terminal.writeDebugLine(\n      `[http-build-cache] actual response: ${response.status} ${url} ${\n        result === true ? 'true' : result.length\n      } bytes`\n    );\n\n    return result;\n  }\n\n  private async _tryGetCredentials(options: CredentialsOptions.Required): Promise<string>;\n  private async _tryGetCredentials(options: CredentialsOptions.Optional): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions.Omit): Promise<undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined>;\n  private async _tryGetCredentials(options: CredentialsOptions): Promise<string | undefined> {\n    if (options === CredentialsOptions.Omit) {\n      return;\n    }\n\n    let credentials: string | undefined = this._environmentCredential;\n\n    if (credentials === undefined) {\n      credentials = await this._tryGetCredentialsFromCache();\n    }\n\n    if (typeof credentials !== 'string' && options === CredentialsOptions.Required) {\n      throw new Error(\n        [\n          `Credentials for ${this._url.href} have not been provided.`,\n          `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n          ``,\n          `For local developers, run:`,\n          ``,\n          `    rush update-cloud-credentials --interactive`,\n          ``\n        ].join('\\n')\n      );\n    }\n\n    return credentials;\n  }\n\n  private async _tryGetCredentialsFromCache(): Promise<string | undefined> {\n    let cacheEntry: ICredentialCacheEntry | undefined;\n\n    await CredentialCache.usingAsync(\n      {\n        supportEditing: false\n      },\n      (credentialsCache: CredentialCache) => {\n        cacheEntry = credentialsCache.tryGetCacheEntry(this._credentialCacheId);\n      }\n    );\n\n    if (cacheEntry) {\n      const expirationTime: number | undefined = cacheEntry.expires?.getTime();\n      if (!expirationTime || expirationTime >= Date.now()) {\n        return cacheEntry.credential;\n      }\n    }\n  }\n\n  private _getFailureType(requestMethod: string, response: Response, isRedirect: boolean): FailureType {\n    if (response.ok) {\n      return FailureType.None;\n    }\n\n    switch (response.status) {\n      case 503: {\n        // We select 503 specifically because this represents \"service unavailable\" and\n        // \"rate limit throttle\" errors, which are transient issues.\n        //\n        // There are other 5xx errors, such as 501, that can occur if the request is\n        // malformed, so as a general rule we want to let through other 5xx errors\n        // so the user can troubleshoot.\n\n        // Don't fail production builds with warnings for transient issues\n        return FailureType.Informational;\n      }\n\n      case 401:\n      case 403:\n      case 407: {\n        if (requestMethod === 'GET' && (isRedirect || response.redirected)) {\n          // Cache misses for GET requests are not errors\n          // This is a workaround behavior where a server can issue a redirect and we fail to authenticate at the new location.\n          // We do not want to signal this as an authentication failure because the authorization header is not passed on to redirects.\n          // i.e The authentication header was accepted for the first request and therefore subsequent failures\n          // where it was not present should not be attributed to the header.\n          // This scenario usually comes up with services that redirect to pre-signed URLS that don't actually exist.\n          // Those services then usually treat the 404 as a 403 to prevent leaking information.\n          return FailureType.None;\n        }\n\n        return FailureType.Authentication;\n      }\n\n      case 404: {\n        if (requestMethod === 'GET') {\n          // Cache misses for GET requests are not errors\n          return FailureType.None;\n        }\n      }\n    }\n\n    // Let dev builds succeed, let Prod builds fail\n    return FailureType.Warning;\n  }\n\n  private _reportFailure(\n    terminal: ITerminal,\n    requestMethod: string,\n    response: Response,\n    isRedirect: boolean,\n    message: string\n  ): void {\n    switch (this._getFailureType(requestMethod, response, isRedirect)) {\n      default: {\n        terminal.writeErrorLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Warning: {\n        terminal.writeWarningLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Informational: {\n        terminal.writeLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.None: {\n        terminal.writeDebugLine(`${message}: HTTP ${response.status}: ${response.statusText}`);\n        break;\n      }\n\n      case FailureType.Authentication: {\n        throw new Error(\n          [\n            `${this._url.href} responded with ${response.status}: ${response.statusText}.`,\n            `Credentials may be misconfigured or have expired.`,\n            `In CI, verify that RUSH_BUILD_CACHE_CREDENTIAL contains a valid Authorization header value.`,\n            ``,\n            `For local developers, run:`,\n            ``,\n            `    rush update-cloud-credentials --interactive`,\n            ``\n          ].join('\\n')\n        );\n      }\n    }\n  }\n}\n"]}

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e6/RushHttpBuildCachePlugin_e69b4b7cd4f95aa49455690c88f00247

@@ -1,4 +1,4 @@
-b1c643a20f2b33a82c96b418af6f8ba6
+ba8171a7f5a89355e62f0cbaf3ee701a
 "use strict";
 
 /* istanbul ignore next */
@@ -359,4 +359,4 @@ class RushHttpBuildCachePlugin {
 /* istanbul ignore next */
 cov_ffzf8czsk().s[12]++;
 exports.RushHttpBuildCachePlugin = RushHttpBuildCachePlugin;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztJQTBETTtJQUFBQTtNQUFBO0lBQUE7RUFBQTtFQUFBO0FBQUE7QUFBQUE7QUFBQUE7Ozs7Ozs7QUExRE47QUFBQTtBQUFBO0FBSUEsTUFBTUMsNEJBQTRCO0FBQUE7QUFBQSx5QkFBOENDLDBCQUFNLENBQUNDLElBQUksQ0FDekYsMEJBQTBCLEVBQzFCQyxPQUFPLENBQ1I7QUFFRCxNQUFNQyxXQUFXO0FBQUE7QUFBQSx5QkFBVyxzQkFBc0I7QUF5Q2xEOzs7QUFHQSxNQUFhQyx3QkFBd0I7RUFBckNDO0lBQUE7SUFBQVA7SUFBQUE7SUFDa0IsZUFBVSxHQUFXSyxXQUFXO0VBK0JsRDtFQTdCU0csS0FBS0EsQ0FBQ0MsV0FBd0IsRUFBRUMsVUFBNkI7SUFBQTtJQUFBVjtJQUFBQTtJQUNsRVMsV0FBVyxDQUFDRSxLQUFLLENBQUNDLFVBQVUsQ0FBQ0MsR0FBRyxDQUFDLElBQUksQ0FBQ0MsVUFBVSxFQUFFLE1BQUs7TUFBQTtNQUFBZDtNQUFBQTtNQUNyRFMsV0FBVyxDQUFDTSxzQ0FBc0MsQ0FDaEQsTUFBTSxFQUNMQyxnQkFBZ0IsSUFBNEI7UUFBQTtRQUFBaEI7UUFDM0MsTUFBTWlCLE1BQU07UUFBQTtRQUFBLHlCQUNWRCxnQkFHRCxDQUFDRSxpQkFBaUI7UUFFbkIsTUFBTTtVQUFFQyxHQUFHO1VBQUVDLFlBQVk7VUFBRUMsT0FBTztVQUFFQyxZQUFZO1VBQUVDLGNBQWM7VUFBRUM7UUFBbUIsQ0FBRTtRQUFBO1FBQUEseUJBQUdQLE1BQU07UUFFaEcsTUFBTVEsT0FBTztRQUFBO1FBQUEsMEJBQW1DO1VBQzlDWCxVQUFVLEVBQUUsSUFBSSxDQUFDQSxVQUFVO1VBQzNCWSxlQUFlLEVBQUVoQixVQUFVLENBQUNpQixjQUFjO1VBQzFDUixHQUFHLEVBQUVBLEdBQUc7VUFDUkMsWUFBWSxFQUFFQSxZQUFZO1VBQzFCQyxPQUFPLEVBQUVBLE9BQU87VUFDaEJDLFlBQVksRUFBRUEsWUFBWTtVQUMxQkMsY0FBYyxFQUFFQSxjQUFjO1VBQzlCQyxtQkFBbUIsRUFBRSxDQUFDLENBQUNBO1NBQ3hCO1FBQUM7UUFBQXhCO1FBRUYsT0FBTyxJQUFJQyw0QkFBNEIsQ0FBQzJCLHNCQUFzQixDQUFDSCxPQUFPLEVBQUVoQixXQUFXLENBQUM7TUFDdEYsQ0FBQyxDQUNGO0lBQ0gsQ0FBQyxDQUFDO0VBQ0o7O0FBQ0Q7QUFBQVQ7QUFoQ0Q2QiIsIm5hbWVzIjpbImNvdl9mZnpmOGN6c2siLCJIdHRwQnVpbGRDYWNoZVByb3ZpZGVyTW9kdWxlIiwibm9kZV9jb3JlX2xpYnJhcnlfMSIsImxhenkiLCJyZXF1aXJlIiwiUExVR0lOX05BTUUiLCJSdXNoSHR0cEJ1aWxkQ2FjaGVQbHVnaW4iLCJjb25zdHJ1Y3RvciIsImFwcGx5IiwicnVzaFNlc3Npb24iLCJydXNoQ29uZmlnIiwiaG9va3MiLCJpbml0aWFsaXplIiwidGFwIiwicGx1Z2luTmFtZSIsInJlZ2lzdGVyQ2xvdWRCdWlsZENhY2hlUHJvdmlkZXJGYWN0b3J5IiwiYnVpbGRDYWNoZUNvbmZpZyIsImNvbmZpZyIsImh0dHBDb25maWd1cmF0aW9uIiwidXJsIiwidXBsb2FkTWV0aG9kIiwiaGVhZGVycyIsInRva2VuSGFuZGxlciIsImNhY2hlS2V5UHJlZml4IiwiaXNDYWNoZVdyaXRlQWxsb3dlZCIsIm9wdGlvbnMiLCJydXNoUHJvamVjdFJvb3QiLCJydXNoSnNvbkZvbGRlciIsIkh0dHBCdWlsZENhY2hlUHJvdmlkZXIiLCJleHBvcnRzIl0sInNvdXJjZXMiOlsiL2hvbWUvdnN0cy93b3JrLzEvcy9ydXNoLXBsdWdpbnMvcnVzaC1odHRwLWJ1aWxkLWNhY2hlLXBsdWdpbi9zcmMvUnVzaEh0dHBCdWlsZENhY2hlUGx1Z2luLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEltcG9ydCB9IGZyb20gJ0BydXNoc3RhY2svbm9kZS1jb3JlLWxpYnJhcnknO1xuaW1wb3J0IHR5cGUgeyBJUnVzaFBsdWdpbiwgUnVzaFNlc3Npb24sIFJ1c2hDb25maWd1cmF0aW9uIH0gZnJvbSAnQHJ1c2hzdGFjay9ydXNoLXNkayc7XG5pbXBvcnQgdHlwZSB7IEh0dHBCdWlsZENhY2hlUHJvdmlkZXIsIElIdHRwQnVpbGRDYWNoZVByb3ZpZGVyT3B0aW9ucyB9IGZyb20gJy4vSHR0cEJ1aWxkQ2FjaGVQcm92aWRlcic7XG5cbmNvbnN0IEh0dHBCdWlsZENhY2hlUHJvdmlkZXJNb2R1bGU6IHR5cGVvZiBpbXBvcnQoJy4vSHR0cEJ1aWxkQ2FjaGVQcm92aWRlcicpID0gSW1wb3J0LmxhenkoXG4gICcuL0h0dHBCdWlsZENhY2hlUHJvdmlkZXInLFxuICByZXF1aXJlXG4pO1xuXG5jb25zdCBQTFVHSU5fTkFNRTogc3RyaW5nID0gJ0h0dHBCdWlsZENhY2hlUGx1Z2luJztcblxuLyoqXG4gKiBAcHVibGljXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSVJ1c2hIdHRwQnVpbGRDYWNoZVBsdWdpbkNvbmZpZyB7XG4gIC8qKlxuICAgKiBUaGUgVVJMIG9mIHRoZSBzZXJ2ZXIgdGhhdCBzdG9yZXMgdGhlIGNhY2hlcyAoZS5nLiBcImh0dHBzOi8vYnVpbGQtY2FjaGVzLmV4YW1wbGUuY29tXCIpLlxuICAgKi9cbiAgdXJsOiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIFRoZSBIVFRQIG1ldGhvZCB0byB1c2Ugd2hlbiB3cml0aW5nIHRvIHRoZSBjYWNoZSAoZGVmYXVsdHMgdG8gUFVUKS5cbiAgICovXG4gIHVwbG9hZE1ldGhvZD86IHN0cmluZztcblxuICAvKipcbiAgICogQW4gb3B0aW9uYWwgc2V0IG9mIEhUVFAgaGVhZGVycyB0byBwYXNzIHRvIHRoZSBjYWNoZSBzZXJ2ZXIuXG4gICAqL1xuICBoZWFkZXJzPzogUmVjb3JkPHN0cmluZywgc3RyaW5nPjtcblxuICAvKipcbiAgICogQW4gb3B0aW9uYWwgY29tbWFuZCB0aGF0IHByaW50cyB0aGUgZW5kcG9pbnQncyBjcmVkZW50aWFscyB0byBzdGRvdXQuIFByb3ZpZGUgdGhlXG4gICAqIGNvbW1hbmQgb3Igc2NyaXB0IHRvIGV4ZWN1dGUgYW5kLCBvcHRpb25hbGx5LCBhbnkgYXJndW1lbnRzIHRvIHBhc3MgdG8gdGhlIHNjcmlwdC5cbiAgICovXG4gIHRva2VuSGFuZGxlcj86IHtcbiAgICBleGVjOiBzdHJpbmc7XG4gICAgYXJncz86IHN0cmluZ1tdO1xuICB9O1xuXG4gIC8qKlxuICAgKiBQcmVmaXggZm9yIGNhY2hlIGtleXMuXG4gICAqL1xuICBjYWNoZUtleVByZWZpeD86IHN0cmluZztcblxuICAvKipcbiAgICogSWYgc2V0IHRvIHRydWUsIGFsbG93IHdyaXRpbmcgdG8gdGhlIGNhY2hlLiBEZWZhdWx0cyB0byBmYWxzZS5cbiAgICovXG4gIGlzQ2FjaGVXcml0ZUFsbG93ZWQ/OiBib29sZWFuO1xufVxuXG4vKipcbiAqIEBwdWJsaWNcbiAqL1xuZXhwb3J0IGNsYXNzIFJ1c2hIdHRwQnVpbGRDYWNoZVBsdWdpbiBpbXBsZW1lbnRzIElSdXNoUGx1Z2luIHtcbiAgcHVibGljIHJlYWRvbmx5IHBsdWdpbk5hbWU6IHN0cmluZyA9IFBMVUdJTl9OQU1FO1xuXG4gIHB1YmxpYyBhcHBseShydXNoU2Vzc2lvbjogUnVzaFNlc3Npb24sIHJ1c2hDb25maWc6IFJ1c2hDb25maWd1cmF0aW9uKTogdm9pZCB7XG4gICAgcnVzaFNlc3Npb24uaG9va3MuaW5pdGlhbGl6ZS50YXAodGhpcy5wbHVnaW5OYW1lLCAoKSA9PiB7XG4gICAgICBydXNoU2Vzc2lvbi5yZWdpc3RlckNsb3VkQnVpbGRDYWNoZVByb3ZpZGVyRmFjdG9yeShcbiAgICAgICAgJ2h0dHAnLFxuICAgICAgICAoYnVpbGRDYWNoZUNvbmZpZyk6IEh0dHBCdWlsZENhY2hlUHJvdmlkZXIgPT4ge1xuICAgICAgICAgIGNvbnN0IGNvbmZpZzogSVJ1c2hIdHRwQnVpbGRDYWNoZVBsdWdpbkNvbmZpZyA9IChcbiAgICAgICAgICAgIGJ1aWxkQ2FjaGVDb25maWcgYXMgdHlwZW9mIGJ1aWxkQ2FjaGVDb25maWcgJiB7XG4gICAgICAgICAgICAgIGh0dHBDb25maWd1cmF0aW9uOiBJUnVzaEh0dHBCdWlsZENhY2hlUGx1Z2luQ29uZmlnO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICkuaHR0cENvbmZpZ3VyYXRpb247XG5cbiAgICAgICAgICBjb25zdCB7IHVybCwgdXBsb2FkTWV0aG9kLCBoZWFkZXJzLCB0b2tlbkhhbmRsZXIsIGNhY2hlS2V5UHJlZml4LCBpc0NhY2hlV3JpdGVBbGxvd2VkIH0gPSBjb25maWc7XG5cbiAgICAgICAgICBjb25zdCBvcHRpb25zOiBJSHR0cEJ1aWxkQ2FjaGVQcm92aWRlck9wdGlvbnMgPSB7XG4gICAgICAgICAgICBwbHVnaW5OYW1lOiB0aGlzLnBsdWdpbk5hbWUsXG4gICAgICAgICAgICBydXNoUHJvamVjdFJvb3Q6IHJ1c2hDb25maWcucnVzaEpzb25Gb2xkZXIsXG4gICAgICAgICAgICB1cmw6IHVybCxcbiAgICAgICAgICAgIHVwbG9hZE1ldGhvZDogdXBsb2FkTWV0aG9kLFxuICAgICAgICAgICAgaGVhZGVyczogaGVhZGVycyxcbiAgICAgICAgICAgIHRva2VuSGFuZGxlcjogdG9rZW5IYW5kbGVyLFxuICAgICAgICAgICAgY2FjaGVLZXlQcmVmaXg6IGNhY2hlS2V5UHJlZml4LFxuICAgICAgICAgICAgaXNDYWNoZVdyaXRlQWxsb3dlZDogISFpc0NhY2hlV3JpdGVBbGxvd2VkXG4gICAgICAgICAgfTtcblxuICAgICAgICAgIHJldHVybiBuZXcgSHR0cEJ1aWxkQ2FjaGVQcm92aWRlck1vZHVsZS5IdHRwQnVpbGRDYWNoZVByb3ZpZGVyKG9wdGlvbnMsIHJ1c2hTZXNzaW9uKTtcbiAgICAgICAgfVxuICAgICAgKTtcbiAgICB9KTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/.heft/build-cache/jest-cache/jest-transform-cache-bae913f9b9aa720eb4deeae0a60a4b27-474488b31a4a940a3990e9eaf06f1647/e6/RushHttpBuildCachePlugin_e69b4b7cd4f95aa49455690c88f00247.map

@@ -1 +1 @@
-{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0DM;IAAAA;MAAA;IAAA;EAAA;EAAA;AAAA;AAAAA;AAAAA;;;;;;;AA1DN;AAAA;AAAA;AAIA,MAAMC,4BAA4B;AAAA;AAAA,yBAA8CC,0BAAM,CAACC,IAAI,CACzF,0BAA0B,EAC1BC,OAAO,CACR;AAED,MAAMC,WAAW;AAAA;AAAA,yBAAW,sBAAsB;AAyClD;;;AAGA,MAAaC,wBAAwB;EAArCC;IAAA;IAAAP;IAAAA;IACkB,eAAU,GAAWK,WAAW;EA+BlD;EA7BSG,KAAKA,CAACC,WAAwB,EAAEC,UAA6B;IAAA;IAAAV;IAAAA;IAClES,WAAW,CAACE,KAAK,CAACC,UAAU,CAACC,GAAG,CAAC,IAAI,CAACC,UAAU,EAAE,MAAK;MAAA;MAAAd;MAAAA;MACrDS,WAAW,CAACM,sCAAsC,CAChD,MAAM,EACLC,gBAAgB,IAA4B;QAAA;QAAAhB;QAC3C,MAAMiB,MAAM;QAAA;QAAA,yBACVD,gBAGD,CAACE,iBAAiB;QAEnB,MAAM;UAAEC,GAAG;UAAEC,YAAY;UAAEC,OAAO;UAAEC,YAAY;UAAEC,cAAc;UAAEC;QAAmB,CAAE;QAAA;QAAA,yBAAGP,MAAM;QAEhG,MAAMQ,OAAO;QAAA;QAAA,0BAAmC;UAC9CX,UAAU,EAAE,IAAI,CAACA,UAAU;UAC3BY,eAAe,EAAEhB,UAAU,CAACiB,cAAc;UAC1CR,GAAG,EAAEA,GAAG;UACRC,YAAY,EAAEA,YAAY;UAC1BC,OAAO,EAAEA,OAAO;UAChBC,YAAY,EAAEA,YAAY;UAC1BC,cAAc,EAAEA,cAAc;UAC9BC,mBAAmB,EAAE,CAAC,CAACA;SACxB;QAAC;QAAAxB;QAEF,OAAO,IAAIC,4BAA4B,CAAC2B,sBAAsB,CAACH,OAAO,EAAEhB,WAAW,CAAC;MACtF,CAAC,CACF;IACH,CAAC,CAAC;EACJ;;AACD;AAAAT;AAhCD6B","names":["cov_ffzf8czsk","HttpBuildCacheProviderModule","node_core_library_1","lazy","require","PLUGIN_NAME","RushHttpBuildCachePlugin","constructor","apply","rushSession","rushConfig","hooks","initialize","tap","pluginName","registerCloudBuildCacheProviderFactory","buildCacheConfig","config","httpConfiguration","url","uploadMethod","headers","tokenHandler","cacheKeyPrefix","isCacheWriteAllowed","options","rushProjectRoot","rushJsonFolder","HttpBuildCacheProvider","exports"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/RushHttpBuildCachePlugin.ts"],"sourcesContent":["import { Import } from '@rushstack/node-core-library';\nimport type { IRushPlugin, RushSession, RushConfiguration } from '@rushstack/rush-sdk';\nimport type { HttpBuildCacheProvider, IHttpBuildCacheProviderOptions } from './HttpBuildCacheProvider';\n\nconst HttpBuildCacheProviderModule: typeof import('./HttpBuildCacheProvider') = Import.lazy(\n  './HttpBuildCacheProvider',\n  require\n);\n\nconst PLUGIN_NAME: string = 'HttpBuildCachePlugin';\n\n/**\n * @public\n */\nexport interface IRushHttpBuildCachePluginConfig {\n  /**\n   * The URL of the server that stores the caches (e.g. \"https://build-caches.example.com\").\n   */\n  url: string;\n\n  /**\n   * The HTTP method to use when writing to the cache (defaults to PUT).\n   */\n  uploadMethod?: string;\n\n  /**\n   * An optional set of HTTP headers to pass to the cache server.\n   */\n  headers?: Record<string, string>;\n\n  /**\n   * An optional command that prints the endpoint's credentials to stdout. Provide the\n   * command or script to execute and, optionally, any arguments to pass to the script.\n   */\n  tokenHandler?: {\n    exec: string;\n    args?: string[];\n  };\n\n  /**\n   * Prefix for cache keys.\n   */\n  cacheKeyPrefix?: string;\n\n  /**\n   * If set to true, allow writing to the cache. Defaults to false.\n   */\n  isCacheWriteAllowed?: boolean;\n}\n\n/**\n * @public\n */\nexport class RushHttpBuildCachePlugin implements IRushPlugin {\n  public readonly pluginName: string = PLUGIN_NAME;\n\n  public apply(rushSession: RushSession, rushConfig: RushConfiguration): void {\n    rushSession.hooks.initialize.tap(this.pluginName, () => {\n      rushSession.registerCloudBuildCacheProviderFactory(\n        'http',\n        (buildCacheConfig): HttpBuildCacheProvider => {\n          const config: IRushHttpBuildCachePluginConfig = (\n            buildCacheConfig as typeof buildCacheConfig & {\n              httpConfiguration: IRushHttpBuildCachePluginConfig;\n            }\n          ).httpConfiguration;\n\n          const { url, uploadMethod, headers, tokenHandler, cacheKeyPrefix, isCacheWriteAllowed } = config;\n\n          const options: IHttpBuildCacheProviderOptions = {\n            pluginName: this.pluginName,\n            rushProjectRoot: rushConfig.rushJsonFolder,\n            url: url,\n            uploadMethod: uploadMethod,\n            headers: headers,\n            tokenHandler: tokenHandler,\n            cacheKeyPrefix: cacheKeyPrefix,\n            isCacheWriteAllowed: !!isCacheWriteAllowed\n          };\n\n          return new HttpBuildCacheProviderModule.HttpBuildCacheProvider(options, rushSession);\n        }\n      );\n    });\n  }\n}\n"]}
+{"version":3,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0DM;IAAA;MAAA;IAAA;EAAA;EAAA;AAAA;AAAA;AAAA;;;;;;;AA1DN;AAAA;AAAA;AAIA,MAAMA,4BAA4B;AAAA;AAAA,yBAA8CC,0BAAM,CAACC,IAAI,CACzF,0BAA0B,EAC1BC,OAAO,CACR;AAED,MAAMC,WAAW;AAAA;AAAA,yBAAW,sBAAsB;AAyClD;;;AAGA,MAAaC,wBAAwB;EAArCC;IAAA;IAAA;IAAA;IACkB,eAAU,GAAWF,WAAW;EA+BlD;EA7BSG,KAAK,CAACC,WAAwB,EAAEC,UAA6B;IAAA;IAAA;IAAA;IAClED,WAAW,CAACE,KAAK,CAACC,UAAU,CAACC,GAAG,CAAC,IAAI,CAACC,UAAU,EAAE,MAAK;MAAA;MAAA;MAAA;MACrDL,WAAW,CAACM,sCAAsC,CAChD,MAAM,EACLC,gBAAgB,IAA4B;QAAA;QAAA;QAC3C,MAAMC,MAAM;QAAA;QAAA,yBACVD,gBAGD,CAACE,iBAAiB;QAEnB,MAAM;UAAEC,GAAG;UAAEC,YAAY;UAAEC,OAAO;UAAEC,YAAY;UAAEC,cAAc;UAAEC;QAAmB,CAAE;QAAA;QAAA,yBAAGP,MAAM;QAEhG,MAAMQ,OAAO;QAAA;QAAA,0BAAmC;UAC9CX,UAAU,EAAE,IAAI,CAACA,UAAU;UAC3BY,eAAe,EAAEhB,UAAU,CAACiB,cAAc;UAC1CR,GAAG,EAAEA,GAAG;UACRC,YAAY,EAAEA,YAAY;UAC1BC,OAAO,EAAEA,OAAO;UAChBC,YAAY,EAAEA,YAAY;UAC1BC,cAAc,EAAEA,cAAc;UAC9BC,mBAAmB,EAAE,CAAC,CAACA;SACxB;QAAC;QAAA;QAEF,OAAO,IAAIvB,4BAA4B,CAAC2B,sBAAsB,CAACH,OAAO,EAAEhB,WAAW,CAAC;MACtF,CAAC,CACF;IACH,CAAC,CAAC;EACJ;;AACD;AAAA;AAhCDoB","names":["HttpBuildCacheProviderModule","node_core_library_1","lazy","require","PLUGIN_NAME","RushHttpBuildCachePlugin","constructor","apply","rushSession","rushConfig","hooks","initialize","tap","pluginName","registerCloudBuildCacheProviderFactory","buildCacheConfig","config","httpConfiguration","url","uploadMethod","headers","tokenHandler","cacheKeyPrefix","isCacheWriteAllowed","options","rushProjectRoot","rushJsonFolder","HttpBuildCacheProvider","exports"],"sources":["/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/RushHttpBuildCachePlugin.ts"],"sourcesContent":["import { Import } from '@rushstack/node-core-library';\nimport type { IRushPlugin, RushSession, RushConfiguration } from '@rushstack/rush-sdk';\nimport type { HttpBuildCacheProvider, IHttpBuildCacheProviderOptions } from './HttpBuildCacheProvider';\n\nconst HttpBuildCacheProviderModule: typeof import('./HttpBuildCacheProvider') = Import.lazy(\n  './HttpBuildCacheProvider',\n  require\n);\n\nconst PLUGIN_NAME: string = 'HttpBuildCachePlugin';\n\n/**\n * @public\n */\nexport interface IRushHttpBuildCachePluginConfig {\n  /**\n   * The URL of the server that stores the caches (e.g. \"https://build-caches.example.com\").\n   */\n  url: string;\n\n  /**\n   * The HTTP method to use when writing to the cache (defaults to PUT).\n   */\n  uploadMethod?: string;\n\n  /**\n   * An optional set of HTTP headers to pass to the cache server.\n   */\n  headers?: Record<string, string>;\n\n  /**\n   * An optional command that prints the endpoint's credentials to stdout. Provide the\n   * command or script to execute and, optionally, any arguments to pass to the script.\n   */\n  tokenHandler?: {\n    exec: string;\n    args?: string[];\n  };\n\n  /**\n   * Prefix for cache keys.\n   */\n  cacheKeyPrefix?: string;\n\n  /**\n   * If set to true, allow writing to the cache. Defaults to false.\n   */\n  isCacheWriteAllowed?: boolean;\n}\n\n/**\n * @public\n */\nexport class RushHttpBuildCachePlugin implements IRushPlugin {\n  public readonly pluginName: string = PLUGIN_NAME;\n\n  public apply(rushSession: RushSession, rushConfig: RushConfiguration): void {\n    rushSession.hooks.initialize.tap(this.pluginName, () => {\n      rushSession.registerCloudBuildCacheProviderFactory(\n        'http',\n        (buildCacheConfig): HttpBuildCacheProvider => {\n          const config: IRushHttpBuildCachePluginConfig = (\n            buildCacheConfig as typeof buildCacheConfig & {\n              httpConfiguration: IRushHttpBuildCachePluginConfig;\n            }\n          ).httpConfiguration;\n\n          const { url, uploadMethod, headers, tokenHandler, cacheKeyPrefix, isCacheWriteAllowed } = config;\n\n          const options: IHttpBuildCacheProviderOptions = {\n            pluginName: this.pluginName,\n            rushProjectRoot: rushConfig.rushJsonFolder,\n            url: url,\n            uploadMethod: uploadMethod,\n            headers: headers,\n            tokenHandler: tokenHandler,\n            cacheKeyPrefix: cacheKeyPrefix,\n            isCacheWriteAllowed: !!isCacheWriteAllowed\n          };\n\n          return new HttpBuildCacheProviderModule.HttpBuildCacheProvider(options, rushSession);\n        }\n      );\n    });\n  }\n}\n"]}

package/.heft/build-cache/jest-cache/perf-cache-bae913f9b9aa720eb4deeae0a60a4b27-da39a3ee5e6b4b0d3255bfef95601890

@@ -1 +1 @@
-{"/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.test.ts":[1,1231]}
+{"/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.test.ts":[1,724]}

package/.rush/temp/operation/_phase_build/state.json

@@ -1,3 +1,3 @@
 {
-  "nonCachedDurationMs": 5631.620368999895
+  "nonCachedDurationMs": 7222.965680000023
 }

package/.rush/temp/operation/_phase_test/all.log

@@ -0,0 +1,29 @@
+This project does not define the caching behavior of the "_phase:test" command, so caching has been disabled.
+Invoking: heft test --no-build --production
+Using local Heft from /home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin/node_modules/@rushstack/heft
+
+Project build folder is "/home/vsts/work/1/s/rush-plugins/rush-http-build-cache-plugin"
+Using rig configuration from ./node_modules/@rushstack/heft-node-rig/profiles/default
+Starting test
+[jest] Using Jest version 29.5.0
+
+Run start. 1 test suite
+START src/HttpBuildCacheProvider.test.ts
+PASS src/HttpBuildCacheProvider.test.ts (duration: 0.724s, 1 passed, 0 failed)
+
+Tests finished:
+  Successes: 1
+  Failures: 0
+  Total: 1
+-----------------------------|---------|----------|---------|---------|---------------------------------------------------
+File                         | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s                                 
+-----------------------------|---------|----------|---------|---------|---------------------------------------------------
+All files                    |   42.74 |    39.02 |    40.9 |   42.74 |                                                   
+ HttpBuildCacheProvider.ts   |   47.45 |    39.02 |      50 |   47.45 | 58,89,101-174,184,209,213-214,237-249,258,297-380 
+ RushHttpBuildCachePlugin.ts |       0 |      100 |       0 |       0 | 1-81                                              
+ index.ts                    |       0 |      100 |     100 |       0 | 1-3                                               
+-----------------------------|---------|----------|---------|---------|---------------------------------------------------
+-------------------- Finished (1.873s) --------------------
+Project: @rushstack/rush-http-build-cache-plugin@5.97.1
+Heft version: 0.50.0
+Node version: v14.21.3

package/.rush/temp/operation/_phase_test/state.json

@@ -1,3 +1,3 @@
 {
-  "nonCachedDurationMs": 2220.253922999953
+  "nonCachedDurationMs": 1913.9834889998892
 }

package/.rush/temp/package-deps__phase_build.json

@@ -3,7 +3,7 @@
     "rush-plugins/rush-http-build-cache-plugin/README.md": "d8468855d6f34e6f4cc79b6a3f05d57e0b1aaf83",
     "rush-plugins/rush-http-build-cache-plugin/config/jest.config.json": "fa6760fad1e1c41d73a7b6e38783d941a7c969dd",
     "rush-plugins/rush-http-build-cache-plugin/config/rig.json": "f497ba3bb0a8bcb25471bfc11342bd9278d7c4c7",
-    "rush-plugins/rush-http-build-cache-plugin/package.json": "7d565a4576d1d28a67a84f8ab0bc69fd1482be7b",
+    "rush-plugins/rush-http-build-cache-plugin/package.json": "e08240f7c8e8d65a0a54cd1372b0b35f777e30c8",
     "rush-plugins/rush-http-build-cache-plugin/rush-plugin-manifest.json": "126dfa796b3ce186d8a6892e8bdd26da17d88a57",
     "rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.test.ts": "e5ec316a00a8bd8626fcfd0340e72a1704427be4",
     "rush-plugins/rush-http-build-cache-plugin/src/HttpBuildCacheProvider.ts": "cb77033abae83e2f2f4b6ea08e2c4672a3dee03c",
@@ -11,7 +11,7 @@
     "rush-plugins/rush-http-build-cache-plugin/src/index.ts": "17e67ac185927e9c650b3c3004cc00d9ad996bb5",
     "rush-plugins/rush-http-build-cache-plugin/src/schemas/plugin-config.schema.json": "abd50212fa286348eb3dc493c14f1794487756f4",
     "rush-plugins/rush-http-build-cache-plugin/tsconfig.json": "6798ece734411b68717f5951516928084866c250",
-    "rush-plugins/rush-http-build-cache-plugin/.rush/temp/shrinkwrap-deps.json": "6f519c2b521ae5936f071a5774e05d3d2e9fe4fa"
+    "rush-plugins/rush-http-build-cache-plugin/.rush/temp/shrinkwrap-deps.json": "3fddc062a66b13bc08832b2600412cfb97ebfcdd"
   },
   "arguments": "heft build --clean --production"
 }