@gitkraken/core-gitlens 0.4.0 → 0.4.101

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

@@ -2,6 +2,7 @@ import type { Account } from '../../../../git/models/author.js';
 import type { DefaultBranch } from '../../../../git/models/defaultBranch.js';
 import type { IssueOrPullRequest } from '../../../../git/models/issueOrPullRequest.js';
 import { PullRequest } from '../../../../git/models/pullRequest.js';
+import type { PullRequestState } from '../../../../git/models/pullRequest.js';
 import type { Provider } from '../../../../git/models/remoteProvider.js';
 import type { RepositoryMetadata } from '../../../../git/models/repositoryMetadata.js';
 import { CancellationError } from '../../../../utils/cancellation.js';
@@ -18,11 +19,14 @@ import type { IntegrationServiceContext } from '../../context.js';
 import {
 	AuthenticationError,
 	AuthenticationErrorReason,
+	isRateLimitResponse,
 	ProviderFetchError,
 	RequestClientError,
 	RequestNotFoundError,
-	RequestRateLimitError,
+	toRateLimitError,
 } from '../../errors.js';
+import type { ProviderApiConfig } from '../apiConfig.js';
+import { baseProviderApiConfig } from '../apiConfig.js';
 import { selectGitLabUserForCommit } from './gitlab.utils.js';
 import type {
 	GitLabCommit,
@@ -32,9 +36,15 @@ import type {
 	GitLabMergeRequestREST,
 	GitLabMergeRequestState,
 	GitLabProjectREST,
+	GitLabSshKey,
 	GitLabUser,
 } from './models.js';
-import { fromGitLabMergeRequest, fromGitLabMergeRequestREST, fromGitLabMergeRequestState } from './models.js';
+import {
+	fromGitLabMergeRequest,
+	fromGitLabMergeRequestREST,
+	fromGitLabMergeRequestState,
+	toGitLabMergeRequestState,
+} from './models.js';
 
 // drop it as soon as we switch to @gitkraken/providers-api
 const gitlabUserIdPrefix = 'gid://gitlab/User/';
@@ -47,19 +57,15 @@ function buildGitLabUserId(id: string | number | undefined): string | undefined
 }
 
 export class GitLabApi implements Disposable {
-	private readonly _disposable: Disposable;
+	private readonly _disposable: Disposable | undefined;
 	private _projectIds = new Map<string, Promise<string | undefined>>();
 
-	constructor(private readonly ctx: IntegrationServiceContext) {
-		this._disposable = ctx.config.onDidChange(e => {
-			if (e.httpProxy || e.remotes) {
-				this.resetCaches();
-			}
-		});
+	constructor(private readonly config: ProviderApiConfig) {
+		this._disposable = config.onConfigChanged?.(() => this.resetCaches());
 	}
 
 	dispose(): void {
-		this._disposable.dispose();
+		this._disposable?.dispose();
 	}
 
 	private resetCaches(): void {
@@ -180,6 +186,43 @@ export class GitLabApi implements Disposable {
 		}
 	}
 
+	@trace({
+		args: (provider, token, userId) => ({
+			provider: provider.name,
+			token: `<token:${token.microHash}>`,
+			userId: userId,
+		}),
+	})
+	async getUserSigningKeys(
+		provider: Provider,
+		token: TokenWithInfo,
+		userId: string | number,
+		options?: { baseUrl?: string },
+		cancellation?: AbortSignal,
+	): Promise<GitLabSshKey[]> {
+		const scope = getScopedLogger();
+
+		// SSH keys are public, so this works for any user with the current token (covered by the `read_user` scope).
+		try {
+			const keys = await this.request<GitLabSshKey[]>(
+				provider,
+				token,
+				options?.baseUrl,
+				`v4/users/${userId}/keys`,
+				{ method: 'GET' },
+				cancellation,
+				scope,
+			);
+			// Exclude auth-only keys — only signing-capable keys belong in an allowed_signers file.
+			return keys?.filter(k => k.usage_type === 'signing' || k.usage_type === 'auth_and_signing') ?? [];
+		} catch (ex) {
+			if (ex instanceof RequestNotFoundError) return [];
+
+			this.handleException(ex, provider, scope);
+			return [];
+		}
+	}
+
 	@trace({
 		args: (provider, token, owner, repo) => ({
 			provider: provider.name,
@@ -514,11 +557,14 @@ export class GitLabApi implements Disposable {
 				provider,
 				{
 					id: buildGitLabUserId(pr.author?.id) ?? '',
-					name: pr.author?.name ?? 'Unknown',
-					avatarUrl: pr.author?.avatarUrl ?? '',
-					url: pr.author?.webUrl ?? '',
+					// An absent author stays absent: no `'Unknown'` name a consumer can't tell from a real one, and no
+					// `''` url/avatar that passes a presence check and renders as a link to nowhere. Matches
+					// `fromProviderAccount`/`toIssueShape`.
+					name: pr.author?.name ?? undefined,
+					avatarUrl: pr.author?.avatarUrl ?? undefined,
+					url: pr.author?.webUrl ?? undefined,
 				},
-				// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+				// oxlint-disable-next-line typescript/no-unnecessary-type-conversion
 				String(pr.iid),
 				undefined,
 				pr.title,
@@ -753,7 +799,14 @@ export class GitLabApi implements Disposable {
 	async searchPullRequests(
 		provider: Provider,
 		token: TokenWithInfo,
-		options?: { search?: string; user?: string; repos?: string[]; baseUrl?: string; avatarSize?: number },
+		options?: {
+			search?: string;
+			user?: string;
+			repos?: string[];
+			baseUrl?: string;
+			avatarSize?: number;
+			include?: PullRequestState[];
+		},
 		cancellation?: AbortSignal,
 	): Promise<PullRequest[]> {
 		const scope = getScopedLogger();
@@ -764,17 +817,57 @@ export class GitLabApi implements Disposable {
 
 		try {
 			const perPageLimit = 20; // with bigger amount we exceed the max GraphQL complexity in the next query
-			const restPRs = await this.request<GitLabMergeRequestREST[]>(
-				provider,
-				token,
-				options?.baseUrl,
-				`v4/search/?scope=merge_requests&search=${search}&per_page=${perPageLimit}`,
-				{
-					method: 'GET',
-				},
-				cancellation,
-				scope,
-			);
+			const include = options?.include?.length ? options.include : undefined;
+			// GitLab's search API takes a single `state` value, so push it server-side when exactly one state is
+			// requested; that keeps the requested state from being crowded out of the `perPageLimit` slice. For
+			// multiple states there's no single-value qualifier, so those are filtered client-side below.
+			let searchPath = `v4/search/?scope=merge_requests&search=${encodeURIComponent(search)}&per_page=${perPageLimit}`;
+			if (include?.length === 1) {
+				searchPath += `&state=${encodeURIComponent(toGitLabMergeRequestState(include[0]))}`;
+			}
+
+			let restPRs: GitLabMergeRequestREST[];
+			if (include == null) {
+				// Unfiltered search returns the first page as-is (as it did before state filtering existed).
+				restPRs = await this.request<GitLabMergeRequestREST[]>(
+					provider,
+					token,
+					options?.baseUrl,
+					searchPath,
+					{ method: 'GET' },
+					cancellation,
+					scope,
+				);
+			} else {
+				// The search API returns MRs of all states in relevance order, so the requested state(s) may not
+				// appear on the first page. Server-side `&state=` narrows the single-state case when honored, but it
+				// can't express multiple states, so page through the results and accumulate matches until we fill the
+				// detail-query cap (`perPageLimit`) or exhaust the search results. This keeps correctness whether
+				// or not `&state=` takes effect. Bounded by `maxSearchPages` like the other paged provider drains in
+				// this package so a large, low-match result set can't fan out into an unbounded request loop.
+				const maxSearchPages = 20;
+				const matches: GitLabMergeRequestREST[] = [];
+				for (let page = 1; page <= maxSearchPages; page++) {
+					const pagePRs = await this.request<GitLabMergeRequestREST[]>(
+						provider,
+						token,
+						options?.baseUrl,
+						`${searchPath}&page=${page}`,
+						{ method: 'GET' },
+						cancellation,
+						scope,
+					);
+					for (const pr of pagePRs) {
+						if (include.includes(fromGitLabMergeRequestState(pr.state))) {
+							matches.push(pr);
+							if (matches.length >= perPageLimit) break;
+						}
+					}
+					// Stop once we've filled the cap or hit the last (partial or empty) page.
+					if (matches.length >= perPageLimit || pagePRs.length < perPageLimit) break;
+				}
+				restPRs = matches;
+			}
 			if (restPRs.length === 0) {
 				return [];
 			}
@@ -832,12 +925,18 @@ export class GitLabApi implements Disposable {
 						iid: String(restPR.iid),
 						id: String(restPR.id),
 						state: restPR.state,
-						author: {
-							id: buildGitLabUserId(restPR.author?.id) ?? '',
-							name: restPR.author?.name ?? 'Unknown',
-							avatarUrl: restPR.author?.avatar_url ?? '',
-							webUrl: restPR.author?.web_url ?? '',
-						},
+						// An absent REST author stays absent (`null`, as GitLab's own shape expresses it) rather than a
+						// synthesized `'Unknown'` stub: `fromGitLabMergeRequest` collapses `null` to an absent
+						// `PullRequestMember.name`, whereas a placeholder here would launder into a real-looking name.
+						author:
+							restPR.author != null
+								? {
+										id: buildGitLabUserId(restPR.author.id) ?? '',
+										name: restPR.author.name,
+										avatarUrl: restPR.author.avatar_url ?? null,
+										webUrl: restPR.author.web_url,
+									}
+								: null,
 						title: restPR.title,
 						description: restPR.description,
 						webUrl: restPR.web_url,
@@ -1034,8 +1133,8 @@ $search: String!
 			try {
 				if (cancellation?.aborted) throw new CancellationError();
 
-				rsp = await this.ctx.http.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
-					this.ctx.http.fetch(`${baseUrl ?? 'https://gitlab.com/api'}/graphql`, {
+				rsp = await this.config.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
+					this.config.fetch(`${baseUrl ?? 'https://gitlab.com/api'}/graphql`, {
 						method: 'POST',
 						headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
 						signal: cancellation,
@@ -1050,7 +1149,8 @@ $search: String!
 					return data;
 				}
 
-				throw new ProviderFetchError('GitLab', rsp);
+				// Reads the body so the 403 branch below can tell a throttled request from a permission failure.
+				throw await ProviderFetchError.fromResponse('GitLab', rsp);
 			} finally {
 				const match = /(^[^({\n]+)/.exec(query);
 				const message = ` ${match?.[1].trim() ?? query}`;
@@ -1061,7 +1161,7 @@ $search: String!
 			if (ex instanceof ProviderFetchError || ex.name === 'AbortError') {
 				this.handleRequestError(provider, token, ex, scope);
 			} else if (Logger.isDebugging) {
-				this.ctx.hooks?.ui?.onError?.(`GitLab request failed: ${ex.message}`);
+				this.config.onError?.(`GitLab request failed: ${ex.message}`);
 			}
 
 			throw ex;
@@ -1087,8 +1187,8 @@ $search: String!
 			try {
 				if (cancellation?.aborted) throw new CancellationError();
 
-				rsp = await this.ctx.http.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
-					this.ctx.http.fetch(url, {
+				rsp = await this.config.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
+					this.config.fetch(url, {
 						headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
 						signal: cancellation,
 						...options,
@@ -1099,7 +1199,8 @@ $search: String!
 					return (await rsp.json()) as T;
 				}
 
-				throw new ProviderFetchError('GitLab', rsp);
+				// Reads the body so the 403 branch below can tell a throttled request from a permission failure.
+				throw await ProviderFetchError.fromResponse('GitLab', rsp);
 			} finally {
 				sw?.stop();
 			}
@@ -1107,7 +1208,7 @@ $search: String!
 			if (ex instanceof ProviderFetchError || ex.name === 'AbortError') {
 				this.handleRequestError(provider, token, ex, scope);
 			} else if (Logger.isDebugging) {
-				this.ctx.hooks?.ui?.onError?.(`GitLab request failed: ${ex.message}`);
+				this.config.onError?.(`GitLab request failed: ${ex.message}`);
 			}
 
 			throw ex;
@@ -1128,29 +1229,21 @@ $search: String!
 			case 410: // Gone
 			case 422: // Unprocessable Entity
 				throw new RequestNotFoundError(ex);
-			// case 429: //Too Many Requests
+			case 429: // Too Many Requests
+				throw toRateLimitError(ex, accessToken);
 			case 401: // Unauthorized
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Unauthorized, ex);
 			case 403: // Forbidden
-				if (ex.message.includes('rate limit exceeded')) {
-					let resetAt: number | undefined;
-
-					const reset = ex.response?.headers?.get('x-ratelimit-reset');
-					if (reset != null) {
-						resetAt = parseInt(reset, 10);
-						if (Number.isNaN(resetAt)) {
-							resetAt = undefined;
-						}
-					}
+				// GitLab returns 403 for both a permission failure and a throttled request, so the message is the
+				// discriminant (see `isRateLimitResponse`, shared with Bitbucket/Azure).
+				if (isRateLimitResponse(ex)) throw toRateLimitError(ex, accessToken);
 
-					throw new RequestRateLimitError(ex, accessToken, resetAt);
-				}
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
 			case 500: // Internal Server Error
 				scope?.error(ex);
 				if (ex.response != null) {
 					provider?.trackRequestException();
-					this.ctx.hooks?.ui?.onRequestFailed?.(
+					this.config.onRequestFailed?.(
 						`${provider?.name ?? 'GitLab'} failed to respond and might be experiencing issues.${
 							provider == null || provider.id === 'gitlab'
 								? ' Please visit the [GitLab status page](https://status.gitlab.com) for more information.'
@@ -1164,7 +1257,7 @@ $search: String!
 				// GitHub seems to return this status code for timeouts
 				if (ex.message.includes('timeout')) {
 					provider?.trackRequestException();
-					this.ctx.hooks?.ui?.onRequestTimedOut?.(provider?.name ?? 'GitLab');
+					this.config.onRequestTimedOut?.(provider?.name ?? 'GitLab');
 					return;
 				}
 				break;
@@ -1175,9 +1268,7 @@ $search: String!
 
 		scope?.error(ex);
 		if (Logger.isDebugging) {
-			this.ctx.hooks?.ui?.onError?.(
-				`GitLab request failed: ${(ex.response as any)?.errors?.[0]?.message ?? ex.message}`,
-			);
+			this.config.onError?.(`GitLab request failed: ${(ex.response as any)?.errors?.[0]?.message ?? ex.message}`);
 		}
 	}
 
@@ -1193,7 +1284,7 @@ $search: String!
 
 	private async showAuthenticationErrorMessage(ex: AuthenticationError, provider: Provider) {
 		if (ex.reason === AuthenticationErrorReason.Unauthorized || ex.reason === AuthenticationErrorReason.Forbidden) {
-			const reauthenticate = await this.ctx.hooks?.onReauthenticationRequired?.(
+			const reauthenticate = await this.config.onReauthenticationRequired?.(
 				`${ex.message}. Would you like to try reauthenticating${
 					ex.reason === AuthenticationErrorReason.Forbidden ? ' to provide additional access' : ''
 				}?`,
@@ -1204,7 +1295,26 @@ $search: String!
 				this.resetCaches();
 			}
 		} else {
-			this.ctx.hooks?.ui?.onError?.(ex.message);
+			this.config.onError?.(ex.message);
 		}
 	}
 }
+
+/** Wires a {@link GitLabApi} from the full runtime context, mapping `ctx` down to the narrow config. */
+export function createGitLabApi(ctx: IntegrationServiceContext): GitLabApi {
+	const config: ProviderApiConfig = {
+		...baseProviderApiConfig(ctx),
+		// Self-hosted GitLab keys its API base off `remotes`, so reset on both HTTP proxy and remotes changes.
+		onConfigChanged: listener =>
+			ctx.config.onDidChange(e => {
+				if (e.httpProxy || e.remotes) {
+					listener();
+				}
+			}),
+		onReauthenticationRequired: message =>
+			ctx.hooks?.onReauthenticationRequired?.(message) ?? Promise.resolve(false),
+		onRequestTimedOut: providerName => ctx.hooks?.ui?.onRequestTimedOut?.(providerName),
+	};
+
+	return new GitLabApi(config);
+}

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

@@ -69,3 +69,12 @@ export function selectGitLabUserForCommit(
 	// No matches, or multiple name matches we can't disambiguate by email — don't guess
 	return undefined;
 }
+
+/**
+ * Checks whether a repository's namespace belongs to the given org/group, including subgroups
+ * (e.g. namespace `parent/sub` matches org `parent`). Mirrors gkcli's `gitlabOrgMatches`, used to
+ * filter `getReposForCurrentUser` results since GitLab has no group-scoped repos endpoint.
+ */
+export function matchesGitLabOrgNamespace(namespace: string, org: string): boolean {
+	return namespace === org || namespace.startsWith(`${org}/`);
+}

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

@@ -15,6 +15,17 @@ export interface GitLabUser {
 	webUrl: string;
 }
 
+/** A user's SSH key as returned by `GET /users/:id/keys`. */
+export interface GitLabSshKey {
+	id: number;
+	title: string;
+	key: string;
+	created_at: string;
+	expires_at: string | null;
+	/** Whether the key can be used for authentication, signing, or both. */
+	usage_type: 'auth' | 'signing' | 'auth_and_signing';
+}
+
 export interface GitLabCommit {
 	id: string;
 	short_id: string;
@@ -130,9 +141,11 @@ export function fromGitLabMergeRequestREST(
 		provider,
 		{
 			id: pr.author?.id ?? '',
-			name: pr.author?.name ?? 'Unknown',
-			avatarUrl: pr.author?.avatar_url ?? '',
-			url: pr.author?.web_url ?? '',
+			// An absent author stays absent — no invented `'Unknown'` name, no `''` url/avatar. See
+			// `PullRequestMember.name`.
+			name: pr.author?.name ?? undefined,
+			avatarUrl: pr.author?.avatar_url ?? undefined,
+			url: pr.author?.web_url ?? undefined,
 		},
 		String(pr.iid),
 		undefined,
@@ -200,9 +213,10 @@ export function fromGitLabMergeRequest(pr: GitLabMergeRequestFull, provider: Pro
 		{
 			// author
 			id: pr.author?.id ?? '',
-			name: pr.author?.name ?? 'Unknown',
+			// An absent author stays absent — no invented `'Unknown'` name, no `''` url. See `PullRequestMember.name`.
+			name: pr.author?.name ?? undefined,
 			avatarUrl: avatarUrl,
-			url: pr.author?.webUrl ?? '',
+			url: pr.author?.webUrl ?? undefined,
 		},
 		pr.iid, // id
 		pr.id, // nodeId