@gitkraken/core-gitlens 0.5.110 → 0.5.111

package/dist/plus/git-github/api/github.js

@@ -16,7 +16,7 @@ import { getPullRequestComparator } from '../../../git/utils/pullRequest.utils.j
 import { createRevisionRange, getRevisionRangeParts, isRevisionRange, isSha, } from '../../../git/utils/revision.utils.js';
 import { chunk } from '../../../utils/array.js';
 import { base64 } from '../../../utils/base64.js';
-import { CancellationError } from '../../../utils/cancellation.js';
+import { CancellationError, isCancellationError } from '../../../utils/cancellation.js';
 import { trace } from '../../../utils/decorators/log.js';
 import { Emitter } from '../../../utils/event.js';
 import { uniqueBy } from '../../../utils/iterable.js';
@@ -125,6 +125,42 @@ title
 updatedAt
 url
 `;
+/**
+ * Stacked-pull-request selections, appended to a pull request's selection set rather than baked into
+ * the fragments below: GitHub Enterprise Server schemas lag github.com, and selecting `stack` there
+ * fails the entire query with "Field 'stack' doesn't exist on type 'PullRequest'" — which would take
+ * every PR feature down with it, not just stacks. Always add these via `gqlPullRequestStackFragmentFor`.
+ */
+const gqlPullRequestStackFragment = `
+stack {
+	id
+	number
+	size
+	baseRefName
+}
+stackEntry {
+	position
+}
+`;
+function gqlPullRequestStackFragmentFor(options) {
+    return isGitHubDotCom(options) ? gqlPullRequestStackFragment : '';
+}
+/**
+ * A 409 means a merge request is already in flight and carries its ticket, so it resumes rather than fails.
+ *
+ * The body has to be dug out of `original`: `requestCore` routes every 4xx through `handleRequestError`,
+ * which re-wraps octokit's `RequestError` in a `RequestClientError` carrying only `message` and `original`.
+ */
+function getAsyncMergeUuidFromConflict(ex) {
+    const err = (RequestClientError.is(ex) ? ex.original : ex);
+    if (err?.status !== 409)
+        return undefined;
+    return err.response?.data?.details?.uuid;
+}
+const asyncMergePollIntervalMs = 2000;
+/** A stack merges one layer at a time and GitHub only promises "a few minutes", so the ceiling is
+ *  generous — giving up early would report a failure for a merge still in progress. */
+const maxAsyncMergePolls = 300;
 const gqlPullRequestLiteFragment = `
 ${gqlIssueOrPullRequestFragment}
 author {
@@ -189,6 +225,7 @@ assignees(first: 25) {
 		url
 	}
 }
+changedFiles
 checksUrl
 deletions
 mergeable
@@ -218,6 +255,7 @@ reviewRequests(first: 25) {
 	}
 }
 commits(last: 1) {
+	totalCount
 	nodes {
 		commit {
 			statusCheckRollup {
@@ -295,6 +333,7 @@ export class GitHubApi {
         try {
             const query = `query getCurrentAccount($avatarSize: Int) {
 	viewer {
+		databaseId
 		name
 		email
 		login
@@ -306,7 +345,10 @@ export class GitHubApi {
                 return undefined;
             return {
                 provider: provider,
-                id: rsp.viewer.login,
+                // `id` is the provider's own id, as it is for every other provider, and `username` the handle
+                // filters and viewer matching key on. Falls back to the login only when GitHub omits the
+                // database id, which leaves the two equal rather than leaving `id` empty.
+                id: rsp.viewer.databaseId != null ? String(rsp.viewer.databaseId) : rsp.viewer.login,
                 name: rsp.viewer.name ?? undefined,
                 email: rsp.viewer.email ?? undefined,
                 // If we are GitHub Enterprise, we may need to convert the avatar URL since it might require authentication
@@ -603,6 +645,7 @@ export class GitHubApi {
 	repository(name: $repo, owner: $owner) {
 		pullRequest(number: $number) {
 			${gqlPullRequestLiteFragment}
+			${gqlPullRequestStackFragmentFor(options)}
 		}
 	}
 }`;
@@ -638,6 +681,7 @@ export class GitHubApi {
 			associatedPullRequests(first: $limit, orderBy: {field: UPDATED_AT, direction: DESC}, states: $include) {
 				nodes {
 					${gqlPullRequestLiteFragment}
+					${gqlPullRequestStackFragmentFor(options)}
 				}
 			}
 		}
@@ -683,6 +727,7 @@ export class GitHubApi {
 				associatedPullRequests(first: 2, orderBy: {field: UPDATED_AT, direction: DESC}) {
 					nodes {
 						${gqlPullRequestLiteFragment}
+						${gqlPullRequestStackFragmentFor(options)}
 					}
 				}
 			}
@@ -1998,6 +2043,17 @@ export class GitHubApi {
         return promise;
     }
     async request(provider, token, route, options, scope, cancellation) {
+        return (await this.requestCore(provider, token, route, options, scope, cancellation));
+    }
+    /**
+     * REST call for routes `@octokit/types` doesn't describe yet — currently the stacked-pull-request
+     * merge APIs, which are in public preview and absent from the generated endpoint map. Prefer
+     * `request` for anything typed.
+     */
+    async requestPreview(provider, token, route, options, scope, cancellation) {
+        return (await this.requestCore(provider, token, route, options, scope, cancellation));
+    }
+    async requestCore(provider, token, route, options, scope, cancellation) {
         const { accessToken } = token;
         try {
             let signal;
@@ -2010,7 +2066,7 @@ export class GitHubApi {
             // Retry transient gateway/network failures on idempotent reads only
             const method = route.split(' ', 1)[0].toUpperCase();
             const retryable = method === 'GET' || method === 'HEAD';
-            return (await this.requestWithRetries(() => this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () => this.getDefaults(accessToken, request)(route, options)), retryable, signal, scope));
+            return await this.requestWithRetries(() => this.config.wrapForForcedInsecureSSL(provider?.getIgnoreSSLErrors() ?? false, () => this.getDefaults(accessToken, request)(route, options)), retryable, signal, scope);
         }
         catch (ex) {
             if (ex instanceof RequestError || ex.name === 'AbortError') {
@@ -2215,6 +2271,7 @@ export class GitHubApi {
 			nodes {
 				...on PullRequest {
 					${options?.summary ? gqlPullRequestLiteFragment : gqlPullRequestFragment}
+					${gqlPullRequestStackFragmentFor(options)}
 				}
 			}
 		}
@@ -2843,6 +2900,7 @@ export class GitHubApi {
 				nodes {
 					... on PullRequest {
 						${gqlPullRequestFragment}
+						${gqlPullRequestStackFragmentFor(options)}
 					}
 				}
 			}`);
@@ -2954,6 +3012,7 @@ export class GitHubApi {
 		nodes {
 			...on PullRequest {
 				${gqlPullRequestFragment}
+				${gqlPullRequestStackFragmentFor(options)}
 			}
 		}
 	}
@@ -2996,6 +3055,98 @@ export class GitHubApi {
             throw this.handleException(ex, provider, scope);
         }
     }
+    /**
+     * Every stack in the repository, each with its members bottom to top.
+     *
+     * One request regardless of how many pull requests are involved — which is what makes it the right
+     * shape for list surfaces, whose pull requests arrive through the shared providers API and so carry no
+     * stack membership of their own. Callers join the result by pull request number.
+     *
+     * A `404` means the repository isn't enrolled in the stacked-pull-requests preview; that's reported as
+     * `undefined` rather than an error, since "no stacks" and "not available" both mean nothing to show.
+     */
+    async getRepositoryStacks(provider, token, owner, repo, options, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            const rsp = await this.requestPreview(provider, token, 'GET /repos/{owner}/{repo}/stacks', { owner: owner, repo: repo, baseUrl: options?.baseUrl }, scope, cancellation);
+            return rsp.data;
+        }
+        catch (ex) {
+            if (isCancellationError(ex))
+                throw ex;
+            Logger.warn(scope, `Unable to list stacks for ${owner}/${repo}: ${ex}`);
+            return undefined;
+        }
+    }
+    /**
+     * Merges a stacked pull request, and with it every layer below it.
+     *
+     * Stacks cannot go through `mergePullRequest` — GitHub rejects stacked pull requests on the legacy
+     * synchronous merge endpoints and mutations. The replacement is asynchronous: submit, then poll a
+     * ticket until it reaches a terminal state.
+     */
+    async mergeStackedPullRequest(provider, token, owner, repo, pullNumber, expectedSourceSha, options, cancellation) {
+        const scope = getScopedLogger();
+        try {
+            let uuid;
+            try {
+                const submitted = await this.requestPreview(provider, token, 'PUT /repos/{owner}/{repo}/pulls/{pull_number}/merge-async', {
+                    owner: owner,
+                    repo: repo,
+                    pull_number: pullNumber,
+                    sha: expectedSourceSha,
+                    merge_method: options?.mergeMethod,
+                    baseUrl: options?.baseUrl,
+                }, scope, cancellation);
+                // Already merged or rejected outright — nothing to poll for. `enqueued` lands via the merge
+                // queue, which can take several merge groups to settle, so it's transitional like `pending`.
+                if (submitted.data.status !== 'pending' && submitted.data.status !== 'enqueued') {
+                    if (submitted.data.status === 'failed') {
+                        Logger.warn(scope, `Stacked merge refused: ${submitted.data.details?.message ?? 'no reason given'}`);
+                    }
+                    return submitted.data.status === 'merged';
+                }
+                uuid = submitted.data.details?.uuid;
+            }
+            catch (ex) {
+                // A merge request is already in flight (a retry, or a double-click) — adopt its ticket and
+                // poll that instead of reporting a failure for a merge that is actually running.
+                uuid = getAsyncMergeUuidFromConflict(ex);
+                if (uuid == null)
+                    throw ex;
+            }
+            if (uuid == null)
+                return false;
+            // The stack merges server-side one layer at a time, so this can take a while. Poll on a
+            // fixed interval and give up rather than hang forever if the ticket never settles.
+            for (let attempt = 0; attempt < maxAsyncMergePolls; attempt++) {
+                if (cancellation?.aborted)
+                    throw new CancellationError();
+                await new Promise(resolve => setTimeout(resolve, asyncMergePollIntervalMs));
+                const polled = await this.requestPreview(provider, token, 'GET /repos/{owner}/{repo}/pulls/{pull_number}/merge-async/{uuid}', {
+                    owner: owner,
+                    repo: repo,
+                    pull_number: pullNumber,
+                    uuid: uuid,
+                    baseUrl: options?.baseUrl,
+                }, scope, cancellation);
+                if (polled.data.status === 'pending' || polled.data.status === 'enqueued')
+                    continue;
+                if (polled.data.status === 'failed') {
+                    Logger.warn(scope, `Stacked merge failed: ${polled.data.details?.message ?? 'no reason given'}`);
+                }
+                return polled.data.status === 'merged';
+            }
+            Logger.warn(scope, `Timed out waiting for stacked merge of ${owner}/${repo}#${pullNumber}`);
+            return false;
+        }
+        catch (ex) {
+            if (isCancellationError(ex))
+                throw ex;
+            Logger.error(ex, scope);
+            throw this.handleException(ex, provider, scope);
+        }
+    }
     async mergePullRequest(provider, token, nodeId, expectedSourceSha, options, cancellation) {
         const scope = getScopedLogger();
         let githubMergeStrategy;
@@ -3031,7 +3182,7 @@ export class GitHubApi {
                 mergeMethod: githubMergeStrategy,
                 baseUrl: options?.baseUrl,
             }, scope, cancellation);
-            return rsp?.pullRequest?.id === nodeId;
+            return rsp?.mergePullRequest?.pullRequest?.id === nodeId;
         }
         catch (ex) {
             throw this.handleException(ex, provider, scope);
@@ -3342,6 +3493,28 @@ __decorate([
 __decorate([
     trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 ], GitHubApi.prototype, "searchPullRequests", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+        }),
+    })
+], GitHubApi.prototype, "getRepositoryStacks", null);
+__decorate([
+    trace({
+        args: (provider, token, owner, repo, pullNumber, expectedSourceSha) => ({
+            provider: provider.name,
+            token: `<token:${token.microHash}>`,
+            owner: owner,
+            repo: repo,
+            pullNumber: pullNumber,
+            expectedSourceSha: expectedSourceSha,
+        }),
+    })
+], GitHubApi.prototype, "mergeStackedPullRequest", null);
 __decorate([
     trace({
         args: (provider, token, nodeId, expectedSourceSha) => ({