@eleven-am/pondsocket 0.1.56 → 0.1.57

package/src/lobby/JoinResponse.test.ts

@@ -0,0 +1,162 @@
+import { JoinResponse } from './joinResponse';
+import { createChannelEngine } from '../channel/eventResponse.test';
+import { RequestCache } from '../endpoint/endpoint';
+import { ErrorTypes, ServerActions, ChannelReceiver } from '../enums';
+
+const createPondResponse = () => {
+    const channelEngine = createChannelEngine();
+
+    const socket: RequestCache = {
+        clientId: 'sender',
+        assigns: { assign: 'assign' },
+        channelName: 'channel',
+        socket: {
+            send: jest.fn(),
+        } as any,
+    };
+
+    const response = new JoinResponse(socket, channelEngine);
+
+    return {
+        channelEngine,
+        socket,
+        response,
+    };
+};
+
+
+describe('JoinResponse', () => {
+    it('should create a new PondChannelResponse', () => {
+        const { response } = createPondResponse();
+
+        expect(response).toBeDefined();
+    });
+
+    it('should accept the request', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+
+        jest.spyOn(channelEngine, 'addUser');
+        response.accept();
+
+        // check if the response was sent
+        expect(channelEngine.addUser).toHaveBeenCalledWith(socket.clientId, socket.assigns, expect.any(Function));
+        expect(channelEngine.getUserData(socket.clientId)).not.toBeNull();
+    });
+
+    it('should reject the request', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+
+        jest.spyOn(channelEngine, 'addUser');
+        response.reject();
+
+        // check if the response was sent
+        expect(channelEngine.addUser).not.toHaveBeenCalled();
+        expect(channelEngine.getUserData(socket.clientId)).toBeUndefined();
+
+        // also check if the socket was sent a message
+        expect(socket.socket.send).toHaveBeenCalledWith(JSON.stringify({
+            event: ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            payload: {
+                message: 'Request to join channel test rejected: Unauthorized request',
+                code: 403,
+            },
+            channelName: 'test',
+            action: ServerActions.ERROR,
+        }));
+    });
+
+    it('should send a direct message', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+        // spy on the channelEngine to see if the user was added
+
+        jest.spyOn(channelEngine, 'addUser');
+        response.send('POND_MESSAGE', { message: 'message' });
+
+        // check if the response was sent
+        expect(channelEngine.addUser).toHaveBeenCalled();
+        expect(channelEngine.getUserData(socket.clientId)).toStrictEqual({
+            assigns: {
+                assign: 'assign',
+            },
+            id: 'sender',
+            presence: {},
+        });
+
+        // also check if the socket was sent a message
+        expect(socket.socket.send).toHaveBeenCalledWith(JSON.stringify({
+            channelName: 'test',
+            action: ServerActions.SYSTEM,
+            payload: {
+                message: 'message',
+            },
+            event: 'POND_MESSAGE',
+        }));
+    });
+
+    // auxiliary functions
+    it('should send messages to different users', () => {
+        const { response, channelEngine } = createPondResponse();
+        // spy on the channelEngine to see if any messages were published
+        const broadcast = jest.spyOn(channelEngine, 'sendMessage');
+
+        // add a second user to the channel
+        channelEngine.addUser('user2', { assign: 'assign' }, () => {});
+
+        // send a message to a single user
+        // this is because the sender does not exist in the channel yet
+        expect(() => response.sendToUsers('hello_everyone', { message: 'hello' }, ['user2'])).toThrow();
+
+        // clear the spy
+        broadcast.mockClear();
+
+        // add the sender to the channel by using the response.accept() method
+        response.accept().sendToUsers('hello_everyone', { message: 'hello' }, ['user2']);
+
+        // check if the message was sent
+        expect(broadcast).toHaveBeenCalledWith('sender', ['user2'], ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+
+        // clear the spy
+        broadcast.mockClear();
+
+        // send a message to all users
+        response.broadcast('hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('sender', ChannelReceiver.ALL_USERS, ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+
+        // clear the spy
+        broadcast.mockClear();
+
+        // send a message to all users except the sender
+        response.broadcastFromUser('hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('sender', ChannelReceiver.ALL_EXCEPT_SENDER, ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+    });
+
+    it('should be able to track the presence of users', () => {
+        const { response, channelEngine } = createPondResponse();
+
+        // spy on the channelEngine to see if the trackPresence method was called
+        const trackPresence = jest.spyOn(channelEngine, 'trackPresence');
+
+        // add a second user to the channel
+        response.accept()
+            .trackPresence({
+                status: 'online',
+            });
+
+        // check if the trackPresence method was called
+        expect(trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
+    });
+
+    it('should throw an error if accept, reject / send is called more than once', () => {
+        const { response, channelEngine, socket } = createPondResponse();
+
+        jest.spyOn(channelEngine, 'addUser');
+        expect(channelEngine.addUser).not.toHaveBeenCalled();
+        response.accept();
+        expect(channelEngine.addUser).toHaveBeenCalledWith(socket.clientId, socket.assigns, expect.any(Function));
+        expect(() => response.accept()).toThrowError('Request to join channel test rejected: Request already executed');
+        expect(() => response.reject()).toThrowError('Request to join channel test rejected: Request already executed');
+        expect(() => response.send('event', { payload: 'payload' })).toThrowError('Request to join channel test rejected: Request already executed');
+    });
+});

package/src/lobby/joinRequest.ts

@@ -0,0 +1,32 @@
+import { AbstractRequest } from '../abstracts/abstractRequest';
+import { ChannelEngine } from '../channel/channel';
+import { RequestCache } from '../endpoint/endpoint';
+// eslint-disable-next-line import/no-unresolved
+import { JoinParams, UserData, PondAssigns } from '../types';
+
+export class JoinRequest<Path extends string> extends AbstractRequest<Path> {
+    readonly #params: JoinParams;
+
+    readonly #clientId: string;
+
+    readonly #assigns: PondAssigns;
+
+    constructor (event: RequestCache, params: JoinParams, engine: ChannelEngine) {
+        super(engine.name, engine, params);
+        this.#params = params;
+        this.#clientId = event.clientId;
+        this.#assigns = event.assigns;
+    }
+
+    public get joinParams (): JoinParams {
+        return this.#params;
+    }
+
+    public get user (): UserData {
+        return {
+            id: this.#clientId,
+            assigns: this.#assigns,
+            presence: {},
+        };
+    }
+}

package/src/lobby/joinResponse.ts

@@ -0,0 +1,146 @@
+import { PondResponse } from '../abstracts/abstractResponse';
+import { ChannelEngine } from '../channel/channel';
+import { RequestCache } from '../endpoint/endpoint';
+import { ErrorTypes, ServerActions, SystemSender, ChannelReceiver, Events } from '../enums';
+import { ChannelError } from '../errors/pondError';
+// eslint-disable-next-line import/no-unresolved
+import { PondAssigns, ChannelEvent, PondMessage, PondPresence } from '../types';
+
+export class JoinResponse extends PondResponse {
+    readonly #user: RequestCache;
+
+    readonly #engine: ChannelEngine;
+
+    #executed: boolean;
+
+    constructor (user: RequestCache, engine: ChannelEngine) {
+        super();
+        this.#user = user;
+        this.#engine = engine;
+        this.#executed = false;
+    }
+
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    public accept (assigns?: PondAssigns): JoinResponse {
+        this.#performChecks();
+
+        const newAssigns = {
+            ...assigns || {},
+            ...this.#user.assigns,
+        };
+
+        const acknowledgement: ChannelEvent = {
+            action: ServerActions.SYSTEM,
+            channelName: this.#engine.name,
+            event: Events.ACKNOWLEDGE,
+            payload: {},
+        };
+
+        this.#user.socket.send(JSON.stringify(acknowledgement));
+        this.#engine.addUser(this.#user.clientId, newAssigns, (event) => {
+            this.#user.socket.send(JSON.stringify(event));
+        });
+
+        return this;
+    }
+
+    /**
+     * @desc Rejects the request and optionally assigns data to the client
+     * @param message - the error message
+     * @param errorCode - the error code
+     */
+    public reject (message?: string, errorCode?: number): JoinResponse {
+        this.#performChecks();
+
+        const text = `Request to join channel ${this.#engine.name} rejected: ${message || 'Unauthorized request'}`;
+
+        const errorMessage: ChannelEvent = {
+            event: ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            payload: {
+                message: text,
+                code: errorCode || 403,
+            },
+            channelName: this.#engine.name,
+            action: ServerActions.ERROR,
+        };
+
+        this.#user.socket.send(JSON.stringify(errorMessage));
+
+        return this;
+    }
+
+    /**
+     * @desc Emits a direct message to the client
+     * @param event - the event name
+     * @param payload - the payload to send
+     * @param assigns - the data to assign to the client
+     */
+    public send (event: string, payload: PondMessage, assigns?: PondAssigns) {
+        this.accept(assigns);
+        this.#engine.sendMessage(SystemSender.CHANNEL, [this.#user.clientId], ServerActions.SYSTEM, event, payload);
+
+        return this;
+    }
+
+    /**
+     * @desc Emits a message to all clients in the channel
+     * @param event - the event name
+     * @param payload - the payload to send
+     */
+    public broadcast (event: string, payload: PondMessage): JoinResponse {
+        this.#engine.sendMessage(this.#user.clientId, ChannelReceiver.ALL_USERS, ServerActions.BROADCAST, event, payload);
+
+        return this;
+    }
+
+    /**
+     * @desc Emits a message to all clients in the channel except the sender
+     * @param event - the event name
+     * @param payload - the payload to send
+     */
+    public broadcastFromUser (event: string, payload: PondMessage): JoinResponse {
+        this.#engine.sendMessage(this.#user.clientId, ChannelReceiver.ALL_EXCEPT_SENDER, ServerActions.BROADCAST, event, payload);
+
+        return this;
+    }
+
+    /**
+     * @desc Emits a message to a specific set of clients
+     * @param event - the event name
+     * @param payload  - the payload to send
+     * @param userIds - the ids of the clients to send the message to
+     */
+    public sendToUsers (event: string, payload: PondMessage, userIds: string[]): JoinResponse {
+        this.#engine.sendMessage(this.#user.clientId, userIds, ServerActions.BROADCAST, event, payload);
+
+        return this;
+    }
+
+    /**
+     * @desc tracks the presence of a client
+     * @param presence - the presence data to track
+     */
+    public trackPresence (presence: PondPresence): JoinResponse {
+        this.#engine.trackPresence(this.#user.clientId, presence);
+
+        return this;
+    }
+
+    /**
+     * @desc Performs checks to ensure the response has not been executed
+     * @private
+     */
+    #performChecks (): void {
+        if (this.#executed) {
+            const message = `Request to join channel ${this.#engine.name} rejected: Request already executed`;
+            const code = 403;
+
+            throw new ChannelError(message, code, this.#engine.name);
+        }
+
+        this.#executed = true;
+    }
+}

package/src/lobby/lobby.ts

@@ -0,0 +1,182 @@
+import { Middleware } from '../abstracts/middleware';
+import { ChannelEngine, ParentEngine } from '../channel/channel';
+import { EventRequest } from '../channel/eventRequest';
+import { EventResponse } from '../channel/eventResponse';
+import { ServerActions, ChannelReceiver, SystemSender } from '../enums';
+// eslint-disable-next-line import/no-unresolved
+import { PondPath, PondMessage } from '../types';
+
+export class LobbyEngine {
+    readonly #channels: Set<ChannelEngine>;
+
+    readonly #middleware: Middleware<EventRequest<string>, EventResponse>;
+
+    constructor () {
+        this.#channels = new Set<ChannelEngine>();
+        this.#middleware = new Middleware();
+    }
+
+    /**
+     * @desc Handles an event request made by a user
+     * @param event - The event to listen for
+     * @param handler - The handler to execute when the event is received
+     * @example
+     * pond.onEvent('echo', (request, response) => {
+     *     response.send('echo', {
+     *         message: request.event.payload,
+     *     });
+     * });
+     */
+    public onEvent<Event extends string> (event: PondPath<Event>, handler: (request: EventRequest<Event>, response: EventResponse) => void | Promise<void>) {
+        this.#middleware.use((request, response, next) => {
+            if (request._parseQueries(event)) {
+                return handler(request as EventRequest<Event>, response);
+            }
+
+            next();
+        });
+    }
+
+    /**
+     * @desc Broadcasts a message to all users in a channel
+     * @param event - The event to broadcast
+     * @param payload - The payload to send
+     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
+     * @example
+     * pond.broadcast('echo', {
+     *    message: 'Hello World',
+     *    timestamp: Date.now(),
+     *    channel: 'my_channel',
+     *});
+     */
+    public broadcast (event: string, payload: PondMessage, channelName?: string) {
+        if (channelName) {
+            const channel = this.getChannel(channelName) || this.createChannel(channelName);
+
+            channel.sendMessage(SystemSender.CHANNEL, ChannelReceiver.ALL_USERS, ServerActions.SYSTEM, event, payload);
+        } else {
+            this.#channels.forEach((channel) => {
+                channel.sendMessage(SystemSender.CHANNEL, ChannelReceiver.ALL_USERS, ServerActions.SYSTEM, event, payload);
+            });
+        }
+    }
+
+    /**
+     * @desc Removes a user from all channels
+     * @param clientId - The client id of the user to remove
+     * @param graceful - Whether to gracefully remove the user or not
+     */
+    public removeUser (clientId: string, graceful = false) {
+        this.#channels.forEach((channel) => {
+            channel.removeUser(clientId, graceful);
+        });
+    }
+
+    /**
+     * @desc Executes a function on a channel
+     * @param channelName - The name of the channel to execute the function on
+     * @param handler - The function to execute
+     * @private
+     */
+    public execute<Return> (channelName: string, handler: ((channel: ChannelEngine) => Return)) {
+        const newChannel = this.getChannel(channelName);
+
+        if (newChannel) {
+            return handler(newChannel);
+        }
+
+        throw new Error(`GatewayEngine: Channel ${channelName} does not exist`);
+    }
+
+    /**
+     * @desc Gets a channel by name
+     * @param channelName - The name of the channel to get
+     * @private
+     */
+    public getChannel (channelName: string): ChannelEngine | undefined {
+        return Array.from(this.#channels)
+            .find((channel) => channel.name === channelName);
+    }
+
+    /**
+     * @desc Destroys a channel
+     * @param channel - The name of the channel to destroy
+     * @private
+     */
+    public destroyChannel (channel: string) {
+        const newChannel = this.getChannel(channel);
+
+        if (newChannel) {
+            this.#channels.delete(newChannel);
+        }
+    }
+
+    /**
+     * @desc Lists all channels
+     * @private
+     */
+    public listChannels () {
+        return Array.from(this.#channels)
+            .map((channel) => channel.name);
+    }
+
+    /**
+     * @desc Creates a new channel
+     * @param channelName - The name of the channel to create
+     * @private
+     */
+    public createChannel (channelName: string): ChannelEngine {
+        const destroyChannel = this.destroyChannel.bind(this, channelName);
+        const execute = this.#middleware.run.bind(this.#middleware);
+
+        const parentEngine: ParentEngine = {
+            execute,
+            destroyChannel,
+        };
+
+        const newChannel: ChannelEngine = new ChannelEngine(channelName, parentEngine);
+
+        this.#channels.add(newChannel);
+
+        return newChannel;
+    }
+}
+
+export class PondChannel {
+    readonly #lobby: LobbyEngine;
+
+    constructor (lobby: LobbyEngine) {
+        this.#lobby = lobby;
+    }
+
+    /**
+     * @desc Handles an event request made by a user
+     * @param event - The event to listen for
+     * @param handler - The handler to execute when the event is received
+     * @example
+     * pond.onEvent('echo', (request, response) => {
+     *     response.send('echo', {
+     *         message: request.event.payload,
+     *     });
+     * });
+     */
+    public onEvent<Event extends string> (event: PondPath<Event>, handler: (request: EventRequest<Event>, response: EventResponse) => void | Promise<void>) {
+        this.#lobby.onEvent(event, handler);
+    }
+
+    /**
+     * @desc Broadcasts a message to all users in a channel
+     * @param event - The event to broadcast
+     * @param payload - The payload to send
+     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
+     * @example
+     * pond.broadcast('echo', {
+     *    message: 'Hello World',
+     *    timestamp: Date.now(),
+     *    channel: 'my_channel',
+     *});
+     */
+    public broadcast (event: string, payload: PondMessage, channelName?: string) {
+        this.#lobby.broadcast(event, payload, channelName);
+    }
+}

package/src/matcher/matcher.test.ts

@@ -0,0 +1,103 @@
+import { parseAddress } from './matcher';
+
+describe('parseAddress', () => {
+    it('should return null if a string does not match a regex and {} if it does', () => {
+        const regex = new RegExp(/^test/);
+
+        expect(parseAddress(regex, 'test')).toStrictEqual({
+            params: {},
+            query: {},
+        });
+
+        const regex2 = new RegExp(/^test2/);
+
+        expect(parseAddress(regex2, 'test')).toBe(null);
+    });
+
+    it('should return the params of a string matching the pattern', () => {
+        const pattern = '/test/:id';
+        const secondPattern = '/test/:id/:id2';
+        const string = '/test/5';
+        const secondString = '/test/5/6';
+
+        expect(parseAddress(pattern, string))
+            .toStrictEqual({
+                params: {
+                    id: '5',
+                },
+                query: {},
+            });
+
+        expect(parseAddress(secondPattern, secondString))
+            .toStrictEqual({
+                params: {
+                    id: '5',
+                    id2: '6',
+                },
+                query: {},
+            });
+
+        expect(parseAddress(pattern, secondString))
+            .toBe(null);
+
+        expect(parseAddress(secondPattern, string))
+            .toBe(null);
+    });
+
+    it('should not match colons without slashes', () => {
+        const pattern = '/test:id';
+        const string = '/test5';
+
+        expect(parseAddress(pattern, string))
+            .toBe(null);
+    });
+
+    it('should match when there is a *', () => {
+        const pattern = '/test/:id/*';
+        const string = '/test/5/6';
+
+        expect(parseAddress(pattern, string))
+            .toStrictEqual({
+                params: {
+                    id: '5',
+                },
+                query: {},
+            });
+
+        const secondPattern = '*';
+        const secondString = '/test/5/6';
+
+        expect(parseAddress(secondPattern, secondString))
+            .toStrictEqual({
+                params: {},
+                query: {},
+            });
+    });
+
+    it('should return the query of string', () => {
+        const pattern = '/test/:id';
+        const string = '/test/5?test=5';
+        const secondString = '/test/5?test=5&test2=6';
+
+        expect(parseAddress(pattern, string))
+            .toStrictEqual({
+                params: {
+                    id: '5',
+                },
+                query: {
+                    test: '5',
+                },
+            });
+
+        expect(parseAddress(pattern, secondString))
+            .toStrictEqual({
+                params: {
+                    id: '5',
+                },
+                query: {
+                    test: '5',
+                    test2: '6',
+                },
+            });
+    });
+});