polfan-server-js-client 0.2.2 → 0.2.6

package/src/AbstractChatClient.ts

@@ -82,14 +82,30 @@ import {
     GetEmoticons,
     Emoticons,
     EmoticonDeleted,
-    NewEmoticon, Bans, GetBans, Ban, Unban, Kick, ClientData, GetClientData, SetClientData,
+    NewEmoticon,
+    Bans,
+    GetBans,
+    Ban,
+    Unban,
+    Kick,
+    ClientData,
+    GetClientData,
+    SetClientData,
     GetRoomSummary,
     GetSpaceSummary,
     RoomSummaryEvent,
     SpaceSummaryEvent,
-    SetCustomNick,
+    UpdateSpaceMember,
+    Relationships,
+    RelationshipDeleted,
+    NewRelationship,
+    DeleteRelationship,
+    CreateRelationship,
+    RoomSummaryUpdated,
 } from "./types/src/index";
 import {EventTarget} from "./EventTarget";
+import {GetRelationships} from "./types/src/schemes/commands/GetRelationships";
+import {UpdateRoomMember} from "./types/src/schemes/commands/UpdateRoomMember";
 
 type ArrayOfPromiseResolvers = [(value: any) => void, (reason?: any) => void];
 
@@ -139,7 +155,7 @@ export abstract class AbstractChatClient extends EventTarget {
         if (!this.awaitingResponse.has(envelope.ref)) {
             return;
         }
-        this.awaitingResponse.get(envelope.ref)[0](error);
+        this.awaitingResponse.get(envelope.ref)[1](error);
         this.awaitingResponse.delete(envelope.ref);
     }
 }
@@ -165,6 +181,9 @@ export type EventsMap = {
     Emoticons: Emoticons,
     Bans: Bans,
     ClientData: ClientData,
+    NewRelationship: NewRelationship,
+    RelationshipDeleted: RelationshipDeleted,
+    Relationships: Relationships,
     // Space events
     DiscoverableSpaces: DiscoverableSpaces,
     SpaceJoined: SpaceJoined,
@@ -191,6 +210,7 @@ export type EventsMap = {
     RoomDeleted: RoomDeleted,
     RoomUpdated: RoomUpdated,
     RoomSummaryEvent: RoomSummaryEvent,
+    RoomSummaryUpdated: RoomSummaryUpdated,
     // Topic events
     NewTopic: NewTopic,
     TopicDeleted: TopicDeleted,
@@ -227,6 +247,9 @@ export type CommandsMap = {
     Kick: [Kick, EventsMap['Ok']],
     GetClientData: [GetClientData, EventsMap['ClientData']],
     SetClientData: [SetClientData, EventsMap['Ok']],
+    DeleteRelationship: [DeleteRelationship, EventsMap['RelationshipDeleted']],
+    CreateRelationship: [CreateRelationship, EventsMap['NewRelationship']],
+    GetRelationships: [GetRelationships, EventsMap['Relationships']],
     // Space commands
     GetDiscoverableSpaces: [GetDiscoverableSpaces, EventsMap['DiscoverableSpaces']],
     JoinSpace: [JoinSpace, EventsMap['SpaceJoined']],
@@ -242,7 +265,7 @@ export type CommandsMap = {
     AssignRole: [AssignRole, EventsMap['SpaceMemberUpdated'] | EventsMap['RoomMemberUpdated']],
     DeassignRole: [DeassignRole, EventsMap['SpaceMemberUpdated'] | EventsMap['RoomMemberUpdated']],
     GetSpaceSummary: [GetSpaceSummary, EventsMap['SpaceSummaryEvent']],
-    SetCustomNick: [SetCustomNick, EventsMap['SpaceMemberUpdated']],
+    UpdateSpaceMember: [UpdateSpaceMember, EventsMap['SpaceMemberUpdated']],
     // Room commands
     JoinRoom: [JoinRoom, EventsMap['RoomJoined']],
     LeaveRoom: [LeaveRoom, EventsMap['RoomLeft']],
@@ -251,6 +274,7 @@ export type CommandsMap = {
     UpdateRoom: [UpdateRoom, EventsMap['RoomUpdated']],
     GetRoomMembers: [GetRoomMembers, EventsMap['RoomMembers']],
     GetRoomSummary: [GetRoomSummary, EventsMap['RoomSummaryEvent']],
+    UpdateRoomMember: [UpdateRoomMember, EventsMap['RoomMemberUpdated']],
     // Topic commands
     CreateTopic: [CreateTopic, EventsMap['NewTopic']],
     DeleteTopic: [DeleteTopic, EventsMap['TopicDeleted']],

package/src/FilesClient.ts

@@ -3,28 +3,41 @@ import {AbstractRestClient, RestClientResponse} from "./AbstractRestClient";
 export interface File {
     id: string;
     url: string;
-    original_url: string;
-    original_name: string;
-    mime_type: string;
+    name: string;
+    mime: string;
     size: number;
-    image_dimensions: [number, number] | null;
+    width?: number;
+    height?: number;
 }
 
 export class FilesClient extends AbstractRestClient {
-    protected defaultUrl: string = 'https://polfan.pl/webservice/api/files';
+    protected defaultUrl: string = 'https://files.devana.pl';
 
-    public async uploadFile(file: Parameters<typeof FormData.prototype.append>[1]): Promise<RestClientResponse<File>> {
-        const formData = new FormData();
-        formData.append('file', file);
+    public async uploadFile(file: globalThis.File | Blob): Promise<RestClientResponse<File>> {
+        const name = encodeURIComponent((file as globalThis.File).name ?? '');
+        let headers = {
+            ...this.getAuthHeaders(),
+            Accept: 'application/json',
+            'Content-Disposition': `attachment; filename="${name}"`,
+            'Content-Length': file.size
+        };
 
-        let headers = {...this.getAuthHeaders(), Accept: 'application/json'};
-
-        const response = await fetch(this.defaultUrl, {method: 'POST', body: formData, headers});
+        const response = await fetch(this.getUrl('files'), {
+            method: 'POST',
+            body: file,
+            headers
+        });
 
         return this.convertFetchResponse<File>(response);
     }
 
-    public async getFileMetadata(id: string): Promise<RestClientResponse<File>> {
-        return this.send('GET', '/' + id);
+    public async getFileMeta(id: string): Promise<RestClientResponse<File>> {
+        return this.send('GET', 'files/' + id);
+    }
+
+    public async getFileMetaBulk(ids: string[]): Promise<RestClientResponse<File[]>> {
+        const searchParams = new URLSearchParams();
+        ids.forEach(id => searchParams.append('id[]', id));
+        return this.send('GET', 'files?' + searchParams);
     }
 }

package/src/IndexedObjectCollection.ts

@@ -2,16 +2,11 @@ import {EventTarget, ObservableInterface} from "./EventTarget";
 
 export class IndexedCollection<KeyT, ValueT> {
     protected _items: Map<KeyT, ValueT> = new Map();
-    protected _mutationCounter: number = 0;
 
     public constructor(items: [key: KeyT, value: ValueT][] = []) {
         this.set(...items);
     }
 
-    public get mutationCounter(): number {
-        return this._mutationCounter;
-    }
-
     public get items(): Map<KeyT, ValueT> {
         return this._items;
     }
@@ -21,7 +16,6 @@ export class IndexedCollection<KeyT, ValueT> {
     }
 
     public set(...items: [KeyT, ValueT][]): void {
-        this._mutationCounter++;
         for (const item of items) {
             this._items.set(item[0], item[1]);
         }
@@ -58,6 +52,12 @@ export class IndexedCollection<KeyT, ValueT> {
         }
         return result;
     }
+
+    public createMirror(): IndexedCollection<KeyT, ValueT> {
+        const copy = new IndexedCollection<KeyT, ValueT>();
+        copy._items = this._items;
+        return copy;
+    }
 }
 
 export class IndexedObjectCollection<T> {
@@ -79,10 +79,6 @@ export class IndexedObjectCollection<T> {
         return this._items.length;
     }
 
-    public get mutationCounter(): number {
-        return this._items.mutationCounter;
-    }
-
     public set(...items: T[]): void {
         this._items.set(...(items.map(item => [this.getId(item), item] as [string, T])));
     }
@@ -120,6 +116,12 @@ export class IndexedObjectCollection<T> {
         return result;
     }
 
+    public createMirror(): IndexedObjectCollection<T> {
+        const copy = new IndexedObjectCollection<T>(this.id);
+        copy._items = this._items;
+        return copy;
+    }
+
     protected getId(item: T): any {
         return typeof this.id === 'function' ? this.id(item) : item[this.id];
     }
@@ -161,6 +163,13 @@ export class ObservableIndexedCollection<KeyT, ValueT> extends IndexedCollection
         }
     }
 
+    public createMirror(): ObservableIndexedCollection<KeyT, ValueT> {
+        const copy = new ObservableIndexedCollection<KeyT, ValueT>();
+        copy.eventTarget = this.eventTarget;
+        copy._items = this._items;
+        return copy;
+    }
+
     public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<KeyT>) => void): this {
         this.eventTarget.on(eventName, handler);
         return this;
@@ -211,6 +220,13 @@ export class ObservableIndexedObjectCollection<T> extends IndexedObjectCollectio
         }
     }
 
+    public createMirror(): IndexedObjectCollection<T> {
+        const copy = new ObservableIndexedObjectCollection<T>(this.id);
+        copy.eventTarget = this.eventTarget;
+        copy._items = this._items;
+        return copy;
+    }
+
     public on(eventName: 'change', handler: (ev?: ObservableCollectionEvent<string>) => void): this {
         this.eventTarget.on(eventName, handler);
         return this;

package/src/Permissions.ts

@@ -30,6 +30,7 @@ export class Permissions {
         ManageBan: {value: 1 << 15, maxLayer: Layer.Room},
         Kick: {value: 1 << 16, maxLayer: Layer.Room},
         ChangeOwnNick: {value: 1 << 17, maxLayer: Layer.Space},
+        ChangeOwnColor: {value: 1 << 18, maxLayer: Layer.Room},
     };
 
     public static getNames(): (keyof typeof this.list)[] {

package/src/WebSocketChatClient.ts

@@ -60,28 +60,28 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
 
     public async send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandsMap[CommandType][0]):
        Promise<CommandResult<CommandsMap[CommandType][1]>> {
-        if (!this.ws || [this.ws.CLOSED, this.ws.CLOSING].includes(this.ws.readyState)) {
-            throw new Error('Cannot send; close or closing connection state');
-        }
-
         const envelope = this.createEnvelope<CommandsMap[CommandType][0]>(commandType, commandData);
         const promise = this.createPromiseFromCommandEnvelope<CommandType>(envelope);
 
-        if (this.ws.readyState === this.ws.CONNECTING || !this.authenticated) {
+        if (this.isPendingReadyWsState()) {
             this.sendQueue.push(envelope);
             return promise;
         }
 
-        if (this.ws.readyState !== this.ws.OPEN) {
-            throw new Error(`Invalid websocket state=${this.ws.readyState}`);
-        }
-
         this.sendEnvelope(envelope);
         return promise;
     }
 
     private sendEnvelope(envelope: Envelope): void {
-        this.ws.send(JSON.stringify(envelope));
+        if (this.isReadyToSendWsState()) {
+            this.ws.send(JSON.stringify(envelope));
+            return;
+        }
+
+        this.handleEnvelopeSendError(
+            envelope,
+            new Error(`Cannot send; invalid websocket state=${this.ws?.readyState ?? '[no connection]'}`)
+        );
     }
 
     private onMessage(event: MessageEvent): void {
@@ -108,7 +108,7 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
         clearTimeout(this.connectingTimeoutId);
         const reconnect = event.code !== 1000; // Connection was closed because of error
         if (reconnect) {
-            this.connect();
+            void this.connect();
         }
         this.emit(this.Event.disconnect, reconnect);
     }
@@ -129,4 +129,12 @@ export class WebSocketChatClient extends AbstractChatClient implements Observabl
         this.disconnect();
         this.emit(this.Event.error, new Error('Connection timeout'));
     }
+
+    private isPendingReadyWsState(): boolean {
+        return this.ws && this.ws.readyState === this.ws.CONNECTING || !this.authenticated;
+    }
+
+    private isReadyToSendWsState(): boolean {
+        return this.ws && this.ws.readyState === this.ws.OPEN && this.authenticated;
+    }
 }

package/src/state-tracker/ChatStateTracker.ts

@@ -6,38 +6,54 @@ import {PermissionsManager} from "./PermissionsManager";
 import {DeferredTask} from "./AsyncUtils";
 import {EmoticonsManager} from "./EmoticonsManager";
 import {UsersManager} from "./UsersManager";
+import {RelationshipsManager} from "./RelationshipsManager";
 
 export class ChatStateTracker {
+    public readonly client: WebSocketChatClient;
+
     /**
      * State of your permissions.
      */
-    public readonly permissions = new PermissionsManager(this);
+    public readonly permissions: PermissionsManager;
 
     /**
      * State of the rooms you are in.
      */
-    public readonly rooms: RoomsManager = new RoomsManager(this);
+    public readonly rooms: RoomsManager;
 
     /**
      * State of the spaces you are in.
      */
-    public readonly spaces = new SpacesManager(this);
+    public readonly spaces: SpacesManager;
 
     /**
      * State of the emoticons (global and space-related).
      */
-    public readonly emoticons = new EmoticonsManager(this);
+    public readonly emoticons: EmoticonsManager;
 
     /**
      * Users related state.
      */
-    public readonly users = new UsersManager(this);
+    public readonly users: UsersManager;
+
+    /**
+     * State of relationships with other users.
+     */
+    public readonly relationships: RelationshipsManager;
 
     private _me: User = null;
     private readonly deferredSession = new DeferredTask();
 
-    public constructor(public readonly client: WebSocketChatClient) {
+    public constructor(client: WebSocketChatClient) {
+        this.client = client;
         this.client.on('Session', ev => this.handleSession(ev));
+
+        this.permissions = new PermissionsManager(this);
+        this.rooms = new RoomsManager(this);
+        this.spaces = new SpacesManager(this);
+        this.emoticons = new EmoticonsManager(this);
+        this.users = new UsersManager(this);
+        this.relationships = new RelationshipsManager(this);
     }
 
     public get me(): User | null {

package/src/state-tracker/EmoticonsManager.ts

@@ -21,18 +21,20 @@ export class EmoticonsManager {
     }
 
     public async get(spaceId?: string): Promise<ObservableIndexedObjectCollection<Emoticon>> {
-        if (this.emoticonsPromises.notExist(spaceId)) {
+        const key = spaceId ?? GLOBAL_KEY;
+
+        if (this.emoticonsPromises.notExist(key)) {
             this.emoticonsPromises.registerByFunction(async () => {
                 const result = await this.tracker.client.send('GetEmoticons', {spaceId});
                 if (result.error) {
                     throw result.error;
                 }
                 this.handleEmoticons(result.data);
-            }, spaceId ?? GLOBAL_KEY);
+            }, key);
         }
 
-        await this.emoticonsPromises.get(spaceId);
-        return this.list.get(spaceId);
+        await this.emoticonsPromises.get(key);
+        return this.list.get(key);
     }
 
     private handleEmoticons(event: Emoticons): void {

package/src/state-tracker/MessagesManager.ts

@@ -8,7 +8,7 @@ import {
     RoomDeleted,
     RoomLeft,
     TopicDeleted,
-    FollowedTopicUpdated, RoomJoined, NewTopic, Session, Room,
+    FollowedTopicUpdated, RoomJoined, NewTopic, Session, Room, MessageType,
 } from "../types/src";
 import {
     IndexedCollection,
@@ -210,8 +210,8 @@ export class MessagesManager {
         const roomFollowedTopics = this.followedTopics.get(ev.message.location.roomId);
         const followedTopic = roomFollowedTopics?.get(ev.message.location.topicId);
 
-        if (! roomFollowedTopics || ! followedTopic) {
-            // Skip if we don't follow this room or targeted topic
+        if (!roomFollowedTopics || !followedTopic || ev.message.type === 'Ephemeral') {
+            // Skip if we don't follow this room or targeted topic or the message is ephemeral
             return;
         }
 

package/src/state-tracker/RelationshipsManager.ts

@@ -0,0 +1,68 @@
+import {ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
+import {
+    NewRelationship,
+    RelationshipDeleted,
+    Relationships,
+    UserRelationship,
+    UserRelationshipType
+} from "../types/src";
+import {PromiseRegistry} from "./AsyncUtils";
+import {ChatStateTracker} from "./ChatStateTracker";
+
+const getId = (refUserId: string, type: UserRelationshipType): string => `${refUserId}-${type}`;
+const getIdFromRelationship = (relationship: UserRelationship): string => getId(relationship.refUser.id, relationship.type);
+
+export class RelationshipsManager {
+    private relationships: ObservableIndexedObjectCollection<UserRelationship> = new ObservableIndexedObjectCollection<UserRelationship>(getIdFromRelationship);
+    private promises = new PromiseRegistry();
+
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('Relationships', ev => this.handleRelationships(ev));
+        this.tracker.client.on('NewRelationship', ev => this.handleNewRelationship(ev));
+        this.tracker.client.on('RelationshipDeleted', ev => this.handleRelationshipDeleted(ev));
+        this.tracker.client.on('Session', () => this.handleSession());
+    }
+
+    public async get(): Promise<ObservableIndexedObjectCollection<UserRelationship>> {
+        if (this.promises.notExist('all')) {
+            this.promises.registerByFunction(async () => {
+                const result = await this.tracker.client.send('GetRelationships', {});
+                if (result.error) {
+                    throw result.error;
+                }
+            }, 'all');
+        }
+
+        await this.promises.get('all');
+        return this.relationships;
+    }
+
+    public async exists(refUserId: string, type: UserRelationshipType): Promise<boolean> {
+        await this.get();
+        return this.relationships.has(getId(refUserId, type));
+    }
+
+    private handleRelationships(ev: Relationships): void {
+        this.relationships.deleteAll();
+        ev.relationships.forEach(relationship => {
+            this.relationships.set(relationship);
+        });
+    }
+
+    private handleNewRelationship(ev: NewRelationship): void {
+        if (this.promises.has('all')) {
+            this.relationships.set(ev.relationship);
+        }
+    }
+
+    private handleRelationshipDeleted(ev: RelationshipDeleted): void {
+        if (this.promises.has('all')) {
+            this.relationships.delete(getIdFromRelationship(ev.relationship));
+        }
+    }
+
+    private handleSession(): void {
+        this.promises.forgetAll();
+        this.relationships.deleteAll();
+    }
+}

package/src/state-tracker/RoomMessagesHistory.ts

@@ -5,6 +5,7 @@ import {TopicHistoryWindow} from "./TopicHistoryWindow";
 
 export class RoomMessagesHistory {
     private historyWindows = new IndexedCollection<string, TopicHistoryWindow>();
+    private traverseLock: boolean = false;
 
     public constructor(
         private room: Room,
@@ -14,6 +15,8 @@ export class RoomMessagesHistory {
         this.tracker.client.on('NewTopic', ev => this.handleNewTopic(ev));
         this.tracker.client.on('TopicDeleted', ev => this.handleTopicDeleted(ev));
 
+        this.updateTraverseLock(this.room);
+
         if (this.room.defaultTopic) {
             this.createHistoryWindowForTopic(this.room.defaultTopic);
         }
@@ -25,7 +28,7 @@ export class RoomMessagesHistory {
     public async getMessagesWindow(topicId: string): Promise<TopicHistoryWindow | undefined> {
         let historyWindow = this.historyWindows.get(topicId);
 
-        if (! historyWindow) {
+        if (!historyWindow) {
             const topic = (await this.tracker.rooms.getTopics(this.room.id, [topicId])).get(topicId);
 
             if (topic) {
@@ -36,13 +39,19 @@ export class RoomMessagesHistory {
         return this.historyWindows.get(topicId);
     }
 
-    private handleRoomUpdated(ev: RoomUpdated): void {
+    private async handleRoomUpdated(ev: RoomUpdated): Promise<void> {
         if (this.room.id === ev.room.id) {
             this.room = ev.room;
 
+            this.updateTraverseLock(ev.room);
+
             if (ev.room.defaultTopic) {
                 this.createHistoryWindowForTopic(ev.room.defaultTopic);
             }
+
+            for (const [, window] of Array.from(this.historyWindows.items)) {
+                await window.setTraverseLock(this.traverseLock);
+            }
         }
     }
 
@@ -63,7 +72,11 @@ export class RoomMessagesHistory {
             return;
         }
 
-        this.historyWindows.set([topic.id, new TopicHistoryWindow(this.room.id, topic.id, this.tracker)]);
+        const historyWindow = new TopicHistoryWindow(this.room.id, topic.id, this.tracker);
+
+        void historyWindow.setTraverseLock(this.traverseLock);
+
+        this.historyWindows.set([topic.id, historyWindow]);
 
         // If new topic refers to some message from this room, update other structures
         if (topic.refMessage) {
@@ -71,4 +84,8 @@ export class RoomMessagesHistory {
             refHistoryWindow?._updateMessageReference(topic);
         }
     }
+
+    private updateTraverseLock(room: Room): void {
+        this.traverseLock = room.history.mode === 'Ephemeral';
+    }
 }

package/src/state-tracker/RoomsManager.ts

@@ -174,6 +174,7 @@ export class RoomsManager {
         const newMember = ev.member;
         const user = member.spaceMember?.user ?? member.user;
 
+        // Preserving user object, because it's not included in event
         if (newMember.spaceMember) {
             newMember.spaceMember.user = user;
         } else {
@@ -214,7 +215,9 @@ export class RoomsManager {
     }
 
     private handleRoomUpdated(ev: RoomUpdated): void {
-        this.list.set(ev.room);
+        if (this.list.has(ev.room.id)) {
+            this.list.set(ev.room);
+        }
     }
 
     private handleRoomDeleted(ev: RoomDeleted): void {
@@ -295,6 +298,7 @@ export class RoomsManager {
     }
 
     private handleUserUpdated(ev: UserUpdated): void {
+        // Update room members users
         this.members.items.forEach((members) => {
             const member = members.get(ev.user.id);
 
@@ -313,18 +317,37 @@ export class RoomsManager {
 
             members.set(newMember);
         });
+
+        // Update recipients users
+        const newRooms: Room[] = [];
+        this.list.items.forEach(room => {
+            if (room.recipients?.some(user => user.id === ev.user.id)) {
+                room.recipients = room.recipients.map(user => user.id === ev.user.id ? ev.user : user);
+                newRooms.push({...room});
+            }
+        });
+        this.list.set(...newRooms);
     }
 
     private handleNewMessage(ev: NewMessage): void {
         const topics = this.topics.get(ev.message.location.roomId);
         const topic = topics?.get(ev.message.location.topicId);
 
-        if (topic) {
-            topics.set({
-                ...topic,
-                messageCount: topic.messageCount + 1,
-                lastMessage: ev.message,
-            });
+        if (!topic) {
+            return; // No topic found, nothing to update
+        }
+
+        const newTopic = {
+            ...topic,
+            messageCount: topic.messageCount + 1,
+            lastMessage: ev.message,
+        };
+
+        topics.set(newTopic);
+        const room = this.list.get(ev.message.location.roomId);
+
+        if (room.defaultTopic?.id === ev.message.location.topicId) {
+            this.list.set({ ...room, defaultTopic: newTopic });
         }
     }
 }

package/src/state-tracker/SpacesManager.ts

@@ -8,6 +8,7 @@ import {
     RoleUpdated,
     RoomDeleted,
     RoomSummary,
+    RoomSummaryUpdated,
     RoomUpdated,
     Session,
     Space,
@@ -48,6 +49,7 @@ export class SpacesManager {
         this.tracker.client.on('SpaceMemberLeft', ev => this.handleSpaceMemberLeft(ev));
         this.tracker.client.on('SpaceMembers', ev => this.handleSpaceMembers(ev));
         this.tracker.client.on('SpaceRooms', ev => this.handleSpaceRooms(ev));
+        this.tracker.client.on('RoomSummaryUpdated', ev => this.handleRoomSummaryUpdated(ev));
         this.tracker.client.on('SpaceMemberUpdated', ev => this.handleSpaceMemberUpdated(ev));
         this.tracker.client.on('UserUpdated', ev => this.handleUserUpdated(ev));
         this.tracker.client.on('NewRole', ev => this.handleNewRole(ev));
@@ -229,12 +231,37 @@ export class SpacesManager {
     }
 
     private handleSpaceRooms(ev: SpaceRooms): void {
-        if (! this.rooms.has(ev.id)) {
+        if (!this.rooms.has(ev.id)) {
             this.rooms.set([ev.id, new ObservableIndexedObjectCollection('id', ev.summaries)]);
             ev.summaries.forEach(summary => this.roomIdToSpaceId.set([summary.id, ev.id]));
         }
     }
 
+    private async handleRoomSummaryUpdated(ev: RoomSummaryUpdated): Promise<void> {
+        const spaceId = this.roomIdToSpaceId.get(ev.summary.id);
+        const summariesPromise = this.roomsPromises.get(spaceId);
+
+        /**
+         * Update summary only if the list was already loaded.
+         * RoomSummaryUpdated event has a partial summary, so we need to update the existing summary by merging it.
+         */
+        if (spaceId && summariesPromise) {
+            await summariesPromise;
+
+            const summaries = this.rooms.get(spaceId);
+            const oldSummary = summaries.get(ev.summary.id);
+            let newSummary: RoomSummary;
+
+            if (oldSummary) {
+                newSummary = {...oldSummary, ...ev.summary};
+            } else {
+                newSummary = ev.summary;
+            }
+
+            summaries.set(newSummary);
+        }
+    }
+
     private handleSpaceMemberUpdated(ev: SpaceMemberUpdated): void {
         if (this.members.has(ev.spaceId)) {
             const members = this.members.get(ev.spaceId);