@eleven-am/pondsocket 0.1.49 → 0.1.51

package/server/endpoint/endpoint.test.js

@@ -1,428 +0,0 @@
-"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 enums_1 = require("../../enums");
-const pondChannel_1 = require("../pondChannel/pondChannel");
-const pondSocket_1 = require("../server/pondSocket");
-const createPondSocket = () => {
-    const mock = jest.fn();
-    const socket = new pondSocket_1.PondSocket();
-    // GET RANDOM PORT FROM 6000 - 50000
-    const port = Math.floor(Math.random() * (50000 - 6000 + 1) + 6000);
-    const server = socket.listen(port, 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: enums_1.SystemSender.ENDPOINT,
-            action: enums_1.ServerActions.SYSTEM,
-            payload: {
-                room: 'socket',
-            },
-        })
-            .expectJson({
-            event: 'TEST',
-            channelName: enums_1.SystemSender.ENDPOINT,
-            action: enums_1.ServerActions.BROADCAST,
-            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: enums_1.SystemSender.ENDPOINT,
-            action: enums_1.ServerActions.SYSTEM,
-            payload: {
-                room: 'secondSocket',
-            },
-        })
-            .expectJson({
-            event: 'TEST',
-            channelName: enums_1.SystemSender.ENDPOINT,
-            action: enums_1.ServerActions.BROADCAST,
-            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: enums_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.addChannel('/test/:room', testPond);
-        endpoint.addChannel('/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.addChannel('/test/:room', testPond);
-        const message = {
-            action: enums_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: enums_1.ErrorTypes.INTERNAL_SERVER_ERROR,
-            channelName: enums_1.SystemSender.ENDPOINT,
-            action: enums_1.ServerActions.ERROR,
-            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.addChannel('/test/:room', channel);
-        const message = {
-            action: enums_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) // Join the channel
-            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/test/socket', action: enums_1.ClientActions.BROADCAST }))
-            .expectJson({
-            payload: {},
-            event: 'TEST',
-            channelName: '/test/socket',
-            action: enums_1.ServerActions.BROADCAST,
-        })
-            .expectJson({
-            payload: {},
-            event: 'TEST',
-            channelName: '/test/socket',
-            action: enums_1.ServerActions.BROADCAST,
-        })
-            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST2', channelName: '/test/socket', action: enums_1.ClientActions.BROADCAST }))
-            .expectJson({
-            action: enums_1.ServerActions.ERROR,
-            event: enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST,
-            payload: {
-                message: 'Unauthorized request',
-                code: 403,
-            },
-            channelName: '/test/socket',
-        })
-            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST3', channelName: '/test/socket', action: enums_1.ClientActions.BROADCAST }))
-            .expectJson({
-            action: enums_1.ServerActions.ERROR,
-            event: enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST,
-            payload: {
-                message: 'choke on my balls',
-                code: 403,
-            },
-            channelName: '/test/socket',
-        })
-            .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.addChannel('/test/:room', channel);
-        const message = {
-            action: enums_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: enums_1.PresenceEventTypes.JOIN,
-            channelName: '/test/socket',
-            action: enums_1.ServerActions.PRESENCE,
-            payload: {
-                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.addChannel('/test/:room', channel);
-        const message = {
-            action: enums_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: enums_1.ErrorTypes.INTERNAL_SERVER_ERROR,
-            channelName: 'ENDPOINT',
-            action: enums_1.ServerActions.ERROR,
-            payload: {
-                message: 'GatewayEngine: Channel /test/socket does not exist',
-            },
-        })
-            // now join the channel
-            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.JOIN_CHANNEL }))
-            .expectJson({
-            event: 'TEST',
-            channelName: '/test/socket',
-            action: enums_1.ServerActions.SYSTEM,
-            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: enums_1.SystemSender.ENDPOINT,
-            action: enums_1.ServerActions.SYSTEM,
-            payload: {
-                test: 'test',
-            },
-        })
-            .expectClosed();
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .expectJson({
-            event: 'TEST',
-            channelName: enums_1.SystemSender.ENDPOINT,
-            action: enums_1.ServerActions.SYSTEM,
-            payload: {
-                test: 'test',
-            },
-        })
-            .expectClosed();
-        server.close();
-    }));
-});

package/server/endpoint/endpointResponse.test.js

@@ -1,43 +0,0 @@
-"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/server/pondChannel/joinRequest.js

@@ -1,29 +0,0 @@
-"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/server/pondChannel/joinResponse.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JoinResponse = void 0;
-const enums_1 = require("../../enums");
-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: enums_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
-            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(enums_1.SystemSender.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;
-    }
-    /**
-     * @desc Resolves the request as sent with no further action
-     */
-    end() {
-        this._hasExecuted = true;
-    }
-}
-exports.JoinResponse = JoinResponse;