@eleven-am/pondsocket 0.1.10 → 0.1.12

package/dist/server/endpoint/endpoint.test.js

@@ -0,0 +1,406 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const superwstest_1 = __importDefault(require("superwstest"));
+const endpoint_1 = require("./endpoint");
+const pondChannel_1 = require("../pondChannel/pondChannel");
+const pondSocket_1 = require("../server/pondSocket");
+const createPondSocket = () => {
+    const mock = jest.fn();
+    const socket = new pondSocket_1.PondSocket();
+    const server = socket.listen(3001, mock);
+    const createPondChannel = () => new pondChannel_1.PondChannel();
+    return { socket,
+        server,
+        mock,
+        createPondChannel };
+};
+/* eslint-disable line-comment-position, no-inline-comments */
+describe('endpoint', () => {
+    it('should be able to close a socket', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server } = createPondSocket();
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.accept();
+            setTimeout(() => {
+                endpoint.closeConnection(req.id);
+            }, 100);
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .wait(200)
+            .expectClosed();
+        server.close();
+    }));
+    it('should be able to list connections', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server } = createPondSocket();
+        let connectionsCount = 0;
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            connectionsCount = endpoint.listConnections().length;
+            res.accept();
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101));
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101));
+        server.close(); // Close the server to stop the connection from being kept alive
+        expect(connectionsCount).toBe(1);
+        expect(endpoint.listConnections().length).toBe(2); // The connections are still in the list
+    }));
+    it('should be able to refuse connections to the endpoint', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server } = createPondSocket();
+        expect(server).toBeDefined();
+        socket.createEndpoint('/api/:path', (req, res) => {
+            expect(req.params.path).toBe('socket');
+            res.reject();
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectConnectionError(); // The connection should be refused
+        server.close();
+    }));
+    it('should be capable of sending messages to all clients', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server } = createPondSocket();
+        expect(server).toBeDefined();
+        let users = 0;
+        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
+            users++;
+            res.send('Hello', { room: req.params.room });
+            if (users > 0) {
+                endpoint.broadcast('TEST', { message: 'Hello everyone' });
+            }
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .expectJson({
+            event: 'Hello',
+            channelName: 'SERVER',
+            payload: {
+                room: 'socket',
+            },
+        })
+            .expectJson({
+            event: 'TEST',
+            channelName: 'SERVER',
+            payload: {
+                message: 'Hello everyone',
+            },
+        })
+            .close()
+            .expectClosed();
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/secondSocket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .expectJson({
+            event: 'Hello',
+            channelName: 'SERVER',
+            payload: {
+                room: 'secondSocket',
+            },
+        })
+            .expectJson({
+            event: 'TEST',
+            channelName: 'SERVER',
+            payload: {
+                message: 'Hello everyone',
+            },
+        })
+            .close()
+            .expectClosed();
+        server.close();
+    }));
+    it('should be able to accept connections on this handler', () => __awaiter(void 0, void 0, void 0, function* () {
+        const message = {
+            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        const { socket, server, createPondChannel } = createPondSocket();
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        const testPond = createPondChannel();
+        const socketPond = createPondChannel();
+        testPond.onJoinRequest((req, res) => {
+            expect(req.event.params.room).toBeDefined();
+            res.accept({
+                assigns: {
+                    status: 'online',
+                },
+            });
+        });
+        socketPond.onJoinRequest((req, res) => {
+            expect(req.event.params.room).toBeDefined();
+            res.accept({
+                assigns: {
+                    status: 'online socket',
+                },
+            });
+        });
+        endpoint.useChannel('/test/:room', testPond);
+        endpoint.useChannel('/socket/:room', socketPond);
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .close()
+            .expectClosed();
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/socket/socket' }))
+            .close()
+            .expectClosed();
+        expect(endpoint['_channels']).toHaveLength(2);
+        server.close();
+    }));
+    it('should refuse connections if there are no pondChannel handlers', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server, createPondChannel } = createPondSocket();
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        const testPond = createPondChannel();
+        testPond.onJoinRequest((req, res) => {
+            expect(req.event.params.room).toBeDefined();
+            res.accept({
+                assigns: {
+                    status: 'online',
+                },
+            });
+        });
+        endpoint.useChannel('/test/:room', testPond);
+        const message = {
+            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .close()
+            .expectClosed();
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/socket/socket' }))
+            .expectJson({
+            event: 'error',
+            channelName: 'ENDPOINT',
+            payload: {
+                message: 'GatewayEngine: Channel /socket/socket does not exist',
+            },
+        })
+            .close()
+            .expectClosed();
+        server.close();
+        expect(endpoint['_channels']).toHaveLength(1);
+    }));
+    it('should send an error when the channel exists but other things happen', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server, createPondChannel } = createPondSocket();
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        const channel = createPondChannel();
+        channel.onEvent(':room', (req, res) => {
+            if (req.event.params.room === 'TEST') {
+                res.accept().broadcast(req.event.event, req.event.payload);
+            }
+            else if (req.event.params.room === 'TEST2') {
+                res.reject();
+            }
+            else {
+                res.reject('choke on my balls');
+            }
+        });
+        channel.onJoinRequest((_, res) => {
+            res.accept();
+        });
+        endpoint.useChannel('/test/:room', channel);
+        const message = {
+            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST2', action: endpoint_1.ClientActions.BROADCAST }))
+            .expectJson({
+            event: 'error_channel',
+            channelName: '/test/socket',
+            payload: {
+                message: 'Unauthorized request',
+                code: 403,
+            },
+        })
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/test/socket', action: endpoint_1.ClientActions.BROADCAST }))
+            .expectJson({
+            payload: {},
+            event: 'TEST',
+            channelName: '/test/socket',
+        })
+            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST3', action: endpoint_1.ClientActions.BROADCAST }))
+            .expectJson({
+            event: 'error_channel',
+            channelName: '/test/socket',
+            payload: {
+                message: 'choke on my balls',
+                code: 403,
+            },
+        })
+            .close()
+            .expectClosed();
+        server.close();
+        expect(endpoint['_channels']).toHaveLength(1);
+    }));
+    it('should be able to track the presence of its users', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server, createPondChannel } = createPondSocket();
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        const channel = createPondChannel();
+        channel.onJoinRequest((_, res) => {
+            res.accept().trackPresence({
+                status: 'online',
+            });
+        });
+        endpoint.useChannel('/test/:room', channel);
+        const message = {
+            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .expectJson({
+            event: 'presence_change',
+            channelName: '/test/socket',
+            payload: {
+                type: 'join',
+                changed: {
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        status: 'online',
+                    },
+                ],
+            },
+        })
+            .close()
+            .expectClosed();
+        server.close();
+        expect(endpoint['_channels']).toHaveLength(1);
+    }));
+    it('should throw an error when we try to leave a channel that does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server, createPondChannel } = createPondSocket();
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        const channel = createPondChannel();
+        channel.onJoinRequest((_, res) => {
+            res.send('TEST', { test: 'test' });
+        });
+        endpoint.useChannel('/test/:room', channel);
+        const message = {
+            action: endpoint_1.ClientActions.LEAVE_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .expectJson({
+            event: 'error',
+            channelName: 'ENDPOINT',
+            payload: {
+                message: 'GatewayEngine: Channel /test/socket does not exist',
+            },
+        })
+            // now join the channel
+            .sendJson(Object.assign(Object.assign({}, message), { action: endpoint_1.ClientActions.JOIN_CHANNEL }))
+            .expectJson({
+            event: 'TEST',
+            channelName: '/test/socket',
+            payload: {
+                test: 'test',
+            },
+        })
+            // now leave the channel
+            .sendJson(message)
+            .close()
+            .expectClosed();
+        server.close();
+        expect(endpoint['_channels']).toHaveLength(1);
+        // every pond channel can potentially hold a lot of channels
+        // remember that the path a pond channel is created with is a regex pattern
+        // and every channel that matches that pattern will be added to the pond channel
+        // e.g. /test/:room will match /test/1, /test/2, /test/3, /test/4, ... etc
+        // But also when a channel no longer has any users, it will be removed from the pond channel
+        expect(channel['_channels'].size).toEqual(0);
+    }));
+    it('should be able to close multiple sockets', () => __awaiter(void 0, void 0, void 0, function* () {
+        const { socket, server } = createPondSocket();
+        expect(server).toBeDefined();
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.send('TEST', { test: 'test' });
+            const sockets = endpoint.listConnections();
+            endpoint.closeConnection(sockets);
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .expectJson({
+            event: 'TEST',
+            channelName: 'SERVER',
+            payload: {
+                test: 'test',
+            },
+        })
+            .expectClosed();
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .expectJson({
+            event: 'TEST',
+            channelName: 'SERVER',
+            payload: {
+                test: 'test',
+            },
+        })
+            .expectClosed();
+    }));
+});

package/dist/server/endpoint/endpointResponse.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const connectionResponse_1 = require("./connectionResponse");
+describe('EndpointResponse', () => {
+    it('should be able to accept', () => {
+        const handler = jest.fn();
+        const response = new connectionResponse_1.ConnectionResponse(handler);
+        response.accept();
+        expect(handler).toBeCalledWith({}, {});
+    });
+    it('should be able to reject', () => {
+        const handler = jest.fn();
+        const response = new connectionResponse_1.ConnectionResponse(handler);
+        response.reject();
+        expect(handler).toBeCalledWith({}, { error: { message: 'Message rejected',
+                code: 403 } });
+    });
+    it('should be able to send', () => {
+        const handler = jest.fn();
+        const response = new connectionResponse_1.ConnectionResponse(handler);
+        response.send('test', { test: 'test' });
+        expect(handler).toBeCalledWith({}, { message: { event: 'test',
+                payload: { test: 'test' } } });
+    });
+    it('should throw if accept is called twice', () => {
+        const handler = jest.fn();
+        const response = new connectionResponse_1.ConnectionResponse(handler);
+        response.accept();
+        expect(() => response.accept()).toThrow();
+    });
+    it('should throw if reject is called twice', () => {
+        const handler = jest.fn();
+        const response = new connectionResponse_1.ConnectionResponse(handler);
+        response.reject();
+        expect(() => response.reject()).toThrow();
+    });
+    it('should throw if send is called twice', () => {
+        const handler = jest.fn();
+        const response = new connectionResponse_1.ConnectionResponse(handler);
+        response.send('test', { test: 'test' });
+        expect(() => response.send('test', { test: 'test' })).toThrow();
+    });
+});

package/dist/server/pondChannel/joinRequest.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinRequest = void 0;
+const abstractRequest_1 = require("../abstracts/abstractRequest");
+class JoinRequest extends abstractRequest_1.AbstractRequest {
+    constructor(event, engine) {
+        super(event.channelName, engine, event.joinParams);
+        this._requestCache = event;
+    }
+    get joinParams() {
+        return this._requestCache.joinParams;
+    }
+    get user() {
+        return {
+            id: this._requestCache.clientId,
+            assigns: this._requestCache.assigns,
+            presence: {},
+        };
+    }
+    get event() {
+        return {
+            event: this._requestCache.channelName,
+            params: this._requestCache.params,
+            query: this._requestCache.query,
+            payload: this._requestCache.joinParams,
+        };
+    }
+}
+exports.JoinRequest = JoinRequest;

package/dist/server/pondChannel/joinResponse.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinResponse = void 0;
+const abstractResponse_1 = require("../abstracts/abstractResponse");
+const channelEngine_1 = require("../channel/channelEngine");
+class JoinResponse extends abstractResponse_1.PondResponse {
+    constructor(user, engine) {
+        super();
+        this._user = user;
+        this._engine = engine;
+        this._hasExecuted = false;
+    }
+    get responseSent() {
+        return this._hasExecuted;
+    }
+    /**
+     * @desc Accepts the request and optionally assigns data to the client
+     * @param assigns - the data to assign to the client
+     */
+    accept(assigns) {
+        this._hasExecuted = true;
+        assigns = Object.assign(Object.assign({}, assigns), this._user.assigns);
+        this._engine.addUser(this._user.clientId, assigns, (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
+     */
+    reject(message, errorCode) {
+        this._hasExecuted = true;
+        const text = `Request to join channel ${this._engine.name} rejected: ${message || 'Unauthorized request'}`;
+        const errorMessage = {
+            event: 'POND_ERROR',
+            payload: {
+                message: text,
+                code: errorCode || 403,
+            },
+            channelName: this._engine.name,
+            action: channelEngine_1.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
+     */
+    send(event, payload, assigns) {
+        this.accept(assigns);
+        this._engine.sendMessage('channel', [this._user.clientId], channelEngine_1.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
+     */
+    broadcast(event, payload) {
+        this._engine.sendMessage(this._user.clientId, 'all_users', channelEngine_1.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
+     */
+    broadcastFromUser(event, payload) {
+        this._engine.sendMessage(this._user.clientId, 'all_except_sender', channelEngine_1.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
+     */
+    sendToUsers(event, payload, userIds) {
+        this._engine.sendMessage(this._user.clientId, userIds, channelEngine_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc tracks the presence of a client
+     * @param presence - the presence data to track
+     */
+    trackPresence(presence) {
+        this._engine.trackPresence(this._user.clientId, presence);
+        return this;
+    }
+}
+exports.JoinResponse = JoinResponse;