Completion notification/update is delayed (#7198)

* Completion notification/update is delayed
Fixes #7149

* Fix tests

* Actually fix test

Author: alexr00

src/github/activityBarViewProvider.ts

@@ -79,7 +79,7 @@ export class PullRequestViewProvider extends WebviewViewBase implements vscode.W
 		} while (attemptsRemaining > 0 && mergability === PullRequestMergeability.Unknown);
 
 		const result: Partial<PullRequest> = {
-			events: await this._item.getTimelineEvents(),
+			events: await this._item.githubRepository.getTimelineEvents(this._item),
 			mergeable: mergability,
 		};
 		await this.refresh();
@@ -213,7 +213,7 @@ export class PullRequestViewProvider extends WebviewViewBase implements vscode.W
 				pullRequestModel.number,
 			),
 			this._folderRepositoryManager.getPullRequestRepositoryAccessAndMergeMethods(pullRequestModel),
-			pullRequestModel.getTimelineEvents(),
+			pullRequestModel.githubRepository.getTimelineEvents(pullRequestModel),
 			pullRequestModel.getReviewRequests(),
 			this._folderRepositoryManager.getBranchNameForPullRequest(pullRequestModel),
 			this._folderRepositoryManager.getPullRequestRepositoryDefaultBranch(pullRequestModel),

src/github/copilotPrWatcher.ts

@@ -89,11 +89,10 @@ export class CopilotPRWatcher extends Disposable {
 
 	constructor(private readonly _reposManager: RepositoriesManager, private readonly _model: CopilotStateModel) {
 		super();
-		const query = this._queriesIncludeCopilot();
-		if (query) {
-			this._getStateChanges(query);
-		}
+
+		this._getStateChanges();
 		this._pollForChanges();
+		this._register(this._reposManager.onDidChangeAnyPullRequests(() => this._getStateChanges()));
 
 		this._register(vscode.workspace.onDidChangeConfiguration(e => {
 			if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${QUERIES}`)) {
@@ -110,16 +109,13 @@ export class CopilotPRWatcher extends Disposable {
 
 	private _timeout: NodeJS.Timeout | undefined;
 	private async _pollForChanges(): Promise<void> {
-		const query = this._queriesIncludeCopilot();
-		if (!query) {
-			return;
-		}
+		const shouldContinue = await this._getStateChanges();
 
-		await this._getStateChanges(query);
-
-		this._timeout = setTimeout(() => {
-			this._pollForChanges();
-		}, 60 * 1000); // Poll every minute
+		if (shouldContinue) {
+			this._timeout = setTimeout(() => {
+				this._pollForChanges();
+			}, 60 * 1000); // Poll every minute
+		}
 	}
 
 	private _currentUser: string | undefined;
@@ -130,7 +126,11 @@ export class CopilotPRWatcher extends Disposable {
 		return this._currentUser;
 	}
 
-	private async _getStateChanges(query: string) {
+	private async _getStateChanges(): Promise<boolean> {
+		const query = this._queriesIncludeCopilot();
+		if (!query) {
+			return false;
+		}
 		const stateChanges: { owner: string; repo: string; prNumber: number; status: CopilotPRStatus }[] = [];
 		const unseenKeys: Set<string> = new Set(this._model.keys());
 		let initialized = 0;
@@ -170,9 +170,9 @@ export class CopilotPRWatcher extends Disposable {
 			if ((initialized === this._reposManager.folderManagers.length) && (this._reposManager.folderManagers.length > 0)) {
 				this._model.setInitialized();
 			}
-			return [];
+			return true;
 		} else {
-			return stateChanges;
+			return true;
 		}
 	}
 }

src/github/githubRepository.ts

@@ -7,7 +7,7 @@ import * as buffer from 'buffer';
 import { ApolloQueryResult, DocumentNode, FetchResult, MutationOptions, NetworkStatus, QueryOptions } from 'apollo-boost';
 import * as vscode from 'vscode';
 import { AuthenticationError, AuthProvider, GitHubServerType, isSamlError } from '../common/authentication';
-import { COPILOT_ACCOUNTS } from '../common/comment';
+import { COPILOT_ACCOUNTS, IComment, IReviewThread } from '../common/comment';
 import { Disposable } from '../common/lifecycle';
 import Logger from '../common/logger';
 import { GitHubRemote, parseRemote } from '../common/remote';
@@ -69,6 +69,7 @@ import {
 	convertRESTPullRequestToRawPullRequest,
 	getAvatarWithEnterpriseFallback,
 	getOverrideBranch,
+	insertNewCommitsSinceReview,
 	isInCodespaces,
 	parseAccount,
 	parseCombinedTimelineEvents,
@@ -1537,10 +1538,13 @@ export class GitHubRepository extends Disposable {
 					crossRefs.delete(model.html_url);
 				}
 			}
+			const oldEvents = issueModel.timelineEvents;
+			issueModel.timelineEvents = events;
 			if (crossRefs.size > 0) {
 				this._onDidChangePullRequests.fire();
+			} else if (oldEvents.length !== events.length) {
+				this._onDidChangePullRequests.fire();
 			}
-
 			return events;
 		} catch (e) {
 			console.log(e);
@@ -1563,6 +1567,116 @@ export class GitHubRepository extends Disposable {
 		return CopilotWorkingStatus.NotCopilotIssue;
 	}
 
+	/**
+	 * Get the timeline events of a pull request, including comments, reviews, commits, merges, deletes, and assigns.
+	 */
+	async getTimelineEvents(pullRequestModel: PullRequestModel): Promise<Common.TimelineEvent[]> {
+		const getTimelineEvents = async () => {
+			Logger.debug(`Fetch timeline events of PR #${pullRequestModel.number} - enter`, PullRequestModel.ID);
+			const { query, remote, schema } = await this.ensure();
+			try {
+				const { data } = await query<TimelineEventsResponse>({
+					query: schema.TimelineEvents,
+					variables: {
+						owner: remote.owner,
+						name: remote.repositoryName,
+						number: pullRequestModel.number,
+					},
+				});
+
+				if (data.repository === null) {
+					Logger.error('Unexpected null repository when fetching timeline', PullRequestModel.ID);
+				}
+				return data;
+			} catch (e) {
+				Logger.error(`Failed to get pull request timeline events: ${e}`, PullRequestModel.ID);
+				console.log(e);
+				return undefined;
+			}
+		};
+
+		const [data, latestReviewCommitInfo, currentUser, reviewThreads] = await Promise.all([
+			getTimelineEvents(),
+			pullRequestModel.getViewerLatestReviewCommit(),
+			(await this.getAuthenticatedUser()).login,
+			pullRequestModel.getReviewThreads()
+		]);
+
+
+		const ret = data?.repository?.pullRequest.timelineItems.nodes ?? [];
+		const events = await parseCombinedTimelineEvents(ret, await this.getCopilotTimelineEvents(pullRequestModel), this);
+
+		this.addReviewTimelineEventComments(events, reviewThreads);
+		insertNewCommitsSinceReview(events, latestReviewCommitInfo?.sha, currentUser, pullRequestModel.head);
+		Logger.debug(`Fetch timeline events of PR #${pullRequestModel.number} - done`, PullRequestModel.ID);
+		const oldEvents = pullRequestModel.timelineEvents;
+		pullRequestModel.timelineEvents = events;
+		if (oldEvents.length !== events.length) {
+			this._onDidChangePullRequests.fire();
+		}
+		return events;
+	}
+
+	private addReviewTimelineEventComments(events: Common.TimelineEvent[], reviewThreads: IReviewThread[]): void {
+		interface CommentNode extends IComment {
+			childComments?: CommentNode[];
+		}
+
+		const reviewEvents = events.filter((e): e is Common.ReviewEvent => e.event === Common.EventType.Reviewed);
+		const reviewComments = reviewThreads.reduce((previous, current) => (previous as IComment[]).concat(current.comments), []);
+
+		const reviewEventsById = reviewEvents.reduce((index, evt) => {
+			index[evt.id] = evt;
+			evt.comments = [];
+			return index;
+		}, {} as { [key: number]: Common.ReviewEvent });
+
+		const commentsById = reviewComments.reduce((index, evt) => {
+			index[evt.id] = evt;
+			return index;
+		}, {} as { [key: number]: CommentNode });
+
+		const roots: CommentNode[] = [];
+		let i = reviewComments.length;
+		while (i-- > 0) {
+			const c: CommentNode = reviewComments[i];
+			if (!c.inReplyToId) {
+				roots.unshift(c);
+				continue;
+			}
+			const parent = commentsById[c.inReplyToId];
+			parent.childComments = parent.childComments || [];
+			parent.childComments = [c, ...(c.childComments || []), ...parent.childComments];
+		}
+
+		roots.forEach(c => {
+			const review = reviewEventsById[c.pullRequestReviewId!];
+			if (review) {
+				review.comments = review.comments.concat(c).concat(c.childComments || []);
+			}
+		});
+
+		reviewThreads.forEach(thread => {
+			if (!thread.prReviewDatabaseId || !reviewEventsById[thread.prReviewDatabaseId]) {
+				return;
+			}
+			const prReviewThreadEvent = reviewEventsById[thread.prReviewDatabaseId];
+			prReviewThreadEvent.reviewThread = {
+				threadId: thread.id,
+				canResolve: thread.viewerCanResolve,
+				canUnresolve: thread.viewerCanUnresolve,
+				isResolved: thread.isResolved
+			};
+
+		});
+
+		const pendingReview = reviewEvents.filter(r => r.state?.toLowerCase() === 'pending')[0];
+		if (pendingReview) {
+			// Ensures that pending comments made in reply to other reviews are included for the pending review
+			pendingReview.comments = reviewComments.filter(c => c.isDraft);
+		}
+	}
+
 	/**
 	 * Get the status checks of the pull request, those for the last commit.
 	 *

src/github/issueModel.ts

@@ -7,7 +7,7 @@ import * as vscode from 'vscode';
 import { IComment } from '../common/comment';
 import Logger from '../common/logger';
 import { Remote } from '../common/remote';
-import { ClosedEvent, EventType } from '../common/timelineEvent';
+import { ClosedEvent, EventType, TimelineEvent } from '../common/timelineEvent';
 import { formatError } from '../common/utils';
 import { GitHubRepository } from './githubRepository';
 import {
@@ -41,6 +41,8 @@ export class IssueModel<TItem extends Issue = Issue> {
 	public item: TItem;
 	public bodyHTML?: string;
 
+	private _timelineEvents: readonly TimelineEvent[] | undefined;
+
 	private _onDidInvalidate = new vscode.EventEmitter<void>();
 	public onDidInvalidate = this._onDidInvalidate.event;
 
@@ -54,6 +56,14 @@ export class IssueModel<TItem extends Issue = Issue> {
 		}
 	}
 
+	get timelineEvents(): readonly TimelineEvent[] {
+		return this._timelineEvents ?? [];
+	}
+
+	set timelineEvents(timelineEvents: readonly TimelineEvent[]) {
+		this._timelineEvents = timelineEvents;
+	}
+
 	public invalidate() {
 		// Something about the PR data is stale
 		this._onDidInvalidate.fire();