Check if there are updates before refreshing (#6943)

Fixes #6935

Author: alexr00

src/github/graphql.ts

@@ -250,6 +250,48 @@ export interface TimelineEventsResponse {
 	rateLimit: RateLimit;
 }
 
+export interface LatestCommit {
+	commit: {
+		authoredDate: string;
+	}
+}
+
+export interface LatestReviewThread {
+	comments: {
+		nodes: {
+			createdAt: string;
+		}[];
+	}
+}
+
+export interface LatestUpdatesResponse {
+	repository: {
+		pullRequest: {
+			reactions: {
+				nodes: {
+					createdAt: string;
+				}[];
+			}
+			updatedAt: string;
+			comments: {
+				nodes: {
+					updatedAt: string;
+					reactions: {
+						nodes: {
+							createdAt: string;
+						}[];
+					}
+				}[];
+			}
+			timelineItems: {
+				nodes: ({
+					createdAt: string;
+				} | LatestCommit | LatestReviewThread)[];
+			}
+		}
+	}
+}
+
 export interface LatestReviewCommitResponse {
 	repository: {
 		pullRequest: {

src/github/issueModel.ts

@@ -14,6 +14,9 @@ import {
 	AddIssueCommentResponse,
 	AddPullRequestToProjectResponse,
 	EditIssueCommentResponse,
+	LatestCommit,
+	LatestReviewThread,
+	LatestUpdatesResponse,
 	TimelineEventsResponse,
 	UpdateIssueResponse,
 } from './graphql';
@@ -351,6 +354,52 @@ export class IssueModel<TItem extends Issue = Issue> {
 		}
 	}
 
+	protected getUpdatesQuery(schema: any): any {
+		return schema.LatestIssueUpdates;
+	}
+
+	async getLastUpdateTime(time: Date): Promise<Date> {
+		Logger.debug(`Fetch timeline events of issue #${this.number} - enter`, IssueModel.ID);
+		const githubRepository = this.githubRepository;
+		const { query, remote, schema } = await githubRepository.ensure();
+		try {
+			const { data } = await query<LatestUpdatesResponse>({
+				query: this.getUpdatesQuery(schema),
+				variables: {
+					owner: remote.owner,
+					name: remote.repositoryName,
+					number: this.number,
+					since: new Date(time),
+				}
+			});
+
+			const times = [
+				time,
+				new Date(data.repository.pullRequest.updatedAt),
+				...(data.repository.pullRequest.reactions.nodes.map(node => new Date(node.createdAt))),
+				...(data.repository.pullRequest.comments.nodes.map(node => new Date(node.updatedAt))),
+				...(data.repository.pullRequest.comments.nodes.flatMap(node => node.reactions.nodes.map(reaction => new Date(reaction.createdAt)))),
+				...(data.repository.pullRequest.timelineItems.nodes.map(node => {
+					const latestCommit = node as Partial<LatestCommit>;
+					if (latestCommit.commit?.authoredDate) {
+						return new Date(latestCommit.commit.authoredDate);
+					}
+					const latestReviewThread = node as Partial<LatestReviewThread>;
+					if ((latestReviewThread.comments?.nodes.length ?? 0) > 0) {
+						return new Date(latestReviewThread.comments!.nodes[0].createdAt);
+					}
+					return new Date((node as { createdAt: string }).createdAt);
+				}))
+			];
+
+			// Sort times and return the most recent one
+			return new Date(Math.max(...times.map(t => t.getTime())));
+		} catch (e) {
+			Logger.error(`Error fetching timeline events of issue #${this.number} - ${formatError(e)}`, IssueModel.ID);
+			return time; // Return the original time in case of an error
+		}
+	}
+
 	async updateMilestone(id: string): Promise<void> {
 		const { mutate, schema } = await this.githubRepository.ensure();
 		const finalId = id === 'null' ? null : id;

src/github/issueOverview.ts

@@ -137,10 +137,11 @@ export class IssueOverviewPanel<TItem extends IssueModel = IssueModel> extends W
 		}));
 
 		this._register(this._panel.onDidChangeViewState(e => this.onDidChangeViewState(e)));
-		this.pollForUpdates();
+		this.lastRefreshTime = new Date();
+		this.pollForUpdates(true);
 		this._register(vscode.workspace.onDidChangeConfiguration(e => {
 			if (e.affectsConfiguration(`${PR_SETTINGS_NAMESPACE}.${WEBVIEW_REFRESH_INTERVAL}`)) {
-				this.pollForUpdates();
+				this.pollForUpdates(this._panel.visible, true);
 			}
 		}));
 
@@ -157,16 +158,25 @@ export class IssueOverviewPanel<TItem extends IssueModel = IssueModel> extends W
 	}
 
 	private timeout: NodeJS.Timeout | undefined = undefined;
-	private pollForUpdates(refreshImmediately: boolean = false): void {
+	private lastRefreshTime: Date;
+	private pollForUpdates(isVisible: boolean, refreshImmediately: boolean = false): void {
 		clearTimeout(this.timeout);
+		const refresh = async () => {
+			const previousRefreshTime = this.lastRefreshTime;
+			this.lastRefreshTime = await this._item.getLastUpdateTime(previousRefreshTime);
+			if (this.lastRefreshTime.getTime() > previousRefreshTime.getTime()) {
+				return this.refreshPanel();
+			}
+		};
+
 		if (refreshImmediately) {
-			this.refreshPanel();
+			refresh();
 		}
-		const webview = vscode.window.tabGroups.all.find(group => group.activeTab?.input instanceof vscode.TabInputWebview && group.activeTab.input.viewType.endsWith(this.type));
+		const webview = isVisible || vscode.window.tabGroups.all.find(group => group.activeTab?.input instanceof vscode.TabInputWebview && group.activeTab.input.viewType.endsWith(this.type));
 		const timeoutDuration = 1000 * (webview ? this.getRefreshInterval() : (5 * 60));
 		this.timeout = setTimeout(async () => {
-			await this.refreshPanel();
-			this.pollForUpdates();
+			await refresh();
+			this.pollForUpdates(this._panel.visible);
 		}, timeoutDuration);
 	}
 

src/github/pullRequestModel.ts

@@ -1198,6 +1198,10 @@ export class PullRequestModel extends IssueModel<PullRequest> implements IPullRe
 		}
 	}
 
+	protected override getUpdatesQuery(schema: any): any {
+		return schema.LatestUpdates;
+	}
+
 	private addReviewTimelineEventComments(events: TimelineEvent[], reviewThreads: IReviewThread[]): void {
 		interface CommentNode extends IComment {
 			childComments?: CommentNode[];