@gitkraken/core-gitlens 0.7.0 → 0.7.1

package/dist/plus/integrations/integrationService.d.ts

@@ -114,6 +114,35 @@ export declare class IntegrationService implements Disposable, RepositoryResolut
    * self-managed host without persisting `ConfiguredIntegrationService` state.
    */
   getIntegrationForRead(id: IntegrationIds, connectionId: string | undefined, domain?: string): Promise<Integration | undefined>;
+  /**
+   * Resolves every integration instance an account-wide read must cover for `id`. A cloud id has one instance;
+   * a self-managed id has one per configured host, so the read fans out over all of them rather than `get(id)`
+   * silently picking whichever host was cached (or flagged primary) first, which dropped every other GitHub
+   * Enterprise server, GitLab instance, Bitbucket Data Center, Azure DevOps Server or Jira Data Center the user
+   * is connected to (#5873).
+   *
+   * Hosts come from every configured connection, local as well as cloud: that is the set `get(id)` already picked
+   * its primary from, and a locally configured host is as much the user's as a cloud-synced one. This is where it
+   * departs from {@link getSupportedCloudIntegrations}, which only walks cloud connections because it exists to
+   * sync them. The two share the per-host resolution and the fallback to whatever instance is already cached when
+   * no host is configured. A lookup that throws counts as "not available", like {@link getIntegrationForRead}.
+   */
+  getIntegrationsForAccountWideRead<T extends IntegrationIds>(id: T): Promise<IntegrationById<T>[]>;
+  isConnectedForAccountWideRead(id: IntegrationIds, options?: {
+    access?: boolean;
+  }): Promise<boolean>;
+  /**
+   * The open repositories to scope `integration`'s read to, out of the remotes open for its integration id.
+   *
+   * With a single host for the id (every cloud id, and a self-managed id with one configured host) every remote
+   * is that host's, as it was before the read fanned out, so a remote addressed through an SSH alias or a custom
+   * domain keeps its repositories scoped. With several hosts a remote belongs to the one configured host it
+   * names, compared the way {@link resolveRepository} compares them: exactly for a web remote, by hostname for an
+   * SSH/git one, whose parsed domain has lost any port. A remote naming no host, or several (two ports on one
+   * machine), is credited to none, like `resolveRepository`'s `host-mismatch`: asking one server about another
+   * server's `owner/name` reads a different repository, or nothing, under the right name.
+   */
+  private getOpenRemotesForHost;
   resolveDomainForRead(id: IntegrationIds, connectionId: string | undefined, domain: string | undefined): string | undefined;
   /** The primary configured host for a self-managed provider (first configured when none is flagged primary). */
   private primaryConfiguredDomain;
@@ -300,6 +329,11 @@ export declare class IntegrationService implements Disposable, RepositoryResolut
     resourceUrl?: string;
     key: string;
     connectionId?: string;
+    /**
+     * Explicit self-managed host domain. Unlike the paged reads this one does not fall back to the primary
+     * connection for a self-managed tracker; see {@link IntegrationManager.getTrackerIssue}.
+     */
+    domain?: string;
   }): Promise<ProviderResult<TrackerIssueResult>>;
   /**
    * How many pull requests match each scope, without fetching any — the PR twin of {@link countIssues}. See

package/dist/plus/integrations/integrationService.js

@@ -1,16 +1,18 @@
 import { filterMap, flatten } from "../../utils/iterable.js";
 import { getScopedLogger } from "../../utils/logger.scoped.js";
+import { mapSettledBounded } from "../../utils/promise.js";
 import { debug, trace } from "../../utils/decorators/log.js";
 import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
 import { fromDisposables } from "../../utils/disposable.js";
 import { Emitter } from "../../utils/event.js";
 import { gate } from "../../utils/decorators/gate.js";
+import { toError } from "./errors.js";
 import { GitCloudHostIntegrationId, GitSelfManagedHostIntegrationId, IssuesCloudHostIntegrationId, IssuesSelfManagedHostIntegrationId } from "./constants.js";
 import { getSupportedCloudIntegrationIds, isSupportedCloudIntegrationId, toIntegrationId } from "./authentication/models.js";
 import { CloudIntegrationService } from "./authentication/cloudIntegrationService.js";
+import { getRemoteHostMatcher, hostFromDomain, sameConfiguredBaseUrl } from "./utils/domain.utils.js";
 import { convertRemoteProviderIdToIntegrationId, getIntegrationIdForRemote, isCloudSelfManagedHostIntegrationId, isGitCloudHostIntegrationId, isGitSelfManagedHostIntegrationId, isNonExpiringZeroTokenIntegrationId, isSelfManagedHostIntegrationId, remoteProviderTypeForConfig, remoteProviderTypeForIntegration } from "./utils/integration.utils.js";
 import { providersMetadata } from "./providers/models.js";
-import { hostFromDomain, sameConfiguredBaseUrl } from "./utils/domain.utils.js";
 import { ConfiguredIntegrationService } from "./authentication/configuredIntegrationService.js";
 import { IntegrationAuthenticationService } from "./authentication/integrationAuthenticationService.js";
 import { createApiClients } from "./providers/apiClients.js";
@@ -228,7 +230,7 @@ var IntegrationService = class {
 							if (configuredDomain == null) throw new Error(`Domain is required for '${id}' integration`);
 							integration = new (await (import(
 								/* webpackChunkName: "integrations" */
-								"./providers/azureDevOps.js"
+								"./providers/azureDevOpsServer.js"
 ))).AzureDevOpsServerIntegration(this.ctx, this.authenticationService, this.getProvidersApi.bind(this), this._onDidChangeIntegrationConnection, configuredDomain);
 							domain = configuredDomain;
 							break;
@@ -237,7 +239,7 @@ var IntegrationService = class {
 					}
 					integration = new (await (import(
 						/* webpackChunkName: "integrations" */
-						"./providers/azureDevOps.js"
+						"./providers/azureDevOpsServer.js"
 ))).AzureDevOpsServerIntegration(this.ctx, this.authenticationService, this.getProvidersApi.bind(this), this._onDidChangeIntegrationConnection, domain);
 					break;
 				case "jira":
@@ -309,48 +311,51 @@ var IntegrationService = class {
 		return integration?.type === "git" ? integration : void 0;
 	}
 	async getMyIssues(integrationIds, options) {
-		const integrations = /* @__PURE__ */ new Map();
-		const hostingIntegrationIds = integrationIds?.filter((id) => id in GitCloudHostIntegrationId || id in GitSelfManagedHostIntegrationId);
 		const openRemotesByIntegrationId = /* @__PURE__ */ new Map();
 		let hasOpenAzureRepository = false;
 		for (const remote of await this.ctx.repositories.getOpenRemotes()) {
-			const remoteIntegration = await this.getByRemote(remote);
-			if (remoteIntegration == null) continue;
-			if (remoteIntegration.id === "azureDevOps") hasOpenAzureRepository = true;
-			for (const integrationId of hostingIntegrationIds?.length ? hostingIntegrationIds : [...Object.values(GitCloudHostIntegrationId), ...Object.values(GitSelfManagedHostIntegrationId)]) if (remoteIntegration.id === integrationId && remote.provider?.owner != null && remote.provider?.repoName != null) {
-				const descriptor = {
-					key: `${remote.provider.owner}/${remote.provider.repoName}`,
-					owner: remote.provider.owner,
-					name: remote.provider.repoName
-				};
-				if (openRemotesByIntegrationId.has(integrationId)) openRemotesByIntegrationId.get(integrationId)?.push(descriptor);
-				else openRemotesByIntegrationId.set(integrationId, [descriptor]);
-			}
+			const integrationId = getIntegrationIdForRemote(remote.provider);
+			if (integrationId == null) continue;
+			if (integrationId === "azureDevOps") hasOpenAzureRepository = true;
+			if (remote.provider?.owner == null || remote.provider?.repoName == null) continue;
+			const repo = {
+				key: `${remote.provider.owner}/${remote.provider.repoName}`,
+				owner: remote.provider.owner,
+				name: remote.provider.repoName
+			};
+			const remotes = openRemotesByIntegrationId.get(integrationId);
+			if (remotes != null) remotes.push({
+				remote,
+				repo
+			});
+			else openRemotesByIntegrationId.set(integrationId, [{
+				remote,
+				repo
+			}]);
 		}
+		const integrations = /* @__PURE__ */ new Map();
 		for (const integrationId of integrationIds?.length ? integrationIds : [
 			...Object.values(GitCloudHostIntegrationId),
 			...Object.values(IssuesCloudHostIntegrationId),
 			...Object.values(IssuesSelfManagedHostIntegrationId),
 			...Object.values(GitSelfManagedHostIntegrationId)
 		]) {
-			const integration = await this.get(integrationId);
-			const isInvalidIntegration = options?.openRepositoriesOnly && integrationId !== "azureDevOps" && (isGitCloudHostIntegrationId(integrationId) || isGitSelfManagedHostIntegrationId(integrationId)) && !openRemotesByIntegrationId.has(integrationId) || integrationId === "azureDevOps" && !hasOpenAzureRepository;
-			if (integration == null || isInvalidIntegration) continue;
-			integrations.set(integration, options?.openRepositoriesOnly && !isInvalidIntegration ? openRemotesByIntegrationId.get(integrationId) : void 0);
+			if (integrationId === "azureDevOps" && !hasOpenAzureRepository) continue;
+			const integrationsForId = await this.getIntegrationsForAccountWideRead(integrationId);
+			for (const integration of integrationsForId) {
+				const openRemotes = this.getOpenRemotesForHost(integration, integrationsForId, openRemotesByIntegrationId.get(integrationId));
+				if (options?.openRepositoriesOnly && integrationId !== "azureDevOps" && (isGitCloudHostIntegrationId(integrationId) || isGitSelfManagedHostIntegrationId(integrationId)) && openRemotes == null) continue;
+				integrations.set(integration, options?.openRepositoriesOnly ? openRemotes : void 0);
+			}
 		}
 		if (integrations.size === 0) return void 0;
 		return this.getMyIssuesCore(integrations, options?.cancellation);
 	}
 	async getMyIssuesCore(integrations, cancellation) {
 		const start = performance.now();
-		const promises = [];
-		for (const [integration, repos] of integrations) {
-			if (integration == null) continue;
-			promises.push(integration.searchMyIssuesResult(repos, cancellation));
-		}
-		const results = await Promise.allSettled(promises);
+		const results = await mapSettledBounded([...integrations], 6, ([integration, repos]) => integration.searchMyIssuesResult(repos, cancellation));
 		const successfulResults = [...flatten(filterMap(results, (r) => r.status === "fulfilled" && r.value?.value != null ? r.value.value : void 0))];
-		const errors = [...filterMap(results, (r) => r.status === "fulfilled" && r.value?.error != null ? r.value.error : void 0)];
+		const errors = [...filterMap(results, (r) => r.status === "rejected" ? toError(r.reason) : r.value?.error)];
 		return {
 			value: successfulResults,
 			error: errors.length === 0 ? void 0 : errors.length === 1 ? errors[0] : new AggregateError(errors, "Failed to get some issues"),
@@ -391,27 +396,15 @@ var IntegrationService = class {
 	}
 	async getMyPullRequests(integrationIds, cancellation, options) {
 		const integrations = /* @__PURE__ */ new Map();
-		for (const integrationId of integrationIds?.length ? integrationIds : Object.values(GitCloudHostIntegrationId)) {
-			let integration;
-			try {
-				integration = await this.get(integrationId);
-			} catch {}
-			if (integration == null) continue;
-			integrations.set(integration, void 0);
-		}
+		for (const integrationId of integrationIds?.length ? integrationIds : [...Object.values(GitCloudHostIntegrationId), ...Object.values(GitSelfManagedHostIntegrationId)]) for (const integration of await this.getIntegrationsForAccountWideRead(integrationId)) integrations.set(integration, void 0);
 		if (integrations.size === 0) return void 0;
 		return this.getMyPullRequestsCore(integrations, cancellation, options);
 	}
 	async getMyPullRequestsCore(integrations, cancellation, options) {
 		const start = performance.now();
-		const promises = [];
-		for (const [integration, repos] of integrations) {
-			if (integration == null) continue;
-			promises.push(integration.searchMyPullRequests(repos, cancellation, options));
-		}
-		const results = await Promise.allSettled(promises);
+		const results = await mapSettledBounded([...integrations], 6, ([integration, repos]) => integration.searchMyPullRequests(repos, cancellation, options));
 		const successfulResults = [...flatten(filterMap(results, (r) => r.status === "fulfilled" && r.value?.value != null ? r.value.value : void 0))];
-		const errors = [...filterMap(results, (r) => r.status === "fulfilled" && r.value?.error != null ? r.value.error : void 0)];
+		const errors = [...filterMap(results, (r) => r.status === "rejected" ? toError(r.reason) : r.value?.error)];
 		return {
 			value: successfulResults,
 			error: errors.length === 0 ? void 0 : errors.length === 1 ? errors[0] : new AggregateError(errors, "Failed to get some pull requests"),
@@ -481,6 +474,60 @@ var IntegrationService = class {
 			return;
 		}
 	}
+	/**
+	* Resolves every integration instance an account-wide read must cover for `id`. A cloud id has one instance;
+	* a self-managed id has one per configured host, so the read fans out over all of them rather than `get(id)`
+	* silently picking whichever host was cached (or flagged primary) first, which dropped every other GitHub
+	* Enterprise server, GitLab instance, Bitbucket Data Center, Azure DevOps Server or Jira Data Center the user
+	* is connected to (#5873).
+	*
+	* Hosts come from every configured connection, local as well as cloud: that is the set `get(id)` already picked
+	* its primary from, and a locally configured host is as much the user's as a cloud-synced one. This is where it
+	* departs from {@link getSupportedCloudIntegrations}, which only walks cloud connections because it exists to
+	* sync them. The two share the per-host resolution and the fallback to whatever instance is already cached when
+	* no host is configured. A lookup that throws counts as "not available", like {@link getIntegrationForRead}.
+	*/
+	async getIntegrationsForAccountWideRead(id) {
+		const hosts = /* @__PURE__ */ new Set();
+		if (isSelfManagedHostIntegrationId(id)) for (const { domain } of this.getConfigured(id)) {
+			const host = hostFromDomain(domain) ?? domain;
+			if (host) hosts.add(host);
+		}
+		const targets = hosts.size !== 0 ? [...hosts] : [void 0];
+		const integrations = [];
+		for (const host of targets) {
+			const integration = await this.get(id, host).catch(() => void 0);
+			if (integration != null) integrations.push(integration);
+		}
+		return integrations;
+	}
+	async isConnectedForAccountWideRead(id, options) {
+		const integrations = await this.getIntegrationsForAccountWideRead(id);
+		return (await mapSettledBounded(integrations, 6, async (integration) => {
+			return (integration.maybeConnected ?? await integration.isConnected()) && (!options?.access || await integration.access());
+		})).some((result) => result.status === "fulfilled" && result.value);
+	}
+	/**
+	* The open repositories to scope `integration`'s read to, out of the remotes open for its integration id.
+	*
+	* With a single host for the id (every cloud id, and a self-managed id with one configured host) every remote
+	* is that host's, as it was before the read fanned out, so a remote addressed through an SSH alias or a custom
+	* domain keeps its repositories scoped. With several hosts a remote belongs to the one configured host it
+	* names, compared the way {@link resolveRepository} compares them: exactly for a web remote, by hostname for an
+	* SSH/git one, whose parsed domain has lost any port. A remote naming no host, or several (two ports on one
+	* machine), is credited to none, like `resolveRepository`'s `host-mismatch`: asking one server about another
+	* server's `owner/name` reads a different repository, or nothing, under the right name.
+	*/
+	getOpenRemotesForHost(integration, integrationsForId, remotes) {
+		if (!remotes?.length) return void 0;
+		if (integrationsForId.length <= 1) return remotes.map((r) => r.repo);
+		const owned = remotes.filter((r) => {
+			const hostsMatch = getRemoteHostMatcher(r.remote.scheme);
+			const matching = integrationsForId.filter((i) => hostsMatch(r.remote.provider?.domain, i.domain));
+			return matching.length === 1 && matching[0] === integration;
+		});
+		return owned.length ? owned.map((r) => r.repo) : void 0;
+	}
 	resolveDomainForRead(id, connectionId, domain) {
 		if (!isSelfManagedHostIntegrationId(id)) return void 0;
 		return (connectionId != null ? this.getConfiguredConnectionDomain(id, connectionId) : void 0) ?? hostFromDomain(domain) ?? this.primaryConfiguredDomain(id);