@gitkraken/core-gitlens 0.15.3 → 0.15.4

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

@@ -45,11 +45,19 @@ type MyPullRequestsForReposOptions = {
   summary?: boolean;
 };
 /** A repository as the batch and branch reads name it. */
-type RepositoryCoordinate = {
+export type RepositoryCoordinate = {
   owner: string;
   repo: string;
   project?: string;
 };
+/**
+ * Repository scopes as the host settled them ({@link GitHostIntegration.resolveRepositoryScopes}), with the `unsettled`
+ * flag of each, in order. A repo-scoped read given these reads them as given rather than settling them again.
+ */
+export type SettledRepositoryScopes = {
+  repos: ProviderReposInput;
+  unsettled?: readonly boolean[];
+};
 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. */
@@ -60,28 +68,34 @@ export declare abstract class GitHostIntegration<ID extends IntegrationIds = Int
    * 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}).
+   *
+   * The only hook a host overrides to settle a caller's repository: every read settles through it, the list and search
+   * reads by way of {@link resolveRepositoryInputs}.
    */
   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. A scope flagged `unsettled` that then reads nothing is reported as a failure of the read
-   * ({@link toUnsettledScopeFailure}) rather than as an empty scope.
+   * {@link resolveRepositoryCoordinates} for the repository descriptors the list and search reads take. Not an override
+   * point: a host settles its coordinates, which this maps `repos` through. A scope flagged `unsettled` that then reads
+   * nothing is reported as a failure of the read ({@link toUnsettledScopeFailure}) rather than as an empty scope.
    */
-  protected resolveRepositoryInputs(_session: ProviderAuthenticationSession, repos: readonly ProviderRepoInput[], _cancellation?: AbortSignal): Promise<{
+  protected resolveRepositoryInputs(session: ProviderAuthenticationSession, repos: readonly ProviderRepoInput[], cancellation?: AbortSignal): Promise<{
     repos: ProviderRepoInput[];
     unsettled?: readonly boolean[];
   }>;
   /**
    * 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.
+   * shapes the read by them before making it, and then hands them to that read so it doesn't settle them again.
+   * 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 is the read's failure too, handled as the issue read handles it. Only the issue list hands its
+   * read settled scopes today.
    */
-  resolveRepositoryScopes(repos: ProviderReposInput, connectionId?: string): Promise<IntegrationResult<ProviderReposInput>>;
+  resolveRepositoryScopes(repos: ProviderReposInput, connectionId?: string): Promise<IntegrationResult<SettledRepositoryScopes>>;
+  /** `repos` as a repo-scoped read addresses them: settled by the caller already, or here. */
+  private settleRepositoryScopes;
   /**
    * 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
@@ -294,7 +308,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(repos: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<ProviderIssue> & {
+  getMyIssuesForReposResult(repos: ProviderReposInput | SettledRepositoryScopes, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<ProviderIssue> & {
     metadata?: CollectionMetadata;
   }) | undefined>>;
   /**
@@ -307,7 +321,7 @@ export declare abstract class GitHostIntegration<ID extends IntegrationIds = Int
    * `ProviderIssue` round-trip. No provider does today: the one candidate (Bitbucket Cloud's legacy
    * `getUsersIssuesForRepo`) reports `supportsIssues: false`, so the facade never reaches this for it.
    */
-  getMyIssuesForReposAsShapesResult(reposOrRepoIds: ProviderReposInput, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<IssueShape> & {
+  getMyIssuesForReposAsShapesResult(reposOrRepoIds: ProviderReposInput | SettledRepositoryScopes, options?: MyIssuesForReposOptions, connectionId?: string): Promise<IntegrationResult<(PagedResult<IssueShape> & {
     metadata?: CollectionMetadata;
   }) | undefined>>;
   getMyPullRequestsForRepos(reposOrRepoIds: ProviderReposInput, options?: MyPullRequestsForReposOptions, connectionId?: string): Promise<ProviderApiPagedResult<ProviderPullRequest> | undefined>;
@@ -365,8 +379,9 @@ export declare abstract class GitHostIntegration<ID extends IntegrationIds = Int
   /**
    * The current account as each of `pullRequests` identifies its members, in order: what a raw row's
    * `authoredByMe` and `viewer` are resolved against when it's mapped. Most hosts give a person one id, so every
-   * row gets the account itself; Azure DevOps Server answers per collection (see `AzureDevOpsServerIntegration`).
-   * Throws only when the account itself can't be read.
+   * row gets the account itself; Azure DevOps answers per organization (see `AzureDevOpsIntegrationBase`).
+   * Throws only when the account itself can't be read. Azure DevOps never throws: a session it can't resolve leaves
+   * the rows it hadn't already resolved unknown.
    */
   getPullRequestViewers(pullRequests: readonly (ProviderPullRequest | PullRequest)[], connectionId?: string): Promise<({
     id: string;

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

@@ -95,35 +95,58 @@ var GitHostIntegration = class extends IntegrationBase {
 	* 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}).
+	*
+	* The only hook a host overrides to settle a caller's repository: every read settles through it, the list and search
+	* reads by way of {@link resolveRepositoryInputs}.
 	*/
 	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. A scope flagged `unsettled` that then reads nothing is reported as a failure of the read
-	* ({@link toUnsettledScopeFailure}) rather than as an empty scope.
+	* {@link resolveRepositoryCoordinates} for the repository descriptors the list and search reads take. Not an override
+	* point: a host settles its coordinates, which this maps `repos` through. A scope flagged `unsettled` that then reads
+	* nothing is reported as a failure of the read ({@link toUnsettledScopeFailure}) rather than as an empty scope.
 	*/
-	resolveRepositoryInputs(_session, repos, _cancellation) {
-		return Promise.resolve({ repos: [...repos] });
+	async resolveRepositoryInputs(session, repos, cancellation) {
+		const { coordinates, unsettled } = await this.resolveRepositoryCoordinates(session, repos.map((r) => ({
+			...r,
+			owner: r.namespace,
+			repo: r.name
+		})), cancellation);
+		return {
+			repos: coordinates.map(({ owner, repo, ...r }) => ({
+				...r,
+				namespace: owner,
+				name: repo
+			})),
+			unsettled
+		};
 	}
 	/**
 	* 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.
+	* shapes the read by them before making it, and then hands them to that read so it doesn't settle them again.
+	* 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 is the read's failure too, handled as the issue read handles it. Only the issue list hands its
+	* read settled scopes today.
 	*/
 	async resolveRepositoryScopes(repos, connectionId) {
-		if (isRepoIdsInput(repos)) return { value: repos };
+		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)).repos };
-		} catch {
-			return { value: repos };
+			return { value: await this.resolveRepositoryInputs(session, repos) };
+		} catch (ex) {
+			this.handleProviderException("getIssuesForRepos", ex, { connectionId });
+			return { error: toError(ex) };
 		}
 	}
+	/** `repos` as a repo-scoped read addresses them: settled by the caller already, or here. */
+	settleRepositoryScopes(session, repos) {
+		if (!Array.isArray(repos)) return Promise.resolve(repos);
+		if (isRepoIdsInput(repos)) return Promise.resolve({ repos });
+		return this.resolveRepositoryInputs(session, 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
@@ -550,8 +573,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		let customUrl;
 		let api;
 		try {
-			if (isRepoIdsInput(repos)) resolvedRepos = repos;
-			else ({repos: resolvedRepos, unsettled} = await this.resolveRepositoryInputs(session, repos));
+			({repos: resolvedRepos, unsettled} = await this.settleRepositoryScopes(session, repos));
 			customUrl = options?.customUrl ?? (isGitSelfManagedHostIntegrationId(providerId) ? this.getRepositoriesApiBaseUrl(session, resolvedRepos) : void 0);
 			api = await this.getProvidersApi();
 		} catch (ex) {
@@ -897,8 +919,7 @@ var GitHostIntegration = class extends IntegrationBase {
 		let customUrl;
 		let api;
 		try {
-			if (isRepoIdsInput(repos)) resolvedRepos = repos;
-			else ({repos: resolvedRepos, unsettled} = await this.resolveRepositoryInputs(session, repos));
+			({repos: resolvedRepos, unsettled} = await this.settleRepositoryScopes(session, repos));
 			customUrl = options?.customUrl ?? (isGitSelfManagedHostIntegrationId(providerId) ? this.getRepositoriesApiBaseUrl(session, resolvedRepos) : void 0);
 			api = await this.getProvidersApi();
 		} catch (ex) {
@@ -1165,8 +1186,9 @@ var GitHostIntegration = class extends IntegrationBase {
 	/**
 	* The current account as each of `pullRequests` identifies its members, in order: what a raw row's
 	* `authoredByMe` and `viewer` are resolved against when it's mapped. Most hosts give a person one id, so every
-	* row gets the account itself; Azure DevOps Server answers per collection (see `AzureDevOpsServerIntegration`).
-	* Throws only when the account itself can't be read.
+	* row gets the account itself; Azure DevOps answers per organization (see `AzureDevOpsIntegrationBase`).
+	* Throws only when the account itself can't be read. Azure DevOps never throws: a session it can't resolve leaves
+	* the rows it hadn't already resolved unknown.
 	*/
 	async getPullRequestViewers(pullRequests, connectionId) {
 		const account = await this.getCurrentAccount({ connectionId });