@gitkraken/core-gitlens 0.3.1 → 0.4.100

package/dist/plus/integrations/providers/gitlab/gitlab.js

@@ -0,0 +1,902 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { PullRequest } from '../../../../git/models/pullRequest.js';
+import { CancellationError } from '../../../../utils/cancellation.js';
+import { trace } from '../../../../utils/decorators/log.js';
+import { Logger } from '../../../../utils/logger.js';
+import { getScopedLogger } from '../../../../utils/logger.scoped.js';
+import { maybeStopWatch } from '../../../../utils/stopwatch.js';
+import { equalsIgnoreCase } from '../../../../utils/string.js';
+import { joinUriPath, parseUri } from '../../../../utils/uri.js';
+import { AuthenticationError, AuthenticationErrorReason, isRateLimitResponse, ProviderFetchError, RequestClientError, RequestNotFoundError, toRateLimitError, } from '../../errors.js';
+import { baseProviderApiConfig } from '../apiConfig.js';
+import { selectGitLabUserForCommit } from './gitlab.utils.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/';
+const gitlabMergeRequestIdPrefix = 'gid://gitlab/MergeRequest/';
+function buildGitLabUserId(id) {
+    return typeof id === 'string' && id?.startsWith(gitlabUserIdPrefix)
+        ? id.substring(gitlabUserIdPrefix.length)
+        : String(id);
+}
+export class GitLabApi {
+    config;
+    _disposable;
+    _projectIds = new Map();
+    constructor(config) {
+        this.config = config;
+        this._disposable = config.onConfigChanged?.(() => this.resetCaches());
+    }
+    dispose() {
+        this._disposable?.dispose();
+    }
+    resetCaches() {
+        this._projectIds.clear();
+    }
+    async getAccountForCommit(provider, token, owner, repo, rev, options, cancellation) {
+        const scope = getScopedLogger();
+        const projectId = await this.getProjectId(provider, token, owner, repo, options?.baseUrl, cancellation);
+        if (!projectId)
+            return undefined;
+        try {
+            const commit = await this.request(provider, token, options?.baseUrl, `v4/projects/${projectId}/repository/commits/${rev}?stats=false`, {
+                method: 'GET',
+                // ...options,
+            }, cancellation, scope);
+            let users = await this.findUser(provider, token, commit.author_name, options, cancellation);
+            let user = selectGitLabUserForCommit(users, commit.author_name, commit.author_email);
+            // If the name search was ambiguous (multiple users share the name), try an email-scoped search to
+            // disambiguate before giving up — otherwise we'd show a stranger's avatar (see #2205)
+            if (user == null && commit.author_email) {
+                const exactNameMatches = users.filter(u => equalsIgnoreCase(u.name, commit.author_name)).length;
+                if (exactNameMatches > 1) {
+                    users = await this.findUser(provider, token, commit.author_email, options, cancellation);
+                    user = selectGitLabUserForCommit(users, commit.author_name, commit.author_email);
+                }
+            }
+            if (user == null)
+                return undefined;
+            // If the avatarUrl is a relative URL, make it absolute using the webUrl (assuming the webUrl is the root URL with the username tacked on)
+            if (user.avatarUrl && !/^([a-zA-Z][\w+.-]+):/.test(user.avatarUrl)) {
+                user.avatarUrl = joinUriPath(parseUri(user.webUrl), '..', user.avatarUrl).toString();
+            }
+            return {
+                provider: provider,
+                id: String(user.id),
+                name: user.name || undefined,
+                email: commit.author_email || undefined,
+                avatarUrl: user.avatarUrl || undefined,
+                username: user.username || undefined,
+            };
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getAccountForEmail(provider, token, _owner, _repo, email, options) {
+        const scope = getScopedLogger();
+        try {
+            const [user] = await this.findUser(provider, token, email, options);
+            if (user == null)
+                return undefined;
+            return {
+                provider: provider,
+                id: String(user.id),
+                name: user.name || undefined,
+                email: user.publicEmail || undefined,
+                avatarUrl: user.avatarUrl || undefined,
+                username: user.username || undefined,
+            };
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getUserSigningKeys(provider, token, userId, options, cancellation) {
+        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(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 [];
+        }
+    }
+    async getDefaultBranch(provider, token, owner, repo, options, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const query = `query getDefaultBranch(
+	$fullPath: ID!
+) {
+	project(fullPath: $fullPath) {
+		repository {
+			rootRef
+		}
+}`;
+            const rsp = await this.graphql(provider, token, options?.baseUrl, query, {
+                fullPath: `${owner}/${repo}`,
+            }, cancellation, scope);
+            const defaultBranch = rsp?.data?.project?.repository?.rootRef ?? undefined;
+            if (defaultBranch == null)
+                return undefined;
+            return {
+                provider: provider,
+                name: defaultBranch,
+            };
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getIssueOrPullRequest(provider, token, owner, repo, number, options, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const query = `query getIssueOrMergeRequest(
+	$fullPath: ID!
+	$iid: String!
+) {
+	project(fullPath: $fullPath) {
+		mergeRequest(iid: $iid) {
+			author {
+				id
+				name
+				avatarUrl
+				webUrl
+			}
+			iid
+			title
+			description
+			state
+			createdAt
+			updatedAt
+			mergedAt
+			webUrl
+		}
+		issue(iid: $iid) {
+			author {
+				id
+				name
+				avatarUrl
+				webUrl
+			}
+			iid
+			title
+			description
+			state
+			createdAt
+			updatedAt
+			closedAt
+			webUrl
+		}
+	}
+}`;
+            const rsp = await this.graphql(provider, token, options?.baseUrl, query, {
+                fullPath: `${owner}/${repo}`,
+                iid: String(number),
+            }, cancellation, scope);
+            if (rsp?.data?.project?.issue != null) {
+                const issue = rsp.data.project.issue;
+                return {
+                    provider: provider,
+                    type: 'issue',
+                    id: issue.iid,
+                    nodeId: undefined,
+                    createdDate: new Date(issue.createdAt),
+                    updatedDate: new Date(issue.updatedAt),
+                    title: issue.title,
+                    closed: issue.state === 'closed',
+                    closedDate: issue.closedAt == null ? undefined : new Date(issue.closedAt),
+                    url: issue.webUrl,
+                    state: issue.state === 'locked' ? 'closed' : issue.state,
+                };
+            }
+            if (rsp?.data?.project?.mergeRequest != null) {
+                const mergeRequest = rsp.data.project.mergeRequest;
+                return {
+                    provider: provider,
+                    type: 'pullrequest',
+                    id: mergeRequest.iid,
+                    nodeId: undefined,
+                    createdDate: new Date(mergeRequest.createdAt),
+                    updatedDate: new Date(mergeRequest.updatedAt),
+                    title: mergeRequest.title,
+                    closed: mergeRequest.state === 'closed',
+                    // TODO@eamodio this isn't right, but GitLab doesn't seem to provide a closedAt on merge requests in GraphQL
+                    closedDate: mergeRequest.state === 'closed' ? new Date(mergeRequest.updatedAt) : undefined,
+                    url: mergeRequest.webUrl,
+                    state: mergeRequest.state === 'locked' ? 'closed' : mergeRequest.state,
+                };
+            }
+            return undefined;
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getPullRequestForBranch(provider, token, owner, repo, branch, options, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const fragment = `
+			nodes {
+				iid
+				author {
+					id
+					name
+					avatarUrl
+					webUrl
+				}
+				title
+				description
+				state
+				createdAt
+				updatedAt
+				mergedAt
+				webUrl
+			}`;
+            const query = `query getMergeRequestForBranch(
+	$fullPath: ID!
+	$branches: [String!]
+) {
+	project(fullPath: $fullPath) {
+		${options?.include == null
+                ? `mergeRequests(sourceBranches: $branches sort: UPDATED_DESC first: 1) {
+			${fragment}
+		}`
+                : ''}
+		${options?.include?.includes('opened')
+                ? `opened: mergeRequests(sourceBranches: $branches state: opened sort: UPDATED_DESC first: 1) {
+			${fragment}
+		}`
+                : ''}
+		${options?.include?.includes('merged')
+                ? `merged: mergeRequests(sourceBranches: $branches state: merged sort: UPDATED_DESC first: 1) {
+			${fragment}
+		}`
+                : ''}
+		${options?.include?.includes('closed')
+                ? `closed: mergeRequests(sourceBranches: $branches state: closed sort: UPDATED_DESC first: 1) {
+			${fragment}
+		}`
+                : ''}
+	}
+}`;
+            const rsp = await this.graphql(provider, token, options?.baseUrl, query, {
+                fullPath: `${owner}/${repo}`,
+                branches: [branch],
+                state: options?.include,
+            }, cancellation, scope);
+            let pr;
+            if (options?.include == null) {
+                pr = rsp?.data?.project?.mergeRequests?.nodes?.[0];
+            }
+            else {
+                for (const state of options.include) {
+                    let mr;
+                    if (state === 'opened') {
+                        mr = rsp?.data?.project?.opened?.nodes?.[0];
+                    }
+                    else if (state === 'merged') {
+                        mr = rsp?.data?.project?.merged?.nodes?.[0];
+                    }
+                    else if (state === 'closed') {
+                        mr = rsp?.data?.project?.closed?.nodes?.[0];
+                    }
+                    if (mr != null && (pr == null || new Date(mr.updatedAt) > new Date(pr.updatedAt))) {
+                        pr = mr;
+                    }
+                }
+            }
+            if (pr == null)
+                return undefined;
+            return new PullRequest(provider, {
+                id: buildGitLabUserId(pr.author?.id) ?? '',
+                // 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,
+            }, 
+            // oxlint-disable-next-line typescript/no-unnecessary-type-conversion
+            String(pr.iid), undefined, pr.title, pr.webUrl, { owner: owner, repo: repo }, fromGitLabMergeRequestState(pr.state), new Date(pr.createdAt), new Date(pr.updatedAt), 
+            // TODO@eamodio this isn't right, but GitLab doesn't seem to provide a closedAt on merge requests in GraphQL
+            pr.state !== 'closed' ? undefined : new Date(pr.updatedAt), pr.mergedAt == null ? undefined : new Date(pr.mergedAt));
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getPullRequestForCommit(provider, token, owner, repo, rev, options, cancellation) {
+        const scope = getScopedLogger();
+        const projectId = await this.getProjectId(provider, token, owner, repo, options?.baseUrl, cancellation);
+        if (!projectId)
+            return undefined;
+        try {
+            const mrs = await this.request(provider, token, options?.baseUrl, `v4/projects/${projectId}/repository/commits/${rev}/merge_requests`, {
+                method: 'GET',
+                // ...options,
+            }, cancellation, scope);
+            if (mrs == null || mrs.length === 0)
+                return undefined;
+            if (mrs.length > 1) {
+                mrs.sort((a, b) => (a.state === 'opened' ? -1 : 1) - (b.state === 'opened' ? -1 : 1) ||
+                    new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime());
+            }
+            return fromGitLabMergeRequestREST(mrs[0], provider, { owner: owner, repo: repo });
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getPullRequest(provider, token, owner, repo, id, options, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const query = `query getMergeRequest(
+	$fullPath: ID!
+	$iid: String!
+) {
+	project(fullPath: $fullPath) {
+		mergeRequest(iid: $iid) {
+			id,
+			iid
+			state,
+			author {
+				id
+				name
+				avatarUrl
+				webUrl
+			}
+			diffRefs {
+				baseSha
+				headSha
+			}
+			title
+			description
+			webUrl
+			createdAt
+			updatedAt
+			mergedAt
+			targetBranch
+			sourceBranch
+			project {
+				id
+				fullPath
+				webUrl
+			}
+			sourceProject {
+				id
+				fullPath
+				webUrl
+			}
+		}
+	}
+}`;
+            const rsp = await this.graphql(provider, token, options?.baseUrl, query, {
+                fullPath: `${owner}/${repo}`,
+                iid: String(id),
+            }, cancellation, scope);
+            if (rsp?.data?.project?.mergeRequest == null)
+                return undefined;
+            const pr = rsp.data.project.mergeRequest;
+            return fromGitLabMergeRequest(pr, provider);
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async getRepositoryMetadata(provider, token, owner, repo, options, cancellation) {
+        const scope = getScopedLogger();
+        const projectId = await this.getProjectId(provider, token, owner, repo, options?.baseUrl, cancellation);
+        if (!projectId)
+            return undefined;
+        try {
+            const proj = await this.request(provider, token, options?.baseUrl, `v4/projects/${projectId}`, {
+                method: 'GET',
+                // ...options,
+            }, cancellation, scope);
+            if (proj == null)
+                return undefined;
+            return {
+                provider: provider,
+                owner: proj.namespace.full_path,
+                name: proj.path,
+                isFork: proj.forked_from_project != null,
+                parent: proj.forked_from_project != null
+                    ? {
+                        owner: proj.forked_from_project.namespace.full_path,
+                        name: proj.forked_from_project.path,
+                    }
+                    : undefined,
+            };
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async searchPullRequests(provider, token, options, cancellation) {
+        const scope = getScopedLogger();
+        const search = options?.search;
+        if (!search) {
+            return [];
+        }
+        try {
+            const perPageLimit = 20; // with bigger amount we exceed the max GraphQL complexity in the next query
+            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;
+            if (include == null) {
+                // Unfiltered search returns the first page as-is (as it did before state filtering existed).
+                restPRs = await this.request(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 = [];
+                for (let page = 1; page <= maxSearchPages; page++) {
+                    const pagePRs = await this.request(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 [];
+            }
+            const queryArgs = restPRs.map((_, i) => `$id_${i}: MergeRequestID!`).join('\n');
+            const queryFields = restPRs
+                .map((_, i) => `mergeRequest_${i}: mergeRequest(id: $id_${i}) { ...mergeRequestFields }`)
+                .join('\n');
+            // Set of fields includes only additional fields that are not included in GitLabMergeRequestREST.
+            // It's limited as much as possible to reduce complexity of the query.
+            const queryMrFields = `fragment mergeRequestFields on MergeRequest {
+				diffRefs {
+					baseSha
+					headSha
+				}
+				project {
+					id
+					fullPath
+					webUrl
+				}
+				sourceProject {
+					id
+					fullPath
+					webUrl
+				}
+			}`;
+            const query = `query getMergeRequests (${queryArgs}) {${queryFields}} ${queryMrFields}`;
+            const params = restPRs.reduce((ids, gitlabRestPr, i) => {
+                ids[`id_${i}`] = `${gitlabMergeRequestIdPrefix}${gitlabRestPr.id}`;
+                return ids;
+            }, {});
+            const rsp = await this.graphql(provider, token, options?.baseUrl, query, params, cancellation, scope);
+            if (rsp?.data != null) {
+                const resultPRs = restPRs.reduce((accum, restPR, i) => {
+                    const graphQlPR = rsp.data[`mergeRequest_${i}`];
+                    if (graphQlPR == null) {
+                        return accum;
+                    }
+                    const fullPr = {
+                        ...graphQlPR,
+                        iid: String(restPR.iid),
+                        id: String(restPR.id),
+                        state: restPR.state,
+                        // 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,
+                        createdAt: restPR.created_at,
+                        updatedAt: restPR.updated_at,
+                        mergedAt: restPR.merged_at,
+                        sourceBranch: restPR.source_branch,
+                        targetBranch: restPR.target_branch,
+                    };
+                    accum.push(fromGitLabMergeRequest(fullPr, provider));
+                    return accum;
+                }, []);
+                return resultPRs;
+            }
+            return [];
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return [];
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    async findUser(provider, token, search, options, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const query = `query findUser(
+$search: String!
+) {
+	users(search: $search) {
+		nodes {
+			id
+			name
+			username,
+			publicEmail,
+			state
+			avatarUrl
+			webUrl
+		}
+	}
+}`;
+            const rsp = await this.graphql(provider, token, options?.baseUrl, query, {
+                search: search,
+            }, cancellation, scope);
+            const matches = rsp?.data?.users?.nodes;
+            if (matches == null || matches.length === 0)
+                return [];
+            const users = [];
+            for (const user of matches) {
+                const match = /gid:\/\/gitlab\/User\/([0-9]+)\b/.exec(user.id);
+                if (match == null)
+                    continue;
+                users.push({
+                    id: parseInt(match[1], 10),
+                    name: user.name,
+                    username: user.username,
+                    publicEmail: user.publicEmail || undefined,
+                    state: user.state,
+                    avatarUrl: user.avatarUrl,
+                    webUrl: user.webUrl,
+                });
+            }
+            return users;
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return [];
+            this.handleException(ex, provider, scope);
+            return [];
+        }
+    }
+    getProjectId(provider, token, group, repo, baseUrl, cancellation) {
+        const { accessToken } = token;
+        const key = `${accessToken}|${group}/${repo}`;
+        let projectId = this._projectIds.get(key);
+        if (projectId == null) {
+            projectId = this.getProjectIdCore(provider, token, group, repo, baseUrl, cancellation);
+            this._projectIds.set(key, projectId);
+        }
+        return projectId;
+    }
+    async getProjectIdCore(provider, token, group, repo, baseUrl, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const query = `query getProjectId(
+	$fullPath: ID!
+) {
+	project(fullPath: $fullPath) {
+		id
+	}
+}`;
+            const rsp = await this.graphql(provider, token, baseUrl, query, {
+                fullPath: `${group}/${repo}`,
+            }, cancellation, scope);
+            const gid = rsp?.data?.project?.id;
+            if (gid == null)
+                return undefined;
+            const match = /gid:\/\/gitlab\/Project\/([0-9]+)\b/.exec(gid);
+            if (match == null)
+                return undefined;
+            const projectId = match[1];
+            scope?.addExitInfo(`projectId=${projectId}`);
+            return projectId;
+        }
+        catch (ex) {
+            if (ex instanceof RequestNotFoundError)
+                return undefined;
+            this.handleException(ex, provider, scope);
+            return undefined;
+        }
+    }
+    async graphql(provider, token, baseUrl, query, variables, cancellation, scope) {
+        const { accessToken } = token;
+        let rsp;
+        try {
+            const sw = maybeStopWatch(`[GITLAB] POST ${baseUrl}`, { log: { onlyExit: true } });
+            try {
+                if (cancellation?.aborted)
+                    throw new CancellationError();
+                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,
+                    body: JSON.stringify({ query: query, variables: variables }),
+                }));
+                if (rsp.ok) {
+                    const data = (await rsp.json());
+                    if ('errors' in data)
+                        throw new ProviderFetchError('GitLab', rsp, data.errors);
+                    return data;
+                }
+                // 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}`;
+                sw?.stop({ message: message });
+            }
+        }
+        catch (ex) {
+            if (ex instanceof ProviderFetchError || ex.name === 'AbortError') {
+                this.handleRequestError(provider, token, ex, scope);
+            }
+            else if (Logger.isDebugging) {
+                this.config.onError?.(`GitLab request failed: ${ex.message}`);
+            }
+            throw ex;
+        }
+    }
+    async request(provider, token, baseUrl, route, options, cancellation, scope) {
+        const { accessToken } = token;
+        const url = `${baseUrl ?? 'https://gitlab.com/api'}/${route}`;
+        let rsp;
+        try {
+            const sw = maybeStopWatch(`[GITLAB] ${options?.method ?? 'GET'} ${url}`, { log: { onlyExit: true } });
+            try {
+                if (cancellation?.aborted)
+                    throw new CancellationError();
+                rsp = await this.config.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () => this.config.fetch(url, {
+                    headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
+                    signal: cancellation,
+                    ...options,
+                }));
+                if (rsp.ok) {
+                    return (await rsp.json());
+                }
+                // 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();
+            }
+        }
+        catch (ex) {
+            if (ex instanceof ProviderFetchError || ex.name === 'AbortError') {
+                this.handleRequestError(provider, token, ex, scope);
+            }
+            else if (Logger.isDebugging) {
+                this.config.onError?.(`GitLab request failed: ${ex.message}`);
+            }
+            throw ex;
+        }
+    }
+    handleRequestError(provider, token, ex, scope) {
+        if (ex.name === 'AbortError' || !(ex instanceof ProviderFetchError))
+            throw new CancellationError(ex);
+        const { accessToken, ...tokenInfo } = token;
+        switch (ex.status) {
+            case 404: // Not found
+            case 410: // Gone
+            case 422: // Unprocessable Entity
+                throw new RequestNotFoundError(ex);
+            case 429: // Too Many Requests
+                throw toRateLimitError(ex, accessToken);
+            case 401: // Unauthorized
+                throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Unauthorized, ex);
+            case 403: // Forbidden
+                // 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 AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
+            case 500: // Internal Server Error
+                scope?.error(ex);
+                if (ex.response != null) {
+                    provider?.trackRequestException();
+                    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.'
+                        : ''}`);
+                }
+                return;
+            case 502: // Bad Gateway
+                scope?.error(ex);
+                // GitHub seems to return this status code for timeouts
+                if (ex.message.includes('timeout')) {
+                    provider?.trackRequestException();
+                    this.config.onRequestTimedOut?.(provider?.name ?? 'GitLab');
+                    return;
+                }
+                break;
+            default:
+                if (ex.status >= 400 && ex.status < 500)
+                    throw new RequestClientError(ex);
+                break;
+        }
+        scope?.error(ex);
+        if (Logger.isDebugging) {
+            this.config.onError?.(`GitLab request failed: ${ex.response?.errors?.[0]?.message ?? ex.message}`);
+        }
+    }
+    handleException(ex, provider, scope) {
+        scope?.error(ex);
+        // debugger;
+        if (ex instanceof AuthenticationError) {
+            void this.showAuthenticationErrorMessage(ex, provider);
+        }
+        return ex;
+    }
+    async showAuthenticationErrorMessage(ex, provider) {
+        if (ex.reason === AuthenticationErrorReason.Unauthorized || ex.reason === AuthenticationErrorReason.Forbidden) {
+            const reauthenticate = await this.config.onReauthenticationRequired?.(`${ex.message}. Would you like to try reauthenticating${ex.reason === AuthenticationErrorReason.Forbidden ? ' to provide additional access' : ''}?`);
+            if (reauthenticate) {
+                await provider.reauthenticate();
+                this.resetCaches();
+            }
+        }
+        else {
+            this.config.onError?.(ex.message);
+        }
+    }
+}
+__decorate([
+    trace({
+        args: (provider, token, owner, repo, rev) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+            rev: rev,
+        }),
+    })
+], GitLabApi.prototype, "getAccountForCommit", null);
+__decorate([
+    trace({
+        args: (provider, token, _owner, _repo, email) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            email: email,
+        }),
+    })
+], GitLabApi.prototype, "getAccountForEmail", null);
+__decorate([
+    trace({
+        args: (provider, token, userId) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            userId: userId,
+        }),
+    })
+], GitLabApi.prototype, "getUserSigningKeys", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+        }),
+    })
+], GitLabApi.prototype, "getDefaultBranch", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo, number) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+            number: number,
+        }),
+    })
+], GitLabApi.prototype, "getIssueOrPullRequest", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo, branch) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+            branch: branch,
+        }),
+    })
+], GitLabApi.prototype, "getPullRequestForBranch", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo, rev) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+            rev: rev,
+        }),
+    })
+], GitLabApi.prototype, "getPullRequestForCommit", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo, id) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+            id: id,
+        }),
+    })
+], GitLabApi.prototype, "getPullRequest", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+        }),
+    })
+], GitLabApi.prototype, "getRepositoryMetadata", null);
+__decorate([
+    trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+], GitLabApi.prototype, "searchPullRequests", null);
+/** Wires a {@link GitLabApi} from the full runtime context, mapping `ctx` down to the narrow config. */
+export function createGitLabApi(ctx) {
+    const config = {
+        ...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);
+}
+//# sourceMappingURL=gitlab.js.map