Pass around MatrixClients instead of using MatrixClientPeg (#11000)

src/Searching.ts

@@ -25,20 +25,19 @@ import {
 import { IRoomEventFilter } from "matrix-js-sdk/src/filter";
 import { EventType } from "matrix-js-sdk/src/@types/event";
 import { SearchResult } from "matrix-js-sdk/src/models/search-result";
+import { MatrixClient } from "matrix-js-sdk/src/matrix";
 
 import { ISearchArgs } from "./indexing/BaseEventIndexManager";
 import EventIndexPeg from "./indexing/EventIndexPeg";
-import { MatrixClientPeg } from "./MatrixClientPeg";
 
 const SEARCH_LIMIT = 10;
 
 async function serverSideSearch(
+    client: MatrixClient,
     term: string,
     roomId?: string,
     abortSignal?: AbortSignal,
 ): Promise<{ response: ISearchResponse; query: ISearchRequestBody }> {
-    const client = MatrixClientPeg.get();
-
     const filter: IRoomEventFilter = {
         limit: SEARCH_LIMIT,
     };
@@ -66,12 +65,12 @@ async function serverSideSearch(
 }
 
 async function serverSideSearchProcess(
+    client: MatrixClient,
     term: string,
     roomId?: string,
     abortSignal?: AbortSignal,
 ): Promise<ISearchResults> {
-    const client = MatrixClientPeg.get();
-    const result = await serverSideSearch(term, roomId, abortSignal);
+    const result = await serverSideSearch(client, term, roomId, abortSignal);
 
     // The js-sdk method backPaginateRoomEventsSearch() uses _query internally
     // so we're reusing the concept here since we want to delegate the
@@ -96,12 +95,14 @@ function compareEvents(a: ISearchResult, b: ISearchResult): number {
     return 0;
 }
 
-async function combinedSearch(searchTerm: string, abortSignal?: AbortSignal): Promise<ISearchResults> {
-    const client = MatrixClientPeg.get();
-
+async function combinedSearch(
+    client: MatrixClient,
+    searchTerm: string,
+    abortSignal?: AbortSignal,
+): Promise<ISearchResults> {
     // Create two promises, one for the local search, one for the
     // server-side search.
-    const serverSidePromise = serverSideSearch(searchTerm, undefined, abortSignal);
+    const serverSidePromise = serverSideSearch(client, searchTerm, undefined, abortSignal);
     const localPromise = localSearch(searchTerm);
 
     // Wait for both promises to resolve.
@@ -198,7 +199,11 @@ export interface ISeshatSearchResults extends ISearchResults {
     serverSideNextBatch?: string;
 }
 
-async function localSearchProcess(searchTerm: string, roomId?: string): Promise<ISeshatSearchResults> {
+async function localSearchProcess(
+    client: MatrixClient,
+    searchTerm: string,
+    roomId?: string,
+): Promise<ISeshatSearchResults> {
     const emptyResult = {
         results: [],
         highlights: [],
@@ -216,14 +221,17 @@ async function localSearchProcess(searchTerm: string, roomId?: string): Promise<
         },
     };
 
-    const processedResult = MatrixClientPeg.get().processRoomEventsSearch(emptyResult, response);
+    const processedResult = client.processRoomEventsSearch(emptyResult, response);
     // Restore our encryption info so we can properly re-verify the events.
     restoreEncryptionInfo(processedResult.results);
 
     return processedResult;
 }
 
-async function localPagination(searchResult: ISeshatSearchResults): Promise<ISeshatSearchResults> {
+async function localPagination(
+    client: MatrixClient,
+    searchResult: ISeshatSearchResults,
+): Promise<ISeshatSearchResults> {
     const eventIndex = EventIndexPeg.get();
 
     const searchArgs = searchResult.seshatQuery;
@@ -245,7 +253,7 @@ async function localPagination(searchResult: ISeshatSearchResults): Promise<ISes
         },
     };
 
-    const result = MatrixClientPeg.get().processRoomEventsSearch(searchResult, response);
+    const result = client.processRoomEventsSearch(searchResult, response);
 
     // Restore our encryption info so we can properly re-verify the events.
     const newSlice = result.results.slice(Math.max(result.results.length - newResultCount, 0));
@@ -535,9 +543,11 @@ function restoreEncryptionInfo(searchResultSlice: SearchResult[] = []): void {
     }
 }
 
-async function combinedPagination(searchResult: ISeshatSearchResults): Promise<ISeshatSearchResults> {
+async function combinedPagination(
+    client: MatrixClient,
+    searchResult: ISeshatSearchResults,
+): Promise<ISeshatSearchResults> {
     const eventIndex = EventIndexPeg.get();
-    const client = MatrixClientPeg.get();
 
     const searchArgs = searchResult.seshatQuery;
     const oldestEventFrom = searchResult.oldestEventFrom;
@@ -588,31 +598,37 @@ async function combinedPagination(searchResult: ISeshatSearchResults): Promise<I
     return result;
 }
 
-function eventIndexSearch(term: string, roomId?: string, abortSignal?: AbortSignal): Promise<ISearchResults> {
+function eventIndexSearch(
+    client: MatrixClient,
+    term: string,
+    roomId?: string,
+    abortSignal?: AbortSignal,
+): Promise<ISearchResults> {
     let searchPromise: Promise<ISearchResults>;
 
     if (roomId !== undefined) {
-        if (MatrixClientPeg.get().isRoomEncrypted(roomId)) {
+        if (client.isRoomEncrypted(roomId)) {
             // The search is for a single encrypted room, use our local
             // search method.
-            searchPromise = localSearchProcess(term, roomId);
+            searchPromise = localSearchProcess(client, term, roomId);
         } else {
             // The search is for a single non-encrypted room, use the
             // server-side search.
-            searchPromise = serverSideSearchProcess(term, roomId, abortSignal);
+            searchPromise = serverSideSearchProcess(client, term, roomId, abortSignal);
         }
     } else {
         // Search across all rooms, combine a server side search and a
         // local search.
-        searchPromise = combinedSearch(term, abortSignal);
+        searchPromise = combinedSearch(client, term, abortSignal);
     }
 
     return searchPromise;
 }
 
-function eventIndexSearchPagination(searchResult: ISeshatSearchResults): Promise<ISeshatSearchResults> {
-    const client = MatrixClientPeg.get();
-
+function eventIndexSearchPagination(
+    client: MatrixClient,
+    searchResult: ISeshatSearchResults,
+): Promise<ISeshatSearchResults> {
     const seshatQuery = searchResult.seshatQuery;
     const serverQuery = searchResult._query;
 
@@ -622,36 +638,40 @@ function eventIndexSearchPagination(searchResult: ISeshatSearchResults): Promise
         return client.backPaginateRoomEventsSearch(searchResult);
     } else if (!serverQuery) {
         // This is a search in a encrypted room. Do a local pagination.
-        const promise = localPagination(searchResult);
+        const promise = localPagination(client, searchResult);
         searchResult.pendingRequest = promise;
 
         return promise;
     } else {
         // We have both queries around, this is a search across all rooms so a
         // combined pagination needs to be done.
-        const promise = combinedPagination(searchResult);
+        const promise = combinedPagination(client, searchResult);
         searchResult.pendingRequest = promise;
 
         return promise;
     }
 }
 
-export function searchPagination(searchResult: ISearchResults): Promise<ISearchResults> {
+export function searchPagination(client: MatrixClient, searchResult: ISearchResults): Promise<ISearchResults> {
     const eventIndex = EventIndexPeg.get();
-    const client = MatrixClientPeg.get();
 
     if (searchResult.pendingRequest) return searchResult.pendingRequest;
 
     if (eventIndex === null) return client.backPaginateRoomEventsSearch(searchResult);
-    else return eventIndexSearchPagination(searchResult);
+    else return eventIndexSearchPagination(client, searchResult);
 }
 
-export default function eventSearch(term: string, roomId?: string, abortSignal?: AbortSignal): Promise<ISearchResults> {
+export default function eventSearch(
+    client: MatrixClient,
+    term: string,
+    roomId?: string,
+    abortSignal?: AbortSignal,
+): Promise<ISearchResults> {
     const eventIndex = EventIndexPeg.get();
 
     if (eventIndex === null) {
-        return serverSideSearchProcess(term, roomId, abortSignal);
+        return serverSideSearchProcess(client, term, roomId, abortSignal);
     } else {
-        return eventIndexSearch(term, roomId, abortSignal);
+        return eventIndexSearch(client, term, roomId, abortSignal);
     }
 }