@gitkraken/core-gitlens 0.12.0 → 0.14.0

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

@@ -1,22 +1,20 @@
 import { mapSettledBounded } from "../../../utils/promise.js";
-import { PromiseCache } from "../../../utils/promiseCache.js";
 import { RequestNotFoundError } from "../../../git/errors.js";
 import { base64 } from "../../../utils/base64.js";
-import { isTerminalIssueStateCategory } from "../../../git/utils/issue.utils.js";
 import { toError } from "../errors.js";
 import "../constants.js";
 import { UnexpectedHtmlResponseError, getProviderResponseBodyMessage, isAzureProviderId, isProviderIssueNotFoundError, throwProviderError } from "./providerErrors.js";
 import { isIncompleteCollection, toCollectionScopeFailure } from "../collectionMetadata.js";
 import { toTokenWithInfo } from "../authentication/models.js";
 import { collectProviderPagedResult, mergeCollectionMetadata, parsePageCursor, toPageCursor } from "./utils/providerPaging.js";
-import { GitIssueState as GitIssueState$1, isRepoIdsInput, providersMetadata } from "./models.js";
-import { azureWorkItemEtagFieldNames, encodeAzurePathSegment, fromAzureWorkItemToProviderIssue } from "./azure/models.js";
-import { getAzureWorkItemTypeStatesUrl, parseAzureWorkItemTypeStates } from "./azure/workItemStateCategories.js";
+import { isRepoIdsInput, providersMetadata } from "./models.js";
+import { azureIssueStateCategory, azureWorkItemEtagFieldNames, encodeAzurePathSegment, fromAzureWorkItemToProviderIssue } from "./azure/models.js";
+import { AzureWorkItemStatesCache, getAzureWorkItemTypeStatesUrl, getAzureWorkItemTypesUrl } from "./azure/workItemStateCategories.js";
 import { requestJiraIssueByKey, requestJiraIssuesEtagFields } from "./jiraIssueByKey.js";
 import { requestLinearIssuesEtagFields } from "./linearIssuesEtag.js";
 import { requestBitbucketServerProjects, requestBitbucketServerRepositories } from "./bitbucket-server/discovery.js";
 import { countBitbucketServerPullRequests, searchBitbucketServerPullRequestsPage } from "./bitbucket-server/pullRequestSearch.js";
-import ProviderApis from "@gitkraken/provider-apis";
+import ProviderApis, { GitIssueState } from "@gitkraken/provider-apis";
 //#region ../plus/integrations/src/providers/providersApi.ts
 const createProviderApis = ProviderApis.default ?? ProviderApis;
 const repoNotFoundMessage = /^Repository .+ not found$/i;
@@ -49,21 +47,6 @@ function azureAuthorization(token, isPAT) {
 	return isPAT ? `Basic ${base64(`:${token}`)}` : `Bearer ${token}`;
 }
 const azureDevOpsBaseUrl = "https://dev.azure.com";
-/**
-* The work items of an Azure list read that are in the states it asked for. provider-apis selects them by their closed
-* and resolved dates (no state asks for open ones), while a row now also closes on its workflow category: a Removed work
-* item has neither date, so an open read would otherwise list it, closed. A read of closed work items is left as the
-* query selected it, since a resolved date alone selects one that carries no closed date or, when its type's states
-* could not be read, no category; and it can't be completed either, as the query never selects a dateless one.
-*/
-function withRequestedAzureIssueStates(issues, states) {
-	if (!(!states?.length || states.includes(GitIssueState$1.Open) && !states.includes(GitIssueState$1.Closed))) return issues;
-	return issues.filter((i) => i.closedDate == null && !isTerminalIssueStateCategory(i.state?.category));
-}
-/** How long a work item type's states classify its work items before they are read again. */
-const azureWorkItemTypeStatesTTL = 3e5;
-/** The most work item type state reads kept, across hosts, projects, types and credentials. */
-const azureWorkItemTypeStatesCapacity = 256;
 /** The most group descriptors one identity batch read resolves. */
 const azureIdentityBatchSize = 100;
 /** Azure DevOps Services serves the identity APIs from its own host, below the organization like the main one. */
@@ -137,19 +120,12 @@ function toJiraIssuePage(result) {
 }
 var ProvidersApi = class {
 	authenticationService;
+	azureWorkItemTypeStates;
 	providers;
 	request;
-	/**
-	* Each work item type's states, by URL (host, organization, project and type) and credential: coalesces the reads
-	* of the same type, and never answers one credential with what another one read. A failed read is not kept, so the
-	* next read retries it.
-	*/
-	azureWorkItemTypeStates = new PromiseCache({
-		createTTL: azureWorkItemTypeStatesTTL,
-		capacity: azureWorkItemTypeStatesCapacity
-	});
-	constructor(authenticationService) {
+	constructor(authenticationService, azureWorkItemTypeStates = new AzureWorkItemStatesCache()) {
 		this.authenticationService = authenticationService;
+		this.azureWorkItemTypeStates = azureWorkItemTypeStates;
 		const http = authenticationService.ctx.http;
 		const userAgent = http.userAgent;
 		const customFetch = async ({ url, ...options }) => {
@@ -1144,17 +1120,30 @@ var ProvidersApi = class {
 	}
 	async getIssuesForAzureProject(tokenOptInfo, namespace, project, options) {
 		const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, "getIssuesForAzureProjectFn");
-		const result = await this.getPagedResult({
+		const workItemTypeStates = options?.states?.includes(GitIssueState.Open) && options.states.includes(GitIssueState.Closed) ? void 0 : await this.getAzureProjectWorkItemStates(tokenWithInfo, namespace, project, options);
+		const page = await this.getPagedResult({
 			namespace,
 			project,
-			...options
+			...options,
+			workItemTypeStates
 		}, provider.getIssuesForAzureProjectFn, tokenWithInfo, options?.cursor, options?.isPAT, options?.baseUrl);
+		const result = workItemTypeStates?.metadata == null ? page : {
+			...page,
+			metadata: mergeCollectionMetadata(page.metadata, workItemTypeStates.metadata),
+			paging: {
+				...page.paging ?? {
+					cursor: "{}",
+					more: false
+				},
+				truncated: true
+			}
+		};
 		try {
-			await this.classifyAzureIssueStates(result.values, tokenWithInfo, namespace, project, options);
+			await this.classifyAzureIssueStates(result.values, tokenWithInfo, namespace, project, options, workItemTypeStates);
 		} catch (ex) {
 			return {
 				...result,
-				values: withRequestedAzureIssueStates(result.values, options?.states),
+				values: result.values,
 				paging: {
 					...result.paging ?? {
 						cursor: "{}",
@@ -1172,60 +1161,78 @@ var ProvidersApi = class {
 				})
 			};
 		}
+		return result;
+	}
+	azureStatesScope(token, namespace, project, options) {
 		return {
-			...result,
-			values: withRequestedAzureIssueStates(result.values, options?.states)
+			baseUrl: options?.baseUrl ?? azureDevOpsBaseUrl,
+			namespace,
+			project,
+			token: token.accessToken,
+			isPAT: options?.isPAT === true
 		};
 	}
-	/**
-	* Gives each of `issues` with both a type and a state the workflow category of that state, from its type's states
-	* (see {@link azureWorkItemTypeStates}): `undefined` for a state the type doesn't list. Keyed on the raw
-	* `System.State`, which is the state name on every Azure read here because core passes the SDK no state-name map;
-	* passing one would break the lookup.
-	*
-	* Reads each distinct type once, a bounded number at a time. A type whose read fails leaves its issues untouched,
-	* after the other types' issues are classified, and the first failure then rejects, classified by
-	* {@link handleProviderError}.
-	*/
-	async classifyAzureIssueStates(issues, tokenWithInfo, namespace, project, options) {
-		const baseUrl = options?.baseUrl ?? azureDevOpsBaseUrl;
-		const types = [...new Set(issues.flatMap((i) => i.state?.name && i.type ? [i.type] : []))];
-		if (!types.length) return;
-		const token = tokenWithInfo.accessToken;
-		const results = await mapSettledBounded(types, 6, async (type) => {
-			const url = getAzureWorkItemTypeStatesUrl(baseUrl, namespace, project, type);
-			return [type, await this.azureWorkItemTypeStates.getOrCreate(JSON.stringify([
-				baseUrl.replace(/\/$/, ""),
-				namespace.toLowerCase(),
-				project.toLowerCase(),
-				type.toLowerCase(),
-				token,
-				options?.isPAT === true
-			]), async () => {
-				try {
-					const response = await this.request({
-						url,
-						headers: { Authorization: azureAuthorization(token, options?.isPAT) }
-					});
-					return parseAzureWorkItemTypeStates(response.body);
-				} catch (ex) {
-					return this.handleProviderError(tokenWithInfo, ex);
+	async readAzureStatesMetadata(token, url, isPAT) {
+		try {
+			return (await this.request({
+				url,
+				headers: { Authorization: azureAuthorization(token.accessToken, isPAT) }
+			})).body;
+		} catch (ex) {
+			return this.handleProviderError(token, ex);
+		}
+	}
+	getAzureTypeStates(token, scope, type) {
+		return this.azureWorkItemTypeStates.getStates(scope, type, () => this.readAzureStatesMetadata(token, getAzureWorkItemTypeStatesUrl(scope.baseUrl, scope.namespace, scope.project, type), scope.isPAT));
+	}
+	async getAzureProjectWorkItemStates(token, namespace, project, options) {
+		const scope = this.azureStatesScope(token, namespace, project, options);
+		const failureScope = {
+			providerId: token.providerId,
+			resourceId: namespace,
+			projectId: project
+		};
+		let types;
+		try {
+			types = await this.azureWorkItemTypeStates.getTypes(scope, () => this.readAzureStatesMetadata(token, getAzureWorkItemTypesUrl(scope.baseUrl, namespace, project), scope.isPAT));
+		} catch (ex) {
+			return {
+				types: [],
+				metadata: {
+					completeness: "partial",
+					failures: [toCollectionScopeFailure(failureScope, ex)]
 				}
-			})];
-		});
-		const statesByType = /* @__PURE__ */ new Map();
-		let failure;
-		for (const result of results) if (result.status === "fulfilled") statesByType.set(result.value[0], result.value[1]);
-		else failure ??= result;
+			};
+		}
+		const results = await mapSettledBounded(types, 6, async (type) => ({
+			name: type,
+			states: await this.getAzureTypeStates(token, scope, type)
+		}));
+		const failures = results.flatMap((r) => r.status === "rejected" ? [toCollectionScopeFailure(failureScope, r.reason)] : []);
+		return {
+			types: results.map((r, i) => r.status === "fulfilled" ? r.value : { name: types[i] }),
+			...failures.length ? { metadata: {
+				completeness: "partial",
+				failures
+			} } : {}
+		};
+	}
+	async classifyAzureIssueStates(issues, tokenWithInfo, namespace, project, options, snapshot) {
+		const scope = this.azureStatesScope(tokenWithInfo, namespace, project, options);
+		const snapshotTypes = new Map(snapshot?.types.map((type) => [type.name, type.states]));
+		const types = [...new Set(issues.flatMap((i) => i.state?.name && i.type && !snapshotTypes.has(i.type) ? [i.type] : []))];
+		const results = await mapSettledBounded(types, 6, async (type) => [type, await this.getAzureTypeStates(tokenWithInfo, scope, type)]);
+		const statesByType = new Map([...snapshotTypes, ...results.flatMap((r) => r.status === "fulfilled" ? [r.value] : [])]);
 		for (const issue of issues) {
 			const states = issue.type ? statesByType.get(issue.type) : void 0;
 			if (states == null || issue.state == null) continue;
 			issue.state = {
 				...issue.state,
-				category: states.get(issue.state.name)
+				category: azureIssueStateCategory(states.find((s) => s.name === issue.state?.name)?.category)
 			};
 		}
-		if (failure != null) throw failure.reason;
+		const failure = results.find((r) => r.status === "rejected");
+		if (failure?.status === "rejected") throw failure.reason;
 	}
 	async getIssuesForProject(tokenOptInfo, project, resourceId, options) {
 		const { provider, tokenWithInfo } = await this.ensureProviderTokenAndFunction(tokenOptInfo, "getIssuesForProjectFn");