@gitkraken/core-gitlens 0.5.103 → 0.5.104

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

@@ -23,6 +23,8 @@ import { maybeStopWatch } from '../../../utils/stopwatch.js';
 import { parseUri } from '../../../utils/uri.js';
 import { fromString, satisfies } from '../../../utils/version.js';
 import { fromGitHubIssue, fromGitHubIssueOrPullRequestState, fromGitHubPullRequest, fromGitHubPullRequestLite, } from '../models.js';
+import { githubSearchResultLimit } from './config.js';
+import { gitHubIssueSearchRelationships, toGitHubIssueSearchQualifiers, toGitHubIssueSearchScopeQualifiers, } from './issueSearchQuery.js';
 const emptyPagedResult = Object.freeze({ values: [] });
 const emptyBlameResult = Object.freeze({ ranges: [] });
 // Transient gateway/network failures (e.g. an upstream `502 Bad Gateway`) are worth a few quick
@@ -2203,7 +2205,7 @@ export class GitHubApi {
                 values: results,
                 cursor: rsp.search.pageInfo.endCursor ?? undefined,
                 hasMore: rsp.search.pageInfo.hasNextPage,
-                truncated: rsp.search.issueCount > 1000,
+                truncated: rsp.search.issueCount > githubSearchResultLimit,
             };
         }
         catch (ex) {
@@ -2214,7 +2216,164 @@ export class GitHubApi {
         return (await this.searchMyPullRequestsPage(provider, token, options, cancellation)).values;
     }
     async searchMyIssues(provider, token, options, cancellation) {
+        let search = options?.search?.trim() ?? '';
+        if (options?.user) {
+            search += ` user:${options.user}`;
+        }
+        if (options?.repos != null && options.repos.length > 0) {
+            const repo = '  repo:';
+            search += `${repo}${options.repos.join(repo)}`;
+        }
+        const baseFilters = 'type:issue is:open archived:false';
+        // `includeAllAssignees` broadens the assigned category from "assigned to me" to "assigned to anyone"
+        // (`assignee:*` is GitHub's has-any-assignee qualifier). Authored/mentioned stay bound to `@me` — they're
+        // user-relative by definition, so an all-assignees read still only surfaces the current user's authored
+        // and mentioned issues plus every assigned-to-anyone issue.
+        //
+        // NOTE: `assignee:*` requires a SCOPE to be meaningful, but any scope will do — one repository, several,
+        // or an org (measured: `repo:a repo:b … assignee:*` returns exactly the sum of the two per-repo counts).
+        // It is only the UNSCOPED form that is meaningless, matching millions of issues across all of GitHub, so
+        // callers must supply `repos` (or an org qualifier via `search`); the facade refuses the unscoped case.
+        const assignedQualifier = options?.includeAllAssignees ? 'assignee:*' : 'assignee:@me';
+        // A category is read when the caller asked for it AND it hasn't been exhausted (a `null` cursor slot,
+        // which `searchIssuesByAlias` maintains). An excluded category needs no cursor bookkeeping: a missing
+        // response category reads back as `null`, so it stays excluded across continuations on its own.
+        const categories = options?.categories;
+        const requested = {
+            authored: categories?.authored ?? categories == null,
+            assigned: categories?.assigned ?? categories == null,
+            mentioned: categories?.mentioned ?? categories == null,
+        };
+        // Two things are fixed here rather than incidental:
+        // - the alias names are this read's persisted cursor keys, so they can't be renamed;
+        // - the ORDER is assigned → mentioned → authored, which is the order the union is emitted in and, because
+        //   the dedupe keeps the first occurrence of a url, also the precedence between the three. An issue that
+        //   is both assigned to and authored by the user surfaces as the assigned one.
+        const searches = [];
+        if (requested.assigned) {
+            searches.push({ alias: 'assigned', query: `${search} ${baseFilters} ${assignedQualifier}`.trim() });
+        }
+        if (requested.mentioned) {
+            searches.push({ alias: 'mentioned', query: `${search} ${baseFilters} mentions:@me`.trim() });
+        }
+        if (requested.authored) {
+            searches.push({ alias: 'authored', query: `${search} ${baseFilters} author:@me`.trim() });
+        }
+        return this.searchIssuesByAlias(provider, token, searches, options, cancellation);
+    }
+    /**
+     * The filtered issue search: issues matching structured criteria over a repository/org scope, with no forced
+     * relationship to the current user. The issue counterpart of {@link searchMyPullRequestsPage}, and distinct
+     * from {@link searchMyIssues}, which is permanently bound to `@me`.
+     *
+     * Ordering is part of the contract, not an option: always `sort:updated` (most recently updated first). A
+     * consumer's "show the N most recent" policy at GitHub's result ceiling is only correct under a guaranteed
+     * order, and an option would let a caller pick relevance order and then truncate to an arbitrary subset.
+     *
+     * Each requested relationship becomes its own aliased search, unioned and deduped by url; with none, a single
+     * search runs over the scope alone. `criteria.text` and the other free-form values are sanitized so user input
+     * cannot inject a qualifier and re-scope the search — see {@link toGitHubIssueSearchQualifiers}.
+     */
+    async searchIssuesPage(provider, token, options, cancellation) {
+        const base = [
+            ...toGitHubIssueSearchScopeQualifiers(options?.org, options?.repos),
+            ...toGitHubIssueSearchQualifiers(options?.criteria),
+        ].join(' ');
+        // One aliased search per relationship, OR-ed by union. They can't be one query: GitHub AND-s qualifiers,
+        // so `author:@me assignee:@me` would return the intersection — issues the user both opened and is assigned
+        // to — instead of either set. With no relationship the scope + criteria are already the whole query.
+        const relationships = options?.criteria?.relationships;
+        const searches = relationships?.length
+            ? relationships.map(r => ({
+                alias: gitHubIssueSearchRelationships[r].alias,
+                query: `${base} ${gitHubIssueSearchRelationships[r].qualifier}`.trim(),
+            }))
+            : [{ alias: 'matched', query: base }];
+        return this.searchIssuesByAlias(provider, token, searches, options, cancellation);
+    }
+    /**
+     * Counts issues for several scopes in ONE request, transferring no issues at all — each scope is an aliased
+     * `search` selecting only `issueCount`, with `first: 0` so no nodes are fetched.
+     *
+     * This is what makes a "this will fetch ~N issues" preview affordable: measured against the live API, 30
+     * aliased counts cost a single rate-limit point. It is still a network request per chunk, so a caller is
+     * expected to debounce and cache.
+     *
+     * Returns counts positionally — one per input scope, same order — because a caller-supplied key must never
+     * reach the GraphQL document (it would break it); the aliases are generated. `undefined` in a slot means the
+     * response omitted that alias, which the caller reports as "not counted" rather than as zero.
+     */
+    async countIssues(provider, token, scopes, options, cancellation) {
+        const scope = getScopedLogger();
+        if (scopes.length === 0)
+            return [];
+        const queries = scopes.map(s => {
+            const qualifiers = [
+                ...toGitHubIssueSearchScopeQualifiers(s.org, s.repos),
+                ...toGitHubIssueSearchQualifiers(s.criteria),
+            ];
+            // A relationship set is OR-ed across searches, which a single count can't express — the facade splits
+            // such a scope into one count per relationship before calling, so at most one is present here.
+            const relationship = s.criteria?.relationships?.[0];
+            if (relationship != null) {
+                qualifiers.push(gitHubIssueSearchRelationships[relationship].qualifier);
+            }
+            return qualifiers.join(' ');
+        });
+        // Aliases are positional and generated (`s0`, `s1`, …): a caller's key is arbitrary text and would break
+        // the document, so the caller maps results back by index.
+        const params = queries.map((_, i) => `$q${i}: String!`).join('\n\t\t\t\t');
+        // `first: 0` is what makes this cheap — `issueCount` alone, no nodes over the wire.
+        const fields = queries
+            .map((_, i) => `s${i}: search(query: $q${i}, type: ISSUE, first: 0) { issueCount }`)
+            .join('\n\t\t\t\t');
+        const query = `query countIssues(
+				${params}
+			) {
+				${fields}
+			}`;
+        const variables = { baseUrl: options?.baseUrl };
+        queries.forEach((q, i) => {
+            variables[`q${i}`] = q;
+        });
+        try {
+            const rsp = await this.graphql(provider, token, query, variables, scope, cancellation);
+            if (rsp == null)
+                return queries.map(() => undefined);
+            return queries.map((_, i) => rsp[`s${i}`]?.issueCount);
+        }
+        catch (ex) {
+            throw this.handleException(ex, provider, scope);
+        }
+    }
+    /**
+     * The aliased-search engine behind every GitHub issue search: one GraphQL request carrying N independently
+     * cursored `search` fields, `@include`-gated so an exhausted or unrequested one costs nothing.
+     *
+     * It exists as one implementation because the properties that make it correct are subtle and must not be
+     * reproduced per read: each alias advances on its OWN cursor and is dropped from the request once exhausted
+     * (so a finished search is never re-queried, which would re-emit its first page); results are mapped
+     * node-by-node so one unmappable issue can't discard the page; the union is deduped by `url` rather than by
+     * `IssueShape.id`, which for some providers is a per-repository number; and a provider that claims another
+     * page while withholding its `endCursor` is reported as truncated instead of paged forever.
+     *
+     * {@link searchMyIssues} is one configuration of it (its three `@me` categories), and its alias names are
+     * that read's published cursor keys.
+     *
+     * `searches` must have unique aliases, each a valid GraphQL name that is neither `page` nor `truncated` —
+     * the composite cursor keys aliases at its top level, alongside those two reserved fields.
+     */
+    async searchIssuesByAlias(provider, token, searches, options, cancellation) {
         const scope = getScopedLogger();
+        // Enforced, not just documented: aliases share the cursor's top level with `page` and `truncated`, so an
+        // alias colliding with either would overwrite it — and the failure would be SILENT, a page number replaced
+        // by a cursor string that reads back as page 1, restarting the walk with no error and no truncation flag.
+        // Cheap to check, and it fails at the one call that introduced the collision rather than in a consumer's
+        // persisted cursor.
+        const reserved = searches.filter(s => s.alias === 'page' || s.alias === 'truncated');
+        if (reserved.length > 0) {
+            throw new Error(`Issue search alias(es) ${reserved.map(s => `'${s.alias}'`).join(', ')} collide with the composite cursor's reserved keys`);
+        }
         let cursor;
         if (options?.cursor != null) {
             try {
@@ -2223,37 +2382,34 @@ export class GitHubApi {
             catch { }
         }
         const page = Math.max(1, Math.trunc(cursor?.page ?? 1));
-        // A category is read when the caller asked for it AND it hasn't been exhausted (`null` cursor slot). An
-        // excluded category needs no cursor bookkeeping: `nextCategoryCursor` reads a missing response category as
-        // `null`, so it stays excluded across continuations on its own.
-        const categories = options?.categories;
-        const requested = {
-            authored: categories?.authored ?? categories == null,
-            assigned: categories?.assigned ?? categories == null,
-            mentioned: categories?.mentioned ?? categories == null,
+        // A slot is a continuation string, `null` (exhausted), or absent. Anything else came from a malformed or
+        // foreign cursor, and is read as absent rather than threaded back into the request as a continuation.
+        const slotFor = (alias) => {
+            const slot = cursor?.[alias];
+            return slot === null || typeof slot === 'string' ? slot : undefined;
         };
-        const includeAuthored = requested.authored && cursor?.authored !== null;
-        const includeAssigned = requested.assigned && cursor?.assigned !== null;
-        const includeMentioned = requested.mentioned && cursor?.mentioned !== null;
-        // Reading nothing is the honest answer to "none of the three": widening back to the union would return
-        // issues the caller explicitly excluded.
-        if (!includeAuthored && !includeAssigned && !includeMentioned) {
+        // Every requested search is in the document; an exhausted one is switched OFF by its `@include` gate
+        // rather than removed, so a continuation's request keeps the shape of the first one and GitHub's
+        // query-document cache still recognizes it. `active` is what actually runs.
+        const isActive = (s) => slotFor(s.alias) !== null;
+        const active = searches.filter(isActive);
+        // Reading nothing is the honest answer to "every requested search is exhausted (or none was requested)":
+        // widening back to the full set would return items the caller excluded, or re-emit a finished page.
+        if (active.length === 0) {
             return { values: [], hasMore: false, page: page, truncated: cursor?.truncated === true };
         }
-        const query = `query searchMyIssues(
-				$authored: String!
-				$assigned: String!
-				$mentioned: String!
-				$authoredCursor: String
-				$assignedCursor: String
-				$mentionedCursor: String
-				$includeAuthored: Boolean!
-				$includeAssigned: Boolean!
-				$includeMentioned: Boolean!
-				$avatarSize: Int
-			) {
-				authored: search(first: 100, after: $authoredCursor, query: $authored, type: ISSUE)
-					@include(if: $includeAuthored) {
+        // GitHub's search caps a page at 100 regardless of what is asked for.
+        const pageSize = Math.min(100, Math.max(1, Math.trunc(options?.pageSize ?? 100)));
+        // `includeAssigned` etc. — the same variable names the read published before the aliases were made
+        // data-driven, so a recorded/asserted request shape stays recognizable.
+        const includeVar = (alias) => `include${alias.charAt(0).toUpperCase()}${alias.slice(1)}`;
+        const params = searches.flatMap(s => [
+            `$${s.alias}: String!`,
+            `$${s.alias}Cursor: String`,
+            `$${includeVar(s.alias)}: Boolean!`,
+        ]);
+        const fields = searches.map(s => `${s.alias}: search(first: ${pageSize}, after: $${s.alias}Cursor, query: $${s.alias}, type: ISSUE)
+					@include(if: $${includeVar(s.alias)}) {
 					issueCount
 					pageInfo {
 						endCursor
@@ -2265,108 +2421,66 @@ export class GitHubApi {
 							${options?.includeBody ? 'body' : ''}
 						}
 					}
-				}
-				assigned: search(first: 100, after: $assignedCursor, query: $assigned, type: ISSUE)
-					@include(if: $includeAssigned) {
-					issueCount
-					pageInfo {
-						endCursor
-						hasNextPage
-					}
-					nodes {
-						... on Issue {
-							${gqIssueFragment}
-							${options?.includeBody ? 'body' : ''}
-						}
-					}
-				}
-				mentioned: search(first: 100, after: $mentionedCursor, query: $mentioned, type: ISSUE)
-					@include(if: $includeMentioned) {
-					issueCount
-					pageInfo {
-						endCursor
-						hasNextPage
-					}
-					nodes {
-						... on Issue {
-							${gqIssueFragment}
-							${options?.includeBody ? 'body' : ''}
-						}
-					}
-				}
+				}`);
+        const query = `query searchIssues(
+				${params.join('\n\t\t\t\t')}
+				$avatarSize: Int
+			) {
+				${fields.join('\n\t\t\t\t')}
 			}`;
-        let search = options?.search?.trim() ?? '';
-        if (options?.user) {
-            search += ` user:${options.user}`;
-        }
-        if (options?.repos != null && options.repos.length > 0) {
-            const repo = '  repo:';
-            search += `${repo}${options.repos.join(repo)}`;
+        const variables = {
+            baseUrl: options?.baseUrl,
+            avatarSize: options?.avatarSize,
+        };
+        for (const s of searches) {
+            variables[s.alias] = s.query;
+            variables[`${s.alias}Cursor`] = slotFor(s.alias) ?? undefined;
+            variables[includeVar(s.alias)] = isActive(s);
         }
-        const baseFilters = 'type:issue is:open archived:false';
-        // `includeAllAssignees` broadens the assigned category from "assigned to me" to "assigned to anyone"
-        // (`assignee:*` is GitHub's has-any-assignee qualifier). Authored/mentioned stay bound to `@me` — they're
-        // user-relative by definition, so an all-assignees read still only surfaces the current user's authored
-        // and mentioned issues plus every assigned-to-anyone issue.
-        //
-        // NOTE: GitHub only honors `assignee:*` when the search is scoped to a single repository (see GitHub's
-        // issue-search docs). Callers using `includeAllAssignees` must scope the read via `repos` (the broaden
-        // fan-out does this per org/repo); an unscoped account-wide `assignee:*` is not meaningful to GitHub.
-        const assignedQualifier = options?.includeAllAssignees ? 'assignee:*' : 'assignee:@me';
         try {
-            const rsp = await this.graphql(provider, token, query, {
-                authored: `${search} ${baseFilters} author:@me`.trim(),
-                assigned: `${search} ${baseFilters} ${assignedQualifier}`.trim(),
-                mentioned: `${search} ${baseFilters} mentions:@me`.trim(),
-                authoredCursor: cursor?.authored ?? undefined,
-                assignedCursor: cursor?.assigned ?? undefined,
-                mentionedCursor: cursor?.mentioned ?? undefined,
-                includeAuthored: includeAuthored,
-                includeAssigned: includeAssigned,
-                includeMentioned: includeMentioned,
-                baseUrl: options?.baseUrl,
-                avatarSize: options?.avatarSize,
-            }, scope, cancellation);
+            const rsp = await this.graphql(provider, token, query, variables, scope, cancellation);
             if (rsp == null)
                 return { values: [], hasMore: false, page: page, truncated: false };
             // Map node-by-node so one unmappable issue can't discard the whole result set
             const issues = [];
-            for (const node of [
-                ...(rsp.assigned?.nodes ?? []),
-                ...(rsp.mentioned?.nodes ?? []),
-                ...(rsp.authored?.nodes ?? []),
-            ]) {
-                if (node?.id == null)
-                    continue;
-                try {
-                    issues.push(fromGitHubIssue(node, provider));
-                }
-                catch (ex) {
-                    scope?.warn(`skipped unmappable issue; id=${node.id}, url=${node.url}, ex=${ex}`);
+            for (const s of active) {
+                for (const node of rsp[s.alias]?.nodes ?? []) {
+                    if (node?.id == null)
+                        continue;
+                    try {
+                        issues.push(fromGitHubIssue(node, provider));
+                    }
+                    catch (ex) {
+                        scope?.warn(`skipped unmappable issue; id=${node.id}, url=${node.url}, ex=${ex}`);
+                    }
                 }
             }
+            // Dedupe by `url`, not `IssueShape.id`: for some providers `id` is a per-repository number, so an
+            // id-keyed map would collapse distinct issues across repositories.
             const results = uniqueBy(issues, r => r.url, (original, _current) => original);
-            const nextCategoryCursor = (category) => {
-                if (category?.pageInfo?.hasNextPage && category.pageInfo.endCursor) {
-                    return category.pageInfo.endCursor;
+            // Every alias gets a slot, so an inactive one keeps its `null` and stays out of the next request. A
+            // missing slot would be read as "never requested", which for a `searches` set that still lists it
+            // would restart it from its first page.
+            const next = { page: page + 1 };
+            let hasMore = false;
+            let continuationMissing = false;
+            let maxIssueCount = 0;
+            for (const s of searches) {
+                const category = rsp[s.alias];
+                const endCursor = category?.pageInfo?.hasNextPage && category.pageInfo.endCursor ? category.pageInfo.endCursor : null;
+                next[s.alias] = endCursor;
+                if (endCursor != null) {
+                    hasMore = true;
                 }
-                return null;
-            };
-            const next = {
-                page: page + 1,
-                authored: nextCategoryCursor(rsp.authored),
-                assigned: nextCategoryCursor(rsp.assigned),
-                mentioned: nextCategoryCursor(rsp.mentioned),
-            };
-            const hasMore = next.authored != null || next.assigned != null || next.mentioned != null;
-            // GitHub search exposes at most 1,000 results per category. Paging removes the previous 100-item
-            // truncation; only the upstream search ceiling or an unusable continuation remains incomplete.
-            const continuationMissing = [rsp.authored, rsp.assigned, rsp.mentioned].some(category => category?.pageInfo?.hasNextPage === true && category.pageInfo.endCursor == null);
-            const truncated = cursor?.truncated === true ||
-                (rsp.authored?.issueCount ?? 0) > 1000 ||
-                (rsp.assigned?.issueCount ?? 0) > 1000 ||
-                (rsp.mentioned?.issueCount ?? 0) > 1000 ||
-                continuationMissing;
+                if (category?.pageInfo?.hasNextPage === true && category.pageInfo.endCursor == null) {
+                    continuationMissing = true;
+                }
+                maxIssueCount = Math.max(maxIssueCount, category?.issueCount ?? 0);
+            }
+            // GitHub search exposes at most `githubSearchResultLimit` results PER SEARCH, so the ceiling is
+            // reached as soon as any one alias exceeds it. Paging removes the old 100-item truncation; only that
+            // upstream ceiling or an unusable continuation leaves the read incomplete.
+            const truncated = cursor?.truncated === true || maxIssueCount > githubSearchResultLimit || continuationMissing;
             next.truncated = truncated || undefined;
             return {
                 values: [...results],
@@ -2374,6 +2488,7 @@ export class GitHubApi {
                 hasMore: hasMore,
                 page: page,
                 truncated: truncated,
+                totalCount: maxIssueCount,
             };
         }
         catch (ex) {
@@ -2772,6 +2887,12 @@ __decorate([
 __decorate([
     trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 ], GitHubApi.prototype, "searchMyIssues", null);
+__decorate([
+    trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+], GitHubApi.prototype, "searchIssuesPage", null);
+__decorate([
+    trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
+], GitHubApi.prototype, "countIssues", null);
 __decorate([
     trace({ args: (provider, token) => ({ provider: provider.name, token: `<token:${token.microHash}>` }) })
 ], GitHubApi.prototype, "searchPullRequests", null);