polfan-server-js-client 0.1.1 → 0.1.6

package/src/state-tracker/RoomsManager.ts

@@ -0,0 +1,272 @@
+import {IndexedCollection, ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
+import {
+    NewTopic,
+    Room, RoomDeleted,
+    RoomJoined, RoomLeft,
+    RoomMember, RoomMemberJoined, RoomMemberLeft, RoomMembers,
+    RoomMemberUpdated, RoomUpdated, Session, SpaceDeleted, SpaceLeft, SpaceMemberLeft,
+    SpaceMemberUpdated,
+    Topic,
+    TopicDeleted,
+    UserUpdated,
+} from "../types/src";
+import {ChatStateTracker} from "./ChatStateTracker";
+import {DeferredTask, PromiseRegistry} from "./AsyncUtils";
+import {MessagesManager} from "./MessagesManager";
+
+export class RoomsManager {
+    public readonly messages: MessagesManager;
+
+    private readonly list = new ObservableIndexedObjectCollection<Room>('id');
+    private readonly topics = new IndexedCollection<string, ObservableIndexedObjectCollection<Topic>>();
+    private readonly members = new IndexedCollection<string, ObservableIndexedObjectCollection<RoomMember>>();
+    private readonly deferredSession = new DeferredTask();
+    private readonly membersPromises = new PromiseRegistry();
+
+    public constructor(private tracker: ChatStateTracker) {
+        this.messages = new MessagesManager(tracker);
+
+        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('RoomUpdated', ev => this.handleRoomUpdated(ev));
+        this.tracker.client.on('RoomDeleted', ev => this.handleRoomDeleted(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('SpaceMemberLeft', ev => this.handleSpaceMemberLeft(ev));
+        this.tracker.client.on('SpaceMemberUpdated', ev => this.handleSpaceMemberUpdated(ev));
+        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('SpaceLeft', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('UserUpdated', ev => this.handleUserUpdated(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.membersPromises.notExist(roomId)) {
+            this.membersPromises.registerByFunction(async () => {
+                const result = await this.tracker.client.send('GetRoomMembers', {id: roomId});
+                if (result.error) {
+                    throw result.error;
+                }
+                this.handleRoomMembers(result.data);
+            }, roomId);
+        }
+
+        await this.membersPromises.get(roomId);
+        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;
+
+        if (! this.list.has(roomId)) {
+            // User is not in passed room.
+            return undefined;
+        }
+
+        const members = await this.getMembers(roomId);
+        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);
+    }
+
+    private deleteRoom(...roomIds: string[]): void {
+        this.list.delete(...roomIds);
+        this.members.delete(...roomIds);
+        this.membersPromises.forget(...roomIds);
+
+        for (const roomId of roomIds) {
+            const topicIds: string[] = this.topics.get(roomId)?.map(topic => topic.id) ?? [];
+            this.messages._deleteByTopicIds(roomId, ...topicIds);
+        }
+
+        this.topics.delete(...roomIds);
+    }
+
+    private deleteRoomsBySpaceId(spaceId: string): void {
+        this.deleteRoom(
+            ...this.list.findBy('spaceId', spaceId).map(room => room.id)
+        );
+    }
+
+    private handleSpaceMemberUpdated(ev: SpaceMemberUpdated): void {
+        // Update members of rooms related to this space
+        for (const room of this.list.findBy('spaceId', ev.spaceId).items) {
+            const roomMembers = this.members.get(room.id);
+
+            if (! roomMembers || ! roomMembers.has(ev.userId)) {
+                // Skip update if member list for this room is not loaded
+                // or user is not in room
+                continue;
+            }
+
+            const roomMember = roomMembers.get(ev.userId);
+            const user = roomMember.spaceMember.user;
+
+            // Update space member but first fill user object (it's null in event object)
+            roomMember.spaceMember = {...ev.member, user};
+            roomMembers.set(roomMember);
+        }
+    }
+
+    private handleSpaceMemberLeft(ev: SpaceMemberLeft): void {
+        this.list
+            .findBy('spaceId', ev.spaceId).items
+            .forEach(room => this.members.get(room.id)?.delete(ev.userId));
+    }
+
+    private handleRoomMemberUpdated(ev: RoomMemberUpdated): void {
+        if (! this.members.has(ev.roomId)) {
+            // We do not track member list for this room.
+            return;
+        }
+
+        const members = this.members.get(ev.roomId);
+        const member = members.get(ev.userId);
+        const newMember = ev.member;
+        const user = member.spaceMember?.user ?? member.user;
+
+        if (newMember.spaceMember) {
+            newMember.spaceMember.user = user;
+        } else {
+            newMember.user = user;
+        }
+
+        members.set(newMember);
+    }
+
+    private handleSpaceDeleted(ev: SpaceDeleted | SpaceLeft): void {
+        this.deleteRoomsBySpaceId(ev.id);
+    }
+
+    private handleTopicDeleted(ev: TopicDeleted): void {
+        const collection = this.topics.get(ev.location.roomId);
+        collection.delete(ev.location.topicId);
+
+        const room = this.list.get(ev.location.roomId);
+        if (room.defaultTopic?.id === ev.location.topicId) {
+            this.list.set({...room, defaultTopic: null});
+        }
+    }
+
+    private handleNewTopic(ev: NewTopic): void {
+        this.addJoinedRoomTopics(ev.roomId, 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.messages._handleNewTopics(roomId, ...topics);
+    }
+
+    private handleRoomJoined(ev: RoomJoined): void {
+        this.addJoinedRooms(ev.room);
+    }
+
+    private handleRoomUpdated(ev: RoomUpdated): void {
+        this.list.set({
+            ...this.list.get(ev.room.id),
+            name: ev.room.name,
+            description: ev.room.description,
+        } as Room);
+    }
+
+    private handleRoomDeleted(ev: RoomDeleted): void {
+        this.deleteRoom(ev.id);
+    }
+
+    private addJoinedRooms(...rooms: Room[]): void {
+        for (const room of rooms) {
+            if (room.defaultTopic) {
+                this.addJoinedRoomTopics(room.id, room.defaultTopic);
+            }
+        }
+        this.list.set(...rooms);
+    }
+
+    private handleRoomLeft(ev: RoomLeft): void {
+        this.deleteRoom(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): void {
+        this.list.deleteAll();
+        this.topics.deleteAll();
+        this.members.deleteAll();
+
+        this.addJoinedRooms(...ev.state.rooms);
+
+        this.deferredSession.resolve();
+    }
+
+    private handleUserUpdated(ev: UserUpdated): void {
+        this.members.items.forEach((members) => {
+            const member = members.get(ev.user.id);
+
+            if (! member) {
+                // Skip room; updated user is not here
+                return;
+            }
+
+            const newMember: RoomMember = {...member};
+
+            if (member.user) {
+                newMember.user = ev.user;
+            } else {
+                newMember.spaceMember.user = ev.user;
+            }
+
+            members.set(newMember);
+        });
+    }
+}

package/src/state-tracker/SpacesManager.ts

@@ -0,0 +1,267 @@
+import {ChatStateTracker} from "./ChatStateTracker";
+import {IndexedCollection, ObservableIndexedObjectCollection} from "../IndexedObjectCollection";
+import {
+    NewRole,
+    NewRoom,
+    Role,
+    RoleDeleted,
+    RoleUpdated,
+    RoomDeleted,
+    RoomSummary,
+    RoomUpdated,
+    Session,
+    Space,
+    SpaceDeleted,
+    SpaceJoined,
+    SpaceLeft,
+    SpaceMember,
+    SpaceMemberJoined,
+    SpaceMemberLeft,
+    SpaceMembers,
+    SpaceMemberUpdated,
+    SpaceRooms,
+    SpaceUpdated,
+    UserUpdated
+} from "../types/src";
+import {DeferredTask, PromiseRegistry} from "./AsyncUtils";
+import {reorderRolesOnPriorityUpdate} from "./functions";
+
+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 roomIdToSpaceId = new IndexedCollection<string, string>();
+    private readonly members = new IndexedCollection<string, ObservableIndexedObjectCollection<SpaceMember>>();
+    private readonly deferredSession = new DeferredTask();
+    private readonly roomsPromises = new PromiseRegistry();
+    private readonly membersPromises = new PromiseRegistry();
+
+    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('RoomUpdated', ev => this.handleRoomUpdated(ev));
+        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('SpaceUpdated', ev => this.handleSpaceUpdated(ev));
+        this.tracker.client.on('SpaceJoined', ev => this.handleSpaceJoined(ev));
+        this.tracker.client.on('SpaceLeft', ev => this.handleSpaceDeleted(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('UserUpdated', ev => this.handleUserUpdated(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.roomsPromises.notExist(spaceId)) {
+            this.roomsPromises.registerByFunction(async () => {
+                const result = await this.tracker.client.send('GetSpaceRooms', {id: spaceId});
+                if (result.error) {
+                    throw result.error;
+                }
+                this.handleSpaceRooms(result.data);
+            }, spaceId);
+        }
+
+        await this.roomsPromises.get(spaceId);
+        return this.rooms.get(spaceId);
+    }
+
+    /**
+     * Get collection of space members.
+     */
+    public async getMembers(spaceId: string): Promise<ObservableIndexedObjectCollection<SpaceMember> | undefined> {
+        if (this.membersPromises.notExist(spaceId)) {
+            this.membersPromises.registerByFunction(async () => {
+                const result = await this.tracker.client.send('GetSpaceMembers', {id: spaceId});
+                if (result.error) {
+                    throw result.error;
+                }
+                this.handleSpaceMembers(result.data);
+            }, spaceId);
+        }
+
+        await this.membersPromises.get(spaceId);
+        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;
+
+        if (! this.list.has(spaceId)) {
+            // User is not in passed space.
+            return undefined;
+        }
+
+        const members = await this.getMembers(spaceId);
+        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);
+        this.roomIdToSpaceId.set([ev.summary.id, ev.spaceId]);
+    }
+
+    private handleRoomUpdated(ev: RoomUpdated): void {
+        if (ev.room.spaceId && this.rooms.has(ev.room.spaceId)) {
+            const rooms = this.rooms.get(ev.room.spaceId);
+            rooms.set({
+                ...rooms.get(ev.room.id),
+                name: ev.room.name,
+                description: ev.room.description,
+            } as RoomSummary);
+        }
+    }
+
+    private async handleRoomDeleted(ev: RoomDeleted): Promise<void> {
+        const spaceId = this.roomIdToSpaceId.get(ev.id);
+
+        if (spaceId && this.rooms.has(spaceId)) {
+            this.rooms.get(spaceId).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 handleSpaceUpdated(ev: SpaceUpdated): void {
+        this.list.set({
+            ...this.list.get(ev.space.id),
+            name: ev.space.name,
+        } as Space);
+    }
+
+    private handleSpaceDeleted(ev: SpaceDeleted | SpaceLeft): void {
+        const roomIds = this.rooms.get(ev.id)?.map(item => item.id) ?? [];
+        this.roomIdToSpaceId.delete(...roomIds);
+
+        this.roles.delete(ev.id);
+        this.members.delete(ev.id);
+        this.membersPromises.forget(ev.id);
+        this.rooms.delete(ev.id);
+        this.roomsPromises.forget(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 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)) {
+            const members = this.members.get(ev.spaceId);
+            const member = members.get(ev.userId);
+            members.set({...ev.member, user: member.user});
+        }
+    }
+
+    private handleRoleUpdated(ev: RoleUpdated): void {
+        const roles = this.roles.get(ev.spaceId);
+        const oldRole = roles.get(ev.role.id);
+        const newRole = ev.role;
+        const rolesToUpdate = [newRole];
+
+        if (oldRole.priority !== newRole.priority) {
+            rolesToUpdate.push(
+                ...reorderRolesOnPriorityUpdate(roles.items, oldRole, newRole)
+            );
+        }
+
+        this.roles.get(ev.spaceId).set(...rolesToUpdate);
+    }
+
+    private handleSession(ev: Session): void {
+        this.list.deleteAll();
+        this.roles.deleteAll();
+        this.rooms.deleteAll();
+        this.members.deleteAll();
+        this.roomIdToSpaceId.deleteAll();
+
+        this.addJoinedSpaces(...ev.state.spaces);
+
+        this.deferredSession.resolve();
+    }
+
+    private handleUserUpdated(ev: UserUpdated): void {
+        this.members.items.forEach((members) => {
+            const member = members.get(ev.user.id);
+
+            if (! member) {
+                // Skip space; updated user is not here
+                return;
+            }
+
+            members.set({...member, user: ev.user});
+        });
+    }
+}

package/src/state-tracker/functions.ts

@@ -0,0 +1,25 @@
+import {Role} from "../types/src";
+
+export function reorderRolesOnPriorityUpdate(allRoles: Role[], oldRole: Role, updatedRole: Role): Role[] {
+    // If the priority has changed, adjust the rest of roles
+    const increased = (updatedRole.priority - oldRole.priority) > 0;
+    const decreased = ! increased;
+    const changedRoles: Role[] = [];
+
+    allRoles.forEach(role => {
+        if (role.id === updatedRole.id) {
+            // Skip the updated role
+            return;
+        }
+        if (increased && oldRole.priority <= role.priority) {
+            role.priority--;
+            changedRoles.push(role);
+        }
+        if (decreased && updatedRole.priority <= role.priority) {
+            role.priority++;
+            changedRoles.push(role);
+        }
+    });
+
+    return changedRoles;
+}

package/src/types/README.md

@@ -0,0 +1,2 @@
+# pserv-ts-types
+TypeScript type definitions for PServ APIs protocol.

package/src/types/package-lock.json

@@ -0,0 +1,31 @@
+{
+  "name": "pserv-ts-types",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "typescript": "^5.0.2"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz",
+      "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw==",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=12.20"
+      }
+    }
+  },
+  "dependencies": {
+    "typescript": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.0.2.tgz",
+      "integrity": "sha512-wVORMBGO/FAs/++blGNeAVdbNKtIh1rbBL2EyQ1+J9lClJ93KiiKe8PmFIVdXhHcyv44SL9oglmfeSsndo0jRw=="
+    }
+  }
+}

package/src/types/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "pserv-ts-types",
+  "version": "0.0.30",
+  "description": "TypeScript type definitions for PServ APIs protocol.",
+  "author": "Jarosław Żak",
+  "license": "MIT",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.2"
+  }
+}