polfan-server-js-client 0.1.2 → 0.1.7

package/src/Permissions.ts

@@ -0,0 +1,46 @@
+export enum Layer {
+    Global,
+    Space,
+    Room,
+    Topic,
+}
+
+export class PermissionDefinition {
+    value: number;
+    maxLayer: Layer;
+}
+
+export class Permissions {
+    public static readonly list = {
+        Root: {value: 1 << 0, maxLayer: Layer.Room},
+        CreateSpaces: {value: 1 << 1, maxLayer: Layer.Global},
+        ManageSpace: {value: 1 << 2, maxLayer: Layer.Space},
+        ManageSpaceRoles: {value: 1 << 3, maxLayer: Layer.Space},
+        ManageRoom: {value: 1 << 4, maxLayer: Layer.Room},
+        ManageTopic: {value: 1 << 5, maxLayer: Layer.Topic},
+        ManageSpaceMembers: {value: 1 << 6, maxLayer: Layer.Space},
+        ManageRoomMembers: {value: 1 << 7, maxLayer: Layer.Room},
+        CreateMessages: {value: 1 << 8, maxLayer: Layer.Topic},
+        ManagePermissions: {value: 1 << 9, maxLayer: Layer.Topic},
+        CreateSpaceRooms: {value: 1 << 10, maxLayer: Layer.Space},
+        ManageSpaceRooms: {value: 1 << 11, maxLayer: Layer.Space},
+    };
+
+    public static getNames(): (keyof typeof this.list)[] {
+        return Object.keys(this.list) as any;
+    }
+
+    public static getByName(name: keyof typeof this.list): PermissionDefinition | undefined {
+        return this.list[name];
+    }
+
+    public static canBeDefinedOnLayer(permissionName: keyof typeof this.list, layer: Layer): boolean {
+        const def = this.getByName(permissionName);
+
+        if (! def) {
+            throw new Error(`Invalid permission name: ${permissionName}`);
+        }
+
+        return layer <= this.getByName(permissionName).maxLayer;
+    }
+}

package/src/WebApiChatClient.ts

@@ -1,6 +1,6 @@
 import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
 import {ObservableInterface} from "./EventTarget";
-import {Envelope} from "pserv-ts-types";
+import {Envelope} from "./types/src";
 
 export interface WebApiChatClientOptions {
     url: string;

package/src/WebSocketChatClient.ts

@@ -1,7 +1,7 @@
 import {ObservableInterface} from "./EventTarget";
 import {AbstractChatClient, CommandResult, CommandsMap} from "./AbstractChatClient";
-import {Envelope} from "pserv-ts-types";
-import {ChatStateTracker} from "./ChatStateTracker";
+import {ChatStateTracker} from "./state-tracker/ChatStateTracker";
+import {Envelope} from "./types/src";
 
 export interface WebSocketClientOptions {
     url: string;

package/src/index.ts

@@ -7,10 +7,15 @@ import {
     ObservableIndexedObjectCollection
 } from "./IndexedObjectCollection";
 import { AuthClient } from "./AuthClient";
+import { Permissions, PermissionDefinition, Layer } from "./Permissions";
+import * as ChatTypes from './types/src';
 
 export {
     IndexedCollection, ObservableIndexedCollection,
     IndexedObjectCollection, ObservableIndexedObjectCollection,
+    Permissions, PermissionDefinition, Layer,
     WebSocketChatClient, WebApiChatClient,
-    AuthClient
-};
+    AuthClient,
+};
+
+export type {ChatTypes};

package/src/state-tracker/AsyncUtils.ts

@@ -0,0 +1,38 @@
+import {IndexedCollection} from "../IndexedObjectCollection";
+
+export class DeferredTask {
+    public readonly promise: Promise<void>;
+    public resolve: () => void;
+
+    public constructor() {
+        this.promise = new Promise<void>((resolve) => this.resolve = resolve);
+    }
+}
+
+export class PromiseRegistry {
+    private promises = new IndexedCollection<string, Promise<any>>();
+
+    public register<T = any>(promise: Promise<T>, key: string): void {
+        this.promises.set([key, promise]);
+    }
+
+    public registerByFunction(fn: () => Promise<any>, key: string): void {
+        this.register(fn(), key);
+    }
+
+    public get<T = any>(key: string): Promise<T> | undefined {
+        return this.promises.get(key);
+    }
+
+    public has(key: string): boolean {
+        return this.promises.has(key);
+    }
+
+    public notExist(key: string): boolean {
+        return ! this.has(key);
+    }
+
+    public forget(...keys: string[]): void {
+        this.promises.delete(...keys);
+    }
+}

package/src/state-tracker/ChatStateTracker.ts

@@ -0,0 +1,42 @@
+import {WebSocketChatClient} from "../WebSocketChatClient";
+import {Session, User} from "../types/src";
+import {RoomsManager} from "./RoomsManager";
+import {SpacesManager} from "./SpacesManager";
+import {PermissionsManager} from "./PermissionsManager";
+import {DeferredTask} from "./AsyncUtils";
+
+export class ChatStateTracker {
+    /**
+     * State of your permissions.
+     */
+    public readonly permissions = new PermissionsManager(this);
+    /**
+     * State of the rooms you are in.
+     */
+    public readonly rooms: RoomsManager = new RoomsManager(this);
+    /**
+     * State of the spaces you are in.
+     */
+    public readonly spaces = new SpacesManager(this);
+
+    private _me: User = null;
+    private readonly deferredSession = new DeferredTask();
+
+    public constructor(public readonly client: WebSocketChatClient) {
+        this.client.on('Session', ev => this.handleSession(ev));
+    }
+
+    public get me(): User | null {
+        return this._me;
+    }
+
+    public async getMe(): Promise<User> {
+        await this.deferredSession.promise;
+        return this._me;
+    }
+
+    private handleSession(ev: Session): void {
+        this._me = ev.user;
+        this.deferredSession.resolve();
+    }
+}

package/src/state-tracker/MessagesManager.ts

@@ -0,0 +1,168 @@
+import {ChatStateTracker} from "./ChatStateTracker";
+import {AckReport, AckReports, ChatLocation, Message, NewMessage, Topic} from "../types/src";
+import {
+    IndexedCollection,
+    ObservableIndexedObjectCollection
+} from "../IndexedObjectCollection";
+
+export const getCombinedId = (location: ChatLocation) => (location.roomId ?? '') + (location.topicId ?? '');
+
+export class MessagesManager {
+    // Temporary not lazy loaded; server must implement GetTopicMessages command.
+    private readonly list = new IndexedCollection<string, ObservableIndexedObjectCollection<Message>>();
+    private readonly acks: IndexedCollection<string, ObservableIndexedObjectCollection<AckReport>> = new IndexedCollection();
+
+    public constructor(private tracker: ChatStateTracker) {
+        this.tracker.client.on('NewMessage', ev => this.handleNewMessage(ev));
+        this.tracker.client.on('AckReports', ev => this.handleAckReports(ev));
+    }
+
+    /**
+     * Get collection of the messages written in topic.
+     */
+    public async get(location: ChatLocation): Promise<ObservableIndexedObjectCollection<Message> | undefined> {
+        return this.list.get(getCombinedId(location));
+    }
+
+    /**
+     * Cache ack reports for all joined rooms in a space and fetch them in bulk if necessary.
+     * Then you can get the reports using getRoomAckReports().
+     * @see getRoomAckReports
+     */
+    public async cacheSpaceAckReports(spaceId: string): Promise<void> {
+        if (! (await this.tracker.spaces.get()).has(spaceId)) {
+            throw new Error(`You are not in space ${spaceId}`);
+        }
+
+        const roomIds = (await this.tracker.rooms.get()).findBy('spaceId', spaceId).map(room => room.id);
+        const missingRoomIds = roomIds.filter(roomId => ! this.acks.has(roomId));
+
+        if (missingRoomIds.length) {
+            // If we don't have ack reports for all rooms in space, fetch them
+            const result = await this.tracker.client.send('GetAckReports', {location: {spaceId}});
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            missingRoomIds.forEach(roomId => {
+                const reports = result.data.reports.filter(report => report.roomId === roomId);
+                this.acks.set([roomId, new ObservableIndexedObjectCollection('topicId', reports)]);
+            });
+        }
+    }
+
+    /**
+     * Get ack reports for the given room. Undefined if you are not in the room.
+     * @param roomId
+     */
+    public async getRoomAckReports(roomId: string): Promise<ObservableIndexedObjectCollection<AckReport> | undefined> {
+        const room = (await this.tracker.rooms.get()).get(roomId);
+
+        if (! room) {
+            return undefined;
+        }
+
+        if (! this.acks.has(roomId)) {
+            const result = await this.tracker.client.send('GetAckReports', {location: {roomId}});
+
+            if (result.error) {
+                throw result.error;
+            }
+
+            this.acks.set([roomId, new ObservableIndexedObjectCollection('topicId', result.data.reports)]);
+        }
+
+        return this.acks.get(roomId);
+    }
+
+    /**
+     * For internal use. If you want to delete the message, execute a proper command on client object.
+     * @internal
+     */
+    public _deleteByTopicIds(roomId: string, ...topicIds: string[]): void {
+        this.list.delete(...topicIds.map(topicId => getCombinedId({roomId, topicId})));
+        this.acks.get(roomId)?.delete(...topicIds);
+    }
+
+    /**
+     * For internal use. If you want to add new topic, execute a proper command on client object.
+     * @internal
+     */
+    public _handleNewTopics(roomId: string, ...newTopics: Topic[]):void {
+        for (const newTopic of newTopics) {
+            const newTopicCombinedId = getCombinedId({roomId, topicId: newTopic.id});
+
+            this.list.set([newTopicCombinedId, new ObservableIndexedObjectCollection<Message>('id')]);
+
+            // If new topic refers to some message from this room, update other structures
+            if (newTopic.messageRef) {
+                const refTopicCombinedId = getCombinedId({roomId, topicId: newTopic.messageRef.topicId});
+                const refTopicMessages = this.list.get(refTopicCombinedId);
+                const refMessage = refTopicMessages?.get(newTopic.messageRef.messageId);
+
+                if (refMessage) {
+                    // Update referenced topic ID in message
+                    refTopicMessages.set({...refMessage, topicRef: newTopic.id});
+                }
+            }
+        }
+
+        this.createAckReportsForNewTopics(roomId, newTopics);
+    }
+
+    private handleNewMessage(ev: NewMessage): void {
+        this.list.get(getCombinedId(ev.location)).set(ev.message);
+        this.updateLocallyAckReportOnNewMessage(ev);
+    }
+
+    private handleAckReports(ev: AckReports): void {
+        ev.reports.forEach(report => {
+            const ackReports = this.acks.get(report.roomId);
+            if (ackReports) {
+                ackReports.set(report);
+            }
+        });
+    }
+
+    private createAckReportsForNewTopics(roomId: string, topics: Topic[]): void {
+        const ackReports = this.acks.get(roomId);
+
+        if (! ackReports) {
+            // If we don't follow ack reports for this room, skip
+            return;
+        }
+
+        const newReports: AckReport[] = topics.map(topic => ({
+            roomId, topicId: topic.id, lastAckMessageId: null, missed: 0, missedMoreThan: null
+        }));
+
+        ackReports.set(...newReports);
+    }
+
+    private updateLocallyAckReportOnNewMessage(ev: NewMessage): void {
+        const ackReports = this.acks.get(ev.location.roomId);
+
+        if (! ackReports) {
+            // If we don't follow ack reports for this room, skip
+            return;
+        }
+
+        const isMe = ev.message.author.id === this.tracker.me?.id;
+        const currentAckReport = ackReports.get(ev.location.topicId);
+        let update: Partial<AckReport>;
+
+        if (isMe) {
+            // Reset missed messages count if new message is authored by me
+            update = {missed: 0, missedMoreThan: null, lastAckMessageId: ev.message.id};
+        } else {
+            // ...add 1 otherwise
+            update = {
+                missed: currentAckReport.missed === null ? null : currentAckReport.missed + 1,
+                missedMoreThan: currentAckReport.missedMoreThan === null ? null : currentAckReport.missedMoreThan,
+            };
+        }
+
+        ackReports.set({...currentAckReport, ...update});
+    }
+}

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