@gitkraken/core-gitlens 0.5.114 → 0.5.116

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

@@ -20,15 +20,8 @@ import {
 	GitSelfManagedHostIntegrationId,
 	IssuesCloudHostIntegrationId,
 } from '../constants.js';
-import {
-	AuthenticationError,
-	AuthenticationErrorReason,
-	isRateLimitResponse,
-	RequestClientError,
-	RequestNotFoundError,
-	toError,
-	toRateLimitError,
-} from '../errors.js';
+import { RequestNotFoundError, toError } from '../errors.js';
+import { requestJiraIssueByKey } from './jiraIssueByKey.js';
 import type {
 	GetIssueFn,
 	GetIssuesForReposFn,
@@ -69,6 +62,7 @@ import type {
 	PullRequestFilter,
 } from './models.js';
 import { isRepoIdsInput, providersMetadata } from './models.js';
+import { getProviderResponseBodyMessage, isProviderIssueNotFoundError, throwProviderError } from './providerErrors.js';
 import {
 	collectProviderPagedResult,
 	mergeCollectionMetadata,
@@ -88,7 +82,6 @@ const createProviderApis: ProviderApisFactory =
 // `Repository <x> not found`. Anchoring to that shape (rather than a loose `not found` substring) keeps
 // the message fallbacks from misclassifying unrelated GraphQL/transport failures as a confident negative.
 const repoNotFoundMessage = /^Repository .+ not found$/i;
-
 // Duck-typed rather than `ex instanceof GraphQLErrors`, because importing the class as a value makes this
 // module unloadable from plain Node ESM consumers: `@gitkraken/provider-apis` is CommonJS and declares its
 // exports through getters, which Node's `cjs-module-lexer` cannot see, so the only named exports it can
@@ -562,43 +555,13 @@ export class ProvidersApi {
 	}
 
 	private handleProviderError<T>(tokenWithInfo: TokenWithInfo, error: any): T {
-		const { accessToken: token, ...tokenInfo } = tokenWithInfo;
 		const providerId = tokenWithInfo.providerId;
 		const provider = this.providers[providerId];
 		if (provider == null) {
 			throw new Error(`Provider with id ${providerId} not registered`);
 		}
 
-		if (error?.response?.status != null) {
-			const status: number = error.response.status;
-			switch (status) {
-				case 404: // Not found
-				case 410: // Gone
-				case 422: // Unprocessable Entity
-					throw new RequestNotFoundError(error);
-				case 429: // Too Many Requests
-					throw toRateLimitError(error, token);
-				case 401: // Unauthorized
-				case 403: // Forbidden
-					// A throttled request arrives on both statuses depending on the host (see
-					// `isRateLimitResponse`); 403 previously skipped the check, so every provider going through the
-					// SDK reported a rate limit as `auth` and asked the user to reconnect a healthy account.
-					if (isRateLimitResponse({ status: status, message: error.message })) {
-						throw toRateLimitError(error, token);
-					}
-					throw new AuthenticationError(
-						tokenInfo,
-						status === 401 ? AuthenticationErrorReason.Unauthorized : AuthenticationErrorReason.Forbidden,
-						error,
-					);
-				default:
-					if (status >= 400 && status < 500) {
-						throw new RequestClientError(error);
-					}
-			}
-		}
-
-		throw error;
+		return throwProviderError(tokenWithInfo, error);
 	}
 
 	async getPagedResult<T>(
@@ -878,7 +841,7 @@ export class ProvidersApi {
 			/** See {@link GetIssuesOptions.sort}. Linear expresses `created`/`updated`, descending only. */
 			sort?: IssueSorting;
 		},
-	): Promise<PagedResult<ProviderIssue>> {
+	): Promise<ProviderApiPagedResult<ProviderIssue>> {
 		const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(
 			tokenOptInfo,
 			'getLinearIssuesFn',
@@ -1522,7 +1485,7 @@ export class ProvidersApi {
 		tokenOptInfo: TokenOptInfo,
 		reposOrIds: ProviderReposInput,
 		options?: GetIssuesOptions & { isPAT?: boolean; baseUrl?: string },
-	): Promise<PagedResult<ProviderIssue>> {
+	): Promise<ProviderApiPagedResult<ProviderIssue>> {
 		const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(
 			tokenOptInfo,
 			'getIssuesForReposFn',
@@ -1837,6 +1800,24 @@ export class ProvidersApi {
 		);
 	}
 
+	async getJiraIssueByKey(
+		tokenOptInfo: TokenWithInfo<IssuesCloudHostIntegrationId.Jira>,
+		resourceId: string,
+		resourceUrl: string,
+		key: string,
+	): Promise<ProviderIssue | undefined> {
+		const { tokenWithInfo } = await this.ensureProviderToken(tokenOptInfo);
+
+		try {
+			return await requestJiraIssueByKey(this.request, tokenWithInfo.accessToken, resourceId, resourceUrl, key);
+		} catch (e) {
+			const status = (e as { response?: { status?: unknown } }).response?.status;
+			if (status === 404) return undefined;
+
+			return this.handleProviderError<ProviderIssue | undefined>(tokenWithInfo, e);
+		}
+	}
+
 	async getIssue(
 		tokenOptInfo: TokenWithInfo,
 		input: { resourceId: string; number: string } | { namespace: string; name: string; number: string },
@@ -1854,6 +1835,8 @@ export class ProvidersApi {
 
 			return result?.data;
 		} catch (e) {
+			if (isProviderIssueNotFoundError(tokenWithInfo.providerId, e)) return undefined;
+
 			return this.handleProviderError<ProviderIssue | undefined>(tokenWithInfo, e);
 		}
 	}
@@ -1896,28 +1879,3 @@ async function parseFetchResponseForApi<T>(response: Response): Promise<Provider
 
 	return result;
 }
-
-const maxProviderErrorBodyLength = 500;
-
-/** Extracts the useful provider prose from an already-parsed SDK response body. */
-function getProviderResponseBodyMessage(body: unknown): string | undefined {
-	let message: string | undefined;
-	if (typeof body === 'string') {
-		message = body;
-	} else if (body != null && typeof body === 'object') {
-		const { message: direct, error } = body as { message?: unknown; error?: unknown };
-		if (typeof direct === 'string') {
-			message = direct;
-		} else if (typeof error === 'string') {
-			message = error;
-		} else if (error != null && typeof error === 'object') {
-			const nested = (error as { message?: unknown }).message;
-			if (typeof nested === 'string') {
-				message = nested;
-			}
-		}
-	}
-
-	message = message?.trim();
-	return message ? message.slice(0, maxProviderErrorBodyLength) : undefined;
-}

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

@@ -1,4 +1,3 @@
-import type { CollectionMetadata } from '@gitkraken/provider-apis';
 import type { Account } from '../../../git/models/author.js';
 import type { Issue, IssueShape } from '../../../git/models/issue.js';
 import type { IssueOrPullRequest, IssueOrPullRequestType } from '../../../git/models/issueOrPullRequest.js';
@@ -9,7 +8,7 @@ import type { ProviderAuthenticationSession } from '../authentication/models.js'
 import { toTokenWithInfo } from '../authentication/models.js';
 import { IssuesCloudHostIntegrationId } from '../constants.js';
 import { IntegrationReadUnavailableError } from '../errors.js';
-import type { IssuesForProjectOptions } from '../models/issueReads.js';
+import type { IssuesForProjectOptions, ProjectIssuesDrain } from '../models/issueReads.js';
 import { IssuesIntegration } from '../models/issuesIntegration.js';
 import { fromProviderIssue, providersMetadata, toIssueShape } from './models.js';
 
@@ -104,7 +103,7 @@ export class TrelloIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 		session: ProviderAuthenticationSession,
 		project: ResourceDescriptor,
 		options?: IssuesForProjectOptions,
-	): Promise<{ values: IssueShape[]; truncated: boolean; metadata?: CollectionMetadata } | undefined> {
+	): Promise<ProjectIssuesDrain | undefined> {
 		// A non-issue descriptor genuinely has nothing to read (empty), but a missing app key is a broken read.
 		if (!isIssueResourceDescriptor(project)) return undefined;
 
@@ -141,7 +140,9 @@ export class TrelloIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 		// never a cursor. Surface that as terminal truncation; there is no next page to fetch, so retrying the
 		// same read cannot recover the omitted cards (D11).
 		const truncated = result.metadata != null && result.metadata.completeness !== 'complete';
-		return { values: values, truncated: truncated, metadata: result.metadata };
+		return truncated
+			? { values: values, truncated: true, recovery: 'none', metadata: result.metadata }
+			: { values: values, truncated: false, metadata: result.metadata };
 	}
 
 	protected override searchProviderMyIssues(

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

@@ -32,17 +32,24 @@ export function parsePageCursor(cursor: string | undefined): number | undefined
 }
 
 /** Preserves successful sibling scopes, but doesn't turn an all-scope provider failure into an empty success. */
-export async function flatSettledOrThrow<T>(promises: Promise<T[]>[]): Promise<T[]> {
-	const results = await Promise.allSettled(promises);
-	const fulfilled = results.filter((result): result is PromiseFulfilledResult<T[]> => result.status === 'fulfilled');
-	if (fulfilled.length === 0) {
-		const rejected = results.find((result): result is PromiseRejectedResult => result.status === 'rejected');
-		if (rejected != null) throw rejected.reason;
-	}
+export function throwIfAllSettledFailed<T>(results: PromiseSettledResult<T>[]): void {
+	if (results.some(result => result.status === 'fulfilled')) return;
+
+	const rejected = results.find((result): result is PromiseRejectedResult => result.status === 'rejected');
+	if (rejected != null) throw rejected.reason;
+}
 
+export function flatSettledResultsOrThrow<T>(results: PromiseSettledResult<T[]>[]): T[] {
+	throwIfAllSettledFailed(results);
+
+	const fulfilled = results.filter((result): result is PromiseFulfilledResult<T[]> => result.status === 'fulfilled');
 	return fulfilled.flatMap(result => result.value);
 }
 
+export async function flatSettledOrThrow<T>(promises: Promise<T[]>[]): Promise<T[]> {
+	return flatSettledResultsOrThrow(await Promise.allSettled(promises));
+}
+
 /** Precedence for merged completeness: any known omission (`partial`) wins, then inability to confirm
  * (`unknown`), and only an all-`complete` set of pages stays `complete`. */
 const completenessRank: Record<CollectionCompleteness, number> = { partial: 2, unknown: 1, complete: 0 };

package/src/plus/integrations/reads/broaden.ts

@@ -25,6 +25,7 @@ import {
 	otherWarning,
 	truncationWarning,
 	unsupportedIssueSearchCriteriaWarning,
+	unusableSearchScopeMessage,
 } from './warnings.js';
 
 /**
@@ -350,21 +351,6 @@ interface OrgIssuesRead {
 	nothingToRead?: boolean;
 }
 
-/**
- * Whether this org can be read through the FILTERED issue search instead of the repository drain.
- *
- * Two conditions, and the second is not a formality: an empty org name is dropped by the provider's scope
- * translation rather than rejected, which would leave a search of the WHOLE HOST — so the scope is validated
- * through {@link resolveIssueSearchScope}, the same rule `searchIssuesPage` refuses on, rather than by an
- * `org.name.length > 0` written here and free to drift from it.
- */
-function canSearchOrgIssues(org: ProviderBroadenOrg): boolean {
-	return (
-		supportsFilteredIssueSearch(org.providerId) &&
-		resolveIssueSearchScope(undefined, org.name, undefined).rejection == null
-	);
-}
-
 /**
  * The org-scoped filtered search: ONE request per page, whatever the org contains.
  *
@@ -602,6 +588,34 @@ async function readOrgSlice(
 		);
 	}
 
+	// An org name NEITHER engine can use, refused before either is chosen. Declining the search for it is not
+	// enough, because falling through to the repository drain is not the safe default it looks like: the drain
+	// passes the SAME name to the org repository read, which matches nothing and reports `nothingToRead` — an
+	// org that reads as empty, with no warning and no `fetchFailed`, after up to 100 requests. Indistinguishable
+	// from an org that genuinely has no issues, and strictly worse than saying so.
+	//
+	// EVERY rejection, not just `unusable-scope`: with no repositories and no criteria the only other reachable
+	// one is `unscoped`, which here means exactly `org.name === ''` — the same bad outcome by the same route, so
+	// drawing the line between them would leave the emptiest case on the wrong side of the rule. (`repo-ids`
+	// cannot arise: no repositories are passed.) Refusing them all is also what lets the engine choice below be
+	// a plain capability question again, since no rejection survives this point.
+	const scopeRejection = resolveIssueSearchScope(undefined, org.name, undefined).rejection;
+	if (scopeRejection != null) {
+		return barrenSlice(
+			[
+				otherWarning(
+					org.providerId,
+					ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain),
+					connectionId,
+					scopeRejection.reason === 'unusable-scope'
+						? unusableSearchScopeMessage('issue broadening scopes', scopeRejection.scopes)
+						: 'Issue broadening must name an organization; one was supplied with an empty name.',
+				),
+			],
+			{ fetchFailed: true },
+		);
+	}
+
 	// An org a prior round already drained must not be re-read: cursor-only providers would answer a
 	// fresh page-1 request with their first page again, duplicating issues across rounds. Skip it
 	// before any work (including the repo drain) and keep it marked exhausted so it stays skipped
@@ -614,7 +628,12 @@ async function readOrgSlice(
 
 	const domain = ctx.domainForRead(integration, org.providerId, connectionId, requestedDomain);
 	const cursor = getBroadenIssuesCursor(options.cursor, org, page, options.orgs.length);
-	const read = canSearchOrgIssues(org)
+	// A plain capability question, and only because the refusal above has already turned away every org whose
+	// name the scope rule rejects. That order matters: `readOrgIssuesViaSearch` calls the integration's
+	// `searchIssuesPageResult` directly rather than the `searchIssuesPage` read, and that method documents its
+	// scope as already validated ("the facade rejects it before here") — so an unvalidated name reaching it would
+	// go straight to the provider query that sanitizes it.
+	const read = supportsFilteredIssueSearch(org.providerId)
 		? await readOrgIssuesViaSearch(integration, org, domain, cursor)
 		: await readOrgIssuesViaRepoDrain(integration, org, domain, cursor);
 	if (read.nothingToRead === true) {

package/src/plus/integrations/reads/counts.ts

@@ -27,6 +27,7 @@ import {
 	otherWarning,
 	unsupportedIssueSearchCriteriaWarning,
 	unsupportedPullRequestSearchCriteriaWarning,
+	unusableSearchScopeMessage,
 } from './warnings.js';
 
 /**
@@ -199,6 +200,23 @@ export async function countIssues(
 		return refused(issuesUnsupportedWarning(options.providerId, domain, options.connectionId));
 	}
 
+	// A provider with no filtered issue search has no count either: refuse ONCE for the provider rather than
+	// letting every scope repeat the same rejection. `undefined` criteria probes only the search's existence.
+	// Matches `countPullRequests`. Refusing it here rather than per scope also keeps the loop's warnings from
+	// being dominated by N copies of one provider-level fact — see the dedupe below, which handles the
+	// keyless refusals that remain.
+	const searchSupport = resolveIssueSearchCriteria(options.providerId, undefined);
+	if (searchSupport.rejection != null) {
+		return refused(
+			unsupportedIssueSearchCriteriaWarning(
+				options.providerId,
+				domain,
+				options.connectionId,
+				searchSupport.rejection,
+			),
+		);
+	}
+
 	const providerLimit = providersMetadata[options.providerId]?.issueSearchResultLimit;
 	const warnings: ProviderWarning[] = [];
 	let fetchFailed = false;
@@ -209,10 +227,12 @@ export async function countIssues(
 	for (const scope of options.scopes) {
 		const warning = rejectScope(options.providerId, domain, options.connectionId, scope);
 		if (warning != null) {
-			// `push`, not `appendDedupedWarning`: every rejection message embeds the scope's own key, and duplicate
-			// keys were already refused above, so no two of these can ever collapse — deduping them would only pay
-			// the O(n²) key comparison to prove it.
-			warnings.push(warning);
+			// Deduped rather than pushed. The rejections that name the offending SCOPE embed its own key, and
+			// duplicate keys were already refused above, so those can never collapse. But the ones that report a
+			// PROVIDER-level fact — a criterion it cannot express, a contradictory relationship pair — name no
+			// scope, so several scopes failing the same way produce byte-identical warnings, and one refusal
+			// reported N times reads as N different problems.
+			appendDedupedWarning(warnings, warning);
 			fetchFailed = true;
 			continue;
 		}
@@ -304,8 +324,15 @@ function rejectScope(
 	connectionId: string | undefined,
 	scope: IssueCountScope,
 ): ProviderWarning | undefined {
+	const resolved = resolveIssueSearchCriteria(providerId, scope.criteria);
+	if (resolved.rejection != null) {
+		return unsupportedIssueSearchCriteriaWarning(providerId, domain, connectionId, resolved.rejection);
+	}
+
+	// AFTER the criteria check, mirroring `searchIssuesPage`: a provider with no filtered issue search is the more
+	// fundamental refusal, and a count must preview the refusal its read would give.
 	const scoping = resolveIssueSearchScope(scope.repos, scope.org, scope.criteria);
-	switch (scoping.rejection) {
+	switch (scoping.rejection?.reason) {
 		case 'repo-ids':
 			return otherWarning(
 				providerId,
@@ -320,11 +347,15 @@ function rejectScope(
 				connectionId,
 				`Issue count scope '${scope.key}' is unscoped; pass \`repos\`, \`org\`, or a relationship to the current user. \`any-assignee\` and \`unassigned\` are not scopes.`,
 			);
-	}
-
-	const resolved = resolveIssueSearchCriteria(providerId, scope.criteria);
-	if (resolved.rejection != null) {
-		return unsupportedIssueSearchCriteriaWarning(providerId, domain, connectionId, resolved.rejection);
+		// A count applies exactly the qualifiers its search would, so an unusable scope would make it agree with
+		// the wrong search rather than expose it — see `isUsableSearchScopeName`.
+		case 'unusable-scope':
+			return otherWarning(
+				providerId,
+				domain,
+				connectionId,
+				unusableSearchScopeMessage('scopes', scoping.rejection.scopes, `Issue count scope '${scope.key}'`),
+			);
 	}
 
 	// Count-only, with no counterpart in the read: a relationship set is an OR across several searches, which one
@@ -435,9 +466,11 @@ export async function countPullRequests(
 	for (const scope of options.scopes) {
 		const warning = rejectPullRequestScope(options.providerId, domain, options.connectionId, scope);
 		if (warning != null) {
-			// `push`, not `appendDedupedWarning`: every rejection message embeds the scope's own key, and duplicate
-			// keys were already refused above, so no two of these can ever collapse.
-			warnings.push(warning);
+			// Deduped rather than pushed: see the issue twin. Here the keyless set is wider — besides the criteria
+			// rejections, `unsupported-repository-scope` and `unsupported-organization-scope` are scope rejections
+			// that route through the criteria warning and name no key, and both are provider-level facts every
+			// scope would repeat.
+			appendDedupedWarning(warnings, warning);
 			fetchFailed = true;
 			continue;
 		}
@@ -516,7 +549,7 @@ function rejectPullRequestScope(
 	scope: PullRequestCountScope,
 ): ProviderWarning | undefined {
 	const scoping = resolvePullRequestSearchScope(providerId, scope.repos, scope.org, scope.criteria);
-	switch (scoping.rejection) {
+	switch (scoping.rejection?.reason) {
 		case 'repo-ids':
 			return otherWarning(
 				providerId,
@@ -536,9 +569,23 @@ function rejectPullRequestScope(
 			return unsupportedPullRequestSearchCriteriaWarning(providerId, domain, connectionId, {
 				reason: 'unsupported-criteria',
 				criteria: [
-					scoping.rejection === 'unsupported-repository-scope' ? 'repositoryScope' : 'organizationScope',
+					scoping.rejection.reason === 'unsupported-repository-scope'
+						? 'repositoryScope'
+						: 'organizationScope',
 				],
 			});
+		// See the issue twin, and `isUsableSearchScopeName` for the rule.
+		case 'unusable-scope':
+			return otherWarning(
+				providerId,
+				domain,
+				connectionId,
+				unusableSearchScopeMessage(
+					'scopes',
+					scoping.rejection.scopes,
+					`Pull request count scope '${scope.key}'`,
+				),
+			);
 	}
 
 	const resolved = resolvePullRequestSearchCriteria(providerId, scope.criteria);