@eleven-am/pondsocket 0.1.57 → 0.1.58

package/src/channel/channel.ts

@@ -1,305 +0,0 @@
-import { EventRequest } from './eventRequest';
-import { EventResponse } from './eventResponse';
-import { MiddlewareFunction } from '../abstracts/middleware';
-import { SystemSender, ServerActions, ChannelReceiver, ErrorTypes } from '../enums';
-import { ChannelError } from '../errors/pondError';
-import { PresenceEngine } from '../presence/presence';
-import { Subject } from '../subjects/subject';
-import {
-    PondMessage,
-    PondAssigns,
-    PondPresence,
-    UserAssigns,
-    ChannelEvent,
-    ChannelReceivers,
-    ClientMessage,
-    UserData,
-// eslint-disable-next-line import/no-unresolved
-} from '../types';
-
-type ChannelSenders = SystemSender.CHANNEL | string;
-
-export type InternalChannelEvent = ChannelEvent & {
-    recipients: string[];
-}
-
-export type BroadcastEvent = Omit<InternalChannelEvent, 'action' | 'payload'> & {
-    action: ServerActions.BROADCAST;
-    sender: ChannelSenders;
-    payload: PondMessage;
-}
-
-export type ParentEngine = {
-    destroyChannel: () => void;
-    execute: MiddlewareFunction<EventRequest<string>, EventResponse>;
-}
-
-export class ChannelEngine {
-    public readonly name: string;
-
-    readonly #receiver: Subject<InternalChannelEvent>;
-
-    #presenceEngine: PresenceEngine | undefined;
-
-    readonly #users: Map<string, PondAssigns>;
-
-    readonly #parentEngine: ParentEngine;
-
-    constructor (name: string, parent: ParentEngine) {
-        this.name = name;
-        this.#receiver = new Subject<InternalChannelEvent>();
-        this.#users = new Map<string, PondAssigns>();
-        this.#parentEngine = parent;
-    }
-
-    /**
-     * @desc Adds a user to the channel
-     * @param userId - The id of the user to add
-     * @param assigns - The assigns to add to the user
-     * @param onMessage - The callback to call when a message is received
-     */
-    public addUser (userId: string, assigns: PondAssigns, onMessage: (event: ChannelEvent) => void) {
-        const oldUser = this.#users.get(userId);
-
-        if (oldUser) {
-            const message = `ChannelEngine: User with id ${userId} already exists in channel ${this.name}`;
-            const code = 400;
-
-            throw new ChannelError(message, code, this.name);
-        }
-
-        this.#users.set(userId, assigns);
-
-        return this.#subscribe(userId, onMessage);
-    }
-
-    /**
-     * @desc Removes a user from the channel
-     * @param userId - The id of the user to remove
-     * @param graceful - Whether to remove the user gracefully or not
-     */
-    public removeUser (userId: string, graceful = false) {
-        const user = this.#users.get(userId);
-
-        if (user) {
-            this.#users.delete(userId);
-            this.#receiver.unsubscribe(userId);
-            this.#presenceEngine?.removePresence(userId, graceful);
-
-            if (this.#users.size === 0) {
-                this.#parentEngine.destroyChannel();
-            }
-        } else if (!graceful) {
-            throw new ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
-        }
-    }
-
-    /**
-     * @desc Kicks a user from the channel
-     * @param userId - The id of the user to kick
-     * @param reason - The reason for kicking the user
-     */
-    public kickUser (userId: string, reason: string) {
-        this.sendMessage(SystemSender.CHANNEL, [userId], ServerActions.SYSTEM, 'kicked_out', {
-            message: reason ?? 'You have been kicked out of the channel',
-        });
-        this.removeUser(userId);
-        this.sendMessage(SystemSender.CHANNEL, ChannelReceiver.ALL_USERS, ServerActions.SYSTEM, 'kicked', {
-            userId,
-            reason,
-        });
-    }
-
-    /**
-     * @desc Self destructs the channel
-     * @param reason - The reason for self-destructing the channel
-     */
-    public destroy (reason: string) {
-        this.sendMessage(SystemSender.CHANNEL, ChannelReceiver.ALL_USERS, ServerActions.ERROR, 'destroyed', {
-            message: reason ?? 'Channel has been destroyed',
-        });
-        this.#parentEngine.destroyChannel();
-        this.#users.forEach((_, userId) => this.#receiver.unsubscribe(userId));
-    }
-
-    /**
-     * @desc Updates a user's assigns
-     * @param userId - The id of the user to update
-     * @param assigns - The new assigns of the user
-     */
-    public updateAssigns (userId: string, assigns: PondAssigns) {
-        const user = this.#users.get(userId);
-
-        if (user) {
-            this.#users.set(userId, {
-                ...user,
-                ...assigns,
-            });
-        } else {
-            throw new ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
-        }
-    }
-
-    /**
-     * @desc Gets the data of a user
-     * @param userId - The id of the user to get
-     */
-    public getUserData (userId: string): UserData | undefined {
-        const assigns = this.#users.get(userId);
-        const presence = this.#presenceEngine ? this.#presenceEngine.getUserPresence(userId) : {};
-
-        if (assigns) {
-            return {
-                assigns,
-                id: userId,
-                presence: presence || {},
-            };
-        }
-
-        return undefined;
-    }
-
-    /**
-     * @desc Gets the assign data of all users
-     */
-    public getAssigns (): UserAssigns {
-        const assigns: UserAssigns = {};
-
-        this.#users.forEach((value, key) => {
-            assigns[key] = value;
-        });
-
-        return assigns;
-    }
-
-    /**
-     * @desc Sends a message to a specified set of users, from a specified sender
-     * @param sender - The sender of the message
-     * @param recipient - The users to send the message to
-     * @param action - The action of the message
-     * @param event - The event name
-     * @param payload - The payload of the message
-     * @private
-     */
-    public sendMessage (sender: ChannelSenders, recipient: ChannelReceivers, action: ServerActions, event: string, payload: PondMessage) {
-        if (!this.#users.has(sender) && sender !== SystemSender.CHANNEL) {
-            throw new ChannelError(`ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`, 404, this.name);
-        }
-
-        const eventMessage = {
-            recipients: this.#getUsersFromRecipients(recipient, sender),
-            channelName: this.name,
-            action,
-            payload,
-            event,
-        } as InternalChannelEvent;
-
-        this.#receiver.publish(eventMessage);
-    }
-
-    /**
-     * @desc Handles a message from a user
-     * @param userId - The id of the user who sent the message
-     * @param message - The message received
-     */
-    public broadcastMessage (userId: string, message: ClientMessage) {
-        if (!this.#users.has(userId)) {
-            throw new ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
-        }
-
-        const responseEvent: BroadcastEvent = {
-            sender: userId,
-            event: message.event,
-            payload: message.payload,
-            action: ServerActions.BROADCAST,
-            channelName: this.name,
-            recipients: this.#getUsersFromRecipients(message.addresses || ChannelReceiver.ALL_USERS, userId),
-        };
-
-        const request = new EventRequest(responseEvent, this);
-        const response = new EventResponse(responseEvent, this);
-
-        this.#parentEngine.execute(request, response, () => {
-            this.sendMessage(SystemSender.CHANNEL, [userId], ServerActions.ERROR, ErrorTypes.HANDLER_NOT_FOUND, {
-                message: 'A handler did not respond to the event',
-                code: 404,
-            });
-        });
-    }
-
-    /**
-     * @desc Begins tracking a user's presence
-     * @param userId - The id of the user to track
-     * @param presence - The initial presence of the user
-     */
-    public trackPresence (userId: string, presence: PondPresence) {
-        if (!this.#users.has(userId)) {
-            throw new ChannelError(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`, 404, this.name);
-        }
-
-        this.#presenceEngine = this.#presenceEngine ?? new PresenceEngine(this);
-        this.#presenceEngine.trackPresence(userId, presence);
-    }
-
-    /**
-     * @desc Gets the presence engine for the channel
-     */
-    public get presenceEngine () {
-        return this.#presenceEngine;
-    }
-
-    /**
-     * @desc Gets the number of users in the channel
-     */
-    public get size () {
-        return this.#users.size;
-    }
-
-    /**
-     * @desc Subscribes a user to the channel
-     * @param userId - The id of the user to subscribe
-     * @param onMessage - The callback to call when a message is received
-     * @private
-     */
-    #subscribe (userId: string, onMessage: (event: ChannelEvent) => void) {
-        this.#receiver.subscribeWith(userId, ({ recipients, ...event }) => {
-            if (recipients.includes(userId)) {
-                onMessage(event);
-            }
-        });
-    }
-
-    /**
-     * @desc Gets the users from a set of recipients
-     * @param recipients - The recipients to get the users from
-     * @param sender - The sender of the message
-     * @private
-     */
-    #getUsersFromRecipients (recipients: ChannelReceivers, sender: ChannelSenders): string[] {
-        const allUsers = Array.from(this.#users.keys());
-        let users: string[];
-
-        switch (recipients) {
-            case ChannelReceiver.ALL_USERS:
-                users = allUsers;
-                break;
-            case ChannelReceiver.ALL_EXCEPT_SENDER:
-                if (sender === SystemSender.CHANNEL) {
-                    throw new ChannelError(`ChannelEngine: Cannot use ${ChannelReceiver.ALL_EXCEPT_SENDER} with ${SystemSender.CHANNEL}`, 500, this.name);
-                }
-                users = allUsers.filter((user) => user !== sender);
-                break;
-            default:
-                const absentUsers = recipients.filter((user) => !allUsers.includes(user));
-
-                if (absentUsers.length > 0) {
-                    throw new ChannelError(`ChannelEngine: Users ${absentUsers.join(', ')} are not in channel ${this.name}`, 400, this.name);
-                }
-
-                users = recipients;
-                break;
-        }
-
-        return users;
-    }
-}

package/src/channel/eventRequest.test.ts

@@ -1,37 +0,0 @@
-import { EventRequest } from './eventRequest';
-import { createChannelEngine, createChannelEvent } from './eventResponse.test';
-
-describe('ChannelRequest', () => {
-    it('should create a new ChannelRequest', () => {
-        const channelEngine = createChannelEngine();
-        const event = createChannelEvent(channelEngine.name);
-        const channelRequest = new EventRequest(event, channelEngine);
-
-        expect(channelRequest).toBeDefined();
-    });
-
-    it('should return the payload', () => {
-        const channelEngine = createChannelEngine();
-        const event = createChannelEvent(channelEngine.name);
-        const channelRequest = new EventRequest(event, channelEngine);
-
-        channelRequest._parseQueries('event');
-
-        expect(channelRequest.event.payload).toEqual(event.payload);
-    });
-
-    it('should return the user', () => {
-        const channelEngine = createChannelEngine();
-        const event = createChannelEvent(channelEngine.name);
-        const channelRequest = new EventRequest(event, channelEngine);
-
-        // because the user in the event does not exist in the channel, this should throw an error
-        expect(() => channelRequest.user).toThrow();
-
-        // add the user to the channel
-        channelEngine.addUser(event.sender, { assign: 'assign' }, () => {});
-
-        // now the user should be returned
-        expect(channelRequest.user).toEqual(channelEngine.getUserData(event.sender));
-    });
-});

package/src/channel/eventRequest.ts

@@ -1,27 +0,0 @@
-import { ChannelEngine, BroadcastEvent } from './channel';
-import { AbstractRequest } from '../abstracts/abstractRequest';
-import { ChannelError } from '../errors/pondError';
-// eslint-disable-next-line import/no-unresolved
-import { UserData } from '../types';
-
-export class EventRequest<Path extends string> extends AbstractRequest<Path> {
-    private readonly _internalEvent: BroadcastEvent;
-
-    constructor (event: BroadcastEvent, engine: ChannelEngine) {
-        super(event.event, engine, event.payload);
-        this._internalEvent = event;
-    }
-
-    public get user (): UserData {
-        const assigns = this._engine.getUserData(this._internalEvent.sender);
-
-        if (!assigns) {
-            const message = `ChannelRequest: User with id ${this._internalEvent.sender} does not exist in channel ${this._engine.name}`;
-            const code = 404;
-
-            throw new ChannelError(message, code, this._engine.name);
-        }
-
-        return assigns;
-    }
-}

package/src/channel/eventResponse.test.ts

@@ -1,249 +0,0 @@
-import { ChannelEngine, BroadcastEvent } from './channel';
-import { createParentEngine } from './channel.test';
-import { EventResponse } from './eventResponse';
-import { ServerActions, SystemSender, ErrorTypes, ChannelReceiver } from '../enums';
-
-export const createChannelEngine = () => {
-    const parentEngine = createParentEngine();
-
-    return new ChannelEngine('test', parentEngine);
-};
-
-export const createChannelEvent = (name: string) => {
-    const responseEvent: BroadcastEvent = {
-        event: 'event',
-        payload: {
-            payload: 'payload',
-        },
-        sender: 'sender',
-        action: ServerActions.BROADCAST,
-        recipients: ['recipient'],
-        channelName: name,
-    };
-
-    return responseEvent;
-};
-
-const createChannelResponse = () => {
-    const channelEngine = createChannelEngine();
-    const event = createChannelEvent(channelEngine.name);
-
-    channelEngine.addUser(event.sender, { assign: 'assign' }, () => {});
-    channelEngine.addUser(event.recipients[0], { assign: 'assign' }, () => {});
-    const response = new EventResponse(event, channelEngine);
-
-    return {
-        channelEngine,
-        event,
-        response,
-    };
-};
-
-describe('ChannelResponse', () => {
-    it('should create a new ChannelResponse', () => {
-        const { response } = createChannelResponse();
-
-        expect(response).toBeDefined();
-    });
-
-    it('should accept the request', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-
-        response.accept();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['recipient'], ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-
-    it('should reject the request', () => {
-        const { response, channelEngine, event } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.reject();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(SystemSender.CHANNEL, [event.sender], ServerActions.ERROR, ErrorTypes.UNAUTHORIZED_BROADCAST, {
-            message: 'Unauthorized request',
-            code: 403,
-        });
-    });
-
-    it('should send a direct message', () => {
-        const { response, channelEngine, event } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.send('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(SystemSender.CHANNEL, [event.sender], ServerActions.SYSTEM, 'event', { payload: 'payload' });
-    });
-
-    it('should broadcast a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcast('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ChannelReceiver.ALL_USERS, ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-
-    it('should broadcastFromUser a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcastFromUser('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ChannelReceiver.ALL_EXCEPT_SENDER, ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-
-    it('should sendToUsers a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.sendToUsers('event', { payload: 'payload' }, ['recipient']);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['recipient'], ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-
-    it('should fail to send to non existing users', () => {
-        const { event, response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-        event.recipients = ['non_existing_user'];
-
-        expect(() => response.accept()).toThrowError('ChannelEngine: Users non_existing_user are not in channel test');
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(event.sender, ['non_existing_user'], ServerActions.BROADCAST, event.event, event.payload);
-
-        expect(() => response.sendToUsers('event', { payload: 'payload' }, ['non_existing_user']))
-            .toThrowError('ChannelEngine: Users non_existing_user are not in channel test');
-    });
-
-    it('should track a trackPresence', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'trackPresence');
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-    });
-
-    it('should update a users assign data', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'updateAssigns');
-        response.accept({ assign: 'updated' });
-        expect(channelEngine.updateAssigns).toHaveBeenCalledWith('sender', { assign: 'updated' });
-    });
-
-    it('should evict a user', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'kickUser');
-        response.evictUser('recipient');
-        expect(channelEngine.kickUser).toHaveBeenCalledWith('sender', 'recipient');
-    });
-
-    it('should destroy the channel', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'destroy');
-        response.closeChannel('recipient');
-        expect(channelEngine.destroy).toHaveBeenCalledWith('recipient');
-    });
-
-    it('should call the presence engine when the trackPresence is called', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'trackPresence');
-        expect(channelEngine.trackPresence).not.toHaveBeenCalled();
-        expect(channelEngine.presenceEngine).toBeUndefined();
-        response.accept();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-    });
-
-    it('should throw an error if trackPresence is called twice', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'trackPresence');
-        expect(channelEngine.trackPresence).not.toHaveBeenCalled();
-        expect(channelEngine.presenceEngine).toBeUndefined();
-        response.accept();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-        expect(() => response.trackPresence({ status: 'online' })).toThrowError('PresenceEngine: Presence with key sender already exists');
-    });
-
-    it('should throw an error if trackPresence is called for a non existing user', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'trackPresence');
-        expect(channelEngine.trackPresence).not.toHaveBeenCalled();
-        expect(channelEngine.presenceEngine).toBeUndefined();
-        response.accept();
-        expect(() => response.trackPresence({ status: 'online' }, 'non_existent_user'))
-            .toThrowError('ChannelEngine: User with id non_existent_user does not exist in channel test');
-    });
-
-    it('should update the presence of a user that is already tracked', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'trackPresence');
-        expect(channelEngine.trackPresence).not.toHaveBeenCalled();
-        expect(channelEngine.presenceEngine).toBeUndefined();
-        response.accept();
-        expect(channelEngine.presenceEngine?.getPresence()).toBeUndefined();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-        expect(channelEngine.presenceEngine?.getPresence()).toEqual({
-            sender: { status: 'online' },
-        });
-        response.updatePresence({ status: 'offline' });
-        expect(channelEngine.presenceEngine?.getPresence()).toEqual({
-            sender: { status: 'offline' },
-        });
-    });
-
-    it('should throw an error if updatePresence is called for a non existing user', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'trackPresence');
-        expect(channelEngine.trackPresence).not.toHaveBeenCalled();
-        expect(channelEngine.presenceEngine).toBeUndefined();
-        response.accept();
-        expect(channelEngine.presenceEngine?.getPresence()).toBeUndefined();
-        response.trackPresence({ status: 'online' });
-        expect(() => response.updatePresence({ status: 'online' }, 'non_existent_user'))
-            .toThrowError('PresenceEngine: Presence with key non_existent_user does not exist');
-    });
-
-    it('should unTrack a trackPresence', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        expect(channelEngine.presenceEngine).toBeUndefined();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.presenceEngine?.getPresence()).toEqual({
-            sender: { status: 'online' },
-        });
-
-        response.unTrackPresence();
-        expect(channelEngine.presenceEngine?.getPresence()).toEqual({});
-    });
-
-    it('should throw an error if unTrackPresence is called for a non existing user', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        expect(channelEngine.presenceEngine).toBeUndefined();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.presenceEngine?.getPresence()).toEqual({
-            sender: { status: 'online' },
-        });
-
-        expect(() => response.unTrackPresence('non_existent_user'))
-            .toThrowError('PresenceEngine: Presence with key non_existent_user does not exist');
-    });
-
-    it('should throw an error if accept, reject / send is called more than once', () => {
-        const { response, channelEngine } = createChannelResponse();
-
-        jest.spyOn(channelEngine, 'sendMessage');
-        expect(channelEngine.sendMessage).not.toHaveBeenCalled();
-        response.accept();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['recipient'], ServerActions.BROADCAST, 'event', { payload: 'payload' });
-        expect(() => response.accept()).toThrowError('Event response has already been executed');
-        expect(() => response.reject()).toThrowError('Event response has already been executed');
-        expect(() => response.send('event', { payload: 'payload' })).toThrowError('Event response has already been executed');
-    });
-});