Check if there are new PRs in the repo before doing PR search (#7799)

* Check if there are new PRs in the repo before doing PR search
Fixes #7798

* Not sure why these errors didn't show in the watch task...

Author: alexr00

common/types.ts

@@ -0,0 +1,9 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export interface RemoteInfo {
+	owner: string;
+	repositoryName: string;
+}

common/views.ts

@@ -6,11 +6,7 @@
 import { ClosedEvent, CommentEvent } from '../src/common/timelineEvent';
 import { GithubItemStateEnum, IAccount, ILabel, IMilestone, IProject, ITeam, MergeMethod, MergeMethodsAvailability } from '../src/github/interface';
 import { DisplayLabel, PreReviewState } from '../src/github/views';
-
-export interface RemoteInfo {
-	owner: string;
-	repositoryName: string;
-}
+import { RemoteInfo } from './types';
 
 export interface CreateParams {
 	availableBaseRemotes: RemoteInfo[];

src/github/createPRViewProvider.ts

@@ -4,7 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
-import { ChooseBaseRemoteAndBranchResult, ChooseCompareRemoteAndBranchResult, ChooseRemoteAndBranchArgs, CreateParamsNew, CreatePullRequestNew, RemoteInfo, TitleAndDescriptionArgs } from '../../common/views';
+import { RemoteInfo } from '../../common/types';
+import { ChooseBaseRemoteAndBranchResult, ChooseCompareRemoteAndBranchResult, ChooseRemoteAndBranchArgs, CreateParamsNew, CreatePullRequestNew, TitleAndDescriptionArgs } from '../../common/views';
 import type { Branch, Ref } from '../api/api';
 import { GitHubServerType } from '../common/authentication';
 import { emojify, ensureEmojis } from '../common/emoji';

src/github/githubRepository.ts

@@ -834,29 +834,37 @@ export class GitHubRepository extends Disposable {
 		}
 	}
 
-	async getMaxIssue(): Promise<number | undefined> {
+	private async _getMaxItem(isIssue: boolean): Promise<number | undefined> {
 		try {
-			Logger.debug(`Fetch max issue - enter`, this.id);
+			Logger.debug(`Fetch max ${isIssue ? 'issue' : 'pull request'} - enter`, this.id);
 			const { query, remote, schema } = await this.ensure();
 			const { data } = await query<MaxIssueResponse>({
-				query: schema.MaxIssue,
+				query: isIssue ? schema.MaxIssue : schema.MaxPullRequest,
 				variables: {
 					owner: remote.owner,
 					name: remote.repositoryName,
 				},
 			});
-			Logger.debug(`Fetch max issue - done`, this.id);
+			Logger.debug(`Fetch max ${isIssue ? 'issue' : 'pull request'} - done`, this.id);
 
 			if (data?.repository && data.repository.issues.edges.length === 1) {
 				return data.repository.issues.edges[0].node.number;
 			}
 			return;
 		} catch (e) {
-			Logger.error(`Unable to fetch issues with query: ${e}`, this.id);
+			Logger.error(`Unable to fetch ${isIssue ? 'issues' : 'pull requests'} with query: ${e}`, this.id);
 			return;
 		}
 	}
 
+	async getMaxIssue(): Promise<number | undefined> {
+		return this._getMaxItem(true);
+	}
+
+	async getMaxPullRequest(): Promise<number | undefined> {
+		return this._getMaxItem(false);
+	}
+
 	async getViewerPermission(): Promise<ViewerPermission> {
 		try {
 			Logger.debug(`Fetch viewer permission - enter`, this.id);

src/github/queriesShared.gql

@@ -1247,6 +1247,23 @@ query MaxIssue($owner: String!, $name: String!) {
 	}
 }
 
+query MaxPullRequest($owner: String!, $name: String!) {
+	repository(owner: $owner, name: $name) {
+		issues: pullRequests(first: 1, orderBy: { direction: DESC, field: CREATED_AT }) {
+			edges {
+				node {
+					... on PullRequest {
+						number
+					}
+				}
+			}
+		}
+	}
+	rateLimit {
+		...RateLimit
+	}
+}
+
 query GetMilestones($owner: String!, $name: String!, $states: [MilestoneState!]!) {
 	repository(owner: $owner, name: $name) {
 		milestones(first: 100, orderBy: { direction: DESC, field: DUE_DATE }, states: $states) {

src/view/prsTreeModel.ts

@@ -4,6 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as vscode from 'vscode';
+import { RemoteInfo } from '../../common/types';
 import { Disposable, disposeAll } from '../common/lifecycle';
 import { getReviewMode } from '../common/settingsUtils';
 import { ITelemetry } from '../common/telemetry';
@@ -13,7 +14,7 @@ import { PullRequestChangeEvent } from '../github/githubRepository';
 import { CheckState, PRType, PullRequestChecks, PullRequestReviewRequirement } from '../github/interface';
 import { PullRequestModel } from '../github/pullRequestModel';
 import { RepositoriesManager } from '../github/repositoriesManager';
-import { UnsatisfiedChecks } from '../github/utils';
+import { UnsatisfiedChecks, variableSubstitution } from '../github/utils';
 import { CategoryTreeNode } from './treeNodes/categoryNode';
 import { TreeNode } from './treeNodes/treeNode';
 
@@ -24,6 +25,12 @@ interface PRStatusChange {
 	status: UnsatisfiedChecks;
 }
 
+interface CachedPRs {
+	clearRequested: boolean;
+	maxKnownPR: number | undefined; // used to determine if there have been new PRs created since last query
+	items: ItemsResponseResult<PullRequestModel>;
+}
+
 export class PrsTreeModel extends Disposable {
 	private _activePRDisposables: Map<FolderRepositoryManager, vscode.Disposable[]> = new Map();
 	private readonly _onDidChangePrStatus: vscode.EventEmitter<string[]> = this._register(new vscode.EventEmitter<string[]>());
@@ -38,9 +45,10 @@ export class PrsTreeModel extends Disposable {
 	// Key is identifier from createPRNodeUri
 	private readonly _queriedPullRequests: Map<string, PRStatusChange> = new Map();
 
-	private _cachedPRs: Map<FolderRepositoryManager, Map<string | PRType.LocalPullRequest | PRType.All, ItemsResponseResult<PullRequestModel>>> = new Map();
+	private _cachedPRs: Map<FolderRepositoryManager, Map<string | PRType.LocalPullRequest | PRType.All, CachedPRs>> = new Map();
 	private readonly _repoEvents: Map<FolderRepositoryManager, vscode.Disposable[]> = new Map();
 	private _getPullRequestsForQueryLock: Promise<void> = Promise.resolve();
+	private _sentNoRepoTelemetry: boolean = false;
 
 	constructor(private _telemetry: ITelemetry, private readonly _reposManager: RepositoriesManager, private readonly _context: vscode.ExtensionContext) {
 		super();
@@ -144,17 +152,21 @@ export class PrsTreeModel extends Disposable {
 		if (this._cachedPRs.size === 0) {
 			return;
 		}
-		this._cachedPRs.clear();
+
+		// Instead of clearing the entire cache, mark each cached query as requiring refresh.
+		for (const queries of this._cachedPRs.values()) {
+			for (const [, cachedPRs] of queries.entries()) {
+				if (cachedPRs) {
+					cachedPRs.clearRequested = true;
+				}
+			}
+		}
+
 		if (!silent) {
 			this._onDidChangeData.fire();
 		}
 	}
 
-	public clearRepo(folderRepoManager: FolderRepositoryManager) {
-		this._cachedPRs.delete(folderRepoManager);
-		this._onDidChangeData.fire(folderRepoManager);
-	}
-
 	private async _getChecks(pullRequests: PullRequestModel[]) {
 		// If there are too many pull requests then we could hit our internal rate limit
 		// or even GitHub's secondary rate limit. If there are more than 100 PRs,
@@ -207,7 +219,7 @@ export class PrsTreeModel extends Disposable {
 		this._onDidChangePrStatus.fire(changedStatuses);
 	}
 
-	private getFolderCache(folderRepoManager: FolderRepositoryManager): Map<string | PRType.LocalPullRequest | PRType.All, ItemsResponseResult<PullRequestModel>> {
+	private getFolderCache(folderRepoManager: FolderRepositoryManager): Map<string | PRType.LocalPullRequest | PRType.All, CachedPRs> {
 		let cache = this._cachedPRs.get(folderRepoManager);
 		if (!cache) {
 			cache = new Map();
@@ -216,17 +228,22 @@ export class PrsTreeModel extends Disposable {
 		return cache;
 	}
 
-	async getLocalPullRequests(folderRepoManager: FolderRepositoryManager, update?: boolean) {
+	async getLocalPullRequests(folderRepoManager: FolderRepositoryManager, update?: boolean): Promise<ItemsResponseResult<PullRequestModel>> {
 		const cache = this.getFolderCache(folderRepoManager);
 		if (!update && cache.has(PRType.LocalPullRequest)) {
-			return cache.get(PRType.LocalPullRequest)!;
+			return cache.get(PRType.LocalPullRequest)!.items;
 		}
 
 		const useReviewConfiguration = getReviewMode();
 
 		const prs = (await folderRepoManager.getLocalPullRequests())
 			.filter(pr => pr.isOpen || (pr.isClosed && useReviewConfiguration.closed) || (pr.isMerged && useReviewConfiguration.merged));
-		cache.set(PRType.LocalPullRequest, { hasMorePages: false, hasUnsearchedRepositories: false, items: prs, totalCount: prs.length });
+		const toCache: CachedPRs = {
+			clearRequested: false,
+			maxKnownPR: undefined,
+			items: { hasMorePages: false, hasUnsearchedRepositories: false, items: prs, totalCount: prs.length }
+		};
+		cache.set(PRType.LocalPullRequest, toCache);
 
 		/* __GDPR__
 			"pr.expand.local" : {}
@@ -238,6 +255,62 @@ export class PrsTreeModel extends Disposable {
 		return { hasMorePages: false, hasUnsearchedRepositories: false, items: prs };
 	}
 
+	private async _extractRepoFromQuery(folderManager: FolderRepositoryManager, query: string): Promise<RemoteInfo | undefined> {
+		if (!query) {
+			return undefined;
+		}
+
+		const defaults = await folderManager.getPullRequestDefaults();
+		const substituted = await variableSubstitution(query, undefined, defaults, (await folderManager.getCurrentUser()).login);
+
+		const repoRegex = /(?:^|\s)repo:(?:"?(?<owner>[A-Za-z0-9_.-]+)\/(?<repo>[A-Za-z0-9_.-]+)"?)/i;
+		const repoMatch = repoRegex.exec(substituted);
+		if (repoMatch && repoMatch.groups) {
+			return { owner: repoMatch.groups.owner, repositoryName: repoMatch.groups.repo };
+		}
+
+		return undefined;
+	}
+
+	private async _testIfRefreshNeeded(cached: CachedPRs, query: string, folderManager: FolderRepositoryManager): Promise<boolean> {
+		if (!cached.clearRequested) {
+			return false;
+		}
+
+		const repoInfo = await this._extractRepoFromQuery(folderManager, query);
+		if (!repoInfo) {
+			// Query doesn't specify a repo or org, so always refresh
+			// Send telemetry once indicating we couldn't find a repo in the query.
+			if (!this._sentNoRepoTelemetry) {
+				/* __GDPR__
+					"pr.expand.noRepo" : {}
+				*/
+				this._telemetry.sendTelemetryEvent('pr.expand.noRepo');
+				this._sentNoRepoTelemetry = true;
+			}
+			return true;
+		}
+
+		const currentMax = await this._getMaxKnownPR(repoInfo);
+		if (currentMax !== cached.maxKnownPR) {
+			cached.maxKnownPR = currentMax;
+			return true;
+		}
+		return false;
+	}
+
+	private async _getMaxKnownPR(repoInfo: RemoteInfo): Promise<number | undefined> {
+		const manager = this._reposManager.getManagerForRepository(repoInfo.owner, repoInfo.repositoryName);
+		if (!manager) {
+			return;
+		}
+		const repo = manager.findExistingGitHubRepository({ owner: repoInfo.owner, repositoryName: repoInfo.repositoryName });
+		if (!repo) {
+			return;
+		}
+		return repo.getMaxPullRequest();
+	}
+
 	async getPullRequestsForQuery(folderRepoManager: FolderRepositoryManager, fetchNextPage: boolean, query: string): Promise<ItemsResponseResult<PullRequestModel>> {
 		let release: () => void;
 		const lock = new Promise<void>(resolve => { release = resolve; });
@@ -246,17 +319,31 @@ export class PrsTreeModel extends Disposable {
 		await prev;
 
 		try {
+			let maxKnownPR: number | undefined;
 			const cache = this.getFolderCache(folderRepoManager);
 			if (!fetchNextPage && cache.has(query)) {
-				return cache.get(query)!;
+				const shouldRefresh = await this._testIfRefreshNeeded(cache.get(query)!, query, folderRepoManager);
+				const cachedPRs = cache.get(query)!;
+				maxKnownPR = cachedPRs.maxKnownPR;
+				if (!shouldRefresh) {
+					cachedPRs.clearRequested = false;
+					return cachedPRs.items;
+				}
+			}
+
+			if (!maxKnownPR) {
+				const repoInfo = await this._extractRepoFromQuery(folderRepoManager, query);
+				if (repoInfo) {
+					maxKnownPR = await this._getMaxKnownPR(repoInfo);
+				}
 			}
 
 			const prs = await folderRepoManager.getPullRequests(
 				PRType.Query,
 				{ fetchNextPage },
 				query,
 			);
-			cache.set(query, prs);
+			cache.set(query, { clearRequested: false, items: prs, maxKnownPR });
 
 			/* __GDPR__
 				"pr.expand.query" : {}
@@ -274,14 +361,14 @@ export class PrsTreeModel extends Disposable {
 	async getAllPullRequests(folderRepoManager: FolderRepositoryManager, fetchNextPage: boolean, update?: boolean): Promise<ItemsResponseResult<PullRequestModel>> {
 		const cache = this.getFolderCache(folderRepoManager);
 		if (!update && cache.has(PRType.All) && !fetchNextPage) {
-			return cache.get(PRType.All)!;
+			return cache.get(PRType.All)!.items;
 		}
 
 		const prs = await folderRepoManager.getPullRequests(
 			PRType.All,
 			{ fetchNextPage }
 		);
-		cache.set(PRType.All, prs);
+		cache.set(PRType.All, { clearRequested: false, items: prs, maxKnownPR: undefined });
 
 		/* __GDPR__
 			"pr.expand.all" : {}
@@ -299,15 +386,15 @@ export class PrsTreeModel extends Disposable {
 			return;
 		}
 		for (const [, queries] of this._cachedPRs.entries()) {
-			for (const [queryKey, itemsResult] of queries.entries()) {
-				if (!itemsResult || !itemsResult.items || itemsResult.items.length === 0) {
+			for (const [queryKey, cachedPRs] of queries.entries()) {
+				if (!cachedPRs || !cachedPRs.items.items || cachedPRs.items.items.length === 0) {
 					continue;
 				}
 				const hasPR = withStateChange.some(prChange =>
-					itemsResult.items.some(item => item === prChange.model)
+					cachedPRs.items.items.some(item => item === prChange.model)
 				);
 				if (hasPR) {
-					queries.delete(queryKey);
+					queries.get(queryKey)!.clearRequested = true;
 				}
 			}
 		}

webviews/common/createContextNew.ts

@@ -4,7 +4,8 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { createContext } from 'react';
-import { ChooseBaseRemoteAndBranchResult, ChooseCompareRemoteAndBranchResult, ChooseRemoteAndBranchArgs, CreateParamsNew, CreatePullRequestNew, RemoteInfo, ScrollPosition, TitleAndDescriptionArgs, TitleAndDescriptionResult } from '../../common/views';
+import { RemoteInfo } from '../../common/types';
+import { ChooseBaseRemoteAndBranchResult, ChooseCompareRemoteAndBranchResult, ChooseRemoteAndBranchArgs, CreateParamsNew, CreatePullRequestNew, ScrollPosition, TitleAndDescriptionArgs, TitleAndDescriptionResult } from '../../common/views';
 import { compareIgnoreCase } from '../../src/common/utils';
 import { PreReviewState } from '../../src/github/views';
 import { getMessageHandler, MessageHandler, vscode } from './message';

webviews/createPullRequestViewNew/app.tsx

@@ -5,7 +5,8 @@
 
 import React, { useCallback, useContext, useEffect, useRef, useState } from 'react';
 import { render } from 'react-dom';
-import { CreateParamsNew, RemoteInfo } from '../../common/views';
+import { RemoteInfo } from '../../common/types';
+import { CreateParamsNew } from '../../common/views';
 import { isITeam, MergeMethod } from '../../src/github/interface';
 import PullRequestContextNew from '../common/createContextNew';
 import { ErrorBoundary } from '../common/errorBoundary';