@eleven-am/pondsocket 0.1.50 → 0.1.52

package/server/pondChannel/pondChannel.js

@@ -1,185 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondChannel = void 0;
-const joinRequest_1 = require("./joinRequest");
-const joinResponse_1 = require("./joinResponse");
-const enums_1 = require("../../enums");
-const middleware_1 = require("../abstracts/middleware");
-const channelEngine_1 = require("../channel/channelEngine");
-class PondChannel {
-    constructor() {
-        this._authorize = undefined;
-        this._channels = new Set();
-        this._middleware = new middleware_1.Middleware();
-    }
-    /**
-     * @desc Authorize a user to join a channel
-     * @param handler - The handler to authorize the user
-     * @example
-     * const pond = new PondChannelEngine();
-     * pond.onJoinRequest((request, response) => {
-     *     if (request.user.assigns.admin)
-     *          response.accept();
-     *     else
-     *         response.reject('You are not an admin', 403);
-     * });
-     */
-    onJoinRequest(handler) {
-        this._authorize = handler;
-    }
-    /**
-     * @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,
-     *     });
-     * });
-     */
-    onEvent(event, handler) {
-        this._middleware.use((request, response, next) => {
-            if (request._parseQueries(event)) {
-                return handler(request, 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',
-     *});
-     */
-    broadcast(event, payload, channelName) {
-        if (channelName) {
-            const channel = this._getChannel(channelName) || this._createChannel(channelName);
-            channel.sendMessage('channel', 'all_users', enums_1.ServerActions.SYSTEM, event, payload);
-        }
-        else {
-            this._channels.forEach((channel) => {
-                channel.sendMessage('channel', 'all_users', enums_1.ServerActions.SYSTEM, event, payload);
-            });
-        }
-    }
-    /**
-     * @desc Builds a PondChannelManager from the current engine
-     */
-    _buildManager() {
-        return {
-            addUser: this._addUser.bind(this),
-            execute: this._execute.bind(this),
-            removeUser: this._removeUser.bind(this),
-            getChannels: this._getChannels.bind(this),
-            listChannels: this._listChannels.bind(this),
-        };
-    }
-    /**
-     * @desc Adds a user to a channel
-     * @param user - The user to add
-     * @private
-     */
-    _addUser(user) {
-        const newChannel = this._getChannel(user.channelName) || this._createChannel(user.channelName);
-        if (this._authorize) {
-            const socketCache = {
-                clientId: user.clientId,
-                socket: user.socket,
-                assigns: user.assigns,
-            };
-            const request = new joinRequest_1.JoinRequest(user, newChannel);
-            const response = new joinResponse_1.JoinResponse(socketCache, newChannel);
-            void this._authorize(request, response);
-            if (!response.responseSent) {
-                throw new Error('PondChannelEngine: Response was not resolved');
-            }
-        }
-        else {
-            newChannel.addUser(user.clientId, user.assigns, (event) => {
-                user.socket.send(JSON.stringify(event));
-            });
-        }
-    }
-    /**
-     * @desc Removes a user from all channels
-     * @param clientId - The client id of the user to remove
-     * @private
-     */
-    _removeUser(clientId) {
-        this._channels.forEach((channel) => {
-            channel.removeUser(clientId, true);
-        });
-    }
-    /**
-     * @desc Creates a new channel
-     * @param channelName - The name of the channel to create
-     * @private
-     */
-    _createChannel(channelName) {
-        const destroyChannel = this._destroyChannel.bind(this, channelName);
-        const execute = this._middleware.run.bind(this._middleware);
-        const parentEngine = {
-            execute,
-            destroyChannel,
-        };
-        const newChannel = new channelEngine_1.ChannelEngine(channelName, parentEngine);
-        this._channels.add(newChannel);
-        return newChannel;
-    }
-    /**
-     * @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
-     */
-    _execute(channelName, handler) {
-        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
-     */
-    _getChannel(channelName) {
-        return Array.from(this._channels)
-            .find((channel) => channel.name === channelName);
-    }
-    /**
-     * @desc Destroys a channel
-     * @param channel - The name of the channel to destroy
-     * @private
-     */
-    _destroyChannel(channel) {
-        const newChannel = this._getChannel(channel);
-        if (newChannel) {
-            this._channels.delete(newChannel);
-        }
-    }
-    /**
-     * @desc Lists all channels
-     * @private
-     */
-    _listChannels() {
-        return Array.from(this._channels)
-            .map((channel) => channel.name);
-    }
-    /**
-     * @desc Gets all channels
-     * @private
-     */
-    _getChannels() {
-        return Array.from(this._channels);
-    }
-}
-exports.PondChannel = PondChannel;

package/server/pondChannel/pondChannelResponse.test.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const joinResponse_1 = require("./joinResponse");
-const enums_1 = require("../../enums");
-const channelEngine_1 = require("../channel/channelEngine");
-const channelResponse_test_1 = require("../channel/channelResponse.test");
-const createPondResponse = () => {
-    const channelEngine = (0, channelResponse_test_1.createChannelEngine)();
-    const socket = {
-        clientId: 'sender',
-        assigns: { assign: 'assign' },
-        socket: {
-            send: jest.fn(),
-        },
-    };
-    const response = new joinResponse_1.JoinResponse(socket, channelEngine);
-    return { channelEngine,
-        socket,
-        response };
-};
-/* eslint-disable line-comment-position, no-inline-comments */
-describe('pondChannelResponse', () => {
-    it('should create a new PondChannelResponse', () => {
-        const { response } = createPondResponse();
-        expect(response).toBeDefined();
-    });
-    it('should return the responseSent', () => {
-        const { response } = createPondResponse();
-        expect(response.responseSent).toEqual(false);
-    });
-    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(response.responseSent).toEqual(true);
-        expect(response.responseSent).toEqual(true);
-        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(response.responseSent).toEqual(true);
-        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: enums_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
-            payload: {
-                message: 'Request to join channel test rejected: Unauthorized request',
-                code: 403,
-            },
-            channelName: 'test',
-            action: channelEngine_1.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(response.responseSent).toEqual(true);
-        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({
-            action: channelEngine_1.ServerActions.SYSTEM,
-            event: 'POND_MESSAGE',
-            payload: {
-                message: 'message',
-            },
-            channelName: 'test',
-        }));
-    });
-    // 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
-        expect(() => response.sendToUsers('hello_everyone', { message: 'hello' }, ['user2'])).toThrow(); // this is because the sender does not exist in the channel yet
-        // 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'], channelEngine_1.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', 'all_users', channelEngine_1.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', 'all_except_sender', channelEngine_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
-    });
-});

package/server/presence/presenceEngine.js

@@ -1,107 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PresenceEngine = void 0;
-const enums_1 = require("../../enums");
-const subjectUtils_1 = require("../utils/subjectUtils");
-class PresenceEngine {
-    constructor() {
-        this._presence = new subjectUtils_1.BehaviorSubject();
-        this._presenceMap = new Map();
-    }
-    /**
-     * @desc Lists all the presence of the users
-     */
-    getPresence() {
-        return Array.from(this._presenceMap.entries())
-            .reduce((acc, [key, value]) => {
-            acc[key] = value;
-            return acc;
-        }, {});
-    }
-    /**
-     * @desc Returns the presence of a user
-     * @param userId - The id of the user
-     */
-    getUserPresence(userId) {
-        return this._presenceMap.get(userId);
-    }
-    /**
-     * @desc Removes a presence from the presence engine
-     * @param presenceKey - The key of the presence
-     */
-    removePresence(presenceKey) {
-        const presence = this._presenceMap.get(presenceKey);
-        if (presence) {
-            this._presence.unsubscribe(presenceKey);
-            this._presenceMap.delete(presenceKey);
-            if (this._presenceMap.size > 0) {
-                this._presence.next({
-                    type: enums_1.PresenceEventTypes.LEAVE,
-                    changed: presence,
-                    presence: Array.from(this._presenceMap.values()),
-                });
-            }
-        }
-        else {
-            throw new Error(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
-        }
-    }
-    /**
-     * @desc Updates a presence
-     * @param presenceKey - The key of the presence
-     * @param presence - The new presence
-     */
-    updatePresence(presenceKey, presence) {
-        const oldPresence = this._presenceMap.get(presenceKey);
-        if (oldPresence) {
-            this._presenceMap.set(presenceKey, Object.assign(Object.assign({}, oldPresence), presence));
-            this._presence.next({
-                type: enums_1.PresenceEventTypes.UPDATE,
-                changed: Object.assign(Object.assign({}, oldPresence), presence),
-                presence: Array.from(this._presenceMap.values()),
-            });
-        }
-        else {
-            throw new Error(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
-        }
-    }
-    /**
-     * @desc Tracks a presence
-     * @param presenceKey - The key of the presence
-     * @param presence - The presence
-     * @param onPresenceChange - The callback to be called when the presence changes
-     */
-    trackPresence(presenceKey, presence, onPresenceChange) {
-        this._insertPresence(presenceKey, presence);
-        return this._subscribe(presenceKey, onPresenceChange);
-    }
-    /**
-     * @desc Inserts a presence into the presence engine
-     * @param presenceKey - The key of the presence
-     * @param presence - The presence
-     * @private
-     */
-    _insertPresence(presenceKey, presence) {
-        if (!this._presenceMap.has(presenceKey)) {
-            this._presenceMap.set(presenceKey, presence);
-            this._presence.next({
-                type: enums_1.PresenceEventTypes.JOIN,
-                changed: presence,
-                presence: Array.from(this._presenceMap.values()),
-            });
-        }
-        else {
-            throw new Error(`PresenceEngine: Presence with key ${presenceKey} already exists`);
-        }
-    }
-    /**
-     * @desc Subscribes to the presence engine
-     * @param identifier - The identifier of the observer
-     * @param observer - The observer
-     * @private
-     */
-    _subscribe(identifier, observer) {
-        return this._presence.subscribe(identifier, observer);
-    }
-}
-exports.PresenceEngine = PresenceEngine;

package/server/presence/presenceEngine.test.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const presenceEngine_1 = require("./presenceEngine");
-const enums_1 = require("../../enums");
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-describe('PresenceEngine', () => {
-    let presenceEngine;
-    let presence;
-    let presenceKey;
-    let onPresenceChange;
-    beforeEach(() => {
-        presenceEngine = new presenceEngine_1.PresenceEngine();
-        presence = {
-            id: 'id',
-            name: 'name',
-            color: 'color',
-            type: 'type',
-            location: 'location',
-        };
-        presenceKey = 'presenceKey';
-        onPresenceChange = jest.fn();
-    });
-    describe('trackPresence', () => {
-        it('should insert a presence into the presence engine', () => {
-            // spy on the private method _insertPresence
-            // @ts-ignore
-            jest.spyOn(presenceEngine, '_insertPresence');
-            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
-            // @ts-ignore
-            expect(presenceEngine._insertPresence).toHaveBeenCalledWith(presenceKey, presence);
-            expect(onPresenceChange).toHaveBeenCalledWith({
-                type: enums_1.PresenceEventTypes.JOIN,
-                changed: presence,
-                presence: [presence],
-            });
-        });
-        it('should subscribe to the presence engine', () => {
-            // spy on the private method _subscribe
-            // @ts-ignore
-            jest.spyOn(presenceEngine, '_subscribe');
-            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
-            // @ts-ignore
-            expect(presenceEngine._subscribe).toHaveBeenCalledWith(presenceKey, onPresenceChange);
-            expect(onPresenceChange).toHaveBeenCalledWith({
-                type: enums_1.PresenceEventTypes.JOIN,
-                changed: presence,
-                presence: [presence],
-            });
-        });
-        it('should throw an error if the presence already exists', () => {
-            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
-            expect(() => presenceEngine.trackPresence(presenceKey, presence, onPresenceChange)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} already exists`);
-        });
-    });
-    describe('updatePresence', () => {
-        it('should update a presence', () => {
-            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
-            const newPresence = {
-                id: 'id',
-                name: 'name',
-                color: 'color',
-                type: 'type',
-                location: 'location',
-            };
-            presenceEngine.updatePresence(presenceKey, newPresence);
-            expect(onPresenceChange).toHaveBeenCalledWith({
-                type: enums_1.PresenceEventTypes.UPDATE,
-                changed: Object.assign(Object.assign({}, presence), newPresence),
-                presence: [newPresence],
-            });
-        });
-        it('should throw an error if the presence does not exist', () => {
-            expect(() => presenceEngine.updatePresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
-        });
-    });
-    describe('removePresence', () => {
-        it('should remove a presence from the presence engine', () => {
-            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
-            presenceEngine.trackPresence('presenceKey2', Object.assign(Object.assign({}, presence), { key: 'presence2' }), onPresenceChange);
-            presenceEngine.removePresence(presenceKey);
-            expect(onPresenceChange).toHaveBeenCalledWith({
-                type: enums_1.PresenceEventTypes.LEAVE,
-                changed: presence,
-                presence: [
-                    Object.assign(Object.assign({}, presence), { key: 'presence2' }),
-                ],
-            });
-            // @ts-ignore
-            onPresenceChange.mockClear();
-            presenceEngine.removePresence('presenceKey2');
-            expect(onPresenceChange).not.toHaveBeenCalled();
-        });
-        it('should throw an error if the presence does not exist', () => {
-            expect(() => presenceEngine.removePresence(presenceKey)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
-        });
-    });
-    describe('getPresence', () => {
-        it('should return the presence', () => {
-            presenceEngine.trackPresence(presenceKey, presence, onPresenceChange);
-            const data = {};
-            data[presenceKey] = presence;
-            expect(presenceEngine.getPresence()).toEqual(data);
-        });
-    });
-});

package/server/server/pondSocket.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondSocket = void 0;
-const http_1 = require("http");
-const ws_1 = require("ws");
-const endpoint_1 = require("../endpoint/endpoint");
-const matchPattern_1 = require("../utils/matchPattern");
-class PondSocket {
-    constructor(server, socketServer) {
-        this._middleware = [];
-        this._matcher = new matchPattern_1.MatchPattern();
-        this._server = server !== null && server !== void 0 ? server : new http_1.Server();
-        this._socketServer = socketServer !== null && socketServer !== void 0 ? socketServer : new ws_1.WebSocketServer({ noServer: true });
-        this._init();
-    }
-    /**
-     * @desc Specifies the port to listen on
-     * @param args - the arguments to pass to the server
-     */
-    listen(...args) {
-        return this._server.listen(...args);
-    }
-    /**
-     * @desc Closes the server
-     * @param callback - the callback to call when the server is closed
-     */
-    close(callback) {
-        return this._server.close(callback);
-    }
-    /**
-     * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
-     * @param path - the pattern to accept || can also be a regex
-     * @param handler - the handler function to authenticate the socket
-     * @example
-     * const endpoint = pond.createEndpoint('/api/socket', (req, res) => {
-     *    const token = req.query.token;
-     *    if (!token)
-     *       return res.reject("No token provided");
-     *    res.accept({
-     *       assign: {
-     *           token
-     *       }
-     *    });
-     * })
-     */
-    createEndpoint(path, handler) {
-        const endpoint = new endpoint_1.Endpoint(this._socketServer);
-        this._middleware.push((req, socket, head, next) => {
-            const address = req.url || '';
-            const dataEndpoint = this._matcher.parseEvent(path, address);
-            if (!dataEndpoint) {
-                return next();
-            }
-            endpoint._authoriseConnection(req, socket, head, dataEndpoint, handler);
-        });
-        return endpoint;
-    }
-    /**
-     * @desc Adds a middleware function to the socket server
-     * @param middleware - the middleware function to add
-     */
-    use(middleware) {
-        this._middleware.push(middleware);
-    }
-    /**
-     * @desc managed the heartbeat of the socket server
-     * @private
-     */
-    _manageHeartbeat() {
-        this._socketServer.on('connection', (socket) => {
-            socket.on('pong', () => {
-                socket.isAlive = true;
-            });
-        });
-        const interval = setInterval(() => {
-            this._socketServer.clients.forEach((socket) => {
-                if (socket.isAlive === false) {
-                    return socket.terminate();
-                }
-                socket.isAlive = false;
-                socket.ping(() => { });
-            });
-        }, 30000);
-        this._socketServer.on('close', () => clearInterval(interval));
-    }
-    /**
-     * @desc executes the middleware functions
-     * @param req - the request object
-     * @param socket - the socket object
-     * @param head - the head buffer
-     * @private
-     */
-    _execute(req, socket, head) {
-        const temp = this._middleware.concat();
-        const next = () => {
-            const middleware = temp.shift();
-            if (middleware) {
-                middleware(req, socket, head, next);
-            }
-            else {
-                socket.write('HTTP/1.1 400 Bad Request\r\n\r');
-                socket.destroy();
-            }
-        };
-        next();
-    }
-    /**
-     * @desc initialises the socket server
-     * @private
-     */
-    _init() {
-        this._manageHeartbeat();
-        this._server.on('error', (error) => {
-            throw new Error(error.message);
-        });
-        this._server.on('upgrade', (req, socket, head) => {
-            this._execute(req, socket, head);
-        });
-    }
-}
-exports.PondSocket = PondSocket;