polfan-server-js-client 0.0.96 → 0.1.0

package/src/{connections/WebApiConnection.ts → WebApiClient.ts}

@@ -1,82 +1,95 @@
-import {ChatConnectionInterface, ChatConnectionEvent, ConnectionOptionsInterface} from "./ConnectionAssets";
-import {EventTarget} from "../ObservableInterface";
-
-export interface WebApiConnectionOptionsInterface extends ConnectionOptionsInterface {
-    attemptsToSend?: number;
-    attemptDelayMs?: number;
-}
-
-export class WebApiConnection extends EventTarget implements ChatConnectionInterface {
-    protected sendStack: {data: any, attempts: number, lastTimeoutId: any}[];
-
-    public constructor(
-        protected readonly options: WebApiConnectionOptionsInterface
-    ) {
-        super();
-        if (!this.options.token && !this.options.temporaryNick) {
-            throw new Error('Token or temporary nick is required for authentication');
-        }
-    }
-
-    public init() {
-        this.emit(ChatConnectionEvent.ready);
-    }
-
-    public send(data: any): void {
-        this.sendStack.push({data: data, attempts: 0, lastTimeoutId: null});
-        this.makeApiCall(this.sendStack.length - 1);
-    }
-
-    public destroy(): void {
-        // Cancel all awaiting requests
-        this.sendStack.forEach(item => {
-            if (item.lastTimeoutId) {
-                clearTimeout(item.lastTimeoutId);
-            }
-        });
-        this.sendStack = [];
-        this.emit(ChatConnectionEvent.destroy, false);
-    }
-
-    protected async onMessage(reqId: number, response: Response): Promise<void> {
-        this.sendStack.splice(reqId, 1);
-        this.emit(ChatConnectionEvent.message, await response.json());
-    }
-
-    protected onError(reqId: number, body: string): void {
-        if (this.sendStack[reqId].attempts >= (this.options.attemptsToSend ?? 10)) {
-            this.sendStack.splice(reqId, 1);
-            this.emit(ChatConnectionEvent.error, new Error(
-                `Cannot send ${body}; aborting after reaching the maximum connection errors`)
-            );
-            return;
-        }
-        this.sendStack[reqId].lastTimeoutId = setTimeout(
-            () => this.makeApiCall(reqId),
-            this.options.attemptDelayMs ?? 3000
-        );
-    }
-
-    protected makeApiCall(reqId: number): void {
-        this.sendStack[reqId].attempts++;
-        const bodyJson = JSON.stringify(this.sendStack[reqId].data);
-        const headers: any = {
-            'Content-Type': 'application/json',
-            Accept: 'application/json'
-        };
-
-        if (this.options.token) {
-            headers.Authorization = `Bearer ${this.options.token}`;
-        } else if (this.options.temporaryNick) {
-            headers.Authorization = `Temp ${this.options.temporaryNick}`;
-        }
-
-        fetch(this.options.url, {
-            headers,
-            body: bodyJson,
-            method: 'POST',
-        })
-            .then(response => this.onMessage(reqId, response))
-            .catch(() => this.onError(reqId, bodyJson));
-    }
+import {AbstractClient, CommandResult, CommandsMap} from "./AbstractClient";
+import {ObservableInterface} from "./EventTarget";
+import {Envelope} from "pserv-ts-types";
+
+export interface WebApiClientOptions {
+    url: string;
+    token?: string;
+    temporaryNick?: string;
+    attemptsToSend?: number;
+    attemptDelayMs?: number;
+}
+
+enum WebApiClientEvent {
+    message = 'message',
+    error = 'error',
+    destroy = 'destroy',
+}
+
+export class WebApiClient extends AbstractClient implements ObservableInterface {
+    public readonly Event = WebApiClientEvent;
+
+    protected sendStack: {data: any, attempts: number, lastTimeoutId: any}[];
+
+    public constructor(private readonly options: WebApiClientOptions) {
+        super();
+        if (!this.options.token && !this.options.temporaryNick) {
+            throw new Error('Token or temporary nick is required');
+        }
+    }
+
+    public async send<CommandType extends keyof CommandsMap>(commandType: CommandType, commandData: CommandsMap[CommandType][0]):
+        Promise<CommandResult<CommandsMap[CommandType][1]>> {
+        const envelope = this.createEnvelope(commandType, commandData);
+        this.sendStack.push({data: envelope, attempts: 0, lastTimeoutId: null});
+        this.makeApiCall(this.sendStack.length - 1);
+        return this.createPromiseFromCommandEnvelope(envelope);
+    }
+
+    public destroy(): void {
+        // Cancel all awaiting requests
+        this.sendStack.forEach(item => {
+            if (item.lastTimeoutId) {
+                clearTimeout(item.lastTimeoutId);
+            }
+            this.awaitingResponse.delete(item.data.ref);
+        });
+        this.sendStack = [];
+        this.emit(this.Event.destroy, false);
+    }
+
+    protected async onMessage(reqId: number, response: Response): Promise<void> {
+        this.sendStack.splice(reqId, 1);
+        const envelope: Envelope = await response.json();
+        this.handleIncomingEnvelope(envelope);
+        this.emit(envelope.type, envelope);
+        this.emit(this.Event.message, envelope);
+    }
+
+    protected onError(reqId: number, body: string): void {
+        if (this.sendStack[reqId].attempts >= (this.options.attemptsToSend ?? 10)) {
+            this.sendStack.splice(reqId, 1);
+            this.handleEnvelopeSendError(this.sendStack[reqId].data, new Error(
+                `Cannot send ${body}; aborting after reaching the maximum connection errors`
+            ));
+            return;
+        }
+        this.sendStack[reqId].lastTimeoutId = setTimeout(
+            () => this.makeApiCall(reqId),
+            this.options.attemptDelayMs ?? 3000
+        );
+    }
+
+    protected makeApiCall(reqId: number): void {
+        this.sendStack[reqId].attempts++;
+        const bodyJson = JSON.stringify(this.sendStack[reqId].data);
+        const headers: any = {
+            'Content-Type': 'application/json',
+            Accept: 'application/json'
+        };
+
+        if (this.options.token) {
+            headers.Authorization = `Bearer ${this.options.token}`;
+        } else if (this.options.temporaryNick) {
+            headers.Authorization = `Temp ${this.options.temporaryNick}`;
+        }
+
+        fetch(this.options.url, {
+            headers,
+            body: bodyJson,
+            method: 'POST',
+        })
+            .then(response => this.onMessage(reqId, response))
+            .catch(() => this.onError(reqId, bodyJson));
+    }
 }

package/src/WebSocketClient.ts

@@ -0,0 +1,125 @@
+import {ObservableInterface} from "./EventTarget";
+import {AbstractClient, CommandResult, CommandsMap} from "./AbstractClient";
+import {Envelope} from "pserv-ts-types";
+import {WebSocketStateTracker} from "./WebSocketStateTracker";
+
+export interface WebSocketClientOptions {
+    url: string;
+    token?: string;
+    temporaryNick?: string;
+    connectingTimeoutMs?: number;
+    awaitQueueSendDelayMs?: number;
+    stateTracking?: boolean;
+}
+
+enum WebSocketClientEvent {
+    connect = 'connect',
+    disconnect = 'disconnect',
+    message = 'message',
+    error = 'error',
+}
+
+export class WebSocketClient extends AbstractClient implements ObservableInterface {
+    public readonly Event = WebSocketClientEvent;
+    public readonly state?: WebSocketStateTracker;
+
+    protected ws: WebSocket|null = null;
+    protected sendQueue: [commandType: keyof CommandsMap, commandData: any][] = [];
+    protected connectingTimeoutId: any;
+    protected authenticated: boolean;
+    protected authenticatedResolvers: [() => void, (error: Error) => void];
+
+    public constructor(private readonly options: WebSocketClientOptions) {
+        super();
+        if (!this.options.token && !this.options.temporaryNick) {
+            throw new Error('Token or temporary nick is required');
+        }
+        if (this.options.stateTracking ?? true) {
+            this.state = new WebSocketStateTracker(this);
+        }
+    }
+
+    public async connect(): Promise<void> {
+        const authString = this.options.token ? `token=${this.options.token}` : `nick=${this.options.temporaryNick}`;
+        this.ws = new WebSocket(`${this.options.url}?${authString}`);
+        this.ws.onclose = ev => this.onClose(ev);
+        this.ws.onmessage = ev => this.onMessage(ev);
+        this.connectingTimeoutId = setTimeout(
+            () => this.triggerConnectionTimeout(),
+            this.options.connectingTimeoutMs ?? 10000
+        );
+        this.authenticated = false;
+        return new Promise((...args) => this.authenticatedResolvers = args);
+    }
+
+    public disconnect(): void {
+        this.sendQueue = [];
+        this.ws?.close();
+        this.ws = null;
+    }
+
+    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');
+        }
+
+        if (this.ws.readyState === this.ws.CONNECTING || !this.authenticated) {
+            this.sendQueue.push([commandType, commandData] as any);
+            return;
+        }
+
+        if (this.ws.readyState !== this.ws.OPEN) {
+            throw new Error(`Invalid websocket state=${this.ws.readyState}`);
+        }
+
+        const envelope = this.createEnvelope<CommandsMap[CommandType][0]>(commandType, commandData);
+        this.ws.send(JSON.stringify(envelope));
+        return this.createPromiseFromCommandEnvelope<CommandType>(envelope);
+    }
+
+    private onMessage(event: MessageEvent): void {
+        const envelope: Envelope = JSON.parse(event.data);
+        // Login successfully
+        if (!this.authenticated) {
+            const isAuthenticated = envelope.type !== 'Error';
+            this.authenticated = isAuthenticated;
+            if (isAuthenticated) {
+                this.authenticatedResolvers[0]();
+                this.emit(this.Event.connect);
+                this.sendFromQueue();
+            } else {
+                this.authenticatedResolvers[1](envelope.data);
+            }
+        }
+        this.handleIncomingEnvelope(envelope);
+        this.emit(envelope.type, envelope);
+        this.emit(this.Event.message, envelope);
+    }
+
+    private onClose(event: CloseEvent): void {
+        clearTimeout(this.connectingTimeoutId);
+        const reconnect = event.code !== 1000; // Connection was closed because of error
+        if (reconnect) {
+            this.connect();
+        }
+        this.emit(this.Event.disconnect, reconnect);
+    }
+
+    private sendFromQueue(): void {
+        // Send awaiting data to server
+        let lastDelay = 0;
+        for (const dataIndex in this.sendQueue) {
+            const data = this.sendQueue[dataIndex];
+            setTimeout(() => this.send(...data), lastDelay);
+            lastDelay += this.options.awaitQueueSendDelayMs ?? 500;
+        }
+        this.sendQueue = [];
+        clearTimeout(this.connectingTimeoutId);
+    }
+
+    private triggerConnectionTimeout(): void {
+        this.disconnect();
+        this.emit(this.Event.error, new Error('Connection timeout'));
+    }
+}

package/src/WebSocketStateTracker.ts

@@ -0,0 +1,326 @@
+import {WebSocketClient} from "./WebSocketClient";
+import {IndexedCollection, ObservableIndexedObjectCollection} from "./IndexedObjectCollection";
+import {
+    Message,
+    NewMessage,
+    NewRole,
+    NewRoom,
+    NewTopic, Role,
+    RoleDeleted,
+    Room,
+    RoomDeleted,
+    RoomJoined,
+    RoomLeft, RoomMember,
+    RoomMemberJoined,
+    RoomMemberLeft,
+    RoomMembers, RoomSummary,
+    Session,
+    Space,
+    SpaceDeleted,
+    SpaceJoined,
+    SpaceLeft, SpaceMember,
+    SpaceMemberJoined,
+    SpaceMemberLeft,
+    SpaceMembers,
+    SpaceMemberUpdate,
+    SpaceRooms, Topic,
+    TopicDeleted, User
+} from "pserv-ts-types";
+
+type Deferred = {resolver: () => void, promise: Promise<void>};
+
+export class WebSocketStateTracker {
+    private readonly joinedSpaces = new ObservableIndexedObjectCollection<Space>('id');
+    private readonly joinedRooms = new ObservableIndexedObjectCollection<Room>('id');
+    private readonly spacesRoles = new IndexedCollection<string, ObservableIndexedObjectCollection<Role>>();
+    private readonly roomsTopics = new IndexedCollection<string, ObservableIndexedObjectCollection<Topic>>();
+    // Temporary not lazy loaded; server must implement GetTopicMessages command.
+    private readonly topicsMessages = new IndexedCollection<string, ObservableIndexedObjectCollection<Message>>();
+
+    // lazy loaded collections
+    private readonly spacesRooms = new IndexedCollection<string, ObservableIndexedObjectCollection<RoomSummary>>();
+    private readonly spacesMembers = new IndexedCollection<string, ObservableIndexedObjectCollection<SpaceMember>>();
+    private readonly roomsMembers = new IndexedCollection<string, ObservableIndexedObjectCollection<RoomMember>>();
+    private readonly deferredGetters = new IndexedCollection<string, Deferred>();
+
+    private reconnecting: boolean = false;
+    private me: User = null;
+
+    public constructor(private readonly client: WebSocketClient) {
+        this.bind();
+    }
+
+    public async getMe(): Promise<User> {
+        await this.deferredGetterReadiness('session');
+        return this.me;
+    }
+
+    public async getJoinedSpaces(): Promise<ObservableIndexedObjectCollection<Space>> {
+        await this.deferredGetterReadiness('session');
+        return this.joinedSpaces;
+    }
+
+    public async getJoinedRooms(): Promise<ObservableIndexedObjectCollection<Room>> {
+        await this.deferredGetterReadiness('session');
+        return this.joinedRooms;
+    }
+
+    public async getSpaceRoles(spaceId: string): Promise<ObservableIndexedObjectCollection<Role> | null> {
+        await this.deferredGetterReadiness('session');
+        return this.spacesRoles.get(spaceId);
+    }
+
+    public async getRoomTopics(roomId: string): Promise<ObservableIndexedObjectCollection<Topic> | null> {
+        await this.deferredGetterReadiness('session');
+        return this.roomsTopics.get(roomId);
+    }
+
+    public async getTopicMessages(topicId: string): Promise<ObservableIndexedObjectCollection<Message> | null> {
+        return this.topicsMessages.get(topicId);
+    }
+
+    public async getSpaceRooms(spaceId: string): Promise<ObservableIndexedObjectCollection<RoomSummary> | null> {
+        const deferredGetterName = `spaces-rooms-${spaceId}`;
+        if (!this.spacesRooms.has(spaceId) && !this.deferredGetters.has(deferredGetterName)) {
+            this.createDeferredGetter(deferredGetterName);
+            this.client.send('GetSpaceRooms', {id: spaceId});
+        }
+        await this.deferredGetterReadiness(deferredGetterName);
+        return this.spacesRooms.get(spaceId);
+    }
+
+    public async getSpaceMembers(spaceId: string): Promise<ObservableIndexedObjectCollection<SpaceMember> | null> {
+        const deferredGetterName = `spaces-members-${spaceId}`;
+        if (!this.spacesMembers.has(spaceId) && !this.deferredGetters.has(deferredGetterName)) {
+            this.createDeferredGetter(deferredGetterName);
+            this.client.send('GetSpaceMembers', {id: spaceId});
+        }
+        await this.deferredGetterReadiness(deferredGetterName);
+        return this.spacesMembers.get(spaceId);
+    }
+
+    public async getRoomMembers(roomId: string): Promise<ObservableIndexedObjectCollection<RoomMember> | null> {
+        const deferredGetterName = `rooms-members-${roomId}`;
+        if (!this.roomsMembers.has(roomId) && !this.deferredGetters.has(deferredGetterName)) {
+            this.createDeferredGetter(deferredGetterName);
+            this.client.send('GetRoomMembers', {id: roomId});
+        }
+        await this.deferredGetterReadiness(deferredGetterName);
+        return this.roomsMembers.get(roomId);
+    }
+
+    private async deferredGetterReadiness(name: string): Promise<void> {
+        if (this.deferredGetters.has(name)) {
+            await this.deferredGetters.get(name)?.promise;
+        }
+    }
+
+    private bind(): void {
+        this.client.on(this.client.Event.disconnect, ev => this.handleDisconnect(ev as any as boolean));
+        this.client.on('NewMessage', ev => this.handleNewMessage(ev));
+        this.client.on('NewRole', ev => this.handleNewRole(ev));
+        this.client.on('NewRoom', ev => this.handleNewRoom(ev));
+        this.client.on('NewTopic', ev => this.handleNewTopic(ev));
+        this.client.on('RoleDeleted', ev => this.handleRoleDeleted(ev));
+        this.client.on('RoomDeleted', ev => this.handleRoomDeleted(ev));
+        this.client.on('RoomJoined', ev => this.handleRoomJoined(ev));
+        this.client.on('RoomLeft', ev => this.handleRoomLeft(ev));
+        this.client.on('RoomMemberJoined', ev => this.handleRoomMemberJoined(ev));
+        this.client.on('RoomMemberLeft', ev => this.handleRoomMemberLeft(ev));
+        this.client.on('RoomMembers', ev => this.handleRoomMembers(ev));
+        this.client.on('Session', ev => this.handleSession(ev));
+        this.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.client.on('SpaceJoined', ev => this.handleSpaceJoined(ev));
+        this.client.on('SpaceLeft', ev => this.handleSpaceLeft(ev));
+        this.client.on('SpaceMemberJoined', ev => this.handleSpaceMemberJoined(ev));
+        this.client.on('SpaceMemberLeft', ev => this.handleSpaceMemberLeft(ev));
+        this.client.on('SpaceMembers', ev => this.handleSpaceMembers(ev));
+        this.client.on('SpaceRooms', ev => this.handleSpaceRooms(ev));
+        this.client.on('SpaceMemberUpdate', ev => this.handleSpaceMemberUpdate(ev));
+        this.client.on('TopicDeleted', ev => this.handleTopicDeleted(ev));
+    }
+
+    private createDeferredGetter(name: string): void {
+        if (this.deferredGetters.has(name)) {
+            return;
+        }
+        const deferred: Deferred = {promise: undefined, resolver: undefined};
+        deferred.promise = new Promise(resolve => deferred.resolver = resolve);
+        this.deferredGetters.set([name, deferred]);
+    }
+
+    private handleDisconnect(reconnect: boolean): void {
+        if (reconnect) {
+            this.reconnecting = true;
+            return;
+        }
+    }
+
+    private handleNewMessage(ev: NewMessage): void {
+        this.topicsMessages.get(ev.topicId).set(ev.message);
+    }
+
+    private handleNewRole(ev: NewRole): void {
+        const collection = this.spacesRoles.get(ev.spaceId);
+        collection.set(ev.role);
+        this.joinedSpaces.get(ev.spaceId).roles = collection.items;
+    }
+
+    private handleNewRoom(ev: NewRoom): void {
+        this.spacesRooms.get(ev.spaceId)?.set(ev.summary);
+    }
+
+    private handleNewTopic(ev: NewTopic): void {
+        const collection = this.roomsTopics.get(ev.roomId);
+        collection.set(ev.topic);
+        this.joinedRooms.get(ev.roomId).topics = collection.items;
+    }
+
+    private handleRoleDeleted(ev: RoleDeleted): void {
+        const collection = this.spacesRoles.get(ev.spaceId);
+        collection.delete(ev.id);
+        this.joinedSpaces.get(ev.spaceId).roles = collection.items;
+    }
+
+    private handleRoomDeleted(ev: RoomDeleted): void {
+        if (ev.spaceId) {
+            this.spacesRooms.get(ev.spaceId).delete(ev.id);
+        }
+        this.joinedRooms.delete(ev.id);
+        this.roomsMembers.delete(ev.id);
+        this.roomsTopics.delete(ev.id);
+    }
+
+    private handleRoomJoined(ev: RoomJoined): void {
+        this.addJoinedRooms(ev.room);
+    }
+
+    private addJoinedRooms(...rooms: Room[]): void {
+        this.roomsTopics.set(...rooms.map<[string, ObservableIndexedObjectCollection<Topic>]>(room => [
+            room.id,
+            new ObservableIndexedObjectCollection<Topic>('id', room.topics)
+        ]));
+        this.joinedRooms.set(...rooms);
+    }
+
+    private handleRoomLeft(ev: RoomLeft): void {
+        this.joinedRooms.delete(ev.id);
+        this.roomsMembers.delete(ev.id);
+        this.roomsTopics.delete(ev.id);
+    }
+
+    private handleRoomMemberJoined(ev: RoomMemberJoined): void {
+        if (this.roomsMembers.has(ev.roomId)) {
+            this.roomsMembers.get(ev.roomId).set(ev.member);
+        }
+    }
+
+    private handleRoomMemberLeft(ev: RoomMemberLeft): void {
+        if (this.roomsMembers.has(ev.roomId)) {
+            this.roomsMembers.get(ev.roomId).delete(ev.userId);
+        }
+    }
+
+    private handleRoomMembers(ev: RoomMembers): void {
+        if (!this.roomsMembers.has(ev.id)) {
+            this.roomsMembers.set([
+                ev.id,
+                new ObservableIndexedObjectCollection(
+                    member => member?.user.id ?? member.spaceMember.user.id,
+                    ev.members,
+                )
+            ]);
+            this.deferredGetters.get(`rooms-members-${ev.id}`)?.resolver();
+        }
+    }
+
+    private handleSession(ev: Session): void {
+        this.me = ev.user;
+
+        if (this.me && !this.reconnecting) {
+            return;
+        }
+
+        this.reconnecting = false;
+
+        this.joinedRooms.deleteAll();
+        this.roomsTopics.deleteAll();
+        this.roomsMembers.deleteAll();
+        this.joinedSpaces.deleteAll();
+        this.spacesRoles.deleteAll();
+        this.spacesRooms.deleteAll();
+        this.spacesMembers.deleteAll();
+
+        this.addJoinedRooms(...ev.state.rooms);
+        this.addJoinedSpaces(...ev.state.spaces);
+
+        this.deferredGetters.get('session')?.resolver();
+    }
+
+    private handleSpaceDeleted(ev: SpaceDeleted): void {
+        this.spacesRoles.delete(ev.id);
+        this.spacesMembers.delete(ev.id);
+        this.spacesRooms.delete(ev.id);
+        this.joinedSpaces.delete(ev.id);
+    }
+    
+    private handleSpaceJoined(ev: SpaceJoined): void {
+        this.addJoinedSpaces(ev.space);
+    }
+
+    private addJoinedSpaces(...spaces: Space[]): void {
+        this.spacesRoles.set(...(spaces.map(space => [
+            space.id,
+            new ObservableIndexedObjectCollection<Role>('id', space.roles)
+        ]) as [string, ObservableIndexedObjectCollection<Role>][]));
+        this.joinedSpaces.set(...spaces);
+    }
+
+    private handleSpaceLeft(ev: SpaceLeft): void {
+        this.spacesRoles.delete(ev.id);
+        this.spacesMembers.delete(ev.id);
+        this.spacesRooms.delete(ev.id);
+        this.joinedSpaces.delete(ev.id);
+    }
+
+    private handleSpaceMemberJoined(ev: SpaceMemberJoined): void {
+        if (this.spacesMembers.has(ev.spaceId)) {
+            this.spacesMembers.get(ev.spaceId).set(ev.member);
+        }
+    }
+
+    private handleSpaceMemberLeft(ev: SpaceMemberLeft): void {
+        if (this.spacesMembers.has(ev.spaceId)) {
+            this.spacesMembers.get(ev.spaceId).delete(ev.userId);
+        }
+    }
+
+    private handleSpaceMembers(ev: SpaceMembers): void {
+        if (!this.spacesMembers.has(ev.id)) {
+            this.spacesMembers.set([
+                ev.id,
+                new ObservableIndexedObjectCollection(member => member?.user.id, ev.members)
+            ]);
+            this.deferredGetters.get(`spaces-members-${ev.id}`)?.resolver();
+        }
+    }
+
+    private handleSpaceRooms(ev: SpaceRooms): void {
+        if (!this.spacesRooms.has(ev.id)) {
+            this.spacesRooms.set([ev.id, new ObservableIndexedObjectCollection('id', ev.summaries)]);
+            this.deferredGetters.get(`spaces-rooms-${ev.id}`)?.resolver();
+        }
+    }
+
+    private handleSpaceMemberUpdate(ev: SpaceMemberUpdate): void {
+        if (this.spacesMembers.has(ev.spaceId)) {
+            this.spacesMembers.get(ev.spaceId).set(ev.member);
+        }
+    }
+
+    private handleTopicDeleted(ev: TopicDeleted): void {
+        const collection = this.roomsTopics.get(ev.roomId);
+        collection.delete(ev.id);
+        this.joinedRooms.get(ev.roomId).topics = collection.items;
+    }
+}