@gitkraken/core-gitlens 0.11.1 → 0.13.0

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

@@ -435,6 +435,7 @@ export interface IntegrationManager {
     summary?: boolean;
   }): Promise<ProviderPagedResult<PullRequestShape>>;
   listIssuesPage(options: {
+    state?: IssueStateFilter;
     providerId: IntegrationIds;
     repos?: ProviderRepositoriesInput;
     /**

package/dist/plus/integrations/models/gitHostIntegration.d.ts

@@ -44,11 +44,46 @@ type MyPullRequestsForReposOptions = {
   /** Requests the lightweight row shape without per-row build status or commit count. */
   summary?: boolean;
 };
+/** A repository as the batch and branch reads name it. */
+type RepositoryCoordinate = {
+  owner: string;
+  repo: string;
+  project?: string;
+};
 export declare abstract class GitHostIntegration<ID extends IntegrationIds = IntegrationIds, T extends ResourceDescriptor = ResourceDescriptor> extends IntegrationBase<ID> {
   readonly type: IntegrationType;
   /** The self-managed installation `session` addresses, validated against this integration's host. */
   protected getSelfManagedInstallationUrl(session: ProviderAuthenticationSession): string;
   protected getSelfManagedApiBaseUrl(session: ProviderAuthenticationSession): string;
+  /**
+   * The repositories the repo-scoped, batch and branch reads address, given the coordinates their caller named, in
+   * order: those, unless the host names a caller's repository differently than the caller parsed it (see the Azure
+   * DevOps Server override). `unsettled` flags a coordinate the host couldn't place, read as given; a batch or
+   * branch slot that then reads nothing is rejected rather than reported as absent ({@link rejectUnsettledMisses}).
+   */
+  protected resolveRepositoryCoordinates<T extends RepositoryCoordinate>(_session: ProviderAuthenticationSession, coordinates: readonly T[], _cancellation?: AbortSignal): Promise<{
+    coordinates: readonly T[];
+    unsettled?: readonly boolean[];
+  }>;
+  /**
+   * {@link resolveRepositoryCoordinates} for the repository descriptors the list and search reads take: those, unless
+   * the host overrides both.
+   */
+  protected resolveRepositoryInputs(_session: ProviderAuthenticationSession, repos: readonly ProviderRepoInput[], _cancellation?: AbortSignal): Promise<ProviderRepoInput[]>;
+  /**
+   * The repositories a repo-scoped read of `repos` addresses ({@link resolveRepositoryInputs}), for a caller that
+   * shapes the read by them before making it. Resolves the session as that read does, and fails as it would: a
+   * session that can't be resolved is the read's own failure (refreshing a refused token is claimed here), so the
+   * caller reports it rather than making the read. Settling that fails leaves `repos` as given, for the read to
+   * settle or report.
+   */
+  resolveRepositoryScopes(repos: ProviderReposInput, connectionId?: string): Promise<IntegrationResult<ProviderReposInput>>;
+  /**
+   * A batch or branch read's slots, settled against the repositories {@link resolveRepositoryCoordinates} settled
+   * its coordinates to: a miss for one it couldn't settle is rejected ({@link rejectUnsettledMisses}), and a refusal
+   * is recorded against the repository the host read rather than the caller's parse of it.
+   */
+  private settleResolvedSlots;
   /** The base the repository-list reads hand the provider client for a self-managed host. */
   protected getRepositoriesApiBaseUrl(session: ProviderAuthenticationSession, _repos: ProviderReposInput): string;
   getAccountForEmail(repo: T, email: string, options?: {
@@ -83,9 +118,10 @@ export declare abstract class GitHostIntegration<ID extends IntegrationIds = Int
   }): Promise<ProviderRepository | undefined>;
   /**
    * Settles what one repository's refusal of the credential means, as a batch read settles a refused target (see
-   * `IntegrationBase.settleBatchRefusals`): the scope failure it is recorded as, against that repository (and, on
-   * Azure DevOps, its project), with its cause named once the credential checks out. A refused credential throws
-   * its own error, which the caller reports for the connection instead of the repository's refusal.
+   * `IntegrationBase.settleBatchRefusals`): the scope failure it is recorded as, against that repository as the host
+   * names it (and, on Azure DevOps, its project), with its cause named once the credential checks out. `name` names
+   * the repository alone, as a batch target does. A refused credential throws its own error, which the caller reports
+   * for the connection instead of the repository's refusal.
    */
   settleRepositoryRefusal(repo: {
     owner: string;
@@ -254,7 +290,7 @@ export declare abstract class GitHostIntegration<ID extends IntegrationIds = Int
    * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
    * rather than swallowing them to `undefined`.
    */
-  getMyIssuesForReposResult(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<ProviderIssue> & {
+  getMyIssuesForReposResult(repos: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<ProviderIssue> & {
     metadata?: CollectionMetadata;
   }) | undefined>>;
   /**
@@ -277,7 +313,7 @@ export declare abstract class GitHostIntegration<ID extends IntegrationIds = Int
    * thrown errors and validation failures into `{ error }` so callers can surface them as warnings
    * rather than swallowing them to `undefined`.
    */
-  getMyPullRequestsForReposResult(reposOrRepoIds: ProviderReposInput, options?: MyPullRequestsForReposOptions, connectionId?: string): Promise<IntegrationResult<ProviderApiPagedResult<ProviderPullRequest> | undefined>>;
+  getMyPullRequestsForReposResult(repos: ProviderReposInput, options?: MyPullRequestsForReposOptions, connectionId?: string): Promise<IntegrationResult<ProviderApiPagedResult<ProviderPullRequest> | undefined>>;
   /** Account-wide (or repo-scoped) search for the current user's pull requests. */
   searchMyPullRequests(repos?: T | T[], cancellation?: AbortSignal, options?: SearchMyPullRequestsOptions & {
     connectionId?: string;

package/dist/plus/integrations/models/gitHostIntegration.js

@@ -5,6 +5,7 @@ import { Logger as _logger } from "../../../utils/logger.js";
 import { getScopedLogger } from "../../../utils/logger.scoped.js";
 import { trace } from "../../../utils/decorators/log.js";
 import __decorate from "../../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { RequestNotFoundError } from "../../../git/errors.js";
 import { gate } from "../../../utils/decorators/gate.js";
 import "../../../git/models/pullRequest.js";
 import { toError } from "../errors.js";
@@ -13,10 +14,10 @@ import { isAzureProviderId } from "../providers/providerErrors.js";
 import { throwIfCallerContractError, toCollectionFailureError, toCollectionScopeFailure } from "../collectionMetadata.js";
 import { toTokenWithInfo } from "../authentication/models.js";
 import "../providerFilters.js";
-import { mergeCollectionMetadata, throwIfAllSettledFailed } from "../providers/utils/providerPaging.js";
 import { areDomainsOnSameHost } from "../utils/domain.utils.js";
 import { getSelfManagedBaseUrl, isGitSelfManagedHostIntegrationId } from "../utils/integration.utils.js";
-import { toIssueShape, toProviderIssueStates, toProviderPullRequestStates } from "../providers/models.js";
+import { mergeCollectionMetadata, throwIfAllSettledFailed } from "../providers/utils/providerPaging.js";
+import { isRepoIdsInput, toIssueShape, toProviderIssueStates, toProviderPullRequestStates } from "../providers/models.js";
 import { IntegrationBase, isReadSessionFailure } from "./integration.js";
 //#region ../plus/integrations/src/models/gitHostIntegration.ts
 /**
@@ -30,6 +31,18 @@ function sendsBasicCredential(providerId, session) {
 	return isAzureProviderId(providerId) ? session.type !== "oauth" : void 0;
 }
 /**
+* Rejects each slot that read nothing (`isMiss`) for a coordinate whose repository couldn't be settled (see
+* {@link GitHostIntegration.resolveRepositoryCoordinates}): it may have addressed another repository, so its miss is
+* not a proven absence a caller may cache.
+*/
+function rejectUnsettledMisses(slots, unsettled, isMiss) {
+	if (!unsettled?.some(Boolean)) return slots;
+	return slots.map((slot, i) => unsettled[i] && slot.status === "fulfilled" && isMiss(slot.value) ? {
+		status: "rejected",
+		reason: /* @__PURE__ */ new Error("Nothing read for a repository that couldn't be settled")
+	} : slot);
+}
+/**
 * Rejects a read the provider can't serve as asked: logs the reason and returns it as the `{ error }` half of an
 * {@link IntegrationResult}, timed from `start`.
 *
@@ -70,6 +83,47 @@ var GitHostIntegration = class extends IntegrationBase {
 			default: return baseUrl;
 		}
 	}
+	/**
+	* The repositories the repo-scoped, batch and branch reads address, given the coordinates their caller named, in
+	* order: those, unless the host names a caller's repository differently than the caller parsed it (see the Azure
+	* DevOps Server override). `unsettled` flags a coordinate the host couldn't place, read as given; a batch or
+	* branch slot that then reads nothing is rejected rather than reported as absent ({@link rejectUnsettledMisses}).
+	*/
+	resolveRepositoryCoordinates(_session, coordinates, _cancellation) {
+		return Promise.resolve({ coordinates });
+	}
+	/**
+	* {@link resolveRepositoryCoordinates} for the repository descriptors the list and search reads take: those, unless
+	* the host overrides both.
+	*/
+	resolveRepositoryInputs(_session, repos, _cancellation) {
+		return Promise.resolve([...repos]);
+	}
+	/**
+	* The repositories a repo-scoped read of `repos` addresses ({@link resolveRepositoryInputs}), for a caller that
+	* shapes the read by them before making it. Resolves the session as that read does, and fails as it would: a
+	* session that can't be resolved is the read's own failure (refreshing a refused token is claimed here), so the
+	* caller reports it rather than making the read. Settling that fails leaves `repos` as given, for the read to
+	* settle or report.
+	*/
+	async resolveRepositoryScopes(repos, connectionId) {
+		if (isRepoIdsInput(repos)) return { value: repos };
+		const session = await this.resolveReadSession(connectionId, void 0);
+		if (session == null || isReadSessionFailure(session)) return session && { error: session.error };
+		try {
+			return { value: await this.resolveRepositoryInputs(session, repos) };
+		} catch {
+			return { value: repos };
+		}
+	}
+	/**
+	* A batch or branch read's slots, settled against the repositories {@link resolveRepositoryCoordinates} settled
+	* its coordinates to: a miss for one it couldn't settle is rejected ({@link rejectUnsettledMisses}), and a refusal
+	* is recorded against the repository the host read rather than the caller's parse of it.
+	*/
+	settleResolvedSlots(session, resolved, slots, isMiss, options) {
+		return this.settleBatchRefusals(session, resolved.coordinates, rejectUnsettledMisses(slots, resolved.unsettled, isMiss), options);
+	}
 	/** The base the repository-list reads hand the provider client for a self-managed host. */
 	getRepositoriesApiBaseUrl(session, _repos) {
 		return this.getSelfManagedApiBaseUrl(session);
@@ -122,12 +176,17 @@ var GitHostIntegration = class extends IntegrationBase {
 	async getDefaultBranch(repo, options) {
 		const scope = getScopedLogger();
 		if (await this.prepareSessionLookup() != null) return void 0;
-		return this.ctx.cache.getRepositoryDefaultBranch(repo, this, () => ({ value: (async () => {
+		return this.ctx.cache.getRepositoryDefaultBranch(repo, this, (cacheable) => ({ value: (async () => {
 			try {
 				const result = await this.getProviderDefaultBranch(this._session, repo, options?.cancellation);
+				if (result == null && options?.cancellation?.aborted) {
+					cacheable.invalidate();
+					return;
+				}
 				this.resetRequestExceptionCount("getDefaultBranch");
 				return result;
 			} catch (ex) {
+				if (!(ex instanceof RequestNotFoundError)) cacheable.invalidate();
 				this.handleProviderException("getDefaultBranch", ex, { scope });
 				return;
 			}
@@ -135,18 +194,20 @@ var GitHostIntegration = class extends IntegrationBase {
 	}
 	/**
 	* Settles what one repository's refusal of the credential means, as a batch read settles a refused target (see
-	* `IntegrationBase.settleBatchRefusals`): the scope failure it is recorded as, against that repository (and, on
-	* Azure DevOps, its project), with its cause named once the credential checks out. A refused credential throws
-	* its own error, which the caller reports for the connection instead of the repository's refusal.
+	* `IntegrationBase.settleBatchRefusals`): the scope failure it is recorded as, against that repository as the host
+	* names it (and, on Azure DevOps, its project), with its cause named once the credential checks out. `name` names
+	* the repository alone, as a batch target does. A refused credential throws its own error, which the caller reports
+	* for the connection instead of the repository's refusal.
 	*/
 	async settleRepositoryRefusal(repo, refusal) {
 		const session = await this.resolveReadSessionOrThrow(repo.connectionId, void 0);
 		if (session == null) return void 0;
-		const [slot] = await this.settleBatchRefusals(session, [{
+		const { coordinates } = await this.resolveRepositoryCoordinates(session, [{
 			owner: repo.owner,
 			repo: repo.name,
 			project: repo.project
-		}], [{
+		}]);
+		const [slot] = await this.settleBatchRefusals(session, coordinates, [{
 			status: "rejected",
 			reason: refusal
 		}]);
@@ -155,12 +216,17 @@ var GitHostIntegration = class extends IntegrationBase {
 	async getRepositoryMetadata(repo, options) {
 		const scope = getScopedLogger();
 		if (await this.prepareSessionLookup() != null) return void 0;
-		return this.ctx.cache.getRepositoryMetadata(repo, this, () => ({ value: (async () => {
+		return this.ctx.cache.getRepositoryMetadata(repo, this, (cacheable) => ({ value: (async () => {
 			try {
 				const result = await this.getProviderRepositoryMetadata(this._session, repo, options?.cancellation);
+				if (result == null && options?.cancellation?.aborted) {
+					cacheable.invalidate();
+					return;
+				}
 				this.resetRequestExceptionCount("getRepositoryMetadata");
 				return result;
 			} catch (ex) {
+				if (!(ex instanceof RequestNotFoundError)) cacheable.invalidate();
 				this.handleProviderException("getRepositoryMetadata", ex, { scope });
 				return;
 			}
@@ -464,17 +530,19 @@ var GitHostIntegration = class extends IntegrationBase {
 	* thrown errors and validation failures into `{ error }` so callers can surface them as warnings
 	* rather than swallowing them to `undefined`.
 	*/
-	async getMyIssuesForReposResult(reposOrRepoIds, options, connectionId) {
+	async getMyIssuesForReposResult(repos, options, connectionId) {
 		const scope = getScopedLogger();
 		const providerId = this.authProvider.id;
 		const states = toProviderIssueStates(options?.state);
 		const session = await this.resolveReadSession(connectionId, scope);
 		if (session == null || isReadSessionFailure(session)) return session && { error: session.error };
 		const start = performance.now();
+		let resolvedRepos;
 		let customUrl;
 		let api;
 		try {
-			customUrl = options?.customUrl ?? (isGitSelfManagedHostIntegrationId(providerId) ? this.getRepositoriesApiBaseUrl(session, reposOrRepoIds) : void 0);
+			resolvedRepos = isRepoIdsInput(repos) ? repos : await this.resolveRepositoryInputs(session, repos);
+			customUrl = options?.customUrl ?? (isGitSelfManagedHostIntegrationId(providerId) ? this.getRepositoriesApiBaseUrl(session, resolvedRepos) : void 0);
 			api = await this.getProvidersApi();
 		} catch (ex) {
 			this.handleProviderException("getIssuesForRepos", ex, {
@@ -486,6 +554,7 @@ var GitHostIntegration = class extends IntegrationBase {
 				duration: performance.now() - start
 			};
 		}
+		const reposOrRepoIds = resolvedRepos;
 		const repoIdsInput = api.isRepoIdsInput(reposOrRepoIds);
 		if (providerId !== "gitlab" && (repoIdsInput || isAzureProviderId(providerId) && !reposOrRepoIds.every((repo) => repo.project != null && repo.namespace != null))) return unsupportedRead(`Unsupported input for provider ${providerId}`, start, "getIssuesForRepos");
 		let getIssuesOptions;
@@ -571,6 +640,8 @@ var GitHostIntegration = class extends IntegrationBase {
 					}
 					const { projectInput: _projectInput, results } = outcome.value;
 					data.push(...results.values);
+					if (results.paging?.truncated) truncated = true;
+					metadata = mergeCollectionMetadata(metadata, results.metadata);
 					if (results.paging?.more) {
 						hasMore = true;
 						cursor.cursors.push({
@@ -792,17 +863,19 @@ var GitHostIntegration = class extends IntegrationBase {
 	* thrown errors and validation failures into `{ error }` so callers can surface them as warnings
 	* rather than swallowing them to `undefined`.
 	*/
-	async getMyPullRequestsForReposResult(reposOrRepoIds, options, connectionId) {
+	async getMyPullRequestsForReposResult(repos, options, connectionId) {
 		const scope = getScopedLogger();
 		const providerId = this.authProvider.id;
 		const states = toProviderPullRequestStates(options?.state);
 		const session = await this.resolveReadSession(connectionId, scope);
 		if (session == null || isReadSessionFailure(session)) return session && { error: session.error };
 		const start = performance.now();
+		let resolvedRepos;
 		let customUrl;
 		let api;
 		try {
-			customUrl = options?.customUrl ?? (isGitSelfManagedHostIntegrationId(providerId) ? this.getRepositoriesApiBaseUrl(session, reposOrRepoIds) : void 0);
+			resolvedRepos = isRepoIdsInput(repos) ? repos : await this.resolveRepositoryInputs(session, repos);
+			customUrl = options?.customUrl ?? (isGitSelfManagedHostIntegrationId(providerId) ? this.getRepositoriesApiBaseUrl(session, resolvedRepos) : void 0);
 			api = await this.getProvidersApi();
 		} catch (ex) {
 			this.handleProviderException("getPullRequestsForRepos", ex, {
@@ -814,6 +887,7 @@ var GitHostIntegration = class extends IntegrationBase {
 				duration: performance.now() - start
 			};
 		}
+		const reposOrRepoIds = resolvedRepos;
 		if (providerId !== "gitlab" && (api.isRepoIdsInput(reposOrRepoIds) || isAzureProviderId(providerId) && !reposOrRepoIds.every((repo) => repo.project != null && repo.namespace != null))) return unsupportedRead(`Unsupported input for provider ${providerId}`, start);
 		let getPullRequestsOptions;
 		if (options?.filters != null) {
@@ -1228,7 +1302,8 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		let slots;
 		try {
-			slots = await this.getProviderIssuesBatch?.(session, coordinates, cancellation);
+			const targets = await this.resolveRepositoryCoordinates(session, coordinates, cancellation);
+			slots = await this.getProviderIssuesBatch?.(session, targets.coordinates, cancellation);
 			if (slots == null) {
 				this.resetRequestExceptionCount("getIssuesBatch");
 				return {
@@ -1236,9 +1311,9 @@ var GitHostIntegration = class extends IntegrationBase {
 					duration: performance.now() - start
 				};
 			}
-			const settled = await this.settleBatchRefusals(session, coordinates, slots);
+			const settled = await this.settleResolvedSlots(session, targets, slots, (issue) => issue == null);
 			this.resetRequestExceptionCount("getIssuesBatch");
-			this.reportDeferredRequestFailures(slots, false);
+			this.reportDeferredRequestFailures(settled, false);
 			return {
 				value: settled,
 				duration: performance.now() - start
@@ -1279,7 +1354,8 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		let slots;
 		try {
-			slots = await this.getProviderPullRequestsBatch?.(session, coordinates, options, cancellation);
+			const targets = await this.resolveRepositoryCoordinates(session, coordinates, cancellation);
+			slots = await this.getProviderPullRequestsBatch?.(session, targets.coordinates, options, cancellation);
 			if (slots == null) {
 				this.resetRequestExceptionCount("getPullRequestsBatch");
 				return {
@@ -1287,9 +1363,9 @@ var GitHostIntegration = class extends IntegrationBase {
 					duration: performance.now() - start
 				};
 			}
-			const settled = await this.settleBatchRefusals(session, coordinates, slots);
+			const settled = await this.settleResolvedSlots(session, targets, slots, (pr) => pr == null);
 			this.resetRequestExceptionCount("getPullRequestsBatch");
-			this.reportDeferredRequestFailures(slots, false);
+			this.reportDeferredRequestFailures(settled, false);
 			return {
 				value: settled,
 				duration: performance.now() - start
@@ -1326,13 +1402,14 @@ var GitHostIntegration = class extends IntegrationBase {
 		if (session == null || isReadSessionFailure(session)) return session && { error: session.error };
 		const start = performance.now();
 		try {
-			const slots = await this.getProviderIssuesEtagFields?.(session, coordinates, options, cancellation);
-			if (slots == null) return {
+			const targets = await this.resolveRepositoryCoordinates(session, coordinates, cancellation);
+			const read = await this.getProviderIssuesEtagFields?.(session, targets.coordinates, options, cancellation);
+			if (read == null) return {
 				value: void 0,
 				duration: performance.now() - start
 			};
-			const settled = await this.settleBatchRefusals(session, coordinates, slots, { keepOtherFailures: true });
-			if (slots.some((slot) => slot.status === "fulfilled")) this.resetRequestExceptionCount("getIssuesEtagFields");
+			const settled = await this.settleResolvedSlots(session, targets, read, (fields) => fields == null, { keepOtherFailures: true });
+			if (settled.some((slot) => slot.status === "fulfilled")) this.resetRequestExceptionCount("getIssuesEtagFields");
 			return {
 				value: settled,
 				duration: performance.now() - start
@@ -1362,13 +1439,14 @@ var GitHostIntegration = class extends IntegrationBase {
 		if (session == null || isReadSessionFailure(session)) return session && { error: session.error };
 		const start = performance.now();
 		try {
-			const slots = await this.getProviderPullRequestsEtagFields?.(session, coordinates, options, cancellation);
-			if (slots == null) return {
+			const targets = await this.resolveRepositoryCoordinates(session, coordinates, cancellation);
+			const read = await this.getProviderPullRequestsEtagFields?.(session, targets.coordinates, options, cancellation);
+			if (read == null) return {
 				value: void 0,
 				duration: performance.now() - start
 			};
-			const settled = await this.settleBatchRefusals(session, coordinates, slots, { keepOtherFailures: true });
-			if (slots.some((slot) => slot.status === "fulfilled")) this.resetRequestExceptionCount("getPullRequestsEtagFields");
+			const settled = await this.settleResolvedSlots(session, targets, read, (fields) => fields == null, { keepOtherFailures: true });
+			if (settled.some((slot) => slot.status === "fulfilled")) this.resetRequestExceptionCount("getPullRequestsEtagFields");
 			return {
 				value: settled,
 				duration: performance.now() - start
@@ -1406,7 +1484,8 @@ var GitHostIntegration = class extends IntegrationBase {
 		const start = performance.now();
 		let slots;
 		try {
-			slots = await this.getProviderPullRequestsForBranches?.(session, targets, options, cancellation);
+			const resolved = await this.resolveRepositoryCoordinates(session, targets, cancellation);
+			slots = await this.getProviderPullRequestsForBranches?.(session, resolved.coordinates, options, cancellation);
 			if (slots == null) {
 				this.resetRequestExceptionCount("getPullRequestsForBranches");
 				return {
@@ -1414,9 +1493,9 @@ var GitHostIntegration = class extends IntegrationBase {
 					duration: performance.now() - start
 				};
 			}
-			const settled = await this.settleBatchRefusals(session, targets, slots);
+			const settled = await this.settleResolvedSlots(session, resolved, slots, (found) => found.pullRequests.length === 0 && !found.truncated);
 			this.resetRequestExceptionCount("getPullRequestsForBranches");
-			this.reportDeferredRequestFailures(slots, false);
+			this.reportDeferredRequestFailures(settled, false);
 			return {
 				value: settled,
 				duration: performance.now() - start