polfan-server-js-client 0.1.24 → 0.1.25

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> | null> {
+        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 | null> {
+        const userId = (await this.tracker.getMe()).id;
+        const members = await this.getMembers(roomId);
+
+        if (! members) {
+            // User is not in passed room.
+            return null;
+        }
+
+        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> | null> {
+        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> | null> {
+        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> | null> {
+        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> | null> {
+        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> | null> {
+        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 | null> {
+        const userId = (await this.tracker.getMe()).id;
+        const members = await this.getMembers(spaceId);
+
+        if (! members) {
+            // User is not in passed space.
+            return null;
+        }
+
+        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;
-}