@gitkraken/core-gitlens 0.5.109 → 0.5.110

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

@@ -1755,6 +1755,35 @@ export abstract class GitHostIntegration<
 		cancellation?: AbortSignal,
 	): Promise<(number | undefined)[] | undefined>;
 
+	/** The PR twin of {@link countIssuesResult}: counts each scope's pull requests, transferring none. */
+	async countPullRequestsResult(
+		scopes: readonly { repos?: ProviderRepoInput[]; org?: string; criteria?: PullRequestSearchCriteria }[],
+		cancellation?: AbortSignal,
+		connectionId?: string,
+	): Promise<IntegrationResult<(number | undefined)[] | undefined>> {
+		const scope = getScopedLogger();
+		// `connectionId` targets a specific account (multi-account); omitted reads the primary.
+		const session = await this.resolveReadSession(connectionId, scope);
+		if (session == null) return undefined;
+
+		const start = performance.now();
+		try {
+			const counts = await this.countProviderPullRequests?.(session, scopes, cancellation);
+			this.resetRequestExceptionCount('countPullRequests');
+			return { value: counts, duration: performance.now() - start };
+		} catch (ex) {
+			this.handleProviderException('countPullRequests', ex, { scope: scope, connectionId: connectionId });
+			return { error: toError(ex), duration: performance.now() - start };
+		}
+	}
+
+	/** OPTIONAL, like {@link countProviderIssues}: only a provider that can count without fetching implements it. */
+	protected countProviderPullRequests?(
+		session: ProviderAuthenticationSession,
+		scopes: readonly { repos?: ProviderRepoInput[]; org?: string; criteria?: PullRequestSearchCriteria }[],
+		cancellation?: AbortSignal,
+	): Promise<(number | undefined)[] | undefined>;
+
 	getPullRequestIdentityFromMaybeUrl(search: string): PullRequestUrlIdentity | undefined {
 		return this.getProviderPullRequestIdentityFromMaybeUrl?.(search);
 	}

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

@@ -81,6 +81,7 @@ type SyncReqUsecase = Exclude<
 	| 'getResourcesForUser'
 	| 'getSshSigningKeysForEmails'
 	| 'countIssues'
+	| 'countPullRequests'
 	| 'mergePullRequest'
 	| 'searchIssuesPage'
 	| 'searchPullRequestsPage'

package/src/plus/integrations/providerFilters.ts

@@ -28,4 +28,9 @@ export type {
  * same dependency-direction reason as the issue-search model above: provider API clients translate them below
  * this package and cannot import this facade.
  */
-export type { PullRequestSearchCapabilities, PullRequestSearchCriteria } from '../../git/models/pullRequest.js';
+export type {
+	PullRequestSearchCapabilities,
+	PullRequestSearchCriteria,
+	PullRequestSortField,
+	PullRequestSorting,
+} from '../../git/models/pullRequest.js';

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

@@ -0,0 +1,34 @@
+import type { Account as ProviderAccount } from '@gitkraken/provider-apis';
+import type { IssueMember } from '../../../git/models/issue.js';
+import type { PullRequestMember } from '../../../git/models/pullRequest.js';
+
+export function toProviderAccount(account: PullRequestMember | IssueMember): ProviderAccount {
+	return {
+		id: account.id ?? null,
+		avatarUrl: account.avatarUrl ?? null,
+		name: account.name ?? null,
+		url: account.url ?? null,
+		// TODO: Implement these in our own model
+		email: '',
+		username: account.name ?? null,
+	};
+}
+
+export function fromProviderAccount(account: ProviderAccount | null): PullRequestMember | IssueMember {
+	return {
+		id: account?.id ?? '',
+		// An absent name stays absent. `'unknown'` was a display fallback invented in the provider layer, and a
+		// consumer couldn't tell it apart from a member genuinely named that — so it couldn't be undone where a
+		// name-shaped placeholder is wrong (rendering an avatar-only chip, or building an AI prompt, where
+		// `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,
+		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
+		// collapses to `undefined` — even though BOTH mappers feed `listIssuesPage` (the repo-scoped path goes
+		// through `toIssueShape`, Azure's account-wide path through {@link fromProviderIssue}). Same facade
+		// method, two shapes. Matches {@link toProviderRepositoryShape}, which collapses every absent optional.
+		url: account?.url ?? undefined,
+	};
+}

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

@@ -1,3 +1,4 @@
+import { gitHubPullRequestRelationshipQualifiers } from '../../git-github/api/pullRequestSearchQuery.js';
 import type { Account, UnidentifiedAuthor } from '../../../git/models/author.js';
 import type { DefaultBranch } from '../../../git/models/defaultBranch.js';
 import type { Issue, IssueSearchCriteria, IssueShape } from '../../../git/models/issue.js';
@@ -50,17 +51,6 @@ import {
 } from './models.js';
 import type { ProvidersApi } from './providersApi.js';
 
-/**
- * Page size for GitHub's account-wide search reads: the maximum GitHub's search connection accepts, and what
- * `GitHubApi.searchMyPullRequestsPage` already caps itself to.
- *
- * Requested explicitly rather than left to the SDK's own fallback. That fallback is also 100 as of
- * `@gitkraken/provider-apis` 0.54.0 (it was 15 before, which cost a drained sweep ~7x the round trips it needs),
- * so this is now a pin rather than an override — it keeps the size this read is tuned for from silently tracking
- * a shared SDK default that other reads may want smaller.
- */
-const githubSearchMaxPageSize = 100;
-
 type GitHubPullRequestFacetCursor = Record<string, string>;
 
 function toPullRequestFacetCursor(value: unknown): GitHubPullRequestFacetCursor {
@@ -91,13 +81,6 @@ function parsePullRequestFacetCursor(cursor: string | undefined): GitHubPullRequ
 	}
 }
 
-const pullRequestRelationshipQualifier: Record<PullRequestFilter, string> = {
-	[PullRequestFilter.Author]: 'author:@me',
-	[PullRequestFilter.Assignee]: 'assignee:@me',
-	[PullRequestFilter.ReviewRequested]: 'review-requested:@me',
-	[PullRequestFilter.Mention]: 'mentions:@me',
-};
-
 const metadata = providersMetadata[GitCloudHostIntegrationId.GitHub];
 const authProvider: IntegrationAuthenticationProviderDescriptor = Object.freeze({
 	id: metadata.id,
@@ -441,140 +424,124 @@ abstract class GitHubIntegrationBase<ID extends GitHubIntegrationIds> extends Gi
 		},
 	): Promise<ProviderApiPagedResult<ProviderPullRequest> | undefined> {
 		const explicitFilters = options?.filters?.length ? [...new Set(options.filters)] : undefined;
-		// Explicit relationships need independent search facets so the returned union is exact. State-only reads
-		// retain the provider-native `involves:@me` behavior for backward compatibility.
-		if ((options?.state?.length ?? 0) > 0 || explicitFilters != null || options?.includeReviewRequested === true) {
-			const github = await this.authenticationService.apis.github;
-			if (github == null) return undefined;
-
-			const requestedStates: PullRequestStateFilter[] =
-				options?.state != null && options.state.length > 0 ? [...new Set(options.state)] : ['open'];
-			const facets =
-				explicitFilters?.length != null
-					? requestedStates.flatMap(state =>
-							explicitFilters.map(filter => ({
-								key: `${state}:${filter}`,
-								state: state,
-								search: pullRequestRelationshipQualifier[filter],
-							})),
-						)
-					: requestedStates.flatMap(state => [
-							{ key: state, state: state, search: undefined },
-							...(options?.includeReviewRequested === true
-								? [
-										{
-											key: `${state}:${PullRequestFilter.ReviewRequested}`,
-											state: state,
-											search: pullRequestRelationshipQualifier[PullRequestFilter.ReviewRequested],
-										},
-									]
-								: []),
-						]);
-			const cursors = parsePullRequestFacetCursor(options?.cursor);
-			const hasResumableFacetCursor = Object.keys(cursors).length !== 0;
-			const facetsWithCursor = facets.filter(facet => cursors[facet.key] != null);
-			// The first call has no cursor, so query every requested state. A continuation only happens after a
-			// prior page reported `more:true`, whose bundle carries a cursor for each facet still in flight;
-			// facets absent from the bundle are exhausted, so re-querying them from scratch would refetch the
-			// same PRs (duplicated by the dedup-free sweep) and waste an API call per page. Query only the
-			// states that still have a cursor, but degrade a malformed/empty cursor bundle, or one that doesn't
-			// apply to the current requested states, to the first page rather than returning an empty page.
-			const facetsToQuery =
-				options?.cursor != null && hasResumableFacetCursor && facetsWithCursor.length !== 0
-					? facetsWithCursor
-					: facets;
-			const results = await Promise.allSettled(
-				facetsToQuery.map(async facet => ({
-					key: facet.key,
-					result: await github.searchMyPullRequestsPage(this, toTokenWithInfo(this.id, session), {
-						baseUrl: this.apiBaseUrl,
-						state: facet.state,
-						cursor: cursors[facet.key],
-						summary: options?.summary,
-						...(facet.search != null
-							? { search: facet.search, includeDefaultInvolvement: false }
-							: undefined),
-					}),
-				})),
-			);
-			if (results.every(result => result.status === 'rejected')) {
-				const first = results[0];
-				if (first?.status === 'rejected') throw first.reason;
-			}
+		// Every account-wide read goes through our own facet search — there is deliberately no SDK
+		// `getPullRequestsForUser` fallback. It could express neither a state set, nor exact relationships (its
+		// `involves:` is a different question), nor the full projection, so which reads it could serve depended on
+		// the options, and the two routes disagreed on more than they had to: only this one applies the Launchpad
+		// ignored/included repository and organization qualifiers, so the same read returned different pull
+		// requests depending on options that were supposed to affect only projection or relationship. With no
+		// state and no filters this emits a single facet with no relationship qualifier, which is GitHub's own
+		// `involves:@me` and `is:open` default — the same question the fallback asked, now on one route.
+		const github = await this.authenticationService.apis.github;
+		if (github == null) return undefined;
+
+		const requestedStates: PullRequestStateFilter[] =
+			options?.state != null && options.state.length > 0 ? [...new Set(options.state)] : ['open'];
+		const facets =
+			explicitFilters?.length != null
+				? requestedStates.flatMap(state =>
+						explicitFilters.map(filter => ({
+							key: `${state}:${filter}`,
+							state: state,
+							search: gitHubPullRequestRelationshipQualifiers[filter],
+						})),
+					)
+				: requestedStates.flatMap(state => [
+						{ key: state, state: state, search: undefined },
+						...(options?.includeReviewRequested === true
+							? [
+									{
+										key: `${state}:${PullRequestFilter.ReviewRequested}`,
+										state: state,
+										search: gitHubPullRequestRelationshipQualifiers[
+											PullRequestFilter.ReviewRequested
+										],
+									},
+								]
+							: []),
+					]);
+		const cursors = parsePullRequestFacetCursor(options?.cursor);
+		const hasResumableFacetCursor = Object.keys(cursors).length !== 0;
+		const facetsWithCursor = facets.filter(facet => cursors[facet.key] != null);
+		// The first call has no cursor, so query every requested state. A continuation only happens after a
+		// prior page reported `more:true`, whose bundle carries a cursor for each facet still in flight;
+		// facets absent from the bundle are exhausted, so re-querying them from scratch would refetch the
+		// same PRs (duplicated by the dedup-free sweep) and waste an API call per page. Query only the
+		// states that still have a cursor, but degrade a malformed/empty cursor bundle, or one that doesn't
+		// apply to the current requested states, to the first page rather than returning an empty page.
+		const facetsToQuery =
+			options?.cursor != null && hasResumableFacetCursor && facetsWithCursor.length !== 0
+				? facetsWithCursor
+				: facets;
+		const results = await Promise.allSettled(
+			facetsToQuery.map(async facet => ({
+				key: facet.key,
+				result: await github.searchMyPullRequestsPage(this, toTokenWithInfo(this.id, session), {
+					baseUrl: this.apiBaseUrl,
+					state: facet.state,
+					cursor: cursors[facet.key],
+					summary: options?.summary,
+					...(facet.search != null ? { search: facet.search, includeDefaultInvolvement: false } : undefined),
+				}),
+			})),
+		);
+		if (results.every(result => result.status === 'rejected')) {
+			const first = results[0];
+			if (first?.status === 'rejected') throw first.reason;
+		}
 
-			const values = new Map<string, ProviderPullRequest>();
-			const nextCursors: GitHubPullRequestFacetCursor = {};
-			const failures = [];
-			let hasMore = false;
-			let truncated = false;
-			let structuralIncompleteness = false;
-			let unkeyedPullRequest = 0;
-			for (const outcome of results) {
-				if (outcome.status === 'rejected') {
-					failures.push(toCollectionScopeFailure({ providerId: this.id }, outcome.reason));
-					truncated = true;
-					continue;
-				}
+		const values = new Map<string, ProviderPullRequest>();
+		const nextCursors: GitHubPullRequestFacetCursor = {};
+		const failures = [];
+		let hasMore = false;
+		let truncated = false;
+		let structuralIncompleteness = false;
+		let unkeyedPullRequest = 0;
+		for (const outcome of results) {
+			if (outcome.status === 'rejected') {
+				failures.push(toCollectionScopeFailure({ providerId: this.id }, outcome.reason));
+				truncated = true;
+				continue;
+			}
 
-				const { key, result } = outcome.value;
-				for (const pr of result.values) {
-					const mapped = toProviderPullRequest(pr);
-					const identity = getProviderPullRequestIdentity(mapped) ?? `unkeyed:${unkeyedPullRequest++}`;
-					if (!values.has(identity)) {
-						values.set(identity, mapped);
-					}
+			const { key, result } = outcome.value;
+			for (const pr of result.values) {
+				const mapped = toProviderPullRequest(pr);
+				const identity = getProviderPullRequestIdentity(mapped) ?? `unkeyed:${unkeyedPullRequest++}`;
+				if (!values.has(identity)) {
+					values.set(identity, mapped);
 				}
-				if (result.hasMore) {
-					if (result.cursor == null || result.cursor === '{}' || result.cursor === cursors[key]) {
-						truncated = true;
-						structuralIncompleteness = true;
-					} else {
-						hasMore = true;
-						nextCursors[key] = result.cursor;
-					}
-				}
-				if (result.truncated) {
+			}
+			if (result.hasMore) {
+				if (result.cursor == null || result.cursor === '{}' || result.cursor === cursors[key]) {
 					truncated = true;
+					structuralIncompleteness = true;
+				} else {
+					hasMore = true;
+					nextCursors[key] = result.cursor;
 				}
 			}
-
-			return {
-				values: [...values.values()],
-				paging: {
-					more: hasMore,
-					cursor: hasMore ? JSON.stringify({ type: 'cursor', cursors: nextCursors }) : '{}',
-					truncated: truncated || undefined,
-				},
-				...(failures.length || structuralIncompleteness
-					? {
-							metadata: {
-								completeness: 'partial' as const,
-								...(failures.length ? { failures: failures } : {}),
-							},
-						}
-					: undefined),
-			};
+			if (result.truncated) {
+				truncated = true;
+			}
 		}
 
-		// The current user's login scopes the account-wide `involves:` query (see getPullRequestsForUser →
-		// getPullRequestsAssociatedWithUser). Resolve it from THIS session (multi-account safe).
-		const username = (await this.getProviderCurrentAccount(session))?.username;
-		if (username == null) return undefined;
-
-		const api = await this.getProvidersApi();
-		// Only reachable with NO requested state (the branch above owns every state-filtered read), so there is
-		// deliberately no `states` to forward: the SDK's `involves:` search applies its own `is:open` default
-		// qualifier, which is exactly the unfiltered "my open PRs" this path is for. Nor could a state be
-		// honored here — `getPullRequestsAssociatedWithUser` doesn't accept one — which is why the state-filtered
-		// read goes through `searchMyPullRequestsPage` instead of post-filtering a page that never contained the
-		// requested states.
-		const result = await api.getPullRequestsForUser(toTokenWithInfo(this.id, session), username, {
-			baseUrl: this.apiBaseUrl,
-			cursor: options?.cursor,
-			// The sweep drains this read page by page, so it asks for the largest page the search allows.
-			pageSize: githubSearchMaxPageSize,
-		});
-		return result ?? undefined;
+		return {
+			values: [...values.values()],
+			paging: {
+				more: hasMore,
+				cursor: hasMore ? JSON.stringify({ type: 'cursor', cursors: nextCursors }) : '{}',
+				truncated: truncated || undefined,
+			},
+			...(failures.length || structuralIncompleteness
+				? {
+						metadata: {
+							completeness: 'partial' as const,
+							...(failures.length ? { failures: failures } : {}),
+						},
+					}
+				: undefined),
+		};
 	}
 
 	protected override async searchProviderMyIssues(
@@ -719,6 +686,28 @@ abstract class GitHubIntegrationBase<ID extends GitHubIntegrationIds> extends Gi
 		);
 	}
 
+	/**
+	 * Counts several pull-request scopes in ONE request. Like {@link countProviderIssues}, GitHub's `search`
+	 * reports `issueCount` on a zero-node selection, so a count preview costs no pull-request transfer.
+	 */
+	protected override async countProviderPullRequests(
+		session: ProviderAuthenticationSession,
+		scopes: readonly { repos?: ProviderRepoInput[]; org?: string; criteria?: PullRequestSearchCriteria }[],
+		cancellation?: AbortSignal,
+	): Promise<(number | undefined)[] | undefined> {
+		return (await this.authenticationService.apis.github)?.countPullRequests(
+			this,
+			toTokenWithInfo(this.id, session),
+			scopes.map(s => ({
+				repos: s.repos?.map(r => `${r.namespace}/${r.name}`),
+				org: s.org,
+				criteria: s.criteria,
+			})),
+			{ baseUrl: this.apiBaseUrl },
+			cancellation,
+		);
+	}
+
 	protected override async searchProviderPullRequests(
 		session: ProviderAuthenticationSession,
 		searchQuery: string,

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

@@ -23,6 +23,7 @@ import { toTokenWithInfo } from '../authentication/models.js';
 import { toCollectionScopeFailure } from '../collectionMetadata.js';
 import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId } from '../constants.js';
 import type { IntegrationServiceContext } from '../context.js';
+import { IntegrationReadUnavailableError } from '../errors.js';
 import type { IntegrationConnectionChangeEvent } from '../integrationService.js';
 import type { SearchMyPullRequestsOptions } from '../models/gitHostIntegration.js';
 import { GitHostIntegration } from '../models/gitHostIntegration.js';
@@ -64,13 +65,19 @@ const cloudEnterpriseAuthProvider: IntegrationAuthenticationProviderDescriptor =
 type GitLabPullRequestAssociation = 'assigned' | 'authored' | 'reviewRequested';
 type GitLabPullRequestFacetCursor = Partial<Record<GitLabPullRequestAssociation, string>>;
 
-const gitLabAssociationForFilter: Record<
-	Exclude<PullRequestFilter, PullRequestFilter.Mention>,
-	GitLabPullRequestAssociation
-> = {
+/**
+ * The account-wide relationships GitLab can express, and the `scope` each maps to. `undefined` means GitLab has
+ * no equivalent axis (it has neither `Mention` nor `reviewed-by`), and this map is the single declaration of
+ * that. Exhaustive over `PullRequestFilter` on purpose: a new member must be decided for GitLab here rather
+ * than compiling through as silently unsupported. Exported for the advertised-vs-expressible capability test,
+ * which is what keeps it agreeing with `supportedAccountWidePullRequestFilters`; no runtime consumer imports it.
+ */
+export const gitLabAssociationForFilter: Record<PullRequestFilter, GitLabPullRequestAssociation | undefined> = {
 	[PullRequestFilter.Assignee]: 'assigned',
 	[PullRequestFilter.Author]: 'authored',
 	[PullRequestFilter.ReviewRequested]: 'reviewRequested',
+	[PullRequestFilter.Reviewed]: undefined,
+	[PullRequestFilter.Mention]: undefined,
 };
 
 function parseGitLabPullRequestFacetCursor(cursor: string | undefined): GitLabPullRequestFacetCursor {
@@ -473,15 +480,26 @@ abstract class GitLabIntegrationBase<ID extends GitLabIntegrationIds> extends Gi
 
 		const api = await this.getProvidersApi();
 		const requested = options?.filters?.length ? new Set(options.filters) : undefined;
+		// The filter contract is all-or-nothing, so refuse as soon as ONE requested member is inexpressible rather
+		// than only when every one is: dropping the rest would answer a narrower question than was asked
+		// (`[Author, Mention]` becoming `authored`). Throw rather than return `undefined`, which the facade reads
+		// as "no session could be resolved" and a drain turns into a not-connected warning, misattributing a
+		// refusal; `getMyPullRequestsForUserResult` recovers the throw into `{ error }`. Defense in depth:
+		// `resolveAccountWidePullRequestFilters` already refuses such a set, so only a direct caller of the public
+		// method reaches this.
+		const unsupported = requested == null ? [] : [...requested].filter(f => gitLabAssociationForFilter[f] == null);
+		if (unsupported.length > 0) {
+			throw new IntegrationReadUnavailableError(
+				this.name,
+				`account-wide pull request filters not expressible by GitLab: ${unsupported.join(', ')}`,
+			);
+		}
+
 		const associations: GitLabPullRequestAssociation[] =
 			requested == null
 				? ['authored', 'assigned', 'reviewRequested']
-				: [...requested]
-						.filter(
-							(filter): filter is Exclude<PullRequestFilter, PullRequestFilter.Mention> =>
-								filter !== PullRequestFilter.Mention,
-						)
-						.map(filter => gitLabAssociationForFilter[filter]);
+				: Array.from(requested, f => gitLabAssociationForFilter[f]).filter(a => a != null);
+
 		const cursors = parseGitLabPullRequestFacetCursor(options?.cursor);
 		const resumable = associations.filter(association => cursors[association] != null);
 		const associationsToQuery = options?.cursor != null && resumable.length > 0 ? resumable : associations;