@gitkraken/core-gitlens 0.5.113 → 0.5.115

package/src/plus/git-github/api/issueSearchQuery.ts

@@ -1,4 +1,9 @@
-import type { IssueSearchCriteria, IssueSearchRelationship, IssueSorting } from '../../../git/models/issue.js';
+import type {
+	IssueSearchCriteria,
+	IssueSearchRelationship,
+	IssueSortField,
+	IssueSorting,
+} from '../../../git/models/issue.js';
 
 /**
  * Translation of the provider-neutral issue-search criteria into GitHub search qualifiers, and the sanitizing
@@ -120,6 +125,49 @@ export function toGitHubIssueSortQualifier(sort: IssueSorting | undefined): stri
 	return sort != null ? gitHubIssueSortQualifiers[sort] : undefined;
 }
 
+/**
+ * The sort keys a CEILING SLIDE can continue past, and the qualifier each one continues with.
+ *
+ * The slide works by re-issuing the search bounded to the far side of what has already been served, which needs
+ * two things from the sort key: a value carried on the returned issue (so the boundary can be read off the last
+ * item), and a GitHub range qualifier over that same value (so the continuation can be expressed). Only the two
+ * date keys have both. `comments`/`reactions` have range qualifiers but their values are unstable under
+ * concurrent activity — a comment added mid-walk moves an issue across the boundary, which would drop or repeat
+ * it — and `title` has no range qualifier at all. Those keep reporting the ceiling instead, which is correct
+ * rather than a gap: the read stays truthful about what it could not reach.
+ *
+ * A `Partial<Record<…>>` over the union rather than a lookup with a default, so a sort key added later is
+ * NOT-slidable by construction and has to be opted in deliberately.
+ */
+const gitHubSlidableSortFields: Partial<Record<IssueSortField, string>> = {
+	created: 'created',
+	updated: 'updated',
+};
+
+/**
+ * The qualifier that continues a search past the provider's result ceiling: everything at or beyond the last
+ * item already served, under the same key the search is ordered by.
+ *
+ * INCLUSIVE (`<=` / `>=`) rather than exclusive, and that is a correctness requirement rather than a preference.
+ * GitHub timestamps have one-second resolution and ties genuinely occur (measured: one shared second in a
+ * 100-issue sample), so an exclusive bound would silently drop every issue sharing the boundary second with the
+ * last one served. Being inclusive re-serves that second instead, which the caller dedupes.
+ *
+ * Returns `undefined` when the key can't be slid ({@link gitHubSlidableSortFields}), which is the signal to
+ * report the ceiling rather than to continue.
+ */
+export function toGitHubIssueSearchSlideQualifier(sort: IssueSorting, boundary: Date): string | undefined {
+	const [field, direction] = sort.split(':') as [IssueSortField, 'asc' | 'desc'];
+	const qualifier = gitHubSlidableSortFields[field];
+	if (qualifier == null) return undefined;
+
+	// Whole seconds, matching both GitHub's own resolution and what its range qualifiers accept.
+	const value = boundary.toISOString().replace(/\.\d{3}Z$/, 'Z');
+	// Descending walks toward older, so the remainder is everything at or BEFORE the boundary; ascending is the
+	// mirror. Getting this backwards would re-request the half already served, forever.
+	return `${qualifier}:${direction === 'desc' ? '<=' : '>='}${value}`;
+}
+
 /**
  * The scope half of an issue search query: `org:` plus one `repo:` per repository.
  *

package/src/plus/git-github/providers/github/blame.ts

@@ -1,4 +1,5 @@
 import type { Cache } from '../../../../git/cache.js';
+import { shouldEvictBlameCacheEntry } from '../../../../git/cache.js';
 import type { GitBlame, GitBlameAuthor, ProgressiveGitBlame } from '../../../../git/models/blame.js';
 import type { GitCommitLine } from '../../../../git/models/commit.js';
 import { GitCommit, GitCommitIdentity } from '../../../../git/models/commit.js';
@@ -48,7 +49,7 @@ export class BlameGitHubSubProvider implements GitBlameSubProvider {
 
 				return createCompletedBlame(blame);
 			},
-			{ errorTTL: 1000 * 60 },
+			{ errorTTL: 1000 * 60, evictWhen: shouldEvictBlameCacheEntry },
 		);
 		return progressive?.completed;
 	}

package/src/plus/integrations/collectionMetadata.ts

@@ -7,7 +7,13 @@ import type {
 // Matched by its `code` discriminator rather than by `instanceof`: the SDK ships one bundle per entry point, so
 // the class reached through the root is not the same object as the one reached through `/providers`.
 import { isInvalidRequestError, isUnsupportedSortError } from '@gitkraken/provider-apis';
-import { AuthenticationError, RequestNotFoundError, RequestRateLimitError } from '../../git/errors.js';
+import {
+	AuthenticationError,
+	RequestClientError,
+	RequestNotFoundError,
+	RequestRateLimitError,
+} from '../../git/errors.js';
+import type { TokenWithInfo } from './authentication/models.js';
 import type { IntegrationIds } from './constants.js';
 import { isRateLimitResponse } from './errors.js';
 import type { ProviderWarning, ProviderWarningOmission } from './results.js';
@@ -97,6 +103,22 @@ function toCollectionFailureWarningKind(failure: CollectionScopeFailure): Provid
 	}
 }
 
+export function toCollectionFailureError(failure: CollectionScopeFailure, tokenWithInfo: TokenWithInfo): Error {
+	const error = new Error(failure.message ?? 'Provider request failed');
+	const kind = toCollectionFailureWarningKind(failure);
+	const { accessToken, ...tokenInfo } = tokenWithInfo;
+	if (kind === 'auth') return new AuthenticationError(tokenInfo, error.message, error);
+	if (kind === 'rate-limit') return new RequestRateLimitError(error, accessToken, undefined);
+	if (kind === 'not-found') return new RequestNotFoundError(error);
+
+	const status = getCollectionFailureStatus(failure.message);
+	if (kind === 'other' && status != null && status >= 400 && status < 500) {
+		return new RequestClientError(error);
+	}
+
+	return error;
+}
+
 /** ` (resource r, project p, repository o/n)` for the scope IDs present; empty when the scope names none. */
 function collectionScopeText(scope: CollectionScope | undefined): string {
 	const parts: string[] = [];

package/src/plus/integrations/context.ts

@@ -148,7 +148,7 @@ export interface IntegrationCacheProvider {
 		resource: ResourceDescriptor,
 		integration: IntegrationBase | undefined,
 		cacheable: Cacheable<Issue>,
-		options?: CacheExpiryOptions,
+		options?: CacheExpiryOptions & { connectionId?: string; etag?: string },
 	): CacheResult<Issue>;
 	getCurrentAccount(
 		integration: IntegrationBase,

package/src/plus/integrations/index.ts

@@ -225,6 +225,7 @@ export type { IssueSearchCapabilities, IssueSearchCriteria, IssueSearchRelations
 export type { PullRequestSearchCapabilities, PullRequestSearchCriteria } from './providerFilters.js';
 // The count-only issue probe's input and result shapes.
 export type { IssueCountResult, IssueCountScope } from './reads/counts.js';
+export type { TrackerIssueResult } from './reads/trackerIssue.js';
 // Cross-provider PR/issue state filters (string unions in the git models).
 export type { PullRequestStateFilter } from '../../git/models/pullRequest.js';
 export type { IssueStateFilter } from '../../git/models/issue.js';

package/src/plus/integrations/integrationService.ts

@@ -87,6 +87,8 @@ import { countIssues, countPullRequests } from './reads/counts.js';
 import type { SupportedFilters } from './reads/filters.js';
 import { getSupportedFilters } from './reads/filters.js';
 import { listOrgs, listProjects, listRepos } from './reads/hierarchy.js';
+import type { IssueBatchResult, IssueBatchTarget } from './reads/issueBatch.js';
+import { getIssuesBatch } from './reads/issueBatch.js';
 import { listIssuesPage } from './reads/issues.js';
 import { listIssueTrackerIssuesPage } from './reads/issueTracker.js';
 import { listPullRequestsPage } from './reads/pullRequests.js';
@@ -94,6 +96,8 @@ import { resolveRepository } from './reads/resolveRepository.js';
 import { searchIssuesPage } from './reads/searchIssues.js';
 import { searchPullRequestsPage } from './reads/searchPullRequests.js';
 import { sweepClosedPullRequests, sweepPullRequests } from './reads/sweeps.js';
+import type { TrackerIssueResult } from './reads/trackerIssue.js';
+import { getTrackerIssue } from './reads/trackerIssue.js';
 import { noConnectionWarning } from './reads/warnings.js';
 import type {
 	ConnectionStateChangeEvent,
@@ -745,7 +749,6 @@ export class IntegrationService implements Disposable, RepositoryResolutionConte
 	async getMyPullRequests(
 		integrationIds?: (GitCloudHostIntegrationId | CloudGitSelfManagedHostIntegrationIds)[],
 		cancellation?: AbortSignal,
-		silent?: boolean,
 		options?: SearchMyPullRequestsOptions,
 	): Promise<IntegrationResult<PullRequest[] | undefined>> {
 		const integrations: Map<GitHostIntegration, ResourceDescriptor[] | undefined> = new Map();
@@ -762,13 +765,12 @@ export class IntegrationService implements Disposable, RepositoryResolutionConte
 		}
 		if (integrations.size === 0) return undefined;
 
-		return this.getMyPullRequestsCore(integrations, cancellation, silent, options);
+		return this.getMyPullRequestsCore(integrations, cancellation, options);
 	}
 
 	private async getMyPullRequestsCore(
 		integrations: Map<GitHostIntegration, ResourceDescriptor[] | undefined>,
 		cancellation?: AbortSignal,
-		silent?: boolean,
 		options?: SearchMyPullRequestsOptions,
 	): Promise<IntegrationResult<PullRequest[] | undefined>> {
 		const start = performance.now();
@@ -777,7 +779,7 @@ export class IntegrationService implements Disposable, RepositoryResolutionConte
 		for (const [integration, repos] of integrations) {
 			if (integration == null) continue;
 
-			promises.push(integration.searchMyPullRequests(repos, cancellation, silent, undefined, undefined, options));
+			promises.push(integration.searchMyPullRequests(repos, cancellation, options));
 		}
 
 		const results = await Promise.allSettled(promises);
@@ -1156,6 +1158,29 @@ export class IntegrationService implements Disposable, RepositoryResolutionConte
 		return countIssues(this, options);
 	}
 
+	async getIssuesBatch(options: {
+		providerId: IntegrationIds;
+		targets: readonly IssueBatchTarget[];
+		connectionId?: string;
+		/**
+		 * Explicit self-managed host domain. Used only when the requested connection has no configured domain;
+		 * it must come from the trusted authentication configuration, not repository or remote data.
+		 */
+		domain?: string;
+	}): Promise<ProviderResult<IssueBatchResult>> {
+		return getIssuesBatch(this, options);
+	}
+
+	async getTrackerIssue(options: {
+		providerId: IntegrationIds;
+		resourceId: string;
+		resourceUrl?: string;
+		key: string;
+		connectionId?: string;
+	}): Promise<ProviderResult<TrackerIssueResult>> {
+		return getTrackerIssue(this, options);
+	}
+
 	/**
 	 * How many pull requests match each scope, without fetching any — the PR twin of {@link countIssues}. See
 	 * {@link IntegrationManager.countPullRequests} for the cost model, the per-scope isolation rules, and why

package/src/plus/integrations/manager.ts

@@ -16,6 +16,8 @@ import type {
 	PullRequestCountScope,
 } from './reads/counts.js';
 import type { SupportedFilters } from './reads/filters.js';
+import type { IssueBatchResult, IssueBatchTarget } from './reads/issueBatch.js';
+import type { TrackerIssueResult } from './reads/trackerIssue.js';
 import type {
 	ConnectionStateChangeEvent,
 	ProviderBroadenResult,
@@ -563,6 +565,52 @@ export interface IntegrationManager {
 		/** Self-managed host domain fallback; see {@link ProviderSweepTarget.domain}. */
 		domain?: string;
 	}): Promise<ProviderResult<IssueCountResult>>;
+	/**
+	 * Resolves several issues BY COORDINATE — `(owner, repo, number)` — in one request.
+	 *
+	 * The read for "which issue does this branch name reference", which is an IDENTITY question rather than a
+	 * search. Emulating it by paging a scoped list and matching the identifier cannot prove absence without
+	 * walking the whole scope, so a miss stays unproven, uncacheable, and repeats its whole budget on every pass.
+	 * This answers it in one request per chunk, and a miss is final.
+	 *
+	 * Results are echoed under the caller's own `key`, so no positional matching is needed. Per-target isolation
+	 * is the rule: a chunk that fails upstream warns and drops only its own targets (with `fetchFailed` set) while
+	 * every other target still answers.
+	 *
+	 * `issue: undefined` means PROVEN ABSENT — the issue does not exist, or is not visible to this connection —
+	 * and is safe to cache. A target whose chunk failed is NOT returned at all, so the two are distinguishable;
+	 * caching a failure as an absence is exactly the bug this distinction prevents. GitHub/GHE only: a provider
+	 * that cannot batch refuses outright rather than degrading into N requests behind the caller's back.
+	 */
+	getIssuesBatch(options: {
+		providerId: IntegrationIds;
+		/** Each `key` must be unique — a duplicate refuses the whole call, since keys identify results. */
+		targets: readonly IssueBatchTarget[];
+		connectionId?: string;
+		/** Self-managed host domain fallback; see {@link ProviderSweepTarget.domain}. */
+		domain?: string;
+	}): Promise<ProviderResult<IssueBatchResult>>;
+	/**
+	 * Resolves one issue-tracker issue by key within a resource — the tracker counterpart of
+	 * {@link getIssuesBatch}, which cannot serve one.
+	 *
+	 * `issue: undefined` is a proven absence and may be cached. A failed read returns no item and sets
+	 * `fetchFailed`. `resourceId` is required and trusted; Jira also requires the resource's site URL so the result
+	 * retains its browser link. The read performs no resource discovery.
+	 *
+	 * Jira and Linear only. Trello refuses: its single-issue read falls back to a capped board scan for a numeric
+	 * identifier, so it cannot prove absence.
+	 */
+	getTrackerIssue(options: {
+		providerId: IntegrationIds;
+		/** Provider resource ID for the Atlassian site or Linear workspace. */
+		resourceId: string;
+		/** Jira site URL from resource discovery. Required for Jira so the result retains a browser link. */
+		resourceUrl?: string;
+		/** The provider's own key, e.g. `ABC-123`. Not a number. */
+		key: string;
+		connectionId?: string;
+	}): Promise<ProviderResult<TrackerIssueResult>>;
 	/**
 	 * How many pull requests match each scope, fetching none of them — the PR twin of {@link countIssues}, behind a
 	 * "this will fetch ~N pull requests" preview and a live count next to an unapplied filter. Same cost model,