polfan-server-js-client 0.1.2 → 0.1.6

package/src/state-tracker/PermissionsManager.ts

@@ -0,0 +1,306 @@
+import {ChatStateTracker} from "./ChatStateTracker";
+import {
+    ChatLocation,
+    PermissionOverwrites,
+    PermissionOverwritesUpdated,
+    PermissionOverwritesValue,
+    RoleDeleted,
+    RoomDeleted,
+    RoomLeft, RoomMember, RoomMemberUpdated,
+    SpaceDeleted,
+    SpaceLeft, SpaceMember,
+    SpaceMemberUpdated,
+    TopicDeleted,
+} from "../types/src";
+import {EventHandler, EventTarget} from "../EventTarget";
+import {IndexedCollection} from "../IndexedObjectCollection";
+import {Permissions} from "../Permissions";
+import {PromiseRegistry} from "./AsyncUtils";
+
+const getOvId = (
+    location: ChatLocation,
+    target?: PermissionOverwrites['target'],
+    targetId?: PermissionOverwrites['targetId'],
+) => (location.spaceId ?? '') + (location.roomId ?? '') + (location.topicId ?? '') + (target ?? '') + (targetId ?? '');
+
+const getOvIdByObject = (overwrites: PermissionOverwrites | PermissionOverwritesUpdated): string => getOvId(
+    overwrites.location, overwrites.target, overwrites.targetId
+);
+
+interface CheckPermissionsResult {
+    /**
+     * @deprecated Use `hasAll` instead.
+     */
+    ok: boolean;
+    hasAll: boolean;
+    hasAny: boolean;
+    missing: string[];
+}
+
+export class PermissionsManager extends EventTarget {
+    private readonly overwrites = new IndexedCollection<string, PermissionOverwrites>();
+    private readonly overwritesPromises = new PromiseRegistry();
+
+    public constructor(private tracker: ChatStateTracker) {
+        super();
+        this.tracker.client.on('PermissionOverwrites', ev => this.handlePermissionOverwrites(ev));
+        this.tracker.client.on('PermissionOverwritesUpdated', ev => this.handlePermissionOverwrites(ev));
+        this.tracker.client.on('SpaceDeleted', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('SpaceLeft', ev => this.handleSpaceDeleted(ev));
+        this.tracker.client.on('RoomDeleted', ev => this.handleRoomDeleted(ev));
+        this.tracker.client.on('RoomLeft', ev => this.handleRoomDeleted(ev));
+        this.tracker.client.on('TopicDeleted', ev => this.handleTopicDeleted(ev));
+        this.tracker.client.on('RoleDeleted', ev => this.handleRoleDeleted(ev));
+        this.tracker.client.on('SpaceMemberUpdated', ev => this.handleSpaceMemberUpdated(ev));
+        this.tracker.client.on('RoomMemberUpdated', ev => this.handleRoomMemberUpdated(ev));
+    }
+
+    public async getOverwrites(
+        location: ChatLocation,
+        target: PermissionOverwrites['target'],
+        targetId: PermissionOverwrites['targetId'],
+    ): Promise<PermissionOverwrites | undefined> {
+        this.validateLocation(location);
+
+        const id = getOvId(location, target, targetId);
+
+        if (this.overwritesPromises.notExist(id)) {
+            this.overwritesPromises.registerByFunction(async () => {
+                const result = await this.tracker.client.send(
+                    'GetPermissionOverwrites',
+                    {location, target, targetId},
+                );
+                if (result.error) {
+                    throw result.error;
+                }
+                this.handlePermissionOverwrites(result.data);
+            }, id);
+        }
+
+        await this.overwritesPromises.get(id);
+        return this.overwrites.get(id);
+    }
+
+    public on(eventName: 'change', handler: EventHandler<any>): this {
+        return super.on(eventName, handler);
+    }
+
+    public async check(
+        permissionNames: (keyof typeof Permissions.list)[],
+        location: ChatLocation,
+    ): Promise<CheckPermissionsResult> {
+        if (! permissionNames.length) {
+            throw new Error('Permission names array cannot be empty');
+        }
+
+        const ownedPermissions = await this.calculatePermissions(location);
+        const missing: string[] = [];
+
+        permissionNames.forEach(name => {
+            if (~ ownedPermissions & Permissions.getByName(name).value) {
+                missing.push(name as string);
+            }
+        });
+
+        return {
+            ok: missing.length === 0,
+            hasAll: missing.length === 0,
+            hasAny: missing.length < permissionNames.length,
+            missing,
+        };
+    }
+
+    public async calculatePermissions(location: ChatLocation): Promise<number> {
+        this.validateLocation(location);
+
+        const userId = (await this.tracker.getMe()).id;
+        const [spaceMember, roomMember] = await this.fetchMembersOrFail(location);
+        const userRoles: string[] = [...(spaceMember?.roles ?? []), ...(roomMember?.roles ?? [])];
+        const promises: Promise<PermissionOverwritesValue>[] = [
+            // Global user overwrites
+            this.getOverwrites({}, 'User', userId).then(v => v.overwrites),
+        ];
+
+        if (location.spaceId && (await this.tracker.spaces.get())?.has(location.spaceId)) {
+            const filterLocation: ChatLocation = {spaceId: location.spaceId};
+            promises.push(this.collectRoleOverwrites(filterLocation, userRoles));
+            promises.push(this.getOverwrites(filterLocation, 'User', userId).then(v => v.overwrites));
+        }
+
+        if (location.roomId && (await this.tracker.rooms.get())?.has(location.roomId)) {
+            const filterLocation: ChatLocation = {spaceId: location.spaceId, roomId: location.roomId};
+            if (userRoles.length) {
+                promises.push(this.collectRoleOverwrites(filterLocation, userRoles));
+            }
+            promises.push(this.getOverwrites(filterLocation, 'User', userId).then(v => v.overwrites));
+        }
+
+        if (location.topicId && (await this.tracker.rooms.getTopics(location.roomId))?.has(location.topicId)) {
+            if (userRoles.length) {
+                promises.push(this.collectRoleOverwrites(location, userRoles));
+            }
+            promises.push(this.getOverwrites(location, 'User', userId).then(v => v.overwrites));
+        }
+
+        return this.resolveOverwritesHierarchy(await Promise.all(promises));
+    }
+
+    private handlePermissionOverwrites(ev: PermissionOverwritesUpdated | PermissionOverwrites): void {
+        this.overwrites.set([getOvIdByObject(ev), ev]);
+        this.emit('change');
+    }
+
+    private handleSpaceDeleted(ev: SpaceDeleted | SpaceLeft): void {
+        const ids = this.deleteOverwritesByIdPrefix(getOvId({spaceId: ev.id}));
+        this.overwritesPromises.forget(...ids);
+    }
+
+    private async handleRoomDeleted(ev: RoomDeleted | RoomLeft): Promise<void> {
+        const room = (await this.tracker.rooms.get()).get(ev.id);
+        if (room) {
+            const ids = this.deleteOverwritesByIdPrefix(getOvId({spaceId: room.spaceId, roomId: room.id}));
+            this.overwritesPromises.forget(...ids);
+        }
+    }
+
+    private handleTopicDeleted(ev: TopicDeleted): void {
+        const ids = this.deleteOverwritesByIdPrefix(getOvId(ev.location));
+        this.overwritesPromises.forget(...ids);
+    }
+
+    private handleRoleDeleted(ev: RoleDeleted): void {
+        const ids = this.deleteOverwritesByIdPrefix(getOvId({spaceId: ev.spaceId}, 'Role', ev.id));
+        this.overwritesPromises.forget(...ids);
+    }
+
+    private handleSpaceMemberUpdated(ev: SpaceMemberUpdated): void {
+        if (ev.userId === this.tracker.me?.id) {
+            // User roles in space could potentially have changed
+            this.emit('change');
+        }
+    }
+
+    private handleRoomMemberUpdated(ev: RoomMemberUpdated): void {
+        if (ev.userId === this.tracker.me?.id) {
+            // User roles in room could potentially have changed
+            this.emit('change');
+        }
+    }
+
+    /**
+     * @return Matched and deleted ids
+     */
+    private deleteOverwritesByIdPrefix(prefix: string): string[] {
+        const ids: string[] = [];
+        this.overwrites.items.forEach((overwrites) => {
+            const id = getOvIdByObject(overwrites);
+            if (id.startsWith(prefix)) {
+                ids.push(id);
+                this.overwrites.delete(id);
+            }
+        });
+        return ids;
+    }
+
+    private async collectRoleOverwrites(
+        location: ChatLocation,
+        userRoles: string[],
+    ): Promise<PermissionOverwritesValue> {
+        const roleOverwrites = await Promise.all(userRoles.map(
+            roleId => this.getOverwrites(location, 'Role', roleId)
+        ));
+
+        return this.resolveOverwritesFromRolesByOrder(location.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 ?? 0,
+                    currentValue.overwrites.deny?.toString(2).length ?? 0,
+                ),
+            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 & Permissions.getByName('Root').value) {
+                return this.getRootAccessValue();
+            }
+
+            result = (result & ~value.deny) | value.allow;
+        }
+
+        return result;
+    }
+
+    private getRootAccessValue(): number {
+        let result = 0;
+
+        for (const name of Permissions.getNames()) {
+            result |= Permissions.getByName(name).value;
+        }
+
+        return result;
+    }
+
+    private async fetchMembersOrFail(location: ChatLocation): Promise<[SpaceMember | null, RoomMember | null]> {
+        const results = await Promise.all([
+            location.spaceId ? this.tracker.spaces.getMe(location.spaceId) : null,
+            location.roomId ? this.tracker.rooms.getMe(location.roomId) : null,
+        ]);
+
+        const spaceFail = location.spaceId && ! results[0];
+        const roomFail = location.roomId && ! results[1];
+
+        if (spaceFail || roomFail) {
+            const layer = spaceFail ? `space (${location.spaceId})` : `room (${location.roomId})`;
+            throw new Error(`Attempting to calculate permissions for a ${layer} that the user does not belong to`);
+        }
+
+        return results;
+    }
+
+    private validateLocation(location: ChatLocation): void {
+        if (location.topicId && ! location.roomId) {
+            throw new Error('Corrupted arguments hierarchy');
+        }
+    }
+}

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);
+        });
+    }
+}