polfan-server-js-client 0.1.24 → 0.1.26

package/src/state-tracker/PermissionsManager.ts

@@ -0,0 +1,205 @@
+import {ChatStateTracker} from "./ChatStateTracker";
+import {
+    PermissionOverwrites,
+    PermissionOverwritesChanged,
+    PermissionOverwritesValue,
+    Role
+} from "pserv-ts-types";
+import {EventHandler, EventTarget} from "../EventTarget";
+import {IndexedCollection} from "../IndexedObjectCollection";
+import {Permission} from "../Permission";
+
+const getOvId = (
+    layer: PermissionOverwrites['layer'],
+    layerId: PermissionOverwrites['layerId'],
+    target: PermissionOverwrites['target'],
+    targetId: PermissionOverwrites['targetId'],
+) => layer + (layerId ?? '') + target + targetId;
+
+const getOvIdByObject = (overwrites: PermissionOverwrites | PermissionOverwritesChanged): string => getOvId(
+    overwrites.layer, overwrites.layerId, overwrites.target, overwrites.targetId
+);
+
+export class PermissionsManager extends EventTarget {
+    private readonly overwrites = new IndexedCollection<string, PermissionOverwrites>();
+
+    public constructor(private tracker: ChatStateTracker) {
+        super();
+        this.tracker.client.on('PermissionOverwrites', ev => this.handlePermissionOverwrites(ev));
+        this.tracker.client.on('PermissionOverwritesChanged', ev => this.handlePermissionOverwrites(ev));
+    }
+
+    public async getOverwrites(
+        layer: PermissionOverwrites['layer'],
+        layerId: PermissionOverwrites['layerId'],
+        target: PermissionOverwrites['target'],
+        targetId: PermissionOverwrites['targetId'],
+    ): Promise<PermissionOverwrites | undefined> {
+        const id = getOvId(layer, layerId, target, targetId);
+
+        if (this.overwrites.has(id)) {
+            return this.overwrites.get(id);
+        }
+
+        const result = await this.tracker.client.send(
+            'GetPermissionOverwrites',
+            {layer, layerId, target, targetId},
+        );
+
+        return result.error ? null : result.data;
+    }
+
+    public on(eventName: 'change', handler: EventHandler<any>): this {
+        return super.on(eventName, handler);
+    }
+
+    public async check(
+        permissionNames: (keyof typeof Permission)[],
+        spaceId?: string,
+        roomId?: string,
+        topicId?: string,
+    ): Promise<{ok: boolean, missing: string[]}> {
+        const ownedPermissions = await this.calculatePermissions(spaceId, roomId, topicId);
+        const missing: string[] = [];
+
+        permissionNames.forEach(name => {
+            if (~ ownedPermissions & Permission[name]) {
+                missing.push(name);
+            }
+        });
+
+        return {ok: missing.length === 0, missing};
+    }
+
+    public async calculatePermissions(spaceId?: string, roomId?: string, topicId?: string): Promise<number> {
+        if (topicId && ! roomId || roomId && ! spaceId) {
+            throw new Error('Corrupted arguments hierarchy');
+        }
+
+        const userId = (await this.tracker.getMe()).id;
+
+        const userRoles: string[] = [];
+
+        const promises: Promise<PermissionOverwritesValue>[] = [
+            // Global user overwrites
+            this.getOverwrites('Global', null, 'User', userId).then(v => v.overwrites),
+        ];
+
+        if (spaceId) {
+            userRoles.push(...(await this.tracker.spaces.getMe(spaceId)).roles);
+            promises.push(this.collectRoleOverwrites(spaceId, 'Space', spaceId, userRoles));
+            promises.push(this.getOverwrites('Space', spaceId, 'User', userId).then(v => v.overwrites));
+        }
+
+        if (roomId) {
+            const roomMember = await this.tracker.rooms.getMe(roomId);
+
+            if (roomMember.roles !== null) { // Room overwrites from roles (only for space rooms)
+                userRoles.push(...roomMember.roles);
+                promises.push(this.collectRoleOverwrites(spaceId, 'Room', roomId, userRoles));
+            }
+
+            promises.push(this.getOverwrites('Room', roomId, 'User', userId).then(v => v.overwrites));
+        }
+
+        if (topicId) {
+            if (userRoles.length) {
+                promises.push(this.collectRoleOverwrites(spaceId, 'Topic', topicId, userRoles));
+            }
+
+            promises.push(this.getOverwrites('Topic', topicId, 'User', userId).then(v => v.overwrites));
+        }
+
+        return this.resolveOverwritesHierarchy(await Promise.all(promises));
+    }
+
+    private handlePermissionOverwrites(ev: PermissionOverwritesChanged | PermissionOverwrites) {
+        this.overwrites.set([getOvIdByObject(ev), ev]);
+        this.emit('change');
+    }
+
+    private async collectRoleOverwrites(
+        spaceId: string,
+        layer: PermissionOverwrites['layer'],
+        layerId: PermissionOverwrites['layerId'],
+        userRoles: string[],
+    ): Promise<PermissionOverwritesValue> {
+        const roleOverwrites = await Promise.all(userRoles.map(
+            roleId => this.getOverwrites(layer, layerId, 'Role', roleId)
+        ));
+
+        return this.resolveOverwritesFromRolesByOrder(spaceId, roleOverwrites);
+    }
+
+    private async resolveOverwritesFromRolesByOrder(
+        spaceId: string,
+        overwrites: PermissionOverwrites[],
+    ): Promise<PermissionOverwritesValue> {
+        let allows = 0, denies = 0;
+        const roles = await this.tracker.spaces.getRoles(spaceId);
+        const sortedOverwrites = overwrites.sort(
+            (a, b) =>
+                roles.get(a.targetId).priority - roles.get(b.targetId).priority
+        );
+
+        // Max length of bit word
+        const permissionsLength = overwrites.reduce(
+            (previousValue: number, currentValue: PermissionOverwrites) =>
+                Math.max(
+                    previousValue,
+                    currentValue.overwrites.allow.toString(2).length,
+                    currentValue.overwrites.deny.toString(2).length
+                ),
+            0,
+        );
+
+        sortedOverwrites.forEach(overwriteEvent => {
+            const overwrites = overwriteEvent.overwrites;
+            const revDecDenies = overwrites.deny.toString(2).split('').reverse().join('');
+            const revDecAllows = overwrites.allow.toString(2).split('').reverse().join('');
+
+            for (let i = 0; i < permissionsLength; i++) {
+                const deny = parseInt(revDecDenies[i] ?? '0');
+                const allow = parseInt(revDecAllows[i] ?? '0');
+
+                if (deny) {
+                    denies |= 1 << i;
+                }
+
+                if (allow) {
+                    allows |= 1 << i;
+                }
+            }
+        });
+
+        return {allow: allows, deny: denies};
+    }
+
+    private resolveOverwritesHierarchy(permissionOverwritesValues: PermissionOverwritesValue[]): number {
+        let result = 0;
+
+        for (const value of permissionOverwritesValues) {
+            if (value.allow & Permission.Root) {
+                return this.getRootAccessValue();
+            }
+
+            result = (result & ~value.deny) | value.allow;
+        }
+
+        return result;
+    }
+
+    private getRootAccessValue(): number {
+        let result = 0;
+
+        for (const name of this.getPermissionNames()) {
+            result |= Permission[name];
+        }
+
+        return result;
+    }
+
+    private getPermissionNames(): string[] {
+        return Object.keys(Permission).filter(key => Number.isNaN(parseInt(key)));
+    }
+}

package/src/state-tracker/RoomsManager.ts

@@ -0,0 +1,222 @@
+import {IndexedCollection, ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
+import {
+    Message, NewMessage, NewTopic,
+    Room,
+    RoomJoined, RoomLeft,
+    RoomMember, RoomMemberJoined, RoomMemberLeft, RoomMembers,
+    RoomMemberUpdated, Session,
+    SpaceMember,
+    Topic,
+    TopicDeleted
+} from "pserv-ts-types";
+import {ChatStateTracker} from "./ChatStateTracker";
+import {DeferredTask} from "./DeferredTask";
+
+export class RoomsManager {
+    private readonly list = new ObservableIndexedObjectCollection<Room>('id');
+    private readonly topics = new IndexedCollection<string, ObservableIndexedObjectCollection<Topic>>();
+    // Temporary not lazy loaded; server must implement GetTopicMessages command.
+    private readonly topicsMessages = new IndexedCollection<string, ObservableIndexedObjectCollection<Message>>();
+    private readonly members = new IndexedCollection<string, ObservableIndexedObjectCollection<RoomMember>>();
+    private readonly deferredSession = new DeferredTask();
+
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('NewMessage', ev => this.handleNewMessage(ev));
+        this.tracker.client.on('NewTopic', ev => this.handleNewTopic(ev));
+        this.tracker.client.on('TopicDeleted', ev => this.handleTopicDeleted(ev));
+        this.tracker.client.on('RoomJoined', ev => this.handleRoomJoined(ev));
+        this.tracker.client.on('RoomLeft', ev => this.handleRoomLeft(ev));
+        this.tracker.client.on('RoomMemberJoined', ev => this.handleRoomMemberJoined(ev));
+        this.tracker.client.on('RoomMemberLeft', ev => this.handleRoomMemberLeft(ev));
+        this.tracker.client.on('RoomMembers', ev => this.handleRoomMembers(ev));
+        this.tracker.client.on('RoomMemberUpdated', ev => this.handleRoomMemberUpdated(ev));
+        this.tracker.client.on('Session', ev => this.handleSession(ev));
+    }
+
+    /**
+     * Get collection of room members.
+     */
+    public async getMembers(roomId: string): Promise<ObservableIndexedObjectCollection<RoomMember> | undefined> {
+        if (! this.members.has(roomId)) {
+            const result = await this.tracker.client.send('GetRoomMembers', {id: roomId});
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            this.handleRoomMembers(result.data);
+        }
+
+        return this.members.get(roomId);
+    }
+
+    /**
+     * Get a room member representing the current user.
+     */
+    public async getMe(roomId: string): Promise<RoomMember | undefined> {
+        const userId = (await this.tracker.getMe()).id;
+        const members = await this.getMembers(roomId);
+
+        if (! members) {
+            // User is not in passed room.
+            return undefined;
+        }
+
+        return members.items.find(member => (member.user?.id ?? member.spaceMember.user.id) === userId);
+    }
+
+    /**
+     * Get collection of all the rooms you are in.
+     */
+    public async get(): Promise<ObservableIndexedObjectCollection<Room>> {
+        await this.deferredSession.promise;
+        return this.list;
+    }
+
+    /**
+     * Get collection of room topics.
+     */
+    public async getTopics(roomId: string): Promise<ObservableIndexedObjectCollection<Topic> | undefined> {
+        await this.deferredSession.promise;
+        return this.topics.get(roomId);
+    }
+
+    /**
+     * Get collection of the messages written in topic.
+     */
+    public async getMessages(topicId: string): Promise<ObservableIndexedObjectCollection<Message> | undefined> {
+        return this.topicsMessages.get(topicId);
+    }
+
+    /**
+     * For internal use. If you want to leave the room, execute a proper command on client object.
+     * @internal
+     */
+    public _delete(...roomIds: string[]): void {
+        this.list.delete(...roomIds);
+        this.members.delete(...roomIds);
+
+        const topicIds: string[] = [];
+        for (const roomId of roomIds) {
+            topicIds.push(...(this.topics.get(roomId)?.map(topic => topic.id) ?? []));
+        }
+        this.topicsMessages.delete(...topicIds);
+
+        this.topics.delete(...roomIds);
+    }
+
+    /**
+     * For internal use. If you want to leave the room, execute a proper command on client object.
+     * @internal
+     */
+    public _deleteBySpaceId(spaceId: string): void {
+        this._delete(
+            ...this.list.findBy('spaceId', spaceId).map(room => room.id)
+        );
+    }
+
+    /**
+     * For internal use.
+     * @internal
+     */
+    public _handleSpaceMemberUpdate(spaceId: string, member: SpaceMember): void {
+        // Update members of rooms related to this space
+        for (const room of this.list.findBy('spaceId', spaceId).items) {
+            const roomMembers = this.members.get(room.id);
+
+            if (! roomMembers) {
+                // Skip update if member list for this room is not loaded
+                continue;
+            }
+
+            const roomMember = roomMembers.get(member.user.id);
+            roomMember.spaceMember = member;
+            roomMembers.set(roomMember);
+        }
+    }
+
+    private handleRoomMemberUpdated(ev: RoomMemberUpdated): void {
+        if (! this.members.has(ev.roomId)) {
+            return;
+        }
+
+        this.members.get(ev.roomId).set(ev.member);
+    }
+
+    private handleTopicDeleted(ev: TopicDeleted): void {
+        const collection = this.topics.get(ev.roomId);
+        collection.delete(ev.id);
+        this.list.get(ev.roomId).topics = collection.items;
+    }
+
+    private handleNewMessage(ev: NewMessage): void {
+        this.topicsMessages.get(ev.topicId).set(ev.message);
+    }
+
+    private handleNewTopic(ev: NewTopic): void {
+        this.addJoinedRoomTopics(ev.roomId, ev.topic);
+        this.list.get(ev.roomId).topics.push(ev.topic);
+    }
+
+    private addJoinedRoomTopics(roomId: string, ...topics: Topic[]): void {
+        if (this.topics.has(roomId)) {
+            this.topics.get(roomId).set(...topics);
+        } else {
+            this.topics.set([roomId, new ObservableIndexedObjectCollection<Topic>('id', topics)]);
+        }
+
+        this.topicsMessages.set(...topics.map<[string, ObservableIndexedObjectCollection<Message>]>(topic => [
+            topic.id,
+            new ObservableIndexedObjectCollection<Message>('id')
+        ]));
+    }
+
+    private handleRoomJoined(ev: RoomJoined): void {
+        this.addJoinedRooms(ev.room);
+    }
+
+    private addJoinedRooms(...rooms: Room[]): void {
+        for (const room of rooms) {
+            this.addJoinedRoomTopics(room.id, ...room.topics);
+        }
+        this.list.set(...rooms);
+    }
+
+    private handleRoomLeft(ev: RoomLeft): void {
+        this._delete(ev.id);
+    }
+
+    private handleRoomMemberJoined(ev: RoomMemberJoined): void {
+        if (this.members.has(ev.roomId)) {
+            this.members.get(ev.roomId).set(ev.member);
+        }
+    }
+
+    private handleRoomMemberLeft(ev: RoomMemberLeft): void {
+        if (this.members.has(ev.roomId)) {
+            this.members.get(ev.roomId).delete(ev.userId);
+        }
+    }
+
+    private handleRoomMembers(ev: RoomMembers): void {
+        if (! this.members.has(ev.id)) {
+            this.members.set([
+                ev.id,
+                new ObservableIndexedObjectCollection(
+                    member => member.user?.id ?? member.spaceMember.user.id,
+                    ev.members,
+                )
+            ]);
+        }
+    }
+
+    private handleSession(ev: Session) {
+        this.list.deleteAll();
+        this.topics.deleteAll();
+        this.members.deleteAll();
+
+        this.addJoinedRooms(...ev.state.rooms);
+
+        this.deferredSession.resolve();
+    }
+}

package/src/state-tracker/SpacesManager.ts

@@ -0,0 +1,201 @@
+import {ChatStateTracker} from "./ChatStateTracker";
+import {IndexedCollection, ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
+import {
+    NewRole,
+    NewRoom,
+    Role,
+    RoleDeleted, RoleUpdated, RoomDeleted,
+    RoomSummary, Session,
+    Space,
+    SpaceDeleted, SpaceJoined, SpaceLeft,
+    SpaceMember, SpaceMemberJoined, SpaceMemberLeft, SpaceMembers, SpaceMemberUpdated, SpaceRooms
+} from "pserv-ts-types";
+import {DeferredTask} from "./DeferredTask";
+
+export class SpacesManager {
+    private readonly list = new ObservableIndexedObjectCollection<Space>('id');
+    private readonly roles = new IndexedCollection<string, ObservableIndexedObjectCollection<Role>>();
+    private readonly rooms = new IndexedCollection<string, ObservableIndexedObjectCollection<RoomSummary>>();
+    private readonly members = new IndexedCollection<string, ObservableIndexedObjectCollection<SpaceMember>>();
+    private readonly deferredSession = new DeferredTask();
+
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('NewRoom', ev => this.handleNewRoom(ev));
+        this.tracker.client.on('RoomDeleted', ev => this.handleRoomDeleted(ev));
+        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('SpaceJoined', ev => this.handleSpaceJoined(ev));
+        this.tracker.client.on('SpaceLeft', ev => this.handleSpaceLeft(ev));
+        this.tracker.client.on('SpaceMemberJoined', ev => this.handleSpaceMemberJoined(ev));
+        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('SpaceMemberUpdated', ev => this.handleSpaceMemberUpdated(ev));
+        this.tracker.client.on('NewRole', ev => this.handleNewRole(ev));
+        this.tracker.client.on('RoleDeleted', ev => this.handleRoleDeleted(ev));
+        this.tracker.client.on('RoleUpdated', ev => this.handleRoleUpdated(ev));
+        this.tracker.client.on('Session', ev => this.handleSession(ev));
+    }
+
+    /**
+     * Get collection of all the spaces you are in.
+     */
+    public async get(): Promise<ObservableIndexedObjectCollection<Space>> {
+        await this.deferredSession.promise;
+        return this.list;
+    }
+
+    /**
+     * Get collection of space roles.
+     */
+    public async getRoles(spaceId: string): Promise<ObservableIndexedObjectCollection<Role> | undefined> {
+        await this.deferredSession.promise;
+        return this.roles.get(spaceId);
+    }
+
+    /**
+     * Get collection of the all available rooms inside given space.
+     */
+    public async getRooms(spaceId: string): Promise<ObservableIndexedObjectCollection<RoomSummary> | undefined> {
+        if (! this.rooms.has(spaceId)) {
+            const result = await this.tracker.client.send('GetSpaceRooms', {id: spaceId});
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            this.handleSpaceRooms(result.data);
+        }
+
+        return this.rooms.get(spaceId);
+    }
+
+    /**
+     * Get collection of space members.
+     */
+    public async getMembers(spaceId: string): Promise<ObservableIndexedObjectCollection<SpaceMember> | undefined> {
+        if (! this.members.has(spaceId)) {
+            const result = await this.tracker.client.send('GetSpaceMembers', {id: spaceId});
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            this.handleSpaceMembers(result.data);
+        }
+
+        return this.members.get(spaceId);
+    }
+
+    /**
+     * Get a space member representing the current user.
+     */
+    public async getMe(spaceId: string): Promise<SpaceMember | undefined> {
+        const userId = (await this.tracker.getMe()).id;
+        const members = await this.getMembers(spaceId);
+
+        if (! members) {
+            // User is not in passed space.
+            return undefined;
+        }
+
+        return members.items.find(member => member.user.id === userId);
+    }
+
+    private handleNewRole(ev: NewRole): void {
+        const collection = this.roles.get(ev.spaceId);
+        collection.set(ev.role);
+        this.list.get(ev.spaceId).roles = collection.items;
+    }
+
+    private handleNewRoom(ev: NewRoom): void {
+        this.rooms.get(ev.spaceId)?.set(ev.summary);
+    }
+
+    private handleRoomDeleted(ev: RoomDeleted): void {
+        if (ev.spaceId) {
+            this.rooms.get(ev.spaceId).delete(ev.id);
+        }
+
+        this.tracker.rooms._delete(ev.id);
+    }
+
+    private handleRoleDeleted(ev: RoleDeleted): void {
+        const collection = this.roles.get(ev.spaceId);
+        collection.delete(ev.id);
+        this.list.get(ev.spaceId).roles = collection.items;
+    }
+
+    private handleSpaceDeleted(ev: SpaceDeleted): void {
+        this.tracker.rooms._deleteBySpaceId(ev.id);
+        this.roles.delete(ev.id);
+        this.members.delete(ev.id);
+        this.rooms.delete(ev.id);
+        this.list.delete(ev.id);
+    }
+
+    private handleSpaceJoined(ev: SpaceJoined): void {
+        this.addJoinedSpaces(ev.space);
+    }
+
+    private addJoinedSpaces(...spaces: Space[]): void {
+        this.roles.set(...(spaces.map(space => [
+            space.id,
+            new ObservableIndexedObjectCollection<Role>('id', space.roles)
+        ]) as [string, ObservableIndexedObjectCollection<Role>][]));
+        this.list.set(...spaces);
+    }
+
+    private handleSpaceLeft(ev: SpaceLeft): void {
+        this.handleSpaceDeleted(ev);
+    }
+
+    private handleSpaceMemberJoined(ev: SpaceMemberJoined): void {
+        if (this.members.has(ev.spaceId)) {
+            this.members.get(ev.spaceId).set(ev.member);
+        }
+    }
+
+    private handleSpaceMemberLeft(ev: SpaceMemberLeft): void {
+        if (this.members.has(ev.spaceId)) {
+            this.members.get(ev.spaceId).delete(ev.userId);
+        }
+    }
+
+    private handleSpaceMembers(ev: SpaceMembers): void {
+        if (! this.members.has(ev.id)) {
+            this.members.set([
+                ev.id,
+                new ObservableIndexedObjectCollection(member => member?.user.id, ev.members)
+            ]);
+        }
+    }
+
+    private handleSpaceRooms(ev: SpaceRooms): void {
+        if (! this.rooms.has(ev.id)) {
+            this.rooms.set([ev.id, new ObservableIndexedObjectCollection('id', ev.summaries)]);
+        }
+    }
+
+    private handleSpaceMemberUpdated(ev: SpaceMemberUpdated): void {
+        if (this.members.has(ev.spaceId)) {
+            this.members.get(ev.spaceId).set(ev.member);
+        }
+
+        this.tracker.rooms._handleSpaceMemberUpdate(ev.spaceId, ev.member);
+    }
+
+    private handleRoleUpdated(ev: RoleUpdated): void {
+        this.roles.get(ev.spaceId).set(ev.role);
+    }
+
+    private handleSession(ev: Session) {
+        this.list.deleteAll();
+        this.roles.deleteAll();
+        this.rooms.deleteAll();
+        this.members.deleteAll();
+
+        this.addJoinedSpaces(...ev.state.spaces);
+
+        this.deferredSession.resolve();
+    }
+}

package/build/types/ChatStateTracker.d.ts

@@ -1,56 +0,0 @@
-import { WebSocketChatClient } from "./WebSocketChatClient";
-import { ObservableIndexedObjectCollection } from "./IndexedObjectCollection";
-import { Message, Role, Room, RoomMember, RoomSummary, Space, SpaceMember, Topic, User } from "pserv-ts-types";
-export declare class ChatStateTracker {
-    private readonly client;
-    private readonly joinedSpaces;
-    private readonly joinedRooms;
-    private readonly spacesRoles;
-    private readonly roomsTopics;
-    private readonly topicsMessages;
-    private readonly spacesRooms;
-    private readonly spacesMembers;
-    private readonly roomsMembers;
-    private readonly deferredGetters;
-    private reconnecting;
-    private me;
-    constructor(client: WebSocketChatClient);
-    getMe(): Promise<User>;
-    getJoinedSpaces(): Promise<ObservableIndexedObjectCollection<Space>>;
-    getJoinedRooms(): Promise<ObservableIndexedObjectCollection<Room>>;
-    getSpaceRoles(spaceId: string): Promise<ObservableIndexedObjectCollection<Role> | null>;
-    getRoomTopics(roomId: string): Promise<ObservableIndexedObjectCollection<Topic> | null>;
-    getTopicMessages(topicId: string): Promise<ObservableIndexedObjectCollection<Message> | null>;
-    getSpaceRooms(spaceId: string): Promise<ObservableIndexedObjectCollection<RoomSummary> | null>;
-    getSpaceMembers(spaceId: string): Promise<ObservableIndexedObjectCollection<SpaceMember> | null>;
-    getRoomMembers(roomId: string): Promise<ObservableIndexedObjectCollection<RoomMember> | null>;
-    private deferredGetterReadiness;
-    private bind;
-    private createDeferredGetter;
-    private handleDisconnect;
-    private handleNewMessage;
-    private handleNewRole;
-    private handleNewRoom;
-    private handleNewTopic;
-    private addJoinedRoomTopics;
-    private handleRoleDeleted;
-    private handleRoomDeleted;
-    private handleRoomJoined;
-    private addJoinedRooms;
-    private handleRoomLeft;
-    private deleteJoinedRooms;
-    private handleRoomMemberJoined;
-    private handleRoomMemberLeft;
-    private handleRoomMembers;
-    private handleSession;
-    private handleSpaceDeleted;
-    private handleSpaceJoined;
-    private addJoinedSpaces;
-    private handleSpaceLeft;
-    private handleSpaceMemberJoined;
-    private handleSpaceMemberLeft;
-    private handleSpaceMembers;
-    private handleSpaceRooms;
-    private handleSpaceMemberUpdate;
-    private handleTopicDeleted;
-}