@gitkraken/core-gitlens 0.7.1 → 0.8.0

package/dist/plus/git-github/api/github.js

@@ -7,7 +7,7 @@ import { trace } from "../../../utils/decorators/log.js";
 import { parseUri } from "../../../utils/uri.js";
 import { createRevisionRange, getRevisionRangeParts, isRevisionRange, isSha, isUncommitted } from "../../../git/utils/revision.utils.js";
 import __decorate from "../../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
-import { AuthenticationError, RequestClientError, RequestNotFoundError, RequestRateLimitError } from "../../../git/errors.js";
+import { AuthenticationError, RequestClientError, RequestNotFoundError, RequestRateLimitError, reportRequestFailure } from "../../../git/errors.js";
 import { Emitter } from "../../../utils/event.js";
 import { fromString, satisfies } from "../../../utils/version.js";
 import { maybeStopWatch } from "../../../utils/stopwatch.js";
@@ -302,6 +302,21 @@ repository {
 	url
 }
 `;
+/**
+* What an alias's own errors say about its slot in an {@link AliasedGraphqlResult}: `'absent'` only when its node
+* is null and every error on it is NOT_FOUND; a rejection when a node arrived with an error, or on any other error
+* (even a NOT_FOUND nested under the node), since neither is trustworthy; `undefined` when the alias has no errors.
+*/
+function getAliasErrorVerdict(errors, alias, node) {
+	const aliasErrors = errors.filter((e) => e.path?.[0] === alias);
+	if (aliasErrors.length === 0) return void 0;
+	if (node == null && aliasErrors.every((e) => e.type === "NOT_FOUND")) return "absent";
+	const primary = aliasErrors.find((e) => e.type !== "NOT_FOUND") ?? aliasErrors[0];
+	return {
+		status: "rejected",
+		reason: new Error(primary.message)
+	};
+}
 var GitHubApi = class {
 	config;
 	_onDidReauthenticate = new Emitter();
@@ -1728,7 +1743,7 @@ var GitHubApi = class {
 		let dedupeKey;
 		if (dedupable) {
 			try {
-				dedupeKey = `${token.microHash}|${provider?.id ?? ""}|${query}|${JSON.stringify(variables ?? null)}`;
+				dedupeKey = `${token.microHash}|${provider?.id ?? ""}|${allowPartialNotFound ?? ""}|${query}|${JSON.stringify(variables ?? null)}`;
 			} catch {
 				dedupeKey = void 0;
 			}
@@ -1750,10 +1765,19 @@ var GitHubApi = class {
 					};
 				}
 				const retryable = graphqlReadQueryRegex.test(query);
-				return await this.requestWithRetries(() => this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () => this.getDefaults(accessToken, graphql)(query, variables)), retryable, cancellation, scope);
+				const data = await this.requestWithRetries(() => this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () => this.getDefaults(accessToken, graphql)(query, variables)), retryable, cancellation, scope);
+				return allowPartialNotFound === "aliased" ? {
+					data,
+					errors: []
+				} : data;
 			} catch (ex) {
 				if (ex instanceof GraphqlResponseError) {
-					if (allowPartialNotFound && ex.data != null && (ex.errors?.every((e) => e.type === "NOT_FOUND") ?? false)) return ex.data;
+					if (allowPartialNotFound === "aliased" && ex.data != null && ex.errors != null && ex.errors.length > 0) {
+						if (ex.errors.every((e) => e.path != null && e.path.length > 0 && e.path[0] in ex.data)) return {
+							data: ex.data,
+							errors: ex.errors
+						};
+					}
 					switch (ex.errors?.[0]?.type) {
 						case "NOT_FOUND": throw new RequestNotFoundError(ex);
 						case "FORBIDDEN": throw new AuthenticationError(tokenInfo, 3, ex);
@@ -1768,7 +1792,7 @@ var GitHubApi = class {
 						}
 					}
 					if (_logger.isDebugging) this.config.onDebugError?.(`GitHub request failed: ${ex.errors?.[0]?.message ?? ex.message}`);
-				} else if (ex instanceof RequestError || ex.name === "AbortError") this.handleRequestError(provider, token, ex, scope);
+				} else if (ex instanceof RequestError || ex.name === "AbortError") this.handleRequestError(provider, token, ex, scope, allowPartialNotFound === "aliased");
 				else if (_logger.isDebugging) this.config.onDebugError?.(`GitHub request failed: ${ex.message}`);
 				throw ex;
 			}
@@ -1812,7 +1836,7 @@ var GitHubApi = class {
 			const retryable = method === "GET" || method === "HEAD";
 			return await this.requestWithRetries(() => this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () => this.getDefaults(accessToken, request)(route, options)), retryable, signal, scope);
 		} catch (ex) {
-			if (ex instanceof RequestError || ex.name === "AbortError") this.handleRequestError(provider, token, ex, scope);
+			if (ex instanceof RequestError || ex.name === "AbortError") this.handleRequestError(provider, token, ex, scope, void 0);
 			else if (_logger.isDebugging) this.config.onDebugError?.(`GitHub request failed: ${ex.message}`);
 			throw ex;
 		}
@@ -1856,7 +1880,7 @@ var GitHubApi = class {
 		}
 		return defaults;
 	}
-	handleRequestError(provider, token, ex, scope) {
+	handleRequestError(provider, token, ex, scope, deferFailure) {
 		if (ex.name === "AbortError") throw new CancellationError(ex);
 		const { accessToken, ...tokenInfo } = token;
 		switch (ex.status) {
@@ -1870,23 +1894,18 @@ var GitHubApi = class {
 				throw new AuthenticationError(tokenInfo, 3, ex);
 			case 500:
 				scope?.error(ex);
-				if (ex.response != null) {
-					provider?.trackRequestException();
-					this.config.onRequestError?.(provider, provider == null || provider.id === "github" ? l10n.t("{0} failed to respond and might be experiencing issues. Please visit the [GitHub status page](https://githubstatus.com) for more information.", provider?.name ?? "GitHub") : l10n.t("{0} failed to respond and might be experiencing issues.", provider.name));
-				}
+				if (ex.response != null) reportRequestFailure(provider, ex, () => this.config.onRequestError?.(provider, provider == null || provider.id === "github" ? l10n.t("{0} failed to respond and might be experiencing issues. Please visit the [GitHub status page](https://githubstatus.com) for more information.", provider?.name ?? "GitHub") : l10n.t("{0} failed to respond and might be experiencing issues.", provider.name)), deferFailure);
 				return;
 			case 502:
 				scope?.error(ex);
 				if (ex.message.includes("timeout")) {
-					provider?.trackRequestException();
-					this.config.onRequestError?.(provider, `${provider?.name ?? "GitHub"} request timed out`);
+					reportRequestFailure(provider, ex, () => this.config.onRequestError?.(provider, `${provider?.name ?? "GitHub"} request timed out`), deferFailure);
 					return;
 				}
 				break;
 			case 503:
 				scope?.error(ex);
-				provider?.trackRequestException();
-				this.config.onRequestError?.(provider, provider == null || provider.id === "github" ? l10n.t("{0} failed to respond and might be experiencing issues. Please visit the [GitHub status page](https://githubstatus.com) for more information.", provider?.name ?? "GitHub") : l10n.t("{0} failed to respond and might be experiencing issues.", provider.name));
+				reportRequestFailure(provider, ex, () => this.config.onRequestError?.(provider, provider == null || provider.id === "github" ? l10n.t("{0} failed to respond and might be experiencing issues. Please visit the [GitHub status page](https://githubstatus.com) for more information.", provider?.name ?? "GitHub") : l10n.t("{0} failed to respond and might be experiencing issues.", provider.name)), deferFailure);
 				return;
 			default: if (ex.status >= 400 && ex.status < 500) throw new RequestClientError(ex);
 		}
@@ -2206,8 +2225,10 @@ var GitHubApi = class {
 	*
 	* Returns POSITIONALLY — one slot per input coordinate, in order — for the same reason {@link countIssues}
 	* does: a caller's key is arbitrary text and would break the GraphQL document, so the aliases are generated
-	* and the caller maps back by index. `undefined` in a slot means the issue does not exist (or is not visible
-	* to this token), never that the read failed; a failure throws.
+	* and the caller maps back by index. A `fulfilled` slot with `undefined` means the issue does not exist (or
+	* is not visible to this token) — a PROVEN ABSENCE. A `rejected` slot means only THAT target failed — e.g. an
+	* org enforcing SAML SSO the token isn't authorized for — which is not proof the issue is gone, so it must
+	* not be cached as absent. A whole-request failure (bad credentials, rate limit, no data at all) still throws.
 	*/
 	async getIssuesBatch(provider, token, coordinates, options, cancellation) {
 		const scope = getScopedLogger();
@@ -2232,16 +2253,200 @@ var GitHubApi = class {
 			variables[`k${i}`] = c.number;
 		});
 		try {
-			const rsp = await this.graphql(provider, token, query, variables, scope, cancellation, true);
-			if (rsp == null) return coordinates.map(() => void 0);
+			const rsp = await this.graphql(provider, token, query, variables, scope, cancellation, "aliased");
+			if (rsp?.data == null) throw new Error("GitHub returned no data for the issue batch");
 			return coordinates.map((c, i) => {
-				const node = rsp[`i${i}`]?.issue;
-				if (node == null) return void 0;
+				const alias = `i${i}`;
+				const node = rsp.data[alias]?.issue;
+				const verdict = getAliasErrorVerdict(rsp.errors, alias, node);
+				if (verdict === "absent") return {
+					status: "fulfilled",
+					value: void 0
+				};
+				if (verdict != null) return verdict;
+				if (node == null) return {
+					status: "fulfilled",
+					value: void 0
+				};
 				try {
-					return fromGitHubIssue(node, provider);
+					return {
+						status: "fulfilled",
+						value: fromGitHubIssue(node, provider)
+					};
 				} catch (ex) {
-					scope?.warn(`skipped unmappable issue; ${c.owner}/${c.repo}#${c.number}, ex=${ex}`);
-					return;
+					scope?.warn(`failed to map issue; ${c.owner}/${c.repo}#${c.number}, ex=${ex}`);
+					return {
+						status: "rejected",
+						reason: ex
+					};
+				}
+			});
+		} catch (ex) {
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+	/**
+	* Resolves several pull requests, in any state (open/closed/merged), BY COORDINATE — `(owner, repo, number)`
+	* — in one request, via aliased `repository` fields rather than aliased searches. The pull-request twin of
+	* {@link getIssuesBatch}; see that method for why aliasing the point read (exact number, no result ceiling,
+	* a proven absence) is the design.
+	*
+	* Selects the FULL {@link gqlPullRequestFragment} — not the lite shape {@link getPullRequest} uses — so a
+	* row from this read carries the same fields (reviews, review requests, checks, diff stats, assignees,
+	* mergeable state) as {@link searchMyPullRequestsPage}'s account-wide rows.
+	*
+	* Returns POSITIONALLY — one slot per input coordinate, in order — for the same reason {@link getIssuesBatch}
+	* does: a caller's key is arbitrary text and would break the GraphQL document, so the aliases are generated
+	* and the caller maps back by index. A `fulfilled` slot with `undefined` means the pull request (or its
+	* repository) does not exist or is not visible to this token — a PROVEN ABSENCE. A `rejected` slot means only
+	* THAT target failed — e.g. an org enforcing SAML SSO the token isn't authorized for — which is not proof the
+	* pull request is gone, so it must not be cached as absent. A whole-request failure still throws.
+	*/
+	async getPullRequestsBatch(provider, token, coordinates, options, cancellation) {
+		const scope = getScopedLogger();
+		if (coordinates.length === 0) return [];
+		const query = `query getPullRequestsBatch(
+				${coordinates.map((_, i) => `$o${i}: String!\n\t\t\t\t$n${i}: String!\n\t\t\t\t$k${i}: Int!`).join("\n				")}
+				$avatarSize: Int
+			) {
+				${coordinates.map((_, i) => `p${i}: repository(owner: $o${i}, name: $n${i}) {
+					pullRequest(number: $k${i}) {
+						${gqlPullRequestFragment}
+						${gqlPullRequestStackFragmentFor(options)}
+					}
+				}`).join("\n				")}
+			}`;
+		const variables = {
+			baseUrl: options?.baseUrl,
+			avatarSize: options?.avatarSize
+		};
+		coordinates.forEach((c, i) => {
+			variables[`o${i}`] = c.owner;
+			variables[`n${i}`] = c.repo;
+			variables[`k${i}`] = c.number;
+		});
+		try {
+			const rsp = await this.graphql(provider, token, query, variables, scope, cancellation, "aliased");
+			if (rsp?.data == null) throw new Error("GitHub returned no data for the pull request batch");
+			return coordinates.map((c, i) => {
+				const alias = `p${i}`;
+				const node = rsp.data[alias]?.pullRequest;
+				const verdict = getAliasErrorVerdict(rsp.errors, alias, node);
+				if (verdict === "absent") return {
+					status: "fulfilled",
+					value: void 0
+				};
+				if (verdict != null) return verdict;
+				if (node == null) return {
+					status: "fulfilled",
+					value: void 0
+				};
+				try {
+					return {
+						status: "fulfilled",
+						value: fromGitHubPullRequest(node, provider)
+					};
+				} catch (ex) {
+					scope?.warn(`failed to map pull request; ${c.owner}/${c.repo}#${c.number}, ex=${ex}`);
+					return {
+						status: "rejected",
+						reason: ex
+					};
+				}
+			});
+		} catch (ex) {
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+	/**
+	* Finds, for several branches in one request, every pull request whose head is that branch — in any state,
+	* most recently updated first, up to `limit` per branch. Each target names the BASE repository the pull
+	* requests are opened against, the head branch's short name and, for a branch that lives in a fork,
+	* `headOwner`, the fork's owner.
+	*
+	* Keyed on the head ref NAME (`repository.pullRequests(headRefName:)`) rather than on the ref itself
+	* (`repository.ref(qualifiedName:).associatedPullRequests`, which {@link getPullRequestForBranch} uses): a
+	* merged pull request's branch is usually deleted afterwards, and the ref lookup then answers "none" for a
+	* pull request that exists.
+	*
+	* `headRefName` matches every fork's branch of that name too, so rows are kept only when their head
+	* repository is the base repository itself (`headOwner` omitted) or a fork owned by `headOwner` — otherwise
+	* a `main` in the base repository would claim every fork's `main`. That filter runs after the server's
+	* `limit`, so `truncated` is set whenever the server matched more rows than it returned, since any of the
+	* unfetched ones might have passed it.
+	*
+	* Returns POSITIONALLY, with the same per-alias rules as {@link getPullRequestsBatch}: a missing base
+	* repository (NOT_FOUND on a null repository) is a PROVEN "none" — an empty list — while any other error on
+	* a target's alias rejects only that target, and a whole-request failure still throws.
+	*/
+	async getPullRequestsForBranches(provider, token, targets, options, cancellation) {
+		const scope = getScopedLogger();
+		if (targets.length === 0) return [];
+		const query = `query getPullRequestsForBranches(
+				${targets.map((_, i) => `$o${i}: String!\n\t\t\t\t$n${i}: String!\n\t\t\t\t$h${i}: String!`).join("\n				")}
+				$limit: Int!
+				$avatarSize: Int
+			) {
+				${targets.map((_, i) => `b${i}: repository(owner: $o${i}, name: $n${i}) {
+					pullRequests(headRefName: $h${i}, states: [OPEN, CLOSED, MERGED], first: $limit, orderBy: {field: UPDATED_AT, direction: DESC}) {
+						totalCount
+						nodes {
+							${gqlPullRequestFragment}
+							${gqlPullRequestStackFragmentFor(options)}
+							headRepositoryOwner {
+								login
+							}
+						}
+					}
+				}`).join("\n				")}
+			}`;
+		const variables = {
+			baseUrl: options.baseUrl,
+			avatarSize: options.avatarSize,
+			limit: options.limit
+		};
+		targets.forEach((t, i) => {
+			variables[`o${i}`] = t.owner;
+			variables[`n${i}`] = t.repo;
+			variables[`h${i}`] = t.branch;
+		});
+		try {
+			const rsp = await this.graphql(provider, token, query, variables, scope, cancellation, "aliased");
+			if (rsp?.data == null) throw new Error("GitHub returned no data for the pull requests by branch");
+			return targets.map((t, i) => {
+				const alias = `b${i}`;
+				const repository = rsp.data[alias];
+				const verdict = getAliasErrorVerdict(rsp.errors, alias, repository);
+				if (verdict != null && verdict !== "absent") return verdict;
+				if (repository == null) return {
+					status: "fulfilled",
+					value: {
+						pullRequests: [],
+						truncated: false
+					}
+				};
+				const connection = repository.pullRequests;
+				if (connection == null) return {
+					status: "rejected",
+					reason: /* @__PURE__ */ new Error(`GitHub returned no pull requests for ${t.owner}/${t.repo}:${t.branch}`)
+				};
+				const headOwner = t.headOwner?.toLowerCase();
+				const nodes = connection.nodes.filter((pr) => pr != null);
+				const matches = nodes.filter((pr) => pr.headRefName === t.branch && (headOwner == null ? !pr.isCrossRepository : pr.isCrossRepository && pr.headRepositoryOwner?.login.toLowerCase() === headOwner));
+				try {
+					return {
+						status: "fulfilled",
+						value: {
+							pullRequests: matches.map((pr) => fromGitHubPullRequest(pr, provider)).sort((a, b) => b.updatedDate.getTime() - a.updatedDate.getTime()),
+							truncated: connection.totalCount > nodes.length
+						}
+					};
+				} catch (ex) {
+					scope?.warn(`failed to map pull requests; ${t.owner}/${t.repo}:${t.branch}, ex=${ex}`);
+					return {
+						status: "rejected",
+						reason: ex
+					};
 				}
 			});
 		} catch (ex) {
@@ -3016,6 +3221,14 @@ __decorate([trace({ args: (provider, token) => ({
 	provider: provider.name,
 	token: `<token:${token.microHash}>`
 }) })], GitHubApi.prototype, "getIssuesBatch", null);
+__decorate([trace({ args: (provider, token) => ({
+	provider: provider.name,
+	token: `<token:${token.microHash}>`
+}) })], GitHubApi.prototype, "getPullRequestsBatch", null);
+__decorate([trace({ args: (provider, token) => ({
+	provider: provider.name,
+	token: `<token:${token.microHash}>`
+}) })], GitHubApi.prototype, "getPullRequestsForBranches", null);
 __decorate([trace({ args: (provider, token) => ({
 	provider: provider.name,
 	token: `<token:${token.microHash}>`