De-duplicate code and fix types (#2319)

spec/unit/room.spec.ts

@@ -1471,16 +1471,13 @@ describe("Room", function() {
                 isRoomEncrypted: function() {
                     return false;
                 },
-                http: {
-                    serverResponse,
-                    authedRequest: function() {
-                        if (this.serverResponse instanceof Error) {
-                            return Promise.reject(this.serverResponse);
-                        } else {
-                            return Promise.resolve({ chunk: this.serverResponse });
-                        }
-                    },
-                },
+                members: jest.fn().mockImplementation(() => {
+                    if (serverResponse instanceof Error) {
+                        return Promise.reject(serverResponse);
+                    } else {
+                        return Promise.resolve({ chunk: serverResponse });
+                    }
+                }),
                 store: {
                     storageResponse,
                     storedMembers: null,
@@ -1547,7 +1544,7 @@ describe("Room", function() {
             }
             expect(hasThrown).toEqual(true);
 
-            client.http.serverResponse = [memberEvent];
+            client.members.mockReturnValue({ chunk: [memberEvent] });
             await room.loadMembersIfNeeded();
             const memberA = room.getMember("@user_a:bar");
             expect(memberA.name).toEqual("User A");

src/client.ts

@@ -7277,12 +7277,12 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
      */
     public members(
         roomId: string,
-        includeMembership?: string[],
-        excludeMembership?: string[],
+        includeMembership?: string,
+        excludeMembership?: string,
         atEventId?: string,
         callback?: Callback,
-    ): Promise<{ [userId: string]: IStateEventWithRoomId }> {
-        const queryParams: any = {};
+    ): Promise<{ [userId: string]: IStateEventWithRoomId[] }> {
+        const queryParams: Record<string, string> = {};
         if (includeMembership) {
             queryParams.membership = includeMembership;
         }

src/models/room.ts

@@ -46,8 +46,8 @@ import {
     FILTER_RELATED_BY_SENDERS,
     ThreadFilterType,
 } from "./thread";
-import { Method } from "../http-api";
 import { TypedEventEmitter } from "./typed-event-emitter";
+import { IStateEventWithRoomId } from "../@types/search";
 
 // These constants are used as sane defaults when the homeserver doesn't support
 // the m.room_versions capability. In practice, KNOWN_SAFE_ROOM_VERSION should be
@@ -788,16 +788,9 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
         }
     }
 
-    private async loadMembersFromServer(): Promise<IEvent[]> {
+    private async loadMembersFromServer(): Promise<IStateEventWithRoomId[]> {
         const lastSyncToken = this.client.store.getSyncToken();
-        const queryString = utils.encodeParams({
-            not_membership: "leave",
-            at: lastSyncToken,
-        });
-        const path = utils.encodeUri("/rooms/$roomId/members?" + queryString,
-            { $roomId: this.roomId });
-        const http = this.client.http;
-        const response = await http.authedRequest<{ chunk: IEvent[] }>(undefined, Method.Get, path);
+        const response = await this.client.members(this.roomId, undefined, "leave", lastSyncToken);
         return response.chunk;
     }
 
@@ -806,12 +799,13 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
         let fromServer = false;
         let rawMembersEvents = await this.client.store.getOutOfBandMembers(this.roomId);
         // If the room is encrypted, we always fetch members from the server at
-        // least once, in case the latest state wasn't persisted properly.  Note
+        // least once, in case the latest state wasn't persisted properly. Note
         // that this function is only called once (unless loading the members
         // fails), since loadMembersIfNeeded always returns this.membersPromise
         // if set, which will be the result of the first (successful) call.
         if (rawMembersEvents === null ||
-            (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId))) {
+            (this.client.isCryptoEnabled() && this.client.isRoomEncrypted(this.roomId))
+        ) {
             fromServer = true;
             rawMembersEvents = await this.loadMembersFromServer();
             logger.log(`LL: got ${rawMembersEvents.length} ` +
@@ -857,7 +851,7 @@ export class Room extends TypedEventEmitter<EmittedEvents, RoomEventHandlerMap>
             if (fromServer) {
                 const oobMembers = this.currentState.getMembers()
                     .filter((m) => m.isOutOfBand())
-                    .map((m) => m.events.member.event as IEvent);
+                    .map((m) => m.events.member.event as IStateEventWithRoomId);
                 logger.log(`LL: telling store to write ${oobMembers.length}`
                     + ` members for room ${this.roomId}`);
                 const store = this.client.store;

src/store/index.ts

@@ -17,11 +17,12 @@ limitations under the License.
 import { EventType } from "../@types/event";
 import { Room } from "../models/room";
 import { User } from "../models/user";
-import { IEvent, MatrixEvent } from "../models/event";
+import { MatrixEvent } from "../models/event";
 import { Filter } from "../filter";
 import { RoomSummary } from "../models/room-summary";
 import { IMinimalEvent, IRooms, ISyncResponse } from "../sync-accumulator";
 import { IStartClientOpts } from "../client";
+import { IStateEventWithRoomId } from "../@types/search";
 
 export interface ISavedSync {
     nextBatch: string;
@@ -204,9 +205,9 @@ export interface IStore {
      */
     deleteAllData(): Promise<void>;
 
-    getOutOfBandMembers(roomId: string): Promise<IEvent[] | null>;
+    getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null>;
 
-    setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void>;
+    setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void>;
 
     clearOutOfBandMembers(roomId: string): Promise<void>;
 

src/store/indexeddb-backend.ts

@@ -15,7 +15,7 @@ limitations under the License.
 */
 
 import { ISavedSync } from "./index";
-import { IEvent, IStartClientOpts, ISyncResponse } from "..";
+import { IEvent, IStartClientOpts, IStateEventWithRoomId, ISyncResponse } from "..";
 
 export interface IIndexedDBBackend {
     connect(): Promise<void>;
@@ -25,8 +25,8 @@ export interface IIndexedDBBackend {
     getSavedSync(): Promise<ISavedSync>;
     getNextBatchToken(): Promise<string>;
     clearDatabase(): Promise<void>;
-    getOutOfBandMembers(roomId: string): Promise<IEvent[] | null>;
-    setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void>;
+    getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null>;
+    setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void>;
     clearOutOfBandMembers(roomId: string): Promise<void>;
     getUserPresenceEvents(): Promise<UserTuple[]>;
     getClientOptions(): Promise<IStartClientOpts>;

src/store/indexeddb-local-backend.ts

@@ -18,7 +18,7 @@ import { IMinimalEvent, ISyncData, ISyncResponse, SyncAccumulator } from "../syn
 import * as utils from "../utils";
 import * as IndexedDBHelpers from "../indexeddb-helpers";
 import { logger } from '../logger';
-import { IEvent, IStartClientOpts } from "..";
+import { IStartClientOpts, IStateEventWithRoomId } from "..";
 import { ISavedSync } from "./index";
 import { IIndexedDBBackend, UserTuple } from "./indexeddb-backend";
 
@@ -229,15 +229,15 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns {Promise<event[]>} the events, potentially an empty array if OOB loading didn't yield any new members
      * @returns {null} in case the members for this room haven't been stored yet
      */
-    public getOutOfBandMembers(roomId: string): Promise<IEvent[] | null> {
-        return new Promise<IEvent[] | null>((resolve, reject) => {
+    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
+        return new Promise<IStateEventWithRoomId[] | null>((resolve, reject) => {
             const tx = this.db.transaction(["oob_membership_events"], "readonly");
             const store = tx.objectStore("oob_membership_events");
             const roomIndex = store.index("room");
             const range = IDBKeyRange.only(roomId);
             const request = roomIndex.openCursor(range);
 
-            const membershipEvents: IEvent[] = [];
+            const membershipEvents: IStateEventWithRoomId[] = [];
             // did we encounter the oob_written marker object
             // amongst the results? That means OOB member
             // loading already happened for this room
@@ -278,7 +278,7 @@ export class LocalIndexedDBStoreBackend implements IIndexedDBBackend {
      * @param {string} roomId
      * @param {event[]} membershipEvents the membership events to store
      */
-    public async setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public async setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
         logger.log(`LL: backend about to store ${membershipEvents.length}` +
             ` members for ${roomId}`);
         const tx = this.db.transaction(["oob_membership_events"], "readwrite");

src/store/indexeddb-remote-backend.ts

@@ -18,7 +18,7 @@ import { logger } from "../logger";
 import { defer, IDeferred } from "../utils";
 import { ISavedSync } from "./index";
 import { IStartClientOpts } from "../client";
-import { IEvent, ISyncResponse } from "..";
+import { IStateEventWithRoomId, ISyncResponse } from "..";
 import { IIndexedDBBackend, UserTuple } from "./indexeddb-backend";
 
 export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
@@ -97,7 +97,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
      * @returns {null} in case the members for this room haven't been stored yet
      */
-    public getOutOfBandMembers(roomId: string): Promise<IEvent[] | null> {
+    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
         return this.doCmd('getOutOfBandMembers', [roomId]);
     }
 
@@ -109,7 +109,7 @@ export class RemoteIndexedDBStoreBackend implements IIndexedDBBackend {
      * @param {event[]} membershipEvents the membership events to store
      * @returns {Promise} when all members have been stored
      */
-    public setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
         return this.doCmd('setOutOfBandMembers', [roomId, membershipEvents]);
     }
 

src/store/indexeddb.ts

@@ -26,6 +26,7 @@ import { ISavedSync } from "./index";
 import { IIndexedDBBackend } from "./indexeddb-backend";
 import { ISyncResponse } from "../sync-accumulator";
 import { TypedEventEmitter } from "../models/typed-event-emitter";
+import { IStateEventWithRoomId } from "../@types/search";
 
 /**
  * This is an internal module. See {@link IndexedDBStore} for the public class.
@@ -242,7 +243,7 @@ export class IndexedDBStore extends MemoryStore {
      * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
      * @returns {null} in case the members for this room haven't been stored yet
      */
-    public getOutOfBandMembers = this.degradable((roomId: string): Promise<IEvent[]> => {
+    public getOutOfBandMembers = this.degradable((roomId: string): Promise<IStateEventWithRoomId[]> => {
         return this.backend.getOutOfBandMembers(roomId);
     }, "getOutOfBandMembers");
 
@@ -254,10 +255,13 @@ export class IndexedDBStore extends MemoryStore {
      * @param {event[]} membershipEvents the membership events to store
      * @returns {Promise} when all members have been stored
      */
-    public setOutOfBandMembers = this.degradable((roomId: string, membershipEvents: IEvent[]): Promise<void> => {
-        super.setOutOfBandMembers(roomId, membershipEvents);
-        return this.backend.setOutOfBandMembers(roomId, membershipEvents);
-    }, "setOutOfBandMembers");
+    public setOutOfBandMembers = this.degradable(
+        (roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> => {
+            super.setOutOfBandMembers(roomId, membershipEvents);
+            return this.backend.setOutOfBandMembers(roomId, membershipEvents);
+        },
+        "setOutOfBandMembers",
+    );
 
     public clearOutOfBandMembers = this.degradable((roomId: string) => {
         super.clearOutOfBandMembers(roomId);

src/store/memory.ts

@@ -22,13 +22,14 @@ limitations under the License.
 import { EventType } from "../@types/event";
 import { Room } from "../models/room";
 import { User } from "../models/user";
-import { IEvent, MatrixEvent } from "../models/event";
+import { MatrixEvent } from "../models/event";
 import { RoomState, RoomStateEvent } from "../models/room-state";
 import { RoomMember } from "../models/room-member";
 import { Filter } from "../filter";
 import { ISavedSync, IStore } from "./index";
 import { RoomSummary } from "../models/room-summary";
 import { ISyncResponse } from "../sync-accumulator";
+import { IStateEventWithRoomId } from "../@types/search";
 
 function isValidFilterId(filterId: string): boolean {
     const isValidStr = typeof filterId === "string" &&
@@ -60,7 +61,7 @@ export class MemoryStore implements IStore {
     private filters: Record<string, Record<string, Filter>> = {};
     public accountData: Record<string, MatrixEvent> = {}; // type : content
     private readonly localStorage: Storage;
-    private oobMembers: Record<string, IEvent[]> = {}; // roomId: [member events]
+    private oobMembers: Record<string, IStateEventWithRoomId[]> = {}; // roomId: [member events]
     private clientOptions = {};
 
     constructor(opts: IOpts = {}) {
@@ -389,7 +390,7 @@ export class MemoryStore implements IStore {
      * @returns {event[]} the events, potentially an empty array if OOB loading didn't yield any new members
      * @returns {null} in case the members for this room haven't been stored yet
      */
-    public getOutOfBandMembers(roomId: string): Promise<IEvent[] | null> {
+    public getOutOfBandMembers(roomId: string): Promise<IStateEventWithRoomId[] | null> {
         return Promise.resolve(this.oobMembers[roomId] || null);
     }
 
@@ -401,7 +402,7 @@ export class MemoryStore implements IStore {
      * @param {event[]} membershipEvents the membership events to store
      * @returns {Promise} when all members have been stored
      */
-    public setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
         this.oobMembers[roomId] = membershipEvents;
         return Promise.resolve();
     }

src/store/stub.ts

@@ -22,11 +22,12 @@ limitations under the License.
 import { EventType } from "../@types/event";
 import { Room } from "../models/room";
 import { User } from "../models/user";
-import { IEvent, MatrixEvent } from "../models/event";
+import { MatrixEvent } from "../models/event";
 import { Filter } from "../filter";
 import { ISavedSync, IStore } from "./index";
 import { RoomSummary } from "../models/room-summary";
 import { ISyncResponse } from "../sync-accumulator";
+import { IStateEventWithRoomId } from "../@types/search";
 
 /**
  * Construct a stub store. This does no-ops on most store methods.
@@ -242,11 +243,11 @@ export class StubStore implements IStore {
         return Promise.resolve();
     }
 
-    public getOutOfBandMembers(): Promise<IEvent[]> {
+    public getOutOfBandMembers(): Promise<IStateEventWithRoomId[]> {
         return Promise.resolve(null);
     }
 
-    public setOutOfBandMembers(roomId: string, membershipEvents: IEvent[]): Promise<void> {
+    public setOutOfBandMembers(roomId: string, membershipEvents: IStateEventWithRoomId[]): Promise<void> {
         return Promise.resolve();
     }