@gitkraken/core-gitlens 0.5.109 → 0.5.111

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

@@ -0,0 +1,38 @@
+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 {
+		// 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,
+		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,
+		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
+		// 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/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

@@ -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';
@@ -6,6 +7,7 @@ import type {
 	PullRequest,
 	PullRequestMergeMethod,
 	PullRequestSearchCriteria,
+	PullRequestStackInfo,
 	PullRequestState,
 	PullRequestStateFilter,
 } from '../../../git/models/pullRequest.js';
@@ -50,17 +52,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 +82,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 +425,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);
-					}
-				}
-				if (result.hasMore) {
-					if (result.cursor == null || result.cursor === '{}' || result.cursor === cursors[key]) {
-						truncated = true;
-						structuralIncompleteness = true;
-					} else {
-						hasMore = true;
-						nextCursors[key] = result.cursor;
-					}
+			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.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 +687,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,
@@ -739,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,
@@ -759,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

@@ -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;
@@ -567,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