@gitkraken/core-gitlens 0.5.104 → 0.5.106

package/src/git/models/pullRequest.ts

@@ -149,9 +149,59 @@ export interface PullRequestMember {
 	url?: string;
 }
 
+/** Provider-neutral relationship facets shared by PR listings and filtered PR search. */
+export enum PullRequestFilter {
+	Author = 'author',
+	Assignee = 'assignee',
+	ReviewRequested = 'review-requested',
+	Mention = 'mention',
+}
+
 /** Selects which pull request states a read should include. `all` covers open + closed + merged. */
 export type PullRequestStateFilter = 'open' | 'closed' | 'merged' | 'all';
 
+/**
+ * What the filtered pull-request search narrows on.
+ *
+ * Structured rather than a provider query string so callers can send free text without giving it a qualifier
+ * channel, and can check {@link PullRequestSearchCapabilities} before issuing a read. Every requested criterion
+ * is validated all-or-nothing before the provider runs; unsupported criteria never fall through to a wider
+ * result set whose paging would no longer describe the returned items.
+ *
+ * Relationships are OR-ed, as are states. Omitting `relationships` removes the current-user constraint, which is
+ * only safe when the manager call supplies a repository or organization scope. Omitting `states` reads open PRs.
+ */
+export interface PullRequestSearchCriteria {
+	/**
+	 * Free text matched by the provider's own relevance rules. Tokens that look like provider qualifiers are
+	 * removed before the query is built, so text cannot change the search's scope or state.
+	 */
+	text?: string;
+	/** Current-user relationship facets to union. Empty/omitted means no relationship constraint. */
+	relationships?: PullRequestFilter[];
+	/** Pull request states to union. Empty/omitted reads open PRs; `all` subsumes every other member. */
+	states?: PullRequestStateFilter[];
+	/** Includes PRs from archived repositories. They are excluded by default. */
+	includeArchived?: boolean;
+}
+
+/**
+ * Which {@link PullRequestSearchCriteria} fields and manager-level scopes a provider can express server-side.
+ * An empty `relationships` means the provider has no filtered PR search at all.
+ */
+export interface PullRequestSearchCapabilities {
+	/** Current-user relationship facets the provider can union. Empty means the search itself is unsupported. */
+	relationships: PullRequestFilter[];
+	/** Individual state values the provider can union in one logical search. */
+	states: PullRequestStateFilter[];
+	text: boolean;
+	includeArchived: boolean;
+	/** Whether the manager's repository-descriptor scope is supported. */
+	repositoryScope: boolean;
+	/** Whether the manager's organization scope is supported. */
+	organizationScope: boolean;
+}
+
 export interface PullRequestRef {
 	owner: string;
 	repo: string;

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

@@ -13,7 +13,13 @@ 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';
 import type { IssueOrPullRequest } from '../../../git/models/issueOrPullRequest.js';
-import type { PullRequest, PullRequestState, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
+import type {
+	PullRequest,
+	PullRequestSearchCriteria,
+	PullRequestShape,
+	PullRequestState,
+	PullRequestStateFilter,
+} from '../../../git/models/pullRequest.js';
 import { PullRequestMergeMethod } from '../../../git/models/pullRequest.js';
 import type { Provider } from '../../../git/models/remoteProvider.js';
 import type { RepositoryMetadata } from '../../../git/models/repositoryMetadata.js';
@@ -72,6 +78,7 @@ import {
 	toGitHubIssueSearchQualifiers,
 	toGitHubIssueSearchScopeQualifiers,
 } from './issueSearchQuery.js';
+import { toGitHubPullRequestSearchFacets } from './pullRequestSearchQuery.js';
 import type { GitHubTokenInfo } from './token.js';
 
 const emptyPagedResult: PagedResult<any> = Object.freeze({ values: [] });
@@ -89,6 +96,13 @@ const requestRetryMaxDelay = 2000; // ms
 /** How many email->login user searches to alias into a single GraphQL request (keeps query cost within limits). */
 const accountResolveBatchSize = 25;
 
+// Pull-request search selects the full PR fragment (reviews, requests, refs, commits, etc.),
+// which makes GitHub reject broad 100-node searches with `Resource limits for this query
+// exceeded` on large repositories. Thirty keeps the default within that GraphQL cost budget
+// while callers that know their scope is cheap can still opt into the supported 100-node max.
+const defaultPullRequestSearchPageSize = 30;
+const maxPullRequestSearchPageSize = 100;
+
 function isRetryableTransientError(ex: unknown): ex is RequestError {
 	// An aborted request is rethrown as the original `AbortError` (not a `RequestError`), so it is
 	// excluded here. octokit maps a fetch/network failure to a `RequestError` with status 500 and
@@ -164,6 +178,22 @@ export interface AliasedIssueSearchResult {
 	totalCount?: number;
 }
 
+/** One page of the filtered pull-request search. */
+export interface PullRequestSearchResult {
+	values: PullRequestShape[];
+	/** Opaque cursor carrying each active facet continuation plus the positional page. */
+	cursor?: string;
+	hasMore: boolean;
+	page: number;
+	/** True at GitHub's search ceiling or when GitHub advertises a page without a usable cursor. */
+	truncated: boolean;
+	/**
+	 * The largest pre-ceiling `issueCount` any relationship × state facet reported, which is what
+	 * {@link githubSearchResultLimit} applies to. Never the number of rows reachable after that ceiling.
+	 */
+	totalCount?: number;
+}
+
 // Matches a GraphQL document whose operation is definitely a read query — the `query` keyword as
 // the first significant token, after any leading whitespace or `#` comment lines. We retry only
 // when this matches; a mutation (even one prefixed by a comment), a subscription, or anything we
@@ -4022,6 +4052,229 @@ export class GitHubApi {
 		}
 	}
 
+	/**
+	 * Searches pull requests over a repository/org or current-user relationship scope. One GraphQL document carries
+	 * every active relationship × state facet, so one HTTP request serves one page even when the logical search is
+	 * a union. The cursor preserves each facet's continuation plus the positional page.
+	 *
+	 * Ordering is always most-recently-updated-first, and user text is sanitized before it reaches the provider
+	 * query. See {@link toGitHubPullRequestSearchFacets}.
+	 */
+	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+	async searchPullRequestsPage(
+		provider: Provider,
+		token: GitHubTokenInfo,
+		options?: {
+			repos?: string[];
+			org?: string;
+			criteria?: PullRequestSearchCriteria;
+			baseUrl?: string;
+			avatarSize?: number;
+			cursor?: string;
+			pageSize?: number;
+		},
+		cancellation?: AbortSignal,
+	): Promise<PullRequestSearchResult | undefined> {
+		const scope = getScopedLogger();
+
+		const pageSize = Math.min(
+			maxPullRequestSearchPageSize,
+			Math.max(1, Math.trunc(options?.pageSize ?? defaultPullRequestSearchPageSize)),
+		);
+		const facets = toGitHubPullRequestSearchFacets(options?.criteria);
+		const facetAliases = facets.map(f => f.alias).sort();
+		const scopeQualifiers = toGitHubIssueSearchScopeQualifiers(options?.org, options?.repos);
+		const facetSearches = new Map(
+			facets.map(f => [f.alias, [...scopeQualifiers, ...f.qualifiers].join(' ')] as const),
+		);
+		// Bind a cursor to every qualifier without publishing the user text/scope inside the opaque cursor. FNV-1a
+		// is a compact drift key, not a security primitive: a mismatch only degrades safely to page 1.
+		let cursorKeyHash = 0x811c9dc5;
+		for (const value of [...facetSearches.entries()].sort(([a], [b]) => a.localeCompare(b)).flat()) {
+			for (let i = 0; i < value.length; i++) {
+				cursorKeyHash ^= value.charCodeAt(i);
+				cursorKeyHash = Math.imul(cursorKeyHash, 0x01000193);
+			}
+			cursorKeyHash ^= 0;
+			cursorKeyHash = Math.imul(cursorKeyHash, 0x01000193);
+		}
+		const cursorKey = (cursorKeyHash >>> 0).toString(36);
+
+		type SearchCategory = {
+			issueCount: number;
+			pageInfo?: { endCursor?: string | null; hasNextPage: boolean };
+			nodes: (GitHubPullRequest | null)[] | null;
+		};
+		interface SearchCursor {
+			key: string;
+			page: number;
+			facets: Record<string, string | null>;
+			truncated?: boolean;
+			totalCount?: number;
+		}
+
+		let cursor: SearchCursor | undefined;
+		if (options?.cursor != null) {
+			try {
+				const parsed = JSON.parse(options.cursor) as Partial<SearchCursor>;
+				const parsedFacets = parsed.facets;
+				if (parsedFacets != null && typeof parsedFacets === 'object' && !Array.isArray(parsedFacets)) {
+					const parsedAliases = Object.keys(parsedFacets).sort();
+					const sameFacets =
+						parsedAliases.length === facetAliases.length &&
+						parsedAliases.every((alias, index) => alias === facetAliases[index]);
+					const usableSlots = Object.values(parsedFacets).every(
+						slot => slot === null || (typeof slot === 'string' && slot.length > 0),
+					);
+					if (parsed.key === cursorKey && sameFacets && usableSlots) {
+						cursor = {
+							key: cursorKey,
+							page:
+								typeof parsed.page === 'number' && Number.isFinite(parsed.page)
+									? Math.max(1, Math.trunc(parsed.page))
+									: 1,
+							facets: parsedFacets,
+							truncated: parsed.truncated === true,
+							totalCount:
+								typeof parsed.totalCount === 'number' && Number.isFinite(parsed.totalCount)
+									? Math.max(0, Math.trunc(parsed.totalCount))
+									: undefined,
+						};
+					}
+				}
+			} catch {}
+		}
+		const page = cursor?.page ?? 1;
+		const isActive = (alias: string): boolean => cursor?.facets[alias] !== null;
+		const activeFacets = facets.filter(f => isActive(f.alias));
+		if (activeFacets.length === 0) {
+			return {
+				values: [],
+				hasMore: false,
+				page: page,
+				truncated: cursor?.truncated === true,
+				totalCount: cursor?.totalCount,
+			};
+		}
+
+		const includeVar = (alias: string): string => `include${alias.charAt(0).toUpperCase()}${alias.slice(1)}`;
+		const params = facets.flatMap(f => [
+			`$${f.alias}Search: String!`,
+			`$${f.alias}Cursor: String`,
+			`$${includeVar(f.alias)}: Boolean!`,
+		]);
+		const fields = facets.map(
+			f => `${f.alias}: search(first: ${pageSize}, after: $${f.alias}Cursor, query: $${f.alias}Search, type: ISSUE)
+				@include(if: $${includeVar(f.alias)}) {
+				issueCount
+				pageInfo {
+					endCursor
+					hasNextPage
+				}
+				nodes {
+					... on PullRequest {
+						${gqlPullRequestFragment}
+					}
+				}
+			}`,
+		);
+		const query = `query searchPullRequestsPage(
+			${params.join('\n\t\t\t')}
+			$avatarSize: Int
+		) {
+			${fields.join('\n\t\t\t')}
+		}`;
+
+		const variables: Record<string, unknown> = {
+			baseUrl: options?.baseUrl,
+			avatarSize: options?.avatarSize,
+		};
+		for (const facet of facets) {
+			variables[`${facet.alias}Search`] = facetSearches.get(facet.alias);
+			variables[`${facet.alias}Cursor`] = cursor?.facets[facet.alias] ?? undefined;
+			variables[includeVar(facet.alias)] = isActive(facet.alias);
+		}
+
+		try {
+			const rsp = await this.graphql<Record<string, SearchCategory | undefined>>(
+				provider,
+				token,
+				query,
+				variables,
+				scope,
+				cancellation,
+			);
+			if (rsp == null) return { values: [], hasMore: false, page: page, truncated: false };
+
+			const pullRequests: PullRequestShape[] = [];
+			for (const facet of activeFacets) {
+				for (const node of rsp[facet.alias]?.nodes ?? []) {
+					if (node?.id == null) continue;
+
+					try {
+						pullRequests.push(fromGitHubPullRequest(node, provider));
+					} catch (ex) {
+						scope?.warn(`skipped unmappable pull request; id=${node.id}, url=${node.url}, ex=${ex}`);
+					}
+				}
+			}
+			pullRequests.sort((a, b) => b.updatedDate.getTime() - a.updatedDate.getTime());
+			const values = [
+				...uniqueBy(
+					pullRequests,
+					pr => pr.url,
+					(original, _current) => original,
+				),
+			];
+
+			const nextFacets: Record<string, string | null> = {};
+			let hasMore = false;
+			let continuationMissing = false;
+			let totalCount = cursor?.totalCount ?? 0;
+			let providerLimitReached = false;
+			for (const facet of facets) {
+				if (!isActive(facet.alias)) {
+					nextFacets[facet.alias] = null;
+					continue;
+				}
+
+				const category = rsp[facet.alias];
+				const endCursor =
+					category?.pageInfo?.hasNextPage === true && category.pageInfo.endCursor
+						? category.pageInfo.endCursor
+						: null;
+				nextFacets[facet.alias] = endCursor;
+				if (endCursor != null) {
+					hasMore = true;
+				}
+				if (category?.pageInfo?.hasNextPage === true && category.pageInfo.endCursor == null) {
+					continuationMissing = true;
+				}
+				totalCount = Math.max(totalCount, category?.issueCount ?? 0);
+				providerLimitReached ||= (category?.issueCount ?? 0) > githubSearchResultLimit;
+			}
+			const truncated = cursor?.truncated === true || providerLimitReached || continuationMissing;
+			const next: SearchCursor = {
+				key: cursorKey,
+				page: page + 1,
+				facets: nextFacets,
+				truncated: truncated || undefined,
+				totalCount: totalCount,
+			};
+
+			return {
+				values: values,
+				cursor: hasMore ? JSON.stringify(next) : undefined,
+				hasMore: hasMore,
+				page: page,
+				truncated: truncated,
+				totalCount: totalCount,
+			};
+		} catch (ex) {
+			throw this.handleException(ex, provider, scope);
+		}
+	}
+
 	@trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 	async searchPullRequests(
 		provider: Provider,

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

@@ -0,0 +1,80 @@
+import type { PullRequestSearchCriteria, PullRequestStateFilter } from '../../../git/models/pullRequest.js';
+import { PullRequestFilter } from '../../../git/models/pullRequest.js';
+import { sanitizeGitHubSearchText } from './issueSearchQuery.js';
+
+export type GitHubPullRequestSearchFacet = {
+	/** Stable GraphQL alias and composite-cursor key. */
+	alias: string;
+	qualifiers: string[];
+};
+
+const relationshipQualifier: Record<PullRequestFilter, string> = {
+	[PullRequestFilter.Author]: 'author:@me',
+	[PullRequestFilter.Assignee]: 'assignee:@me',
+	[PullRequestFilter.ReviewRequested]: 'review-requested:@me',
+	[PullRequestFilter.Mention]: 'mentions:@me',
+};
+
+const relationshipAlias: Record<PullRequestFilter, string> = {
+	[PullRequestFilter.Author]: 'author',
+	[PullRequestFilter.Assignee]: 'assignee',
+	[PullRequestFilter.ReviewRequested]: 'reviewRequested',
+	[PullRequestFilter.Mention]: 'mention',
+};
+
+const stateAlias: Record<PullRequestStateFilter, string> = {
+	open: 'Open',
+	closed: 'Closed',
+	merged: 'Merged',
+	all: 'All',
+};
+
+function stateQualifiers(state: PullRequestStateFilter): string[] {
+	switch (state) {
+		case 'closed':
+			// GitHub's `is:closed` includes merged PRs; `is:unmerged` removes that subset.
+			return ['is:closed', 'is:unmerged'];
+		case 'merged':
+			return ['is:merged'];
+		case 'all':
+			return [];
+		case 'open':
+			return ['is:open'];
+	}
+}
+
+/**
+ * Translates provider-neutral PR criteria into the independent GitHub searches whose union answers the request.
+ *
+ * GitHub's API search syntax ANDs repeated relationship/state qualifiers and does not implement the boolean
+ * groups accepted by the newer web UI. Each requested relationship × state pair therefore becomes one GraphQL
+ * alias; the API client sends every active alias in a single document, preserving one HTTP request per page.
+ * An omitted relationship is the explicitly unfiltered repository/organization scope, never `involves:@me`.
+ */
+export function toGitHubPullRequestSearchFacets(
+	criteria: PullRequestSearchCriteria | undefined,
+): GitHubPullRequestSearchFacet[] {
+	const relationships: (PullRequestFilter | undefined)[] = criteria?.relationships?.length
+		? [...new Set(criteria.relationships)]
+		: [undefined];
+	const requestedStates: PullRequestStateFilter[] = criteria?.states?.length
+		? [...new Set(criteria.states)]
+		: ['open'];
+	const states: PullRequestStateFilter[] = requestedStates.includes('all') ? ['all'] : requestedStates;
+	const text = criteria?.text != null ? sanitizeGitHubSearchText(criteria.text) : '';
+
+	return relationships.flatMap(relationship =>
+		states.map(state => ({
+			alias: `${relationship != null ? relationshipAlias[relationship] : 'scope'}${stateAlias[state]}`,
+			qualifiers: [
+				'is:pr',
+				...(relationship != null ? [relationshipQualifier[relationship]] : []),
+				...stateQualifiers(state),
+				...(criteria?.includeArchived === true ? [] : ['archived:false']),
+				...(text.length > 0 ? [text] : []),
+				// Contract, not an option: a capped result is the N most recently updated only under this order.
+				'sort:updated',
+			],
+		})),
+	);
+}

package/src/plus/integrations/authentication/configuredIntegrationService.ts

@@ -40,6 +40,7 @@ export interface ConfiguredIntegrationsChangeEvent {
 
 export class ConfiguredIntegrationService implements Disposable {
 	private readonly _onDidChange = new Emitter<ConfiguredIntegrationsChangeEvent>();
+	private storeConfiguredQueue: Promise<void> = Promise.resolve();
 	get onDidChange(): Event<ConfiguredIntegrationsChangeEvent> {
 		return this._onDidChange.event;
 	}
@@ -129,7 +130,11 @@ export class ConfiguredIntegrationService implements Disposable {
 			}));
 		}
 
-		await this.ctx.storage.store('integrations:configured', configured);
+		const pending = this.storeConfiguredQueue.then(() =>
+			this.ctx.storage.store('integrations:configured', configured),
+		);
+		this.storeConfiguredQueue = pending.catch(() => {});
+		await pending;
 	}
 
 	private async addOrUpdateConfigured(descriptor: ConfiguredIntegrationDescriptor): Promise<void> {

package/src/plus/integrations/index.ts

@@ -218,6 +218,8 @@ export { IssueFilter, PullRequestFilter } from './providerFilters.js';
 // The filtered issue search's criteria model and the capability table that says which of it a provider honors.
 // String unions and plain interfaces, so a consumer builds criteria without importing an internal subpath.
 export type { IssueSearchCapabilities, IssueSearchCriteria, IssueSearchRelationship } from './providerFilters.js';
+// Account-wide pull-request search criteria and the per-provider capability table.
+export type { PullRequestSearchCapabilities, PullRequestSearchCriteria } from './providerFilters.js';
 // The count-only issue probe's input and result shapes.
 export type { IssueCountResult, IssueCountScope } from './reads/counts.js';
 // Cross-provider PR/issue state filters (string unions in the git models).