@gitkraken/core-gitlens 0.5.110 → 0.5.111

package/src/plus/integrations/models/integration.ts

@@ -929,7 +929,11 @@ export abstract class IntegrationBase<
 	}
 
 	@trace()
-	async getPullRequest(resource: T, id: string): Promise<PullRequest | undefined> {
+	async getPullRequest(
+		resource: T,
+		id: string,
+		options?: { expiryOverride?: boolean | number },
+	): Promise<PullRequest | undefined> {
 		const scope = getScopedLogger();
 
 		const connected = this.maybeConnected ?? (await this.isConnected());
@@ -937,18 +941,24 @@ export abstract class IntegrationBase<
 
 		await this.refreshSessionIfExpired(scope);
 
-		const pr = await this.ctx.cache.getPullRequest(id, resource, this, () => ({
-			value: (async () => {
-				try {
-					const result = await this.getProviderPullRequest?.(this._session!, resource, id);
-					this.resetRequestExceptionCount('getPullRequest');
-					return result;
-				} catch (ex) {
-					this.handleProviderException('getPullRequest', ex, { scope: scope });
-					return undefined;
-				}
-			})(),
-		}));
+		const pr = await this.ctx.cache.getPullRequest(
+			id,
+			resource,
+			this,
+			() => ({
+				value: (async () => {
+					try {
+						const result = await this.getProviderPullRequest?.(this._session!, resource, id);
+						this.resetRequestExceptionCount('getPullRequest');
+						return result;
+					} catch (ex) {
+						this.handleProviderException('getPullRequest', ex, { scope: scope });
+						return undefined;
+					}
+				})(),
+			}),
+			{ expiryOverride: options?.expiryOverride },
+		);
 		return pr;
 	}
 

package/src/plus/integrations/providers/accounts.ts

@@ -4,6 +4,9 @@ import type { PullRequestMember } from '../../../git/models/pullRequest.js';
 
 export function toProviderAccount(account: PullRequestMember | IssueMember): ProviderAccount {
 	return {
+		// Stays the provider id because the categorizer matches the viewer to a pull request's people by `id`,
+		// and every provider but GitHub already agrees on that namespace. Re-keying to the login breaks Azure,
+		// whose account `username` is a display name while its members' is a UPN — different namespaces.
 		id: account.id ?? null,
 		avatarUrl: account.avatarUrl ?? null,
 		name: account.name ?? null,
@@ -23,6 +26,7 @@ export function fromProviderAccount(account: ProviderAccount | null): PullReques
 		// `Assignees: unknown` reads as a real assignee). It also disagreed with {@link toIssueShape}, which
 		// collapsed the same absent name to `''` — same facade method, two fallbacks. Both now emit `undefined`.
 		name: account?.name ?? undefined,
+		username: account?.username ?? undefined,
 		avatarUrl: account?.avatarUrl ?? undefined,
 		// `url` is optional, so an absent one must be `undefined`, not `''`. `''` passes a `!= null` presence
 		// check and renders as a link to nowhere, and it disagreed with {@link toIssueShape} — which already

package/src/plus/integrations/providers/azure/models.ts

@@ -475,6 +475,7 @@ export function fromAzureUserWithVoteToReviewer(reviewer: AzureUserWithVote): Pu
 			avatarUrl: reviewer.imageUrl,
 			id: reviewer.id,
 			name: reviewer.displayName,
+			username: reviewer.uniqueName,
 			url: reviewer.url,
 		},
 		state: fromAzurePullRequestVoteToReviewState(reviewer.vote ?? 0),
@@ -505,6 +506,7 @@ export function fromAzureReviewerToPullRequestMember(reviewer: AzureUser): PullR
 		avatarUrl: reviewer.imageUrl,
 		id: reviewer.id,
 		name: reviewer.displayName,
+		username: reviewer.uniqueName,
 		url: reviewer.url,
 	};
 }
@@ -520,6 +522,7 @@ function fromAzureUserToMember(user: AzureUser, _type: 'issue' | 'pullRequest'):
 		avatarUrl: user.imageUrl,
 		id: user.id,
 		name: user.displayName,
+		username: user.uniqueName,
 		url: user.url,
 	};
 }

package/src/plus/integrations/providers/bitbucket/models.ts

@@ -297,6 +297,7 @@ export function fromBitbucketUser(user: BitbucketUser): PullRequestMember {
 	return {
 		avatarUrl: user.links.avatar.href,
 		name: user.display_name,
+		username: user.nickname,
 		url: user.links.html.href,
 		id: user.uuid,
 	};

package/src/plus/integrations/providers/github.ts

@@ -7,6 +7,7 @@ import type {
 	PullRequest,
 	PullRequestMergeMethod,
 	PullRequestSearchCriteria,
+	PullRequestStackInfo,
 	PullRequestState,
 	PullRequestStateFilter,
 } from '../../../git/models/pullRequest.js';
@@ -728,18 +729,100 @@ abstract class GitHubIntegrationBase<ID extends GitHubIntegrationIds> extends Gi
 		);
 	}
 
+	/**
+	 * Stack membership for every stacked pull request in the repository, keyed by pull request number.
+	 *
+	 * List surfaces get their pull requests from the shared providers API, whose type carries no stack
+	 * membership, so the `stack`/`stackEntry` fields selected on the native per-pull-request reads never
+	 * reach them. This fills that gap in a single request for the whole repository, rather than a
+	 * per-pull-request enrichment that would scale with the list.
+	 *
+	 * `undefined` means unavailable (not enrolled in the preview, or not connected) as distinct from an
+	 * empty map, which means the repository genuinely has no stacks.
+	 */
+	override async getStacksByPullRequestNumber(
+		owner: string,
+		repo: string,
+		cancellation?: AbortSignal,
+	): Promise<Map<number, PullRequestStackInfo> | undefined> {
+		// The shared read path — it refreshes an expired session before use, which a bare `getSession()`
+		// does not (it returns the cached session verbatim once one exists, expired or not).
+		const session = await this.resolveReadSession(undefined, undefined);
+		if (session == null) return undefined;
+
+		const stacks = await (
+			await this.authenticationService.apis.github
+		)?.getRepositoryStacks(
+			this,
+			toTokenWithInfo(this.id, session),
+			owner,
+			repo,
+			{
+				baseUrl: this.apiBaseUrl,
+			},
+			cancellation,
+		);
+		if (stacks == null) return undefined;
+
+		const byNumber = new Map<number, PullRequestStackInfo>();
+		for (const stack of stacks) {
+			// Defensive: this is a public-preview payload reaching us through an unvalidated cast, and a
+			// malformed entry must cost its own stack's badges, not the whole panel.
+			const members = stack?.pull_requests;
+			const baseRef = stack?.base?.ref;
+			if (members == null || baseRef == null) continue;
+
+			// `pull_requests` is ordered bottom to top, and `position` is 1-based from the bottom.
+			members.forEach((pr, i) => {
+				byNumber.set(pr.number, {
+					id: stack.id,
+					number: stack.number,
+					size: members.length,
+					position: i + 1,
+					baseRef: baseRef,
+				});
+			});
+		}
+
+		return byNumber;
+	}
+
 	protected override async mergeProviderPullRequest(
 		session: ProviderAuthenticationSession,
 		pr: PullRequest,
 		options?: {
 			mergeMethod?: PullRequestMergeMethod;
 		},
+		cancellation?: AbortSignal,
 	): Promise<boolean> {
 		const id = pr.nodeId;
 		const headRefSha = pr.refs?.head?.sha;
 		if (id == null || headRefSha == null) return false;
+
+		const api = await this.authenticationService.apis.github;
+
+		// GitHub rejects stacked pull requests on the legacy merge mutation, so they take the
+		// asynchronous merge instead — which also lands every layer below this one.
+		if (pr.stack != null) {
+			return (
+				(await api?.mergeStackedPullRequest(
+					this,
+					toTokenWithInfo(this.id, session),
+					pr.repository.owner,
+					pr.repository.repo,
+					Number(pr.id),
+					headRefSha,
+					{
+						mergeMethod: options?.mergeMethod,
+						baseUrl: this.apiBaseUrl,
+					},
+					cancellation,
+				)) ?? false
+			);
+		}
+
 		return (
-			(await this.authenticationService.apis.github)?.mergePullRequest(
+			api?.mergePullRequest(
 				this,
 				toTokenWithInfo(this.id, session),
 				id,
@@ -748,6 +831,7 @@ abstract class GitHubIntegrationBase<ID extends GitHubIntegrationIds> extends Gi
 					mergeMethod: options?.mergeMethod,
 					baseUrl: this.apiBaseUrl,
 				},
+				cancellation,
 			) ?? false
 		);
 	}

package/src/plus/integrations/providers/gitlab.ts

@@ -585,16 +585,8 @@ abstract class GitLabIntegrationBase<ID extends GitLabIntegrationIds> extends Gi
 		}
 
 		const repoIdsResult = await Promise.allSettled(
-			repos.map(
-				(r: GitLabRepositoryDescriptor): Promise<string | undefined> =>
-					api.getProjectId(
-						this,
-						toTokenWithInfo(this.id, session),
-						r.owner,
-						r.name,
-						this.apiBaseUrl,
-						undefined,
-					),
+			repos.map((r: GitLabRepositoryDescriptor): Promise<string | undefined> =>
+				api.getProjectId(this, toTokenWithInfo(this.id, session), r.owner, r.name, this.apiBaseUrl, undefined),
 			) ?? [],
 		);
 		const repoInput = repoIdsResult

package/src/plus/integrations/providers/models.ts

@@ -13,6 +13,7 @@ import type {
 	CursorPageInput,
 	EnterpriseOptions,
 	GetRepoInput,
+	GitBuildStatus,
 	GitBuildStatusState as GitBuildStatusStateType,
 	GitHub,
 	GitIssueState as GitIssueStateType,
@@ -1349,6 +1350,36 @@ export const fromProviderBuildStatusState = {
 	[GitBuildStatusState.Warning]: undefined,
 };
 
+/** Rolls every check context up into one state, the way a provider's own rollup does: failed, errored, or
+ *  action-required fails; else pending or running is pending; else success — reading only the first context
+ *  would call a pull request passing on the strength of whichever check happens to come back first. States
+ *  carrying no verdict (cancelled, skipped, optional action required, warning) don't vote. Reads the raw
+ *  state rather than `fromProviderBuildStatusState`, which drops errored and running to `undefined` and
+ *  would let a lone success outvote a check still in flight. */
+function toStatusCheckRollupState(
+	statuses: GitBuildStatus[] | null | undefined,
+): PullRequestStatusCheckRollupState | undefined {
+	if (!statuses?.length) return undefined;
+
+	let rollup: PullRequestStatusCheckRollupState | undefined;
+	for (const { state } of statuses) {
+		switch (state) {
+			case GitBuildStatusState.Failed:
+			case GitBuildStatusState.Error:
+			case GitBuildStatusState.ActionRequired:
+				return PullRequestStatusCheckRollupState.Failed;
+			case GitBuildStatusState.Pending:
+			case GitBuildStatusState.Running:
+				rollup = PullRequestStatusCheckRollupState.Pending;
+				break;
+			case GitBuildStatusState.Success:
+				rollup ??= PullRequestStatusCheckRollupState.Success;
+				break;
+		}
+	}
+	return rollup;
+}
+
 export const toProviderPullRequestMergeableState = {
 	[PullRequestMergeableState.Mergeable]: GitPullRequestMergeableState.Mergeable,
 	[PullRequestMergeableState.Conflicting]: GitPullRequestMergeableState.Conflicts,
@@ -1472,7 +1503,7 @@ export function toProviderPullRequest(pr: PullRequest): ProviderPullRequest {
 		mergedDate: pr.mergedDate ?? null,
 		commentCount: pr.commentsCount ?? null,
 		upvoteCount: pr.thumbsUpCount ?? null,
-		commitCount: null,
+		commitCount: pr.commitCount ?? null,
 		fileCount: null,
 		additions: pr.additions ?? null,
 		deletions: pr.deletions ?? null,
@@ -1633,11 +1664,12 @@ export function fromProviderPullRequest(
 		toReviewRequests(pr.reviews),
 		toCompletedReviews(pr.reviews),
 		pr.assignees?.map(fromProviderAccount) ?? undefined,
-		pr.headCommit?.buildStatuses?.[0]?.state
-			? fromProviderBuildStatusState[pr.headCommit.buildStatuses[0].state]
-			: undefined,
+		toStatusCheckRollupState(pr.headCommit?.buildStatuses),
 		options?.project,
 		pr.version,
+		pr.commitCount ?? undefined,
+		undefined, // stack — GK's proxy type has no stack concept; membership is joined host-side
+		pr.fileCount ?? undefined,
 		pr.description ?? undefined,
 		pr.number,
 		options?.currentAccountId != null ? pr.author?.id === options.currentAccountId : undefined,

package/src/plus/integrations/reads/broaden.ts

@@ -140,7 +140,12 @@ export async function broadenIssues(
 		}
 
 		items.push(...result.items);
-		warnings.push(...result.warnings);
+		// Deduped across orgs: several orgs of one provider commonly fail the same way (one expired token, one
+		// rate limit), producing the identical warning per slice, and the array's contract is that no two entries
+		// are equal — `traverseToRequestedPage` already dedupes when it folds these same warnings across rounds.
+		for (const warning of result.warnings) {
+			appendDedupedWarning(warnings, warning);
+		}
 		for (const id of result.broadenedProviderIds) {
 			broadenedProviderIds.add(id);
 		}

package/src/plus/integrations/reads/drains.ts

@@ -174,9 +174,10 @@ export async function drainPullRequests(
 
 		// Composite account-wide queries can surface the same PR on different relationship/state pages
 		// (for example authored + review-requested, or closed + merged). Keep the first stable position but
-		// replace its value with the latest representation so a later, richer merged state wins. A provider
-		// row without a canonical URL falls back to repository-scoped identity; a row with neither stays
-		// unkeyed and is retained so unrelated incomplete rows are never collapsed.
+		// replace its value with the latest representation so a later, richer merged state wins. Repository
+		// identity is what keys a row (see `getProviderPullRequestIdentity`), falling back to the canonical
+		// URL; a row with neither stays unkeyed and is retained so unrelated incomplete rows are never
+		// collapsed.
 		for (const pullRequest of value.values) {
 			const identity = getProviderPullRequestIdentity(pullRequest);
 			if (identity == null) {
@@ -319,7 +320,9 @@ export async function drainRepositories(
 			{ warnOnMissingSession: true },
 		);
 		if (warning != null) {
-			warnings.push(warning);
+			// Deduped, like every other accumulation here: a soft warning (`{ value, error }`) repeats verbatim on
+			// each page that hits the same condition, and the array's contract is that no two entries are equal.
+			appendDedupedWarning(warnings, warning);
 		}
 		if (value == null) {
 			const interruptedAfterProgress = page > 1;

package/src/plus/integrations/reads/hierarchy.ts

@@ -291,7 +291,9 @@ export async function listRepos(
 		domain?: string;
 	},
 ): Promise<ProviderPagedResult<ProviderRepositoryShape>> {
-	const page = Math.max(1, options.page ?? 1);
+	// Truncated as well as floored, like every other paged read here: `page` is reported back as
+	// `page.currentPage` and bounds the cursor walk below, and neither can be fractional.
+	const page = Math.max(1, Math.trunc(options.page ?? 1));
 	if (isIssuesHostIntegrationId(options.providerId)) {
 		return refusedPage(
 			page,

package/src/plus/integrations/reads/issueTracker.ts

@@ -9,7 +9,7 @@ import { isIssuesIntegration } from '../models/issuesIntegration.js';
 import { IssueFilter, providersMetadata } from '../providers/models.js';
 import { mergeCollectionMetadata, parsePageCursor } from '../providers/utils/providerPaging.js';
 import type { ProviderPagedResult, ProviderWarning } from '../results.js';
-import { reconcileOmissionsWithFailure } from '../results.js';
+import { appendDedupedWarning, reconcileOmissionsWithFailure } from '../results.js';
 import { isIssuesHostIntegrationId } from '../utils/integration.utils.js';
 import type { ProviderReadContext } from './context.js';
 import { parseIssueTrackerPageCursor, toIssueTrackerPageCursor } from './cursors.js';
@@ -279,7 +279,11 @@ export async function listIssueTrackerIssuesPage(
 				continue;
 			}
 
-			warnings.push(
+			// Deduped: a captured `accountWarning` carries only the provider error, with no resource in its
+			// message, so one expired token across N resources would otherwise repeat verbatim N times. The
+			// synthesized fallback names the resource, so those stay distinct on their own.
+			appendDedupedWarning(
+				warnings,
 				accountWarning ??
 					otherWarning(
 						options.providerId,
@@ -457,7 +461,9 @@ export async function listIssueTrackerIssuesPage(
 		const key = projectKey(project);
 		const retryProject = result == null;
 		if (warning != null) {
-			warnings.push(warning);
+			// Deduped: the per-project warning is built from the provider error alone and names no project, so a
+			// single failing token repeats verbatim once per project in the window.
+			appendDedupedWarning(warnings, warning);
 			fetchFailed = true;
 			projectTruncated = true;
 		}

package/src/plus/integrations/reads/issues.ts

@@ -143,7 +143,9 @@ export async function listIssuesPage(
 	ctx: ProviderReadContext,
 	options: ListIssuesPageOptions,
 ): Promise<ProviderPagedResult<IssueShape>> {
-	const page = Math.max(1, options.page ?? 1);
+	// Truncated as well as floored, like every other paged read here: `page` is reported back as
+	// `page.currentPage` and compared against the position a drain reached, and neither can be fractional.
+	const page = Math.max(1, Math.trunc(options.page ?? 1));
 	if (isIssuesHostIntegrationId(options.providerId)) {
 		return refusedPage(
 			page,
@@ -487,7 +489,10 @@ async function readRepoScopedIssuesPage({
 					filters: options.filters,
 					includeAllAssignees: options.includeAllAssignees,
 					cursor: cursor,
-					page: options.page,
+					// The normalized `page`, so the number forwarded to the provider can't disagree with the
+					// page-number cursor beside it — both are built from the same value. Only when the caller asked
+					// for one: an omitted page is the provider's own first page.
+					page: options.page != null ? page : undefined,
 					pageSize: options.itemsPerPage,
 					sort: ordering.sort,
 				},
@@ -507,14 +512,14 @@ async function readRepoScopedIssuesPage({
 	if (
 		issuesPagingMode === PagingMode.Repos &&
 		options.page != null &&
-		options.page > 1 &&
+		page > 1 &&
 		options.cursor == null &&
 		paged.page.currentPage === 1
 	) {
 		const drained = await drainToRequestedPage(
 			{ items: items, paged: paged, metadata: allMetadata, fetchFailed: pageFetchFailed },
 			{
-				requestedPage: options.page,
+				requestedPage: page,
 				itemsPerPage: options.itemsPerPage,
 				warnings: warnings,
 				readPage: (cursor: string) =>

package/src/plus/integrations/reads/pullRequests.ts

@@ -58,7 +58,9 @@ export async function listPullRequestsPage(
 		domain?: string;
 	},
 ): Promise<ProviderPagedResult<PullRequestShape>> {
-	const page = Math.max(1, options.page ?? 1);
+	// Truncated as well as floored, like every other paged read here: `page` is reported back as
+	// `page.currentPage` and compared against the position a drain reached, and neither can be fractional.
+	const page = Math.max(1, Math.trunc(options.page ?? 1));
 	if (isIssuesHostIntegrationId(options.providerId)) {
 		return refusedPage(
 			page,
@@ -140,7 +142,10 @@ export async function listPullRequestsPage(
 							state: options.states,
 							filters: resolvedFilters.filters,
 							cursor: cursor,
-							page: options.page,
+							// The normalized `page`, so the number forwarded to the provider can't disagree with the
+							// page-number cursor beside it — both are built from the same value. Only when the caller
+							// asked for one: an omitted page is the provider's own first page.
+							page: options.page != null ? page : undefined,
 							pageSize: options.itemsPerPage,
 						},
 						options.connectionId,
@@ -165,14 +170,14 @@ export async function listPullRequestsPage(
 	if (
 		(accountWide || providersMetadata[options.providerId]?.pullRequestsPagingMode === PagingMode.Repos) &&
 		options.page != null &&
-		options.page > 1 &&
+		page > 1 &&
 		options.cursor == null &&
 		paged.page.currentPage === 1
 	) {
 		const drained = await drainToRequestedPage<ProviderPullRequest>(
 			{ items: items, paged: paged, metadata: allMetadata, fetchFailed: pageFetchFailed },
 			{
-				requestedPage: options.page,
+				requestedPage: page,
 				itemsPerPage: options.itemsPerPage,
 				warnings: warnings,
 				readPage: (cursor: string) =>

package/src/utils/env/browser/base64.ts

@@ -14,7 +14,7 @@ export function base64(data: string | Uint8Array): string {
 	return globalThis.btoa(output);
 }
 
-export function fromBase64(s: string): Uint8Array {
+export function fromBase64(s: string): Uint8Array<ArrayBuffer> {
 	const decoded = globalThis.atob(s);
 
 	const len = decoded.length;

package/src/utils/env/node/base64.ts

@@ -4,7 +4,9 @@ export function base64(data: string | Uint8Array): string {
 	return Buffer.from(data).toString('base64');
 }
 
-export function fromBase64(s: string): Uint8Array {
+// Returns `Uint8Array<ArrayBuffer>` rather than a bare `Uint8Array` (which widens to `ArrayBufferLike` and
+// admits `SharedArrayBuffer`) so the result stays assignable to `BufferSource` — what Web Crypto accepts.
+export function fromBase64(s: string): Uint8Array<ArrayBuffer> {
 	return Buffer.from(s, 'base64');
 }