refactor(core): use async/await in unified search controller

Signed-off-by: Peter Ringelmann <peter.ringelmann@nextcloud.com>

Author: pringelmann

core/src/services/UnifiedSearchController.ts

@@ -1,17 +1,22 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
 import { search as unifiedSearch } from './UnifiedSearchService.js'
 
 type CategorySearchStatus = 'loading' | 'loaded' | 'failed' | 'blocked'
 
-export const REVEAL_INTERVAL = 1500 // milliseconds
-
-type CategorySearchState = {
+interface CategorySearchState {
 	status: CategorySearchStatus
 	entries: unknown[]
 	cursor: string | null
 	hasMore: boolean
 	loadMoreFailed: boolean
 }
 
+export const REVEAL_INTERVAL_MS = 1500
+
 /**
  * Runs a unified search across categories in priority order, blocking
  * lower-priority results until their predecessors arrive or a timer reveals them.
@@ -28,8 +33,9 @@ export class UnifiedSearchController {
 	 *
 	 * @param query the search term
 	 * @param categories category ids in priority order
+	 * @return resolves once every category has settled
 	 */
-	search(query: string, categories: string[]): void {
+	async search(query: string, categories: string[]): Promise<void> {
 		this.cancelPendingRequests()
 		this.searchStates = {}
 		this.searchGeneration++
@@ -38,52 +44,7 @@ export class UnifiedSearchController {
 
 		this.startRevealTimer()
 
-		categories.forEach((category) => {
-			this.searchStates[category] = {
-				status: 'loading',
-				entries: [],
-				cursor: null,
-				hasMore: false,
-				loadMoreFailed: false,
-			}
-			const { request, cancel } = unifiedSearch({
-				type: category,
-				query: this.query,
-				cursor: null,
-			})
-
-			this.pendingCancels.push(cancel)
-
-			request().then((response) => {
-				if (this.searchGeneration !== generation) {
-					// A new search has been started, ignore this result
-					return
-				}
-
-				const { entries, cursor, hasMore } = response.data.ocs.data
-				this.searchStates[category] = {
-					status: 'loaded',
-					entries,
-					cursor,
-					hasMore,
-					loadMoreFailed: false,
-				}
-
-				this.reconcileCategoryStatuses(categories)
-			}).catch(() => {
-				if (this.searchGeneration !== generation) {
-					return
-				}
-				this.searchStates[category] = {
-					status: 'failed',
-					entries: [],
-					cursor: null,
-					hasMore: false,
-					loadMoreFailed: false,
-				}
-				this.reconcileCategoryStatuses(categories)
-			})
-		})
+		await Promise.allSettled(categories.map((category) => this.searchCategory(category, generation, categories)))
 	}
 
 	/**
@@ -93,7 +54,7 @@ export class UnifiedSearchController {
 	 *
 	 * @param category the category id to page
 	 */
-	loadMore(category: string): void {
+	async loadMore(category: string): Promise<void> {
 		const generation = this.searchGeneration
 		const categoryState = this.searchStates[category]
 		if (!categoryState || !categoryState.hasMore || categoryState.status !== 'loaded') {
@@ -110,22 +71,23 @@ export class UnifiedSearchController {
 
 		this.pendingCancels.push(cancel)
 
-		request().then((response) => {
+		try {
+			const response = await request()
 			if (this.searchGeneration !== generation) {
 				return
 			}
 			const { entries, cursor, hasMore } = response.data.ocs.data
 			categoryState.entries.push(...entries)
 			categoryState.cursor = cursor
 			categoryState.hasMore = hasMore
-			categoryState.status = 'loaded'
-		}).catch(() => {
+		} catch {
 			if (this.searchGeneration !== generation) {
 				return
 			}
-			categoryState.status = 'loaded'
 			categoryState.loadMoreFailed = true
-		})
+		}
+
+		categoryState.status = 'loaded'
 	}
 
 	/**
@@ -145,6 +107,53 @@ export class UnifiedSearchController {
 		this.stopRevealTimer()
 	}
 
+	private async searchCategory(category: string, generation: number, categories: string[]): Promise<void> {
+		this.searchStates[category] = {
+			status: 'loading',
+			entries: [],
+			cursor: null,
+			hasMore: false,
+			loadMoreFailed: false,
+		}
+		const { request, cancel } = unifiedSearch({
+			type: category,
+			query: this.query,
+			cursor: null,
+		})
+
+		this.pendingCancels.push(cancel)
+
+		try {
+			const response = await request()
+			if (this.searchGeneration !== generation) {
+				// A new search has been started, ignore this result
+				return
+			}
+
+			const { entries, cursor, hasMore } = response.data.ocs.data
+			this.searchStates[category] = {
+				status: 'loaded',
+				entries,
+				cursor,
+				hasMore,
+				loadMoreFailed: false,
+			}
+		} catch {
+			if (this.searchGeneration !== generation) {
+				return
+			}
+			this.searchStates[category] = {
+				status: 'failed',
+				entries: [],
+				cursor: null,
+				hasMore: false,
+				loadMoreFailed: false,
+			}
+		}
+
+		this.reconcileCategoryStatuses(categories)
+	}
+
 	private reconcileCategoryStatuses(categories: string[]): void {
 		categories.forEach((category) => {
 			if (['loading', 'failed'].includes(this.searchStates[category].status)) {
@@ -163,7 +172,7 @@ export class UnifiedSearchController {
 			if (hasPendingCategories) {
 				this.startRevealTimer()
 			}
-		}, REVEAL_INTERVAL)
+		}, REVEAL_INTERVAL_MS)
 	}
 
 	private stopRevealTimer(): void {

core/src/tests/services/UnifiedSearchController.spec.ts

@@ -3,7 +3,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { REVEAL_INTERVAL, UnifiedSearchController } from '../../services/UnifiedSearchController.ts'
+import { REVEAL_INTERVAL_MS, UnifiedSearchController } from '../../services/UnifiedSearchController.ts'
 
 const service = vi.hoisted(() => ({
 	search: vi.fn(),
@@ -215,6 +215,34 @@ describe('UnifiedSearchController', () => {
 				loadMoreFailed: false,
 			})
 		})
+
+		it('ignores a stale response for a category the newer search dropped', async () => {
+			const first = mockProviders(['files', 'talk'])
+
+			const searchController = new UnifiedSearchController()
+			searchController.search('first', ['files', 'talk'])
+
+			// A newer search with a completely different category set supersedes it.
+			const second = mockProviders(['deck'])
+			searchController.search('second', ['deck'])
+
+			// The stale response is for 'files', which no longer exists in the
+			// current search. Reconciling it must not throw on the missing category.
+			first.files.resolve(['Stale files'])
+			await vi.advanceTimersByTimeAsync(0)
+
+			expect(searchController.getSnapshot()).toEqual({
+				deck: loading,
+			})
+
+			// The live search still resolves normally.
+			second.deck.resolve(['Live deck'])
+			await vi.advanceTimersByTimeAsync(0)
+
+			expect(searchController.getSnapshot()).toEqual({
+				deck: { status: 'loaded', entries: ['Live deck'], cursor: undefined, hasMore: undefined, loadMoreFailed: false },
+			})
+		})
 	})
 
 	describe('resetting between searches', () => {
@@ -416,7 +444,7 @@ describe('UnifiedSearchController', () => {
 				deck: { status: 'blocked', entries: ['Deck result'], cursor: undefined, hasMore: undefined, loadMoreFailed: false },
 			})
 
-			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL)
+			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL_MS)
 
 			expect(searchController.getSnapshot()).toEqual({
 				files: loading,
@@ -433,19 +461,19 @@ describe('UnifiedSearchController', () => {
 
 			// deck arrives out of order and is revealed by the first flush.
 			providers.deck.resolve(['Deck result'])
-			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL)
+			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL_MS)
 			expect(searchController.getSnapshot().deck.status).toBe('loaded')
 
 			// A later flush passes with nothing blocked while files/talk keep loading.
-			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL)
+			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL_MS)
 
 			// talk now arrives out of order (files still loading) and is blocked.
 			providers.talk.resolve(['Talk result'])
 			await vi.advanceTimersByTimeAsync(0)
 			expect(searchController.getSnapshot().talk.status).toBe('blocked')
 
 			// The timer must still be running to flush talk on a later cycle.
-			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL)
+			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL_MS)
 			expect(searchController.getSnapshot().talk.status).toBe('loaded')
 		})
 
@@ -460,7 +488,7 @@ describe('UnifiedSearchController', () => {
 			await vi.advanceTimersByTimeAsync(0)
 
 			// Nothing is loading or blocked, so the next flush should not re-arm.
-			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL)
+			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL_MS)
 			expect(vi.getTimerCount()).toBe(0)
 		})
 
@@ -472,7 +500,7 @@ describe('UnifiedSearchController', () => {
 
 			// First search: deck is blocked and its reveal timer is pending.
 			first.deck.resolve(['First deck'])
-			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL - 500)
+			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL_MS - 500)
 			expect(searchController.getSnapshot().deck.status).toBe('blocked')
 
 			// A new search starts before the first timer fires. It must clear that
@@ -483,7 +511,7 @@ describe('UnifiedSearchController', () => {
 			second.deck.resolve(['Second deck'])
 			// Advance past when the first search's timer would have fired (500ms from
 			// now) but before the second search's timer is due.
-			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL - 500)
+			await vi.advanceTimersByTimeAsync(REVEAL_INTERVAL_MS - 500)
 
 			expect(searchController.getSnapshot().deck.status).toBe('blocked')
 		})