@gitkraken/core-gitlens 0.12.0 → 0.14.0

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

@@ -10,7 +10,7 @@ import { toTokenWithInfo } from "../authentication/models.js";
 import "../providerFilters.js";
 import { decodePathSegment } from "../utils/domain.utils.js";
 import { collectProviderPagedResult, flatSettledResultsOrThrow, mergeCollectionMetadata, resolveBranchPullRequests, selectBranchPullRequests } from "./utils/providerPaging.js";
-import { fromProviderIssue, fromProviderPullRequest, getProviderPullRequestIdentity, providerPullRequestMatchesSearch, providersMetadata, toIssueShape, toProviderPullRequestStates } from "./models.js";
+import { fromProviderIssue, fromProviderPullRequest, getProviderPullRequestIdentity, providerPullRequestMatchesSearch, providersMetadata, toIssueShape, toProviderIssueStates, toProviderPullRequestStates } from "./models.js";
 import { toAzurePullRequestEtagFields, toAzureWorkItemEtagFields } from "./azure/models.js";
 import { GitHostIntegration } from "../models/gitHostIntegration.js";
 import { getAzurePullRequestIdentityFromMaybeUrl } from "./azure/azure.utils.js";
@@ -26,8 +26,18 @@ function getAzureRepositoryIdentity(repo) {
 	};
 }
 function getAzureRepositoryApiBaseUrl(baseUrl, repo) {
+	if (!isValidAzureVirtualDirectory(repo.virtualDirectory)) throw new Error(`Invalid Azure virtual directory '${repo.virtualDirectory}'.`);
+	const url = findAzureRepositoryApiBaseUrl(baseUrl, repo);
+	if (url == null) throw new Error("Azure repository virtual directory does not match the configured installation");
+	return url;
+}
+/**
+* {@link getAzureRepositoryApiBaseUrl}, `undefined` when the connection doesn't serve `repo`'s virtual directory or it
+* isn't a valid one.
+*/
+function findAzureRepositoryApiBaseUrl(baseUrl, repo) {
+	if (!isValidAzureVirtualDirectory(repo.virtualDirectory)) return void 0;
 	const directory = repo.virtualDirectory?.split("/");
-	if (directory?.some((segment) => !segment || segment === "." || segment === "..")) throw new Error(`Invalid Azure virtual directory '${repo.virtualDirectory}'.`);
 	const url = new URL(baseUrl);
 	const toUrl = (segments) => `${url.protocol}//${url.host}${segments.map((s) => `/${s}`).join("")}`;
 	const configured = url.pathname.split("/").filter(Boolean);
@@ -36,7 +46,39 @@ function getAzureRepositoryApiBaseUrl(baseUrl, repo) {
 	const installation = namesCollection ? configured.slice(0, -1) : configured;
 	if (directory == null) return toUrl(installation);
 	for (const candidate of namesCollection ? [configured, installation] : [configured]) if (candidate.length === directory.length && candidate.every((s, i) => sameAzurePathSegment(s, directory[i]))) return toUrl(candidate);
-	throw new Error("Azure repository virtual directory does not match the configured installation");
+}
+function isValidAzureVirtualDirectory(virtualDirectory) {
+	return !virtualDirectory?.split("/").some((segment) => !segment || segment === "." || segment === "..");
+}
+/**
+* The paths a project-less reading's `{vdir}/{owner}` can be below the connection `baseUrl` addresses: the address
+* itself, or its parent when the address names a collection (see {@link resolveAzureProjectlessRepository}). A
+* connection at the host root serves no virtual directory, so none.
+*/
+function getAzureProjectlessDirectories(baseUrl) {
+	const configured = new URL(baseUrl).pathname.split("/").filter(Boolean);
+	return [configured, configured.slice(0, -1)].filter((path) => path.length > 0);
+}
+/**
+* Whether `repo`'s path could be the project-less form of a repository named after its project, as read below the
+* connection `baseUrl` addresses: that reading moves the parsed owner into the virtual directory, so its directory and
+* owner must be one of {@link getAzureProjectlessDirectories}.
+*/
+function isAzureProjectlessCandidate(baseUrl, repo) {
+	if (getAzureRepositoryIdentity({
+		owner: repo.owner,
+		name: repo.name
+	}).projectName == null) return false;
+	const directory = [...repo.virtualDirectory?.split("/") ?? [], repo.owner];
+	return getAzureProjectlessDirectories(baseUrl).some((path) => path.length === directory.length && path.every((s, i) => sameAzurePathSegment(s, directory[i])));
+}
+/**
+* The virtual directory ahead of `owner` (empty when nothing is) in whichever of {@link getAzureProjectlessDirectories}
+* ends with it, `undefined` when none does. A caller-supplied repository scope carries only its owner, so this places
+* it where {@link isAzureProjectlessCandidate} expects it.
+*/
+function getAzureScopeVirtualDirectory(baseUrl, owner) {
+	return getAzureProjectlessDirectories(baseUrl).find((p) => sameAzurePathSegment(p.at(-1), owner))?.slice(0, -1).map(decodePathSegment).join("/");
 }
 function sameAzurePathSegment(encoded, value) {
 	return decodePathSegment(encoded).toLowerCase() === value.toLowerCase();
@@ -55,6 +97,28 @@ function uniqueAzureNames(names) {
 	return unique;
 }
 /**
+* Re-reads a remote's `{owner}/{project}/_git/{repo}` as the project-less form of a repository named after its
+* project: behind a path, `{vdir}/{collection}/_git/{repo}` parses as collection `{vdir}` and project `{collection}`.
+* When `collections` lists the parsed project but not the parsed owner, the owner joins the virtual directory, the
+* parsed project is the collection, and the project is the repository's own name. Otherwise returns `repo`.
+*/
+function resolveAzureProjectlessRepository(repo, collections) {
+	const { projectName, repositoryName } = getAzureRepositoryIdentity({
+		owner: repo.owner,
+		name: repo.name
+	});
+	if (projectName == null) return repo;
+	const collection = collections.find((c) => sameAzureName(c, projectName));
+	if (collection == null || collections.some((c) => sameAzureName(c, repo.owner))) return repo;
+	return {
+		...repo,
+		owner: collection,
+		name: `${repositoryName}/_git/${repositoryName}`,
+		project: repositoryName,
+		virtualDirectory: repo.virtualDirectory ? `${repo.virtualDirectory}/${repo.owner}` : repo.owner
+	};
+}
+/**
 * Flags the reviews of `pr` that name one of the current user's groups (see `PullRequestReviewer.isMyGroup`), which a
 * reviewer read finds through that group rather than through the user.
 */
@@ -119,6 +183,30 @@ var AzureDevOpsIntegrationBase = class extends GitHostIntegration {
 	collectionApiBaseUrl(session, _collection) {
 		return this.apiBaseUrlFor(session);
 	}
+	/**
+	* The repository a remote-derived descriptor names, and the base its requests append it to. Azure DevOps Services
+	* reads the descriptor as parsed; the server override first settles a path the parser can't (see
+	* {@link resolveAzureProjectlessRepository}).
+	*/
+	getRepositoryTarget(session, repo, _cancellation) {
+		return Promise.resolve({
+			repo,
+			baseUrl: getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo)
+		});
+	}
+	/**
+	* Reads `repo` with GitLens' Azure client at its target (see {@link getRepositoryTarget}). A read that finds nothing
+	* for a target whose path couldn't be settled may have addressed the wrong collection, so it throws instead, which
+	* keeps that miss out of the host's caches until the path can be settled.
+	*/
+	async readRepository(session, repo, read, cancellation) {
+		const azure = await this.authenticationService.apis.azure;
+		if (azure == null) return void 0;
+		const target = await this.getRepositoryTarget(session, repo, cancellation);
+		const result = await read(azure, target);
+		if (result == null && target.unsettled) throw new Error(`${this.name}: nothing read for '${target.repo.owner}/${target.repo.name}', whose collection couldn't be settled`);
+		return result;
+	}
 	/** Reads the organizations (Azure DevOps Server: the collections) the account can see. */
 	async requestResourcesForUser(session, userId) {
 		const api = await this.getProvidersApi();
@@ -467,19 +555,19 @@ var AzureDevOpsIntegrationBase = class extends GitHostIntegration {
 		this.ctx.hooks?.ui?.onError?.(`${ex.message}. Check branch policies, and ensure you have the necessary permissions to merge the pull request.`);
 	}
 	async getProviderAccountForCommit(session, repo, rev, options) {
-		return (await this.authenticationService.apis.azure)?.getAccountForCommit(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, rev, getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo), options);
+		return this.readRepository(session, repo, (azure, target) => azure.getAccountForCommit(this, toTokenWithInfo(this.id, session), target.repo.owner, target.repo.name, rev, target.baseUrl, options));
 	}
 	async getProviderAccountForEmail(_session, _repo, _email, _options) {
 		return Promise.resolve(void 0);
 	}
 	async getProviderDefaultBranch(session, repo, cancellation) {
-		return (await this.authenticationService.apis.azure)?.getDefaultBranch(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, { baseUrl: getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo) }, cancellation);
+		return this.readRepository(session, repo, (azure, target) => azure.getDefaultBranch(this, toTokenWithInfo(this.id, session), target.repo.owner, target.repo.name, { baseUrl: target.baseUrl }, cancellation), cancellation);
 	}
 	async getProviderLinkedIssueOrPullRequest(session, repo, { id }, type) {
-		return (await this.authenticationService.apis.azure)?.getIssueOrPullRequest(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, id, {
-			baseUrl: getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo),
+		return this.readRepository(session, repo, (azure, target) => azure.getIssueOrPullRequest(this, toTokenWithInfo(this.id, session), target.repo.owner, target.repo.name, id, {
+			baseUrl: target.baseUrl,
 			type
-		});
+		}));
 	}
 	async getProviderIssue(session, project, id) {
 		if ((await this.getProviderCurrentAccount(session))?.username == null) return void 0;
@@ -492,10 +580,10 @@ var AzureDevOpsIntegrationBase = class extends GitHostIntegration {
 		return (await this.authenticationService.apis.azure)?.getIssue(this, toTokenWithInfo(this.id, session), matchingProject, id, { baseUrl: this.collectionApiBaseUrl(session, matchingProject.resourceName) });
 	}
 	async getProviderPullRequestForBranch(session, repo, branch, _options) {
-		return (await this.authenticationService.apis.azure)?.getPullRequestForBranch(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, branch, { baseUrl: getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo) });
+		return this.readRepository(session, repo, (azure, target) => azure.getPullRequestForBranch(this, toTokenWithInfo(this.id, session), target.repo.owner, target.repo.name, branch, { baseUrl: target.baseUrl }));
 	}
 	async getProviderPullRequestForCommit(session, repo, rev) {
-		return (await this.authenticationService.apis.azure)?.getPullRequestForCommit(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, rev, getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo));
+		return this.readRepository(session, repo, (azure, target) => azure.getPullRequestForCommit(this, toTokenWithInfo(this.id, session), target.repo.owner, target.repo.name, rev, target.baseUrl));
 	}
 	/**
 	* One request per target, settled independently so one target's failure rejects only its own slot; converted
@@ -697,25 +785,27 @@ var AzureDevOpsIntegrationBase = class extends GitHostIntegration {
 		return resolveBranchPullRequests(targets, found, (coordinates) => this.getProviderPullRequestsBatch(session, coordinates, { currentAccount: options.currentAccount }, cancellation));
 	}
 	async getProviderPullRequest(session, resource, id) {
-		return (await this.authenticationService.apis.azure)?.getPullRequest(this, toTokenWithInfo(this.id, session), resource.owner, resource.project ?? resource.name, id, { baseUrl: getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), resource) });
+		return this.readRepository(session, resource, (azure, target) => azure.getPullRequest(this, toTokenWithInfo(this.id, session), target.repo.owner, target.repo.project ?? target.repo.name, id, { baseUrl: target.baseUrl }));
 	}
 	getProviderPullRequestIdentityFromMaybeUrl(search) {
 		return getAzurePullRequestIdentityFromMaybeUrl(search, this.id);
 	}
 	async getRepoInfo(repo) {
-		const identity = getAzureRepositoryIdentity(repo);
-		if (identity.projectName == null) return void 0;
+		if (getAzureRepositoryIdentity(repo).projectName == null) return void 0;
 		const api = await this.getProvidersApi();
 		const session = await this.resolveReadSessionOrThrow(repo.connectionId, void 0);
 		if (session == null) return void 0;
+		const target = await this.getRepositoryTarget(session, repo);
+		const identity = getAzureRepositoryIdentity(target.repo);
+		if (identity.projectName == null) return void 0;
 		const { tokenWithInfo, options } = this.getApiOptions(session);
 		return api.getRepo(tokenWithInfo, identity.resourceName, identity.repositoryName, identity.projectName, {
 			...options,
-			baseUrl: getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo)
+			baseUrl: target.baseUrl
 		});
 	}
 	async getProviderRepositoryMetadata(session, repo, cancellation) {
-		return (await this.authenticationService.apis.azure)?.getRepositoryMetadata(this, toTokenWithInfo(this.id, session), repo.owner, repo.name, { baseUrl: getAzureRepositoryApiBaseUrl(this.apiBaseUrlFor(session), repo) }, cancellation);
+		return this.readRepository(session, repo, (azure, target) => azure.getRepositoryMetadata(this, toTokenWithInfo(this.id, session), target.repo.owner, target.repo.name, { baseUrl: target.baseUrl }, cancellation), cancellation);
 	}
 	async searchProviderMyPullRequests(session, repos, _cancellation, options) {
 		if (repos != null) return;
@@ -991,7 +1081,8 @@ var AzureDevOpsIntegrationBase = class extends GitHostIntegration {
 				...this.getCollectionApiOptions(session, p.resourceName),
 				...filter,
 				cursor,
-				sort: searchOptions?.sort
+				sort: searchOptions?.sort,
+				states: toProviderIssueStates(searchOptions?.state)
 			}), 20, {
 				providerId: this.id,
 				resourceId: p.resourceId,
@@ -1156,6 +1247,6 @@ var AzureDevOpsIntegration = class extends AzureDevOpsIntegrationBase {
 	}
 };
 //#endregion
-export { AzureDevOpsIntegration, AzureDevOpsIntegrationBase, getAzureRepositoryApiBaseUrl, getAzureRepositoryIdentity, markMyGroupReviews, sameAzureName, toAzureReviewerReads, uniqueAzureNames };
+export { AzureDevOpsIntegration, AzureDevOpsIntegrationBase, findAzureRepositoryApiBaseUrl, getAzureRepositoryApiBaseUrl, getAzureRepositoryIdentity, getAzureScopeVirtualDirectory, isAzureProjectlessCandidate, markMyGroupReviews, resolveAzureProjectlessRepository, sameAzureName, toAzureReviewerReads, uniqueAzureNames };
 
 //# sourceMappingURL=azureDevOps.js.map