@gitkraken/core-gitlens 0.2.0 → 0.3.0

package/src/plus/git-github/api/github.ts

@@ -1,3 +1,7 @@
+import { graphql, GraphqlResponseError } from '@octokit/graphql';
+import { request } from '@octokit/request';
+import { RequestError } from '@octokit/request-error';
+import type { Endpoints, RequestParameters } from '@octokit/types';
 import {
 	AuthenticationError,
 	AuthenticationErrorReason,
@@ -37,10 +41,6 @@ import { maybeStopWatch } from '../../../utils/stopwatch.js';
 import { parseUri } from '../../../utils/uri.js';
 import type { Version } from '../../../utils/version.js';
 import { fromString, satisfies } from '../../../utils/version.js';
-import { graphql, GraphqlResponseError } from '@octokit/graphql';
-import { request } from '@octokit/request';
-import { RequestError } from '@octokit/request-error';
-import type { Endpoints, RequestParameters } from '@octokit/types';
 import type {
 	GitHubBlame,
 	GitHubBlameRange,
@@ -120,7 +120,7 @@ repository {
 const gqlPullRequestFragment = `
 ${gqlPullRequestLiteFragment}
 additions
-assignees(first: 10) {
+assignees(first: 25) {
 	nodes {
 		login
 		avatarUrl(size: $avatarSize)
@@ -134,7 +134,7 @@ mergedBy {
 	login
 }
 reviewDecision
-latestReviews(first: 10) {
+latestReviews(first: 25) {
 	nodes {
 		author {
 			login
@@ -144,7 +144,7 @@ latestReviews(first: 10) {
 		state
 	}
 }
-reviewRequests(first: 10) {
+reviewRequests(first: 25) {
 	nodes {
 		asCodeOwner
 		id
@@ -187,7 +187,7 @@ author {
 comments {
 	totalCount
 }
-labels(first: 20) {
+labels(first: 50) {
 	nodes {
 		color
 		name
@@ -1138,7 +1138,7 @@ export class GitHubApi {
 						endingLine
 						commit {
 							oid
-							parents(first: 3) { nodes { oid } }
+							parents(first: 8) { nodes { oid } }
 							message
 							additions
 							changedFiles
@@ -1406,7 +1406,7 @@ export class GitHubApi {
 	$until: GitTimestamp!
 ) {
 	repository(owner: $owner, name: $repo) {
-		refs(first: 20, refPrefix: "refs/heads/") {
+		refs(first: 100, refPrefix: "refs/heads/") {
 			nodes {
 				name
 				target {
@@ -1691,7 +1691,7 @@ export class GitHubApi {
 						... on Commit {
 							oid
 							message
-							parents(first: 3) { nodes { oid } }
+							parents(first: 8) { nodes { oid } }
 							additions
 							changedFiles
 							deletions
@@ -1767,6 +1767,115 @@ export class GitHubApi {
 		}
 	}
 
+	@trace({
+		args: (token, owner, repo, ref) => ({
+			token: `<token:${token.microHash}>`,
+			owner: owner,
+			repo: repo,
+			ref: ref,
+		}),
+	})
+	async getCommitShas(
+		token: GitHubTokenInfo,
+		owner: string,
+		repo: string,
+		ref: string,
+		options?: {
+			after?: string;
+			before?: string;
+			limit?: number;
+			path?: string;
+			since?: string | Date;
+			until?: string | Date;
+		},
+	): Promise<PagedResult<string>> {
+		const scope = getScopedLogger();
+
+		interface QueryResult {
+			repository:
+				| {
+						object:
+							| {
+									history: {
+										pageInfo: GitHubPageInfo;
+										nodes: { oid: string }[];
+									};
+							  }
+							| null
+							| undefined;
+				  }
+				| null
+				| undefined;
+		}
+
+		try {
+			const query = `query getCommitShas(
+	$owner: String!
+	$repo: String!
+	$ref: String!
+	$path: String
+	$after: String
+	$before: String
+	$limit: Int = 100
+	$since: GitTimestamp
+	$until: GitTimestamp
+) {
+	repository(name: $repo, owner: $owner) {
+		object(expression: $ref) {
+			... on Commit {
+				history(first: $limit, path: $path, after: $after, before: $before, since: $since, until: $until) {
+					pageInfo {
+						startCursor
+						endCursor
+						hasNextPage
+						hasPreviousPage
+					}
+					nodes {
+						... on Commit { oid }
+					}
+				}
+			}
+		}
+	}
+}`;
+
+			const rsp = await this.graphql<QueryResult>(
+				undefined,
+				token,
+				query,
+				{
+					owner: owner,
+					repo: repo,
+					ref: ref,
+					after: options?.after,
+					before: options?.before,
+					path: options?.path,
+					limit: Math.min(100, options?.limit ?? 100),
+					since: typeof options?.since === 'string' ? options?.since : options?.since?.toISOString(),
+					until: typeof options?.until === 'string' ? options?.until : options?.until?.toISOString(),
+				},
+				scope,
+			);
+			const history = rsp?.repository?.object?.history;
+			if (history == null) return emptyPagedResult;
+
+			return {
+				paging:
+					history.pageInfo.endCursor != null
+						? {
+								cursor: history.pageInfo.endCursor ?? undefined,
+								more: history.pageInfo.hasNextPage,
+							}
+						: undefined,
+				values: history.nodes.map(n => n.oid),
+			};
+		} catch (ex) {
+			if (ex instanceof RequestNotFoundError) return emptyPagedResult;
+
+			throw this.handleException(ex, undefined, scope);
+		}
+	}
+
 	private async getCommitsCoreRange(
 		token: GitHubTokenInfo,
 		owner: string,
@@ -1830,7 +1939,7 @@ export class GitHubApi {
 		object(expression: $ref) {
 			...on Commit {
 				oid
-				parents(first: 3) { nodes { oid } }
+				parents(first: 8) { nodes { oid } }
 				message
 				additions
 				changedFiles
@@ -2016,12 +2125,12 @@ export class GitHubApi {
 	$until: GitTimestamp!
 ) {
 	repository(owner: $owner, name: $repo) {
-		refs(first: 20, refPrefix: "refs/tags/") {
+		refs(first: 100, refPrefix: "refs/tags/") {
 			nodes {
 				name
 				target {
 					... on Commit {
-						history(first: 3, since: $since until: $until) {
+						history(first: 10, since: $since until: $until) {
 							nodes { oid }
 						}
 					}
@@ -2757,6 +2866,10 @@ export class GitHubApi {
 		return version ?? undefined;
 	}
 
+	// Inflight dedupe: identical concurrent GraphQL requests share a single promise
+	// to cut redundant traffic during graph/details enrichment bursts.
+	private readonly _pendingGraphQL = new Map<string, Promise<unknown>>();
+
 	private async graphql<T>(
 		provider: Provider | undefined,
 		token: GitHubTokenInfo,
@@ -2766,56 +2879,89 @@ export class GitHubApi {
 		cancellation?: CancellationToken | undefined,
 	): Promise<T | undefined> {
 		const { accessToken, ...tokenInfo } = token;
-		try {
-			let aborter: AbortController | undefined;
-			if (cancellation != null) {
-				if (cancellation.isCancellationRequested) throw new CancellationError();
 
-				aborter = new AbortController();
-				cancellation.onCancellationRequested(() => aborter!.abort());
-
-				variables = {
-					...variables,
-					request: { ...variables?.request, signal: aborter.signal },
-				};
+		// Only dedupe when no cancellation/request option is in play — sharing a promise that
+		// carries one caller's AbortSignal would let one cancellation cancel for everyone.
+		const dedupable = cancellation == null && variables?.request == null;
+		let dedupeKey: string | undefined;
+		if (dedupable) {
+			try {
+				dedupeKey = `${token.microHash}|${provider?.id ?? ''}|${query}|${JSON.stringify(variables ?? null)}`;
+			} catch {
+				// Non-serializable variable (BigInt, function, circular ref) — fall through to direct exec.
+				dedupeKey = undefined;
 			}
+			if (dedupeKey != null) {
+				const inflight = this._pendingGraphQL.get(dedupeKey);
+				if (inflight != null) return inflight as Promise<T | undefined>;
+			}
+		}
 
-			return await this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () =>
-				this.getDefaults(accessToken, graphql)(query, variables),
-			);
-		} catch (ex) {
-			if (ex instanceof GraphqlResponseError) {
-				switch (ex.errors?.[0]?.type) {
-					case 'NOT_FOUND':
-						throw new RequestNotFoundError(ex);
-					case 'FORBIDDEN':
-						throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
-					case 'RATE_LIMITED': {
-						let resetAt: number | undefined;
-
-						const reset = ex.headers?.['x-ratelimit-reset'];
-						if (reset != null) {
-							resetAt = parseInt(reset, 10);
-							if (Number.isNaN(resetAt)) {
-								resetAt = undefined;
+		const run = async (): Promise<T | undefined> => {
+			try {
+				let aborter: AbortController | undefined;
+				if (cancellation != null) {
+					if (cancellation.isCancellationRequested) throw new CancellationError();
+
+					aborter = new AbortController();
+					cancellation.onCancellationRequested(() => aborter!.abort());
+
+					variables = {
+						...variables,
+						request: { ...variables?.request, signal: aborter.signal },
+					};
+				}
+
+				return await this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () =>
+					this.getDefaults(accessToken, graphql)(query, variables),
+				);
+			} catch (ex) {
+				if (ex instanceof GraphqlResponseError) {
+					switch (ex.errors?.[0]?.type) {
+						case 'NOT_FOUND':
+							throw new RequestNotFoundError(ex);
+						case 'FORBIDDEN':
+							throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
+						case 'RATE_LIMITED': {
+							let resetAt: number | undefined;
+
+							const reset = ex.headers?.['x-ratelimit-reset'];
+							if (reset != null) {
+								resetAt = parseInt(reset, 10);
+								if (Number.isNaN(resetAt)) {
+									resetAt = undefined;
+								}
 							}
+
+							throw new RequestRateLimitError(ex, accessToken, resetAt);
 						}
+					}
 
-						throw new RequestRateLimitError(ex, accessToken, resetAt);
+					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 (Logger.isDebugging) {
+					this.config.onDebugError?.(`GitHub request failed: ${ex.message}`);
 				}
 
-				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 (Logger.isDebugging) {
-				this.config.onDebugError?.(`GitHub request failed: ${ex.message}`);
+				throw ex;
 			}
+		};
 
-			throw ex;
-		}
+		if (dedupeKey == null) return run();
+
+		const promise = run();
+		this._pendingGraphQL.set(dedupeKey, promise);
+		// Clear from the inflight map once the promise settles — successes and failures both
+		// clear, so failed requests don't poison subsequent retries.
+		void promise.finally(() => {
+			if (this._pendingGraphQL.get(dedupeKey) === promise) {
+				this._pendingGraphQL.delete(dedupeKey);
+			}
+		});
+		return promise;
 	}
 
 	private async request<R extends keyof Endpoints>(

package/src/plus/git-github/api/types.ts

@@ -103,6 +103,21 @@ export interface GitHubApiClient {
 		},
 	): Promise<PagedResult<GitHubCommit> & { viewer?: string }>;
 
+	getCommitShas(
+		token: GitHubTokenInfo,
+		owner: string,
+		repo: string,
+		ref: string,
+		options?: {
+			after?: string;
+			before?: string;
+			limit?: number;
+			path?: string;
+			since?: string | Date;
+			until?: string | Date;
+		},
+	): Promise<PagedResult<string>>;
+
 	getCommitRefs(
 		token: GitHubTokenInfo,
 		owner: string,

package/src/plus/git-github/models.ts

@@ -1,3 +1,4 @@
+import type { Endpoints } from '@octokit/types';
 import { GitFileIndexStatus } from '../../git/models/fileStatus.js';
 import type { IssueLabel } from '../../git/models/issue.js';
 import { Issue, RepositoryAccessLevel } from '../../git/models/issue.js';
@@ -10,7 +11,6 @@ import {
 	PullRequestStatusCheckRollupState,
 } from '../../git/models/pullRequest.js';
 import type { Provider } from '../../git/models/remoteProvider.js';
-import type { Endpoints } from '@octokit/types';
 
 export interface GitHubBlame {
 	ranges: GitHubBlameRange[];

package/src/plus/git-github/providers/github/blame.ts

@@ -73,6 +73,7 @@ export class BlameGitHubSubProvider implements GitBlameSubProvider {
 		let blameLine = blame.lines[editorLine];
 		if (blameLine == null) {
 			if (blame.lines.length !== editorLine) return undefined;
+
 			blameLine = blame.lines[editorLine - 1];
 		}
 
@@ -106,6 +107,7 @@ export class BlameGitHubSubProvider implements GitBlameSubProvider {
 		try {
 			const context = await this.provider.ensureRepositoryContext(repoPath);
 			if (context == null) return undefined;
+
 			const { metadata, github, session } = context;
 
 			const root = this.provider.createVirtualUri(repoPath, undefined);

package/src/plus/git-github/providers/github/branches.ts

@@ -1,6 +1,7 @@
 import type { Cache } from '../../../../git/cache.js';
 import { GitBranch } from '../../../../git/models/branch.js';
 import type { BranchContributionsOverview, GitBranchesSubProvider } from '../../../../git/providers/branches.js';
+import type { GitCommandPriority } from '../../../../git/run.types.js';
 import { createRevisionRange, stripOrigin } from '../../../../git/utils/revision.utils.js';
 import type { BranchSortOptions } from '../../../../git/utils/sorting.js';
 import { sortBranches, sortContributors } from '../../../../git/utils/sorting.js';
@@ -86,6 +87,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		cancellation?: AbortSignal,
 	): Promise<PagedResult<GitBranch>> {
 		if (repoPath == null) return emptyPagedResult;
+
 		const path = repoPath;
 
 		const scope = getScopedLogger();
@@ -176,12 +178,14 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			}
 		};
 
-		// Bypass cache entirely for paged follow-ups — they're driven by an opaque cursor and
-		// don't represent "all branches".
-		const branchesPromise =
-			options?.paging?.cursor != null
-				? load()
-				: this.cache.branches.getOrCreate(path, cacheable => load(cacheable), cancellation);
+		// Compose cache key with cursor so re-loads of the same page hit the cache;
+		// `repoPath` (no suffix) is reserved for the full "all branches" entry.
+		// TODO: `cache.branches` is `PromiseMap<RepoPath, ...>` keyed exactly by repoPath, so
+		// `clearCaches('branches')` / `unregisterRepoPath` will not invalidate composite-key entries.
+		// Acceptable today because branches don't change during a virtual-repo session, but the entries
+		// leak in memory until provider GC. Long-term: switch to RepoPromiseCacheMap or add prefix-invalidate.
+		const cacheKey = options?.paging?.cursor != null ? `${path}#${options.paging.cursor}` : path;
+		const branchesPromise = this.cache.branches.getOrCreate(cacheKey, cacheable => load(cacheable), cancellation);
 
 		let result = await branchesPromise;
 		if (options?.filter != null) {
@@ -202,28 +206,19 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	async getBranchContributionsOverview(
 		repoPath: string,
 		ref: string,
-		options?: { associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined> },
+		// `priority` is unused — the GitHub provider doesn't go through the local git command
+		// queue, so the priority signal has no effect here. Accepted for interface compatibility.
+		options?: {
+			associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined>;
+			priority?: GitCommandPriority;
+		},
 		_cancellation?: AbortSignal,
 	): Promise<BranchContributionsOverview | undefined> {
 		const scope = getScopedLogger();
 
-		// No outer cache here — GitHub provider has no stored-target safety net (no Tier 1
-		// equivalent), so the result is purely PR-resolution-dependent and a `ref`-keyed cache
-		// would serve stale data when the PR is later retargeted.
-		try {
-			let mergeTarget: string | undefined;
-
-			// PR-based lookup (GitHub provider has no stored targets or base branch detection)
-			if (options?.associatedPullRequest != null) {
-				const pr = await options.associatedPullRequest;
-				if (pr?.refs?.base != null) {
-					mergeTarget = pr.refs.base.branch;
-				}
-			}
-
-			mergeTarget ??= await this.getDefaultBranchName(repoPath);
-			if (mergeTarget == null) return undefined;
-
+		// Expensive body — runs only on cache miss. Closes over `mergeTarget` so the cache key
+		// (`${ref}|${mergeTarget}`) fully captures every input that affects the result.
+		const fetchBody = async (mergeTarget: string): Promise<BranchContributionsOverview | undefined> => {
 			const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget);
 			if (mergeBase == null) return undefined;
 
@@ -288,6 +283,31 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 
 				contributors: result.contributors,
 			};
+		};
+
+		try {
+			// Resolve `mergeTarget` (PR base or default branch). Only the expensive body below is
+			// cached — keyed on `${ref}|${mergeTarget}` so callers that resolve to the same target
+			// share the result, while differing targets get independent slots.
+			let mergeTarget: string | undefined;
+
+			if (options?.associatedPullRequest != null) {
+				const pr = await options.associatedPullRequest;
+				if (pr?.refs?.base != null) {
+					mergeTarget = pr.refs.base.branch;
+				}
+			}
+
+			mergeTarget ??= await this.getDefaultBranchName(repoPath);
+			if (mergeTarget == null) return undefined;
+
+			// Safe to cache despite PR retargeting: the cache key includes the resolved `mergeTarget`,
+			// so a retargeted PR resolves to a fresh slot and the old entry is stale-but-unused (and
+			// TTL-evicts). The prior "no outer cache here" rationale assumed a `ref`-only key.
+			const resolvedTarget = mergeTarget;
+			return await this.cache.getBranchOverview(repoPath, `${ref}|${resolvedTarget}`, () =>
+				fetchBody(resolvedTarget),
+			);
 		} catch (ex) {
 			scope?.error(ex);
 			return undefined;
@@ -345,20 +365,30 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	@debug()
 	async getDefaultBranchName(
 		repoPath: string | undefined,
-		_remote?: string,
+		remote?: string,
+		// `priority` is unused — the GitHub provider doesn't go through the local git command
+		// queue, so the priority signal has no effect here. Accepted for interface compatibility.
+		_options?: { priority?: GitCommandPriority },
 		_cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		if (repoPath == null) return undefined;
 
+		remote ??= 'origin';
+
 		const scope = getScopedLogger();
 
+		// Throw inside the factory so RepoPromiseCacheMap's default `expireOnError` evicts the
+		// entry — a transient API failure shouldn't poison the cache for the rest of the session.
+		// The outer try/catch preserves the existing `undefined`-on-error contract for callers.
 		try {
-			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
-			return await github.getDefaultBranchName(
-				toTokenInfo(this.provider.authenticationProviderId, session),
-				metadata.repo.owner,
-				metadata.repo.name,
-			);
+			return await this.cache.getDefaultBranchName(repoPath, remote, async () => {
+				const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+				return github.getDefaultBranchName(
+					toTokenInfo(this.provider.authenticationProviderId, session),
+					metadata.repo.owner,
+					metadata.repo.name,
+				);
+			});
 		} catch (ex) {
 			scope?.error(ex);
 			debugger;