@gitkraken/core-gitlens 0.4.0 → 0.4.100

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

@@ -1,30 +1,37 @@
 import type { UnidentifiedAuthor } from '../../../../git/models/author.js';
+import type { DefaultBranch } from '../../../../git/models/defaultBranch.js';
 import type { Issue } from '../../../../git/models/issue.js';
 import type { IssueOrPullRequest, IssueOrPullRequestType } from '../../../../git/models/issueOrPullRequest.js';
 import type { PullRequest } from '../../../../git/models/pullRequest.js';
 import type { Provider } from '../../../../git/models/remoteProvider.js';
+import type { RepositoryMetadata } from '../../../../git/models/repositoryMetadata.js';
 import { base64 } from '../../../../utils/base64.js';
-import { CancellationError } from '../../../../utils/cancellation.js';
+import { CancellationError, isCancellationError } from '../../../../utils/cancellation.js';
 import { trace } from '../../../../utils/decorators/log.js';
 import type { Disposable } from '../../../../utils/disposable.js';
 import { Logger } from '../../../../utils/logger.js';
 import type { ScopedLogger } from '../../../../utils/logger.scoped.js';
 import { getScopedLogger } from '../../../../utils/logger.scoped.js';
 import { maybeStopWatch } from '../../../../utils/stopwatch.js';
-import type { TokenInfo, TokenWithInfo } from '../../authentication/models.js';
+import type { TokenWithInfo } from '../../authentication/models.js';
 import type { IntegrationServiceContext } from '../../context.js';
 import {
 	AuthenticationError,
 	AuthenticationErrorReason,
+	isRateLimitResponse,
 	ProviderFetchError,
 	RequestClientError,
 	RequestNotFoundError,
+	toRateLimitError,
 } from '../../errors.js';
+import type { ProviderApiConfig } from '../apiConfig.js';
+import { baseProviderApiConfig } from '../apiConfig.js';
 import type {
 	AzureGitCommit,
 	AzureProjectDescriptor,
 	AzurePullRequest,
 	AzurePullRequestWithLinks,
+	AzureRepositoryWithMetadata,
 	AzureWorkItemState,
 	AzureWorkItemStateCategory,
 	WorkItem,
@@ -37,6 +44,7 @@ import {
 	getAzurePullRequestWebUrl,
 	isClosedAzurePullRequestStatus,
 	isClosedAzureWorkItemStateCategory,
+	normalizeAzureBranchName,
 } from './models.js';
 
 class WorkItemStates {
@@ -89,19 +97,15 @@ class WorkItemStates {
 }
 
 export class AzureDevOpsApi implements Disposable {
-	private readonly _disposable: Disposable;
+	private readonly _disposable: Disposable | undefined;
 	private _workItemStates: WorkItemStates = new WorkItemStates();
 
-	constructor(private readonly ctx: IntegrationServiceContext) {
-		this._disposable = ctx.config.onDidChange(e => {
-			if (e.httpProxy) {
-				this.resetCaches();
-			}
-		});
+	constructor(private readonly config: ProviderApiConfig) {
+		this._disposable = config.onConfigChanged?.(() => this.resetCaches());
 	}
 
 	dispose(): void {
-		this._disposable.dispose();
+		this._disposable?.dispose();
 	}
 
 	private resetCaches(): void {
@@ -574,6 +578,132 @@ export class AzureDevOpsApi implements Disposable {
 		}
 	}
 
+	@trace({
+		args: (provider, token, owner, repo) => ({
+			provider: provider.name,
+			token: `<token:${token.microHash}>`,
+			owner: owner,
+			repo: repo,
+		}),
+	})
+	async getRepositoryMetadata(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		repo: string,
+		options: {
+			baseUrl: string;
+		},
+		cancellation?: AbortSignal,
+	): Promise<RepositoryMetadata | undefined> {
+		const scope = getScopedLogger();
+
+		try {
+			const response = await this.getRepository(
+				provider,
+				token,
+				owner,
+				repo,
+				options.baseUrl,
+				scope,
+				cancellation,
+			);
+			if (response == null) return undefined;
+
+			// Azure's `parentRepository` only reliably carries the repo name and its project; a fork's parent
+			// lives in the same organization, so the org (`owner`) is the parent owner. Only report `parent`
+			// when the parent's name is actually present — never fall back to the fork's own name.
+			return {
+				provider: provider,
+				owner: owner,
+				// Prefer the API's canonical name over parsing the composite `repo` descriptor string.
+				name: response.name,
+				isFork: response.isFork ?? false,
+				parent:
+					response.isFork && response.parentRepository?.name != null
+						? { owner: owner, name: response.parentRepository.name }
+						: undefined,
+			} satisfies RepositoryMetadata;
+		} catch (ex) {
+			// Cancellations and 404s are expected outcomes for a probe; don't log them as errors.
+			if (!isCancellationError(ex) && !(ex instanceof RequestNotFoundError)) {
+				scope?.error(ex);
+			}
+			return undefined;
+		}
+	}
+
+	@trace({
+		args: (provider, token, owner, repo) => ({
+			provider: provider.name,
+			token: `<token:${token.microHash}>`,
+			owner: owner,
+			repo: repo,
+		}),
+	})
+	async getDefaultBranch(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		repo: string,
+		options: {
+			baseUrl: string;
+		},
+		cancellation?: AbortSignal,
+	): Promise<DefaultBranch | undefined> {
+		const scope = getScopedLogger();
+
+		try {
+			const response = await this.getRepository(
+				provider,
+				token,
+				owner,
+				repo,
+				options.baseUrl,
+				scope,
+				cancellation,
+			);
+			if (response?.defaultBranch == null) return undefined;
+
+			return {
+				provider: provider,
+				name: normalizeAzureBranchName(response.defaultBranch),
+			} satisfies DefaultBranch;
+		} catch (ex) {
+			// Cancellations and 404s are expected outcomes for a probe; don't log them as errors.
+			if (!isCancellationError(ex) && !(ex instanceof RequestNotFoundError)) {
+				scope?.error(ex);
+			}
+			return undefined;
+		}
+	}
+
+	private getRepository(
+		provider: Provider,
+		token: TokenWithInfo,
+		owner: string,
+		repo: string,
+		baseUrl: string,
+		scope: ScopedLogger | undefined,
+		cancellation?: AbortSignal,
+	): Promise<AzureRepositoryWithMetadata | undefined> {
+		const parts = repo.split('/');
+		const [projectName, segment, repoName] = parts;
+		// The descriptor must be exactly `"{project}/_git/{repoName}"`; bail before issuing a bogus request.
+		if (parts.length !== 3 || segment !== '_git' || !projectName || !repoName) {
+			throw new Error(`Invalid Azure repository descriptor '${repo}'; expected '{project}/_git/{repoName}'.`);
+		}
+		return this.request<AzureRepositoryWithMetadata>(
+			provider,
+			token,
+			baseUrl,
+			`${owner}/${projectName}/_apis/git/repositories/${repoName}?api-version=7.1`,
+			{ method: 'GET' },
+			scope,
+			cancellation,
+		);
+	}
+
 	private async request<T>(
 		provider: Provider,
 		token: TokenWithInfo,
@@ -583,7 +713,7 @@ export class AzureDevOpsApi implements Disposable {
 		scope: ScopedLogger | undefined,
 		cancellation?: AbortSignal | undefined,
 	): Promise<T | undefined> {
-		const { accessToken, ...tokenInfo } = token;
+		const { accessToken } = token;
 		const url = baseUrl ? `${baseUrl}/${route}` : route;
 
 		let rsp: Response;
@@ -593,8 +723,8 @@ export class AzureDevOpsApi implements Disposable {
 			try {
 				if (cancellation?.aborted) throw new CancellationError();
 
-				rsp = await this.ctx.http.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
-					this.ctx.http.fetch(url, {
+				rsp = await this.config.wrapForForcedInsecureSSL(provider.getIgnoreSSLErrors(), () =>
+					this.config.fetch(url, {
 						headers: {
 							Authorization: `Basic ${base64(`PAT:${accessToken}`)}`,
 							'Content-Type': 'application/json',
@@ -608,15 +738,16 @@ export class AzureDevOpsApi implements Disposable {
 					return (await rsp.json()) as T;
 				}
 
-				throw new ProviderFetchError('AzureDevOps', rsp);
+				// Reads the body so the 403 branch below can tell a throttled request from a permission failure.
+				throw await ProviderFetchError.fromResponse('AzureDevOps', rsp);
 			} finally {
 				sw?.stop();
 			}
 		} catch (ex) {
 			if (ex instanceof ProviderFetchError || ex.name === 'AbortError') {
-				this.handleRequestError(provider, tokenInfo, ex, scope);
+				this.handleRequestError(provider, token, ex, scope);
 			} else if (Logger.isDebugging) {
-				this.ctx.hooks?.ui?.onError?.(`AzureDevOps request failed: ${ex.message}`);
+				this.config.onError?.(`AzureDevOps request failed: ${ex.message}`);
 			}
 
 			throw ex;
@@ -625,12 +756,13 @@ export class AzureDevOpsApi implements Disposable {
 
 	private handleRequestError(
 		provider: Provider | undefined,
-		tokenInfo: TokenInfo,
+		token: TokenWithInfo,
 		ex: ProviderFetchError | (Error & { name: 'AbortError' }),
 		scope: ScopedLogger | undefined,
 	): void {
 		if (ex.name === 'AbortError' || !(ex instanceof ProviderFetchError)) throw new CancellationError(ex);
 
+		const { accessToken, ...tokenInfo } = token;
 		switch (ex.status) {
 			case 404: // Not found
 			case 410: // Gone
@@ -638,27 +770,21 @@ export class AzureDevOpsApi implements Disposable {
 				throw new RequestNotFoundError(ex);
 			case 401: // Unauthorized
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Unauthorized, ex);
+			case 429: // Too Many Requests
+				throw toRateLimitError(ex, accessToken);
 			case 403: // Forbidden
-				// TODO: Learn the Azure API docs and put it in order:
-				// 	if (ex.message.includes('rate limit')) {
-				// 		let resetAt: number | undefined;
-
-				// 		const reset = ex.response?.headers?.get('x-ratelimit-reset');
-				// 		if (reset != null) {
-				// 			resetAt = parseInt(reset, 10);
-				// 			if (Number.isNaN(resetAt)) {
-				// 				resetAt = undefined;
-				// 			}
-				// 		}
-
-				// 		throw new RequestRateLimitError(ex, token, resetAt);
-				// 	}
+				// Azure returns 403 for both a permission failure and a throttled request ("Request was blocked
+				// due to exceeding usage of resource 'RateLimit'"), so the message is the discriminant. Reporting
+				// a throttle as `auth` would prompt the user to re-authenticate a healthy connection instead of
+				// retrying (see `isRateLimitResponse`).
+				if (isRateLimitResponse(ex)) throw toRateLimitError(ex, accessToken);
+
 				throw new AuthenticationError(tokenInfo, AuthenticationErrorReason.Forbidden, ex);
 			case 500: // Internal Server Error
 				scope?.error(ex);
 				if (ex.response != null) {
 					provider?.trackRequestException();
-					this.ctx.hooks?.ui?.onRequestFailed?.(
+					this.config.onRequestFailed?.(
 						`${provider?.name ?? 'AzureDevOps'} failed to respond and might be experiencing issues.${
 							provider == null || provider.id === 'azure'
 								? ' Please visit the [AzureDevOps status page](https://status.dev.azure.com) for more information.'
@@ -683,9 +809,14 @@ export class AzureDevOpsApi implements Disposable {
 
 		scope?.error(ex);
 		if (Logger.isDebugging) {
-			this.ctx.hooks?.ui?.onError?.(
+			this.config.onError?.(
 				`AzureDevOps request failed: ${(ex.response as any)?.errors?.[0]?.message ?? ex.message}`,
 			);
 		}
 	}
 }
+
+/** Wires an {@link AzureDevOpsApi} from the full runtime context, mapping `ctx` down to the narrow config. */
+export function createAzureDevOpsApi(ctx: IntegrationServiceContext): AzureDevOpsApi {
+	return new AzureDevOpsApi(baseProviderApiConfig(ctx));
+}

package/src/plus/integrations/providers/azure/models.ts

@@ -11,11 +11,12 @@ import {
 import type { Provider } from '../../../../git/models/remoteProvider.js';
 import type { ResourceDescriptor } from '../../../../git/models/resourceDescriptor.js';
 
-const vstsHostnameRegex = /\.visualstudio\.com$/;
+const vstsHostnameSuffix = '.visualstudio.com';
 
 export interface AzureRepositoryDescriptor extends ResourceDescriptor {
 	owner: string;
 	name: string;
+	project?: string;
 }
 
 export interface AzureOrganizationDescriptor extends ResourceDescriptor {
@@ -202,6 +203,18 @@ export interface AzureRepository {
 	isInMaintenance: boolean;
 }
 
+/** The `GET .../_apis/git/repositories/{repositoryId or name}` response, adding fork/default-branch fields to {@link AzureRepository}. */
+export interface AzureRepositoryWithMetadata extends AzureRepository {
+	/** Fully-qualified ref, e.g. `refs/heads/main`. */
+	defaultBranch?: string;
+	isFork?: boolean;
+	parentRepository?: {
+		id: string;
+		name?: string;
+		project?: { id: string; name: string };
+	};
+}
+
 export interface AzureGitUser {
 	date?: string;
 	email?: string;
@@ -362,11 +375,11 @@ export function getAzureDevOpsOwner(url: URL): string {
 	return url.pathname.split('/')[1];
 }
 export function getAzureOwner(url: URL): string {
-	const isVSTS = vstsHostnameRegex.test(url.hostname);
+	const isVSTS = url.hostname.endsWith(vstsHostnameSuffix);
 	return isVSTS ? getVSTSOwner(url) : getAzureDevOpsOwner(url);
 }
 export function isVsts(domain: string): boolean {
-	return vstsHostnameRegex.test(domain);
+	return domain.endsWith(vstsHostnameSuffix);
 }
 
 export function getAzureRepo(pr: AzurePullRequest): string {
@@ -402,7 +415,7 @@ export function parseAzureHttpsUrl(url: string): [owner: string, project: string
 export function parseAzureHttpsUrl(urlObj: URL): [owner: string, project: string, repo: string];
 export function parseAzureHttpsUrl(arg: URL | string): [owner: string, project: string, repo: string] {
 	const url = typeof arg === 'string' ? new URL(arg) : arg;
-	if (vstsHostnameRegex.test(url.hostname)) {
+	if (url.hostname.endsWith(vstsHostnameSuffix)) {
 		return parseVstsHttpsUrl(url);
 	}
 	return parseAzureNewStyleUrl(url);
@@ -412,7 +425,7 @@ export function getAzurePullRequestWebUrl(pr: AzurePullRequest): string {
 	const url = new URL(pr.url);
 	const baseUrl = new URL(url.origin).toString();
 	const repoPath = getAzureRepo(pr);
-	const isVSTS = vstsHostnameRegex.test(url.hostname);
+	const isVSTS = url.hostname.endsWith(vstsHostnameSuffix);
 	if (isVSTS) {
 		return `${baseUrl}/${repoPath}/pullrequest/${pr.pullRequestId}`;
 	}
@@ -496,7 +509,7 @@ export function fromAzureReviewerToPullRequestMember(reviewer: AzureUser): PullR
 	};
 }
 
-function normalizeAzureBranchName(branchName: string): string {
+export function normalizeAzureBranchName(branchName: string): string {
 	return branchName.startsWith('refs/heads/') ? branchName.replace('refs/heads/', '') : branchName;
 }