fix(tasks): show cached GitHub rows on filter change and keep issue-number order (#42128)

* fix(tasks): show cached GitHub rows instead of the skeleton on filter change

Filter handlers set tasksFiltering and only the forced fetch settlement
cleared it, so rows the landing run had already painted from the
per-query cache stayed hidden behind the skeleton. The landing run now
clears the flag when every selected repo (or the restored page) is
cached for the applied query; the forced refetch still runs under the
toolbar spinner and replaces the rows in place.

Rebuilds #41998 by @piotrpawlik (fixes #41997).

Co-authored-by: Piotr Pawlik <piotr.pawlik@apollo.io>

* fix(tasks): keep GitHub Tasks pages in issue-number order

materializeTaskPageItemList re-sorted every page by updatedAt while the
host search, the cross-repo aggregate, the landing pre-paint and mobile
all order by issue number. A triage edit moved old issues to the top,
and the landing probe saw a different key order and reset pagination.
Use the shared sortWorkItemsByNumber so retained pending rows keep
their number slot too.

Rebuilds #41999 by @bbingz (fixes #41987).

Co-authored-by: Bing.Z <zzb@gxsmjx.com>

* test(tasks): make landing tests revert-sensitive; scope refetch comment

Address C1 review: every landing case now fails without the cached-rows
fix, names say what they verify, and the comment no longer claims typed
search forces the refetch.

* test(tasks): replace landing test casts with annotations

* fix(tasks): hold GitHub pagination while a forced refresh is in flight

Cached rows now show during a filter switch's forced refetch, which made the
pager live; opening page 2 then got undone when the refetch replaced every
page. Disable the pager until it lands, as the phone does while revalidating.
Also drops two landing tests that covered no new behavior.

* fix(tasks): hold GitHub pagination for any in-flight landing fetch

A typed search over stale cached rows lands without a forced fetch, so the
pager was still live and its page could be undone when the landing fetch
replaced the pages. Track the landing fetch itself, as the phone holds paging
while any list load revalidates. Shares the retry-key release between the
fetch's settle paths to keep the run under the file-length limit.

---------

Co-authored-by: Piotr Pawlik <piotr.pawlik@apollo.io>
Co-authored-by: Bing.Z <zzb@gxsmjx.com>
Co-authored-by: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
This commit is contained in:
Jinjing
2026-11-13 17:31:49 -08:00
committed by GitHub
co-authored by Piotr Pawlik Bing.Z Brennan Benson
parent 4ccda83aff
commit c2b4e4281f
8 changed files with 267 additions and 36 deletions
@@ -7,11 +7,13 @@ export function PaginationBar({
currentPage,
totalPages,
loadingTarget,
disabled = false,
onPageChange
}: {
currentPage: number
totalPages: number
loadingTarget: number | null
disabled?: boolean
onPageChange: (page: number) => void
}): React.JSX.Element {
const t = useTranslate()
@@ -32,7 +34,7 @@ export function PaginationBar({
>
<button
type="button"
disabled={currentPage === 0 || loadingTarget !== null}
disabled={disabled || currentPage === 0 || loadingTarget !== null}
onClick={() => onPageChange(currentPage - 1)}
aria-label={t('auto.components.TaskPage.6cd6b3ae6a', 'Previous page')}
className={btnClass}
@@ -54,7 +56,7 @@ export function PaginationBar({
<button
key={entry}
type="button"
disabled={loadingTarget !== null && loadingTarget !== entry}
disabled={disabled || (loadingTarget !== null && loadingTarget !== entry)}
onClick={() => onPageChange(entry)}
aria-label={t('auto.components.TaskPage.ae859c816b', 'Page {{value0}}', {
value0: entry + 1
@@ -73,7 +75,7 @@ export function PaginationBar({
<button
type="button"
disabled={currentPage >= totalPages - 1 || loadingTarget !== null}
disabled={disabled || currentPage >= totalPages - 1 || loadingTarget !== null}
onClick={() => onPageChange(currentPage + 1)}
aria-label={t('auto.components.TaskPage.0c8df28045', 'Next page')}
className={btnClass}
@@ -37,6 +37,7 @@ export function TaskPageGitHubList({
pendingGithubScrollRestoreRef,
githubListRestoreWriteRef,
loadingTargetPage,
githubListRevalidating,
taskListPositionRef,
perRepoSourceState,
unresolvedSourceRepos,
@@ -310,6 +311,7 @@ export function TaskPageGitHubList({
currentPage={currentPage}
totalPages={totalPages}
loadingTarget={loadingTargetPage}
disabled={githubListRevalidating}
onPageChange={(page) => {
pendingGithubScrollRestoreRef.current = null
githubListScrollTopRef.current = 0
@@ -44,6 +44,8 @@ export function useTaskPageGitHubListState(model: TaskPageProviderStateModel) {
const [landingRequestKey, setLandingRequestKey] = useState('')
const [tasksRefreshing, setTasksRefreshing] = useState(false)
const [tasksFiltering, setTasksFiltering] = useState(false)
// Why: the landing fetch replaces every page when it lands, so paging while it runs would be undone.
const [githubListRevalidating, setGithubListRevalidating] = useState(false)
const [tasksError, setTasksError] = useState<string | null>(null)
// Why: per-repo failure count for the "N of M" banner; IPC rejections use tasksError instead so partial-failure and hard-reject don't double-show.
const [failedCount, setFailedCount] = useState(0)
@@ -195,6 +197,8 @@ export function useTaskPageGitHubListState(model: TaskPageProviderStateModel) {
setTasksRefreshing,
tasksFiltering,
setTasksFiltering,
githubListRevalidating,
setGithubListRevalidating,
tasksError,
setTasksError,
failedCount,
@@ -0,0 +1,63 @@
import { afterEach, describe, expect, it } from 'vitest'
import type { GitHubWorkItem } from '../../../../../../shared/github/work-items/work-item-types'
import { materializeTaskPageItemList } from './task-page-github-work-item-mutation-pages'
import {
deletePendingTaskPageGitHubOp,
setPendingTaskPageGitHubOp
} from './task-page-github-work-item-mutation-registry'
function issue(number: number, updatedAt: string): GitHubWorkItem {
return {
id: `issue:${number}`,
type: 'issue',
number,
title: `Issue ${number}`,
state: 'open',
url: `https://github.com/acme/orca/issues/${number}`,
labels: [],
updatedAt,
author: 'octocat',
repoId: 'repo-1'
}
}
const pendingKey = { sourceScope: null, repoId: 'repo-1', itemId: 'issue:50', opKey: 'state' }
afterEach(() => {
deletePendingTaskPageGitHubOp(pendingKey)
})
describe('materializeTaskPageItemList', () => {
it('keeps issue-number order when an older issue was edited more recently', () => {
const newest = issue(80, '2026-11-01T00:00:00Z')
const triaged = issue(12, '2026-11-13T00:00:00Z')
const rows = materializeTaskPageItemList({
networkItems: [newest, triaged],
previousItems: [],
queryKey: 'is:issue is:open'
})
expect(rows.map((row) => row.number)).toEqual([80, 12])
})
it('places a retained pending row at its issue-number position', () => {
const pending = issue(50, '2026-11-13T00:00:00Z')
setPendingTaskPageGitHubOp({
generation: 1,
key: pendingKey,
previous: { state: 'open' },
next: { state: 'closed' },
skipMeQualifiers: false,
startedAt: 0
})
const rows = materializeTaskPageItemList({
networkItems: [issue(80, '2026-11-01T00:00:00Z'), issue(12, '2026-11-02T00:00:00Z')],
previousItems: [pending],
queryKey: 'is:issue is:open'
})
expect(rows.map((row) => row.number)).toEqual([80, 50, 12])
})
})
@@ -2,6 +2,7 @@ import { projectPRCheckOwner } from '../../../../../../shared/github/checks/comp
import type { GitHubWorkItem } from '../../../../../../shared/github/work-items/work-item-types'
import type { TaskSourceContext } from '../../../../../../shared/work-items/task-source-context'
import { parseGitHubIssueOrPRLink } from '../../../../../../shared/github/repositories/links'
import { sortWorkItemsByNumber } from '../../../../../../shared/work-items/work-item-order'
import { getRegistryMergedTaskPageGitHubWorkItem } from './task-page-github-work-item-mutation-composition'
import {
getStickyHideEntry,
@@ -111,9 +112,8 @@ export function materializeTaskPageItemList(args: {
const scope = resolveItemSourceScope(item.repoId, item.id)
byKey.set(k, getRegistryMergedTaskPageGitHubWorkItem(item, scope))
}
return [...byKey.values()].sort(
(a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
)
// Why: host pages, the cross-repo aggregate and mobile all order by issue number; retained rows keep their slot.
return sortWorkItemsByNumber([...byKey.values()])
}
export function reconcileTaskPagePagesAfterQuietRefresh(args: {
@@ -16,6 +16,7 @@ export type TaskPageGitHubLandingRefreshModel = Pick<
| 'selectedReposKey'
| 'setTasksRefreshing'
| 'setTasksFiltering'
| 'setGithubListRevalidating'
| 'setTasksError'
| 'setFailedCount'
| 'setGithubUnavailable'
@@ -0,0 +1,159 @@
import { describe, expect, it, vi } from 'vitest'
import type { Repo } from '../../../../../../shared/repo-types'
import type { GitHubWorkItem } from '../../../../../../shared/github/work-items/work-item-types'
import { runTaskPageGitHubLandingRefresh } from './task-page-github-landing-refresh-run'
import type { TaskPageGitHubLandingRefreshModel } from './task-page-github-landing-refresh-model'
const QUERY = 'is:pr is:open author:@me'
function repo(id: string): Repo {
return { id, path: `/repos/${id}`, displayName: id, badgeColor: '#000000', addedAt: 0 }
}
function pr(repoId: string, number: number): GitHubWorkItem {
return {
id: `pr:${number}`,
type: 'pr',
number,
title: `PR ${number}`,
state: 'open',
url: `https://github.com/acme/${repoId}/pull/${number}`,
labels: [],
updatedAt: '2026-11-01T00:00:00Z',
author: 'octocat',
repoId
}
}
type FetchResult = { items: GitHubWorkItem[]; failedCount: number; githubUnavailable: boolean }
type Deferred = { resolve: (result: FetchResult) => void }
// A filter click sets tasksFiltering, bumps the refresh nonce and changes the query; this is the landing run that follows.
function landAfterFilterChange(cache: Record<string, GitHubWorkItem[] | null>) {
const state = { filtering: true, loading: false, refreshing: false, revalidating: false }
const selectedRepos = Object.keys(cache).map(repo)
const fetches: Deferred[] = []
const pending = () => new Promise<never>(() => {})
const pagesRef: { current: (GitHubWorkItem[] | null)[] } = { current: [] }
const model = {
fetchWorkItemsAcrossRepos: vi.fn(
() =>
new Promise<FetchResult>((resolve) => {
fetches.push({ resolve })
})
),
fetchWorkItemsNextPage: vi.fn(pending),
countWorkItemsAcrossRepos: vi.fn(pending),
getCachedWorkItems: (repoId: string) => cache[repoId] ?? null,
workItemsInvalidationNonce: 0,
selectedRepos,
selectedReposKey: selectedRepos.map((r) => r.id).join(','),
taskSource: 'github',
taskResumeApplied: true,
githubMode: 'items',
appliedTaskSearch: QUERY,
taskRefreshNonce: 1,
setTasksLoading: (next: boolean) => {
state.loading = next
},
setTasksRefreshing: (next: boolean) => {
state.refreshing = next
},
setTasksFiltering: (next: boolean) => {
state.filtering = next
},
setGithubListRevalidating: (next: boolean) => {
state.revalidating = next
},
setTasksError: vi.fn(),
setFailedCount: vi.fn(),
setGithubUnavailable: vi.fn(),
lastFetchedNonceRef: { current: 0 },
lastFetchedInvalidationNonceRef: { current: 0 },
paginationGenerationRef: { current: 0 },
landingGitHubRefreshKeysRef: { current: new Set<string>() },
githubPerRepoPageLimit: 30,
githubPageSize: 30,
githubResumeContextKey: 'mine',
setPages: (
next:
| (GitHubWorkItem[] | null)[]
| ((previous: (GitHubWorkItem[] | null)[]) => (GitHubWorkItem[] | null)[])
) => {
pagesRef.current = typeof next === 'function' ? next(pagesRef.current) : next
},
setCurrentPage: vi.fn(),
pagesRef,
currentPageRef: { current: 0 },
githubResumeConsumedRef: { current: true },
githubResumeContextRef: { current: 'open' },
pendingGithubScrollRestoreRef: { current: null },
setPaginationLoading: vi.fn(),
setLoadingTargetPage: vi.fn(),
setCountedTotalPages: vi.fn(),
setProvenPageLimit: vi.fn(),
countedTotalPagesRef: { current: null },
hardRefreshEpochRef: { current: 0 },
retryingSourceKeys: new Set<string>(),
setRetryingSourceKeys: vi.fn(),
githubWorkItemMutationQueryKey: QUERY,
setLandingRequestKey: vi.fn()
}
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: supplies every field the landing run reads.
const landingModel = model as unknown as TaskPageGitHubLandingRefreshModel
runTaskPageGitHubLandingRefresh(landingModel)
const rows = () => pagesRef.current[0]?.map((row) => row.number)
const answer = async (items: GitHubWorkItem[]) => {
fetches[0]?.resolve({ items, failedCount: 0, githubUnavailable: false })
await Promise.resolve()
await Promise.resolve()
}
return { state, model, rows, answer }
}
describe('runTaskPageGitHubLandingRefresh after a filter change', () => {
it('clears the skeleton only when every selected repo has the query cached', () => {
const cached = landAfterFilterChange({ a: [pr('a', 7)], b: [pr('b', 9)] })
const partial = landAfterFilterChange({ a: [pr('a', 7)], b: null })
expect(cached.state).toEqual({
filtering: false,
loading: false,
refreshing: true,
revalidating: true
})
expect(cached.rows()).toEqual([9, 7])
expect(partial.state).toEqual({
filtering: true,
loading: true,
refreshing: true,
revalidating: true
})
})
it('keeps cached rows on screen while the forced refetch runs, then replaces them in place', async () => {
const { state, model, rows, answer } = landAfterFilterChange({ a: [pr('a', 7), pr('a', 5)] })
expect(model.fetchWorkItemsAcrossRepos).toHaveBeenCalledWith(
expect.anything(),
30,
30,
QUERY,
expect.objectContaining({ force: true, noCache: true })
)
expect(rows()).toEqual([7, 5])
expect(state.filtering).toBe(false)
// Paging stays held until the refetch lands, since landing replaces every page.
expect(state.revalidating).toBe(true)
await answer([pr('a', 8), pr('a', 7)])
expect(rows()).toEqual([8, 7])
expect(state).toEqual({
filtering: false,
loading: false,
refreshing: false,
revalidating: false
})
})
})
@@ -38,6 +38,7 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
setTasksLoading,
setTasksRefreshing,
setTasksFiltering,
setGithubListRevalidating,
setTasksError,
setFailedCount,
setGithubUnavailable,
@@ -72,18 +73,14 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
return
}
// Clear retry keys on early returns because no promise handler will run to release Retry.
if (taskSource !== 'github' || githubMode !== 'items') {
// An empty selection is unreachable (the multi-combobox forbids it) but still settles here.
if (taskSource !== 'github' || githubMode !== 'items' || selectedRepos.length === 0) {
setRetryingSourceKeys(new Set())
setTasksRefreshing(false)
setTasksFiltering(false)
setGithubListRevalidating(false)
return
}
if (selectedRepos.length === 0) {
setRetryingSourceKeys(new Set())
setTasksRefreshing(false)
setTasksFiltering(false)
return
} // unreachable — multi-combobox forbids empty
// Why: strip repo:owner/name qualifiers before fan-out — cross-repo they'd pin every fetch to one repo. See stripRepoQualifiers.
const q = stripRepoQualifiers(appliedTaskSearch.trim())
@@ -165,7 +162,14 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
setTasksError(null)
setFailedCount(0) // reset so a prior failure banner doesn't linger
setGithubUnavailable(false)
setTasksLoading(targetPage > 0 ? cachedTargetPage === null : anyUncached)
const landingNeedsNetwork = targetPage > 0 ? cachedTargetPage === null : anyUncached
setTasksLoading(landingNeedsNetwork)
if (!landingNeedsNetwork) {
// Why: the rows just painted were cached for this exact query, so they cannot read as the old filter's result.
// They may be stale or partial (a repo whose last answer carried a source error); the landing fetch below
// still runs (forced after a click, a probe or cache read after typed search) and replaces them in place.
setTasksFiltering(false)
}
model.setLandingRequestKey(taskPageGitHubLandingRequestKey(model))
const forceRefresh = taskRefreshNonce !== lastFetchedNonceRef.current
@@ -277,6 +281,19 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
// Why: snapshot retrying keys at dispatch so an earlier settling effect doesn't wipe a newer retry's pending source.
const dispatchedRetrySourceKeys = retryingSourceKeys
// Why: clear only the dispatch-time snapshot keys so an overlapping retry's newer source isn't wiped.
const releaseDispatchedRetryKeys = () =>
setRetryingSourceKeys((prev) => {
if (dispatchedRetrySourceKeys.size === 0) {
return prev
}
const next = new Set(prev)
for (const key of dispatchedRetrySourceKeys) {
next.delete(key)
}
return next
})
setGithubListRevalidating(true)
void fetchWorkItemsAcrossRepos(repoArgs, githubPerRepoPageLimit, githubPageSize, q, {
...deriveTaskPageGitHubWorkItemsFetchOptions(forcedFetch, shouldProbeOnLanding),
...wake,
@@ -287,17 +304,7 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
: {})
})
.then((result) => {
// Why: clear only the dispatch-time snapshot keys so an overlapping retry's newer source isn't wiped.
setRetryingSourceKeys((prev) => {
if (dispatchedRetrySourceKeys.size === 0) {
return prev
}
const next = new Set(prev)
for (const key of dispatchedRetrySourceKeys) {
next.delete(key)
}
return next
})
releaseDispatchedRetryKeys()
if (cancelled) {
return
}
@@ -305,6 +312,7 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
setTasksLoading(false)
setTasksRefreshing(false)
setTasksFiltering(false)
setGithubListRevalidating(false)
return
}
const {
@@ -373,20 +381,11 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
}
setTasksRefreshing(false)
setTasksFiltering(false)
setGithubListRevalidating(false)
})
.catch((err) => {
// Why: fetchWorkItemsAcrossRepos swallows per-repo failures, so a reject here is IPC/programmer error — surface it.
// Why: clear only the dispatch-time snapshot keys so an overlapping retry's newer source isn't wiped.
setRetryingSourceKeys((prev) => {
if (dispatchedRetrySourceKeys.size === 0) {
return prev
}
const next = new Set(prev)
for (const key of dispatchedRetrySourceKeys) {
next.delete(key)
}
return next
})
releaseDispatchedRetryKeys()
if (cancelled) {
return
}
@@ -405,6 +404,7 @@ export function runTaskPageGitHubLandingRefresh(model: TaskPageGitHubLandingRefr
}
setTasksRefreshing(false)
setTasksFiltering(false)
setGithubListRevalidating(false)
})
// Why: fire-and-forget count query alongside the items fetch; the search API is cached 120s server-side so it adds little cost.