@gitkraken/core-gitlens 0.7.1 → 0.8.0

package/dist/plus/integrations/models/gitHostIntegration.js

@@ -8,8 +8,9 @@ import __decorate from "../../../_virtual/@oxc-project+runtime/helpers/esm/decor
 import { gate } from "../../../utils/decorators/gate.js";
 import "../../../git/models/pullRequest.js";
 import { toError } from "../errors.js";
-import { throwIfCallerContractError, toCollectionFailureError, toCollectionScopeFailure } from "../collectionMetadata.js";
 import "../constants.js";
+import { isAzureProviderId } from "../providers/providerErrors.js";
+import { throwIfCallerContractError, toCollectionFailureError, toCollectionScopeFailure } from "../collectionMetadata.js";
 import { toTokenWithInfo } from "../authentication/models.js";
 import "../providerFilters.js";
 import { mergeCollectionMetadata, throwIfAllSettledFailed } from "../providers/utils/providerPaging.js";
@@ -26,10 +27,7 @@ import { IntegrationBase } from "./integration.js";
 * reads here are shared by every host, so they have to ask; every other provider keeps the SDK's default.
 */
 function sendsBasicCredential(providerId, session) {
-	return isAzureDevOpsProvider(providerId) ? session.type !== "oauth" : void 0;
-}
-function isAzureDevOpsProvider(providerId) {
-	return providerId === "azureDevOps" || providerId === "azure-devops-server";
+	return isAzureProviderId(providerId) ? session.type !== "oauth" : void 0;
 }
 /**
 * Rejects a read the provider can't serve as asked: logs the reason and returns it as the `{ error }` half of an
@@ -210,6 +208,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		try {
 			const result = await this.getProviderOrganizationsForUser?.(session);
+			await this.confirmScopedAuthFailures(session, result?.metadata);
 			const authFailure = result?.metadata?.failures?.find((failure) => failure.kind === "authentication" && failure.scope != null && failure.scope.providerId === this.id && Object.keys(failure.scope).length === 1);
 			if (authFailure != null) this.handleProviderException("getOrganizationsForUser", toCollectionFailureError(authFailure, toTokenWithInfo(this.id, session)), {
 				scope,
@@ -246,6 +245,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		try {
 			const result = await this.getProviderProjectsForOrg(session, org);
+			await this.confirmScopedAuthFailures(session, result?.metadata);
 			this.resetRequestExceptionCount("getProjectsForOrg");
 			return {
 				value: result,
@@ -280,6 +280,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		try {
 			const result = await this.getProviderRepositoriesForOrg?.(session, org, options);
+			await this.confirmScopedAuthFailures(session, result?.metadata);
 			this.resetRequestExceptionCount("getRepositoriesForOrg");
 			return {
 				value: result,
@@ -311,6 +312,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		try {
 			const result = await this.getProviderRepositoriesForUser(session, options);
+			await this.confirmScopedAuthFailures(session, result?.metadata);
 			this.resetRequestExceptionCount("getRepositoriesForUser");
 			return {
 				value: result,
@@ -452,9 +454,9 @@ var GitHostIntegration = class extends IntegrationBase {
 			};
 		}
 		const repoIdsInput = api.isRepoIdsInput(reposOrRepoIds);
-		if (providerId !== "gitlab" && (repoIdsInput || isAzureDevOpsProvider(providerId) && !reposOrRepoIds.every((repo) => repo.project != null && repo.namespace != null))) return unsupportedRead(`Unsupported input for provider ${providerId}`, start, "getIssuesForRepos");
+		if (providerId !== "gitlab" && (repoIdsInput || isAzureProviderId(providerId) && !reposOrRepoIds.every((repo) => repo.project != null && repo.namespace != null))) return unsupportedRead(`Unsupported input for provider ${providerId}`, start, "getIssuesForRepos");
 		let getIssuesOptions;
-		if (isAzureDevOpsProvider(providerId)) {
+		if (isAzureProviderId(providerId)) {
 			const organizations = /* @__PURE__ */ new Set();
 			const projects = /* @__PURE__ */ new Set();
 			for (const repo of reposOrRepoIds) {
@@ -546,6 +548,7 @@ var GitHostIntegration = class extends IntegrationBase {
 					}
 				}
 				if (options?.page != null) cursor.page = options.page;
+				await this.confirmScopedAuthFailures(session, metadata);
 				this.resetRequestExceptionCount("getIssuesForRepos");
 				return {
 					value: {
@@ -650,6 +653,7 @@ var GitHostIntegration = class extends IntegrationBase {
 					}
 				}
 				if (options?.page != null) cursor.page = options.page;
+				await this.confirmScopedAuthFailures(session, metadata);
 				this.resetRequestExceptionCount("getIssuesForRepos");
 				return {
 					value: {
@@ -699,6 +703,7 @@ var GitHostIntegration = class extends IntegrationBase {
 					duration: performance.now() - start
 				};
 			}
+			await this.confirmScopedAuthFailures(session, result.metadata);
 			this.resetRequestExceptionCount("getIssuesForRepos");
 			return {
 				value: result,
@@ -776,12 +781,12 @@ var GitHostIntegration = class extends IntegrationBase {
 				duration: performance.now() - start
 			};
 		}
-		if (providerId !== "gitlab" && (api.isRepoIdsInput(reposOrRepoIds) || isAzureDevOpsProvider(providerId) && !reposOrRepoIds.every((repo) => repo.project != null && repo.namespace != null))) return unsupportedRead(`Unsupported input for provider ${providerId}`, start);
+		if (providerId !== "gitlab" && (api.isRepoIdsInput(reposOrRepoIds) || isAzureProviderId(providerId) && !reposOrRepoIds.every((repo) => repo.project != null && repo.namespace != null))) return unsupportedRead(`Unsupported input for provider ${providerId}`, start);
 		let getPullRequestsOptions;
 		if (options?.filters != null) {
 			if (!api.providerSupportsPullRequestFilters(providerId, options.filters)) return unsupportedRead(`Unsupported filters for provider ${providerId}`, start, "getPullRequestsForRepos");
 			let userAccount;
-			if (isAzureDevOpsProvider(providerId)) {
+			if (isAzureProviderId(providerId)) {
 				const organizations = /* @__PURE__ */ new Set();
 				for (const repo of reposOrRepoIds) organizations.add(repo.namespace);
 				if (organizations.size > 1) {
@@ -875,7 +880,7 @@ var GitHostIntegration = class extends IntegrationBase {
 							page: repoInput.cursor == null ? options?.page : void 0,
 							pageSize: options?.pageSize,
 							states,
-							includeRemoteInfo: isAzureDevOpsProvider(providerId) ? true : void 0
+							includeRemoteInfo: isAzureProviderId(providerId) ? true : void 0
 						})
 					};
 				}));
@@ -906,6 +911,7 @@ var GitHostIntegration = class extends IntegrationBase {
 					failures
 				});
 				if (options?.page != null) cursor.page = options.page;
+				await this.confirmScopedAuthFailures(session, metadata);
 				this.resetRequestExceptionCount("getPullRequestsForRepos");
 				return {
 					value: {
@@ -940,9 +946,10 @@ var GitHostIntegration = class extends IntegrationBase {
 				page: options?.page,
 				pageSize: options?.pageSize,
 				states,
-				includeRemoteInfo: isAzureDevOpsProvider(providerId) ? true : void 0,
+				includeRemoteInfo: isAzureProviderId(providerId) ? true : void 0,
 				fields: options?.summary ? summaryPullRequestFields : void 0
 			});
+			await this.confirmScopedAuthFailures(session, result.metadata);
 			this.resetRequestExceptionCount("getPullRequestsForRepos");
 			return {
 				value: result,
@@ -1000,6 +1007,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		try {
 			const result = await this.getProviderMyPullRequestsForUser(session, options);
+			await this.confirmScopedAuthFailures(session, result?.metadata);
 			this.resetRequestExceptionCount("getMyPullRequestsForUser");
 			return {
 				value: result,
@@ -1042,6 +1050,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		try {
 			const result = await this.searchProviderPullRequestsPage?.(session, options, cancellation);
+			await this.confirmScopedAuthFailures(session, result?.metadata);
 			this.resetRequestExceptionCount("searchPullRequestsPage");
 			return {
 				value: result,
@@ -1141,8 +1150,10 @@ var GitHostIntegration = class extends IntegrationBase {
 		}
 	}
 	/**
-	* Result-returning wrapper for the BATCH issue read: resolves several `(owner, repo, number)` coordinates in
-	* one request. Recovers thrown errors into `{ error }` like the reads around it.
+	* Result-returning wrapper for the BATCH issue read: resolves several `(owner, repo, number)` coordinates, plus
+	* `project` on Azure DevOps, in ONE call to {@link getProviderIssuesBatch}. One settled slot per input
+	* coordinate: `fulfilled` with `undefined` means the issue does not exist or is not visible to this token;
+	* `rejected` means that target could not be checked, never that it is absent.
 	*
 	* Distinct from every search on this class, and deliberately so. A search answers "what matches"; this answers
 	* "does this exact issue exist", which is the question a caller correlating a branch name to an issue is
@@ -1151,26 +1162,139 @@ var GitHostIntegration = class extends IntegrationBase {
 	* miss instead of re-walking for it forever.
 	*
 	* Results come back POSITIONALLY — one per input coordinate, in order — for the same reason
-	* {@link countIssuesResult} does: a caller's key must never reach the provider query. `undefined` in a slot
-	* means the issue does not exist or is not visible to this token, never that the read failed.
+	* {@link countIssuesResult} does: a caller's key must never reach the provider query.
+	*
+	* Failure isolation happens PER TARGET, mirroring {@link getPullRequestsBatchResult}: the whole call counts
+	* as a failure against the integration's request-exception budget only when EVERY slot rejected, and not even
+	* then when a credential that checks out was refused by each target's own scope (`settleBatchRefusals`).
+	* Server errors and timeouts on the targets show one notice however many hit one, and cost a strike only as
+	* part of that whole-call failure (`reportDeferredRequestFailures`), so a call never spends more than one.
 	*/
 	async getIssuesBatchResult(coordinates, cancellation, connectionId) {
 		const scope = getScopedLogger();
 		const session = await this.resolveReadSession(connectionId, scope);
 		if (session == null) return void 0;
 		const start = performance.now();
+		let slots;
 		try {
-			const issues = await this.getProviderIssuesBatch?.(session, coordinates, cancellation);
+			slots = await this.getProviderIssuesBatch?.(session, coordinates, cancellation);
+			if (slots == null) {
+				this.resetRequestExceptionCount("getIssuesBatch");
+				return {
+					value: void 0,
+					duration: performance.now() - start
+				};
+			}
+			const settled = await this.settleBatchRefusals(session, coordinates, slots);
 			this.resetRequestExceptionCount("getIssuesBatch");
+			this.reportDeferredRequestFailures(slots, false);
+			return {
+				value: settled,
+				duration: performance.now() - start
+			};
+		} catch (ex) {
+			const struck = this.handleProviderException("getIssuesBatch", ex, {
+				scope,
+				connectionId
+			});
+			this.reportDeferredRequestFailures(slots, !struck);
+			return {
+				error: toError(ex),
+				duration: performance.now() - start
+			};
+		}
+	}
+	/**
+	* Result-returning wrapper for the BATCH pull request read: resolves several coordinates, in any state, BY
+	* IDENTITY, in ONE call to {@link getProviderPullRequestsBatch}. One settled slot per input coordinate:
+	* `fulfilled` with `undefined` means the pull request does not exist or is not visible to this token;
+	* `rejected` means that target could not be checked, never that it is absent.
+	*
+	* Failure isolation happens PER TARGET, not per call: a hook that reads one pull request per request (every
+	* host but GitHub/GHE) fans its coordinates out itself and settles each independently, so one bad target
+	* rejects only its own slot. Mirrors {@link getMyPullRequestsForReposResult}'s per-repo fan-out — the whole
+	* call counts as a failure against the integration's request-exception budget only when EVERY slot rejected,
+	* and not even then when a credential that checks out was refused by each target's own scope
+	* (`settleBatchRefusals`). Server errors and timeouts on the targets show one notice however many hit one, and
+	* cost a strike only as part of that whole-call failure (`reportDeferredRequestFailures`).
+	*/
+	async getPullRequestsBatchResult(coordinates, options, cancellation, connectionId) {
+		const scope = getScopedLogger();
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null) return void 0;
+		const start = performance.now();
+		let slots;
+		try {
+			slots = await this.getProviderPullRequestsBatch?.(session, coordinates, options, cancellation);
+			if (slots == null) {
+				this.resetRequestExceptionCount("getPullRequestsBatch");
+				return {
+					value: void 0,
+					duration: performance.now() - start
+				};
+			}
+			const settled = await this.settleBatchRefusals(session, coordinates, slots);
+			this.resetRequestExceptionCount("getPullRequestsBatch");
+			this.reportDeferredRequestFailures(slots, false);
+			return {
+				value: settled,
+				duration: performance.now() - start
+			};
+		} catch (ex) {
+			const struck = this.handleProviderException("getPullRequestsBatch", ex, {
+				scope,
+				connectionId
+			});
+			this.reportDeferredRequestFailures(slots, !struck);
+			return {
+				error: toError(ex),
+				duration: performance.now() - start
+			};
+		}
+	}
+	/**
+	* Result-returning wrapper for the pull-requests-by-branch read: for each target, every pull request whose head
+	* is that branch, in any state, in ONE call to {@link getProviderPullRequestsForBranches}. One settled slot
+	* per target: `fulfilled` with an empty list means the host answered and nothing matched; `rejected` means
+	* that target could not be checked, never that it has no pull requests.
+	*
+	* Uncached, and deliberately not built on {@link getPullRequestForBranch}: that read caches through
+	* `IntegrationCacheProvider.getPullRequestForBranch`, answers one pull request, and on several hosts looks the
+	* branch ref up, which answers "none" once a merged pull request's branch is deleted.
+	*
+	* Failure isolation is per target, as in {@link getPullRequestsBatchResult}: the whole call counts against the
+	* request-exception budget only when EVERY slot rejected, and not when each target's own scope refused a
+	* credential that checks out. Server errors and timeouts on the targets show one notice however many hit one, and
+	* cost a strike only as part of that whole-call failure.
+	*/
+	async getPullRequestsForBranchesResult(targets, options, cancellation, connectionId) {
+		const scope = getScopedLogger();
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null) return void 0;
+		const start = performance.now();
+		let slots;
+		try {
+			slots = await this.getProviderPullRequestsForBranches?.(session, targets, options, cancellation);
+			if (slots == null) {
+				this.resetRequestExceptionCount("getPullRequestsForBranches");
+				return {
+					value: void 0,
+					duration: performance.now() - start
+				};
+			}
+			const settled = await this.settleBatchRefusals(session, targets, slots);
+			this.resetRequestExceptionCount("getPullRequestsForBranches");
+			this.reportDeferredRequestFailures(slots, false);
 			return {
-				value: issues,
+				value: settled,
 				duration: performance.now() - start
 			};
 		} catch (ex) {
-			this.handleProviderException("getIssuesBatch", ex, {
+			const struck = this.handleProviderException("getPullRequestsForBranches", ex, {
 				scope,
 				connectionId
 			});
+			this.reportDeferredRequestFailures(slots, !struck);
 			return {
 				error: toError(ex),
 				duration: performance.now() - start