@eleven-am/pondsocket 0.1.126 → 0.1.127

package/channel/eventResponse.test.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChannelEvent = exports.createChannelEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const channel_1 = require("./channel");
+const channel_test_1 = require("./channel.test");
+const eventResponse_1 = require("./eventResponse");
+const createChannelEngine = () => {
+    const parentEngine = (0, channel_test_1.createParentEngine)();
+    return new channel_1.ChannelEngine('test', parentEngine);
+};
+exports.createChannelEngine = createChannelEngine;
+const createChannelEvent = (name) => {
+    const responseEvent = {
+        event: 'event',
+        payload: {
+            payload: 'payload',
+        },
+        sender: 'sender',
+        action: pondsocket_common_1.ServerActions.BROADCAST,
+        recipients: ['recipient'],
+        channelName: name,
+        requestId: 'requestId',
+    };
+    return responseEvent;
+};
+exports.createChannelEvent = createChannelEvent;
+const createChannelResponse = () => {
+    const channelEngine = (0, exports.createChannelEngine)();
+    const event = (0, exports.createChannelEvent)(channelEngine.name);
+    channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
+    channelEngine.addUser(event.recipients[0], { assign: 'assign' }, () => { });
+    const response = new eventResponse_1.EventResponse(event, channelEngine);
+    return {
+        channelEngine,
+        event,
+        response,
+    };
+};
+describe('ChannelResponse', () => {
+    it('should create a new ChannelResponse', () => {
+        const { response } = createChannelResponse();
+        expect(response).toBeDefined();
+    });
+    it('should accept the request', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.accept();
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should reject the request', () => {
+        const { response, channelEngine, event } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.reject();
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_1.ServerActions.ERROR, pondsocket_common_1.ErrorTypes.UNAUTHORIZED_BROADCAST, {
+            message: 'Unauthorized request',
+            code: 403,
+        });
+    });
+    it('should send a direct message', () => {
+        const { response, channelEngine, event } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.send('event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_1.ServerActions.SYSTEM, 'event', { payload: 'payload' });
+    });
+    it('should broadcast a message', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.broadcast('event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should broadcastFromUser a message', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.broadcastFromUser('event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should sendToUsers a message', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.sendToUsers('event', { payload: 'payload' }, ['recipient']);
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should fail to send to non existing users', () => {
+        const { event, response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        event.recipients = ['non_existing_user'];
+        expect(() => response.accept()).toThrow('ChannelEngine: Invalid recipients non_existing_user some users do not exist in channel test');
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', event.sender, ['non_existing_user'], pondsocket_common_1.ServerActions.BROADCAST, event.event, event.payload);
+        expect(() => response.sendToUsers('event', { payload: 'payload' }, ['non_existing_user']))
+            .toThrow('ChannelEngine: Invalid recipients non_existing_user some users do not exist in channel test');
+    });
+    it('should track a trackPresence', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
+        response.trackPresence({ status: 'online' });
+        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
+    });
+    it('should update a users assign data', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'updateAssigns');
+        response.accept({ assign: 'updated' });
+        expect(channelEngine.updateAssigns).toHaveBeenCalledWith('sender', { assign: 'updated' });
+    });
+    it('should evict a user', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'kickUser');
+        response.evictUser('recipient');
+        expect(channelEngine.kickUser).toHaveBeenCalledWith('sender', 'recipient');
+    });
+    it('should destroy the channel', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'destroy');
+        response.closeChannel('recipient');
+        expect(channelEngine.destroy).toHaveBeenCalledWith('recipient');
+    });
+    it('should call the presence engine when the trackPresence is called', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
+        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
+        response.accept();
+        response.trackPresence({ status: 'online' });
+        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
+    });
+    it('should throw an error if trackPresence is called twice', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
+        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
+        response.accept();
+        response.trackPresence({ status: 'online' });
+        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
+        expect(() => response.trackPresence({ status: 'online' })).toThrow('PresenceEngine: Presence with key sender already exists');
+    });
+    it('should throw an error if trackPresence is called for a non existing user', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
+        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
+        response.accept();
+        expect(() => response.trackPresence({ status: 'online' }, 'non_existent_user'))
+            .toThrow('ChannelEngine: Invalid recipients non_existent_user some users do not exist in channel test');
+    });
+    it('should update the presence of a user that is already tracked', () => {
+        var _a, _b;
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
+        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
+        response.accept();
+        response.trackPresence({ status: 'online' });
+        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+            sender: { status: 'online' },
+        });
+        response.updatePresence({ status: 'offline' });
+        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({
+            sender: { status: 'offline' },
+        });
+    });
+    it('should throw an error if updatePresence is called for a non existing user', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
+        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
+        response.accept();
+        response.trackPresence({ status: 'online' });
+        expect(() => response.updatePresence({ status: 'online' }, 'non_existent_user'))
+            .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
+    });
+    it('should unTrack a trackPresence', () => {
+        var _a, _b;
+        const { response, channelEngine } = createChannelResponse();
+        response.trackPresence({ status: 'online' });
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+            sender: { status: 'online' },
+        });
+        response.unTrackPresence();
+        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({});
+    });
+    it('should throw an error if unTrackPresence is called for a non existing user', () => {
+        var _a;
+        const { response, channelEngine } = createChannelResponse();
+        response.trackPresence({ status: 'online' });
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+            sender: { status: 'online' },
+        });
+        expect(() => response.unTrackPresence('non_existent_user'))
+            .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
+    });
+    it('should throw an error if accept, reject / send is called more than once', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        expect(channelEngine.sendMessage).not.toHaveBeenCalled();
+        response.accept();
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+        expect(() => response.accept()).toThrow('Event response has already been executed');
+        expect(() => response.reject()).toThrow('Event response has already been executed');
+        expect(() => response.send('event', { payload: 'payload' })).toThrow('Event response has already been executed');
+    });
+});

package/endpoint/endpoint.js

@@ -10,18 +10,17 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Endpoint_instances, _Endpoint_middleware, _Endpoint_channels, _Endpoint_sockets, _Endpoint_sendMessage, _Endpoint_joinChannel, _Endpoint_execute, _Endpoint_handleMessage, _Endpoint_readMessage, _Endpoint_isObjectEmpty;
+var _Endpoint_instances, _Endpoint_middleware, _Endpoint_channels, _Endpoint_sockets, _Endpoint_sendMessage, _Endpoint_joinChannel, _Endpoint_execute, _Endpoint_handleMessage, _Endpoint_readMessage;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Endpoint = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const zod_1 = require("zod");
 const middleware_1 = require("../abstracts/middleware");
-const enums_1 = require("../enums");
 const pondError_1 = require("../errors/pondError");
 const joinRequest_1 = require("../lobby/joinRequest");
 const joinResponse_1 = require("../lobby/joinResponse");
 const lobby_1 = require("../lobby/lobby");
 const matcher_1 = require("../matcher/matcher");
-const uuid_1 = require("../misc/uuid");
 const schema_1 = require("../schema");
 class Endpoint {
     constructor() {
@@ -86,9 +85,9 @@ class Endpoint {
             const message = {
                 event,
                 payload,
-                requestId: (0, uuid_1.uuid)(),
-                action: enums_1.ServerActions.BROADCAST,
-                channelName: enums_1.SystemSender.ENDPOINT,
+                requestId: (0, pondsocket_common_1.uuid)(),
+                action: pondsocket_common_1.ServerActions.BROADCAST,
+                channelName: pondsocket_common_1.SystemSender.ENDPOINT,
             };
             __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, socket, message);
         });
@@ -145,15 +144,15 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
     throw new Error(`GatewayEngine: Channel ${channel} does not exist`);
 }, _Endpoint_handleMessage = function _Endpoint_handleMessage(cache, message) {
     switch (message.action) {
-        case enums_1.ClientActions.JOIN_CHANNEL:
+        case pondsocket_common_1.ClientActions.JOIN_CHANNEL:
             __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_joinChannel).call(this, message.channelName, cache, message.payload, message.requestId);
             break;
-        case enums_1.ClientActions.LEAVE_CHANNEL:
+        case pondsocket_common_1.ClientActions.LEAVE_CHANNEL:
             __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
                 channel.removeUser(cache.clientId);
             });
             break;
-        case enums_1.ClientActions.BROADCAST:
+        case pondsocket_common_1.ClientActions.BROADCAST:
             __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
                 channel.broadcastMessage(cache.clientId, message);
             });
@@ -163,10 +162,10 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
     }
 }, _Endpoint_readMessage = function _Endpoint_readMessage(cache, message) {
     const errorMessage = {
-        event: enums_1.ErrorTypes.INVALID_MESSAGE,
-        action: enums_1.ServerActions.ERROR,
-        channelName: enums_1.SystemSender.ENDPOINT,
-        requestId: (0, uuid_1.uuid)(),
+        event: pondsocket_common_1.ErrorTypes.INVALID_MESSAGE,
+        action: pondsocket_common_1.ServerActions.ERROR,
+        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+        requestId: (0, pondsocket_common_1.uuid)(),
         payload: {},
     };
     try {
@@ -187,13 +186,13 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
             };
         }
         else if (e instanceof Error) {
-            errorMessage.event = enums_1.ErrorTypes.INTERNAL_SERVER_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.INTERNAL_SERVER_ERROR;
             errorMessage.payload = {
                 message: e.message,
             };
         }
         else if (e instanceof pondError_1.PresenceError) {
-            errorMessage.event = enums_1.ErrorTypes.PRESENCE_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.PRESENCE_ERROR;
             errorMessage.channelName = e.channel;
             errorMessage.payload = {
                 message: e.message,
@@ -202,7 +201,7 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
             };
         }
         else if (e instanceof pondError_1.ChannelError) {
-            errorMessage.event = enums_1.ErrorTypes.CHANNEL_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.CHANNEL_ERROR;
             errorMessage.channelName = e.channel;
             errorMessage.payload = {
                 message: e.message,
@@ -210,7 +209,7 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
             };
         }
         else if (e instanceof pondError_1.EndpointError) {
-            errorMessage.event = enums_1.ErrorTypes.ENDPOINT_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.ENDPOINT_ERROR;
             errorMessage.payload = {
                 message: e.message,
                 code: e.code,
@@ -223,6 +222,4 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
         }
         __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, cache.socket, errorMessage);
     }
-}, _Endpoint_isObjectEmpty = function _Endpoint_isObjectEmpty(obj) {
-    return Object.keys(obj).length === 0;
 };

package/endpoint/endpoint.test.js

@@ -0,0 +1,297 @@
+"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 pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const superwstest_1 = __importDefault(require("superwstest"));
+const pondSocket_1 = require("../server/pondSocket");
+/* eslint-disable line-comment-position, no-inline-comments */
+describe('endpoint', () => {
+    let socket;
+    let server;
+    beforeEach((done) => {
+        socket = new pondSocket_1.PondSocket();
+        server = socket.listen(3000, 'localhost', done);
+    });
+    afterEach((done) => {
+        server.close(done);
+    });
+    it('should be able to close a single socket', () => __awaiter(void 0, void 0, void 0, function* () {
+        let count = 0;
+        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
+            if (req.params.room === 'socket') {
+                res.accept();
+                count++;
+                setTimeout(() => {
+                    endpoint.closeConnection(req.id);
+                }, 1000);
+            }
+            else {
+                res.reject();
+            }
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .wait(200)
+            .expectClosed();
+        expect(count).toBe(1);
+    }));
+    it('should be able to list connections', () => __awaiter(void 0, void 0, void 0, function* () {
+        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
+            if (req.params.room === 'socket') {
+                res.accept();
+                const connections = endpoint.listConnections();
+                expect(connections).toHaveLength(1);
+            }
+            else {
+                res.reject();
+            }
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101));
+    }));
+    it('should be able to refuse connections to the endpoint', () => __awaiter(void 0, void 0, void 0, function* () {
+        let count = 0;
+        socket.createEndpoint('/api/:path', (req, res) => {
+            count++;
+            expect(req.params.path).toBe('socket');
+            res.reject();
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101)) // the connection is still upgraded, so we can send error messages
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.ERROR,
+            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_CONNECTION,
+            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+            payload: {
+                message: 'Unauthorized connection',
+                code: 401,
+            },
+        }))
+            .expectClosed();
+        expect(count).toBe(1);
+    }));
+    it('should be able to send a message to all connection', () => __awaiter(void 0, void 0, void 0, function* () {
+        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
+            if (req.params.room === 'socket') {
+                res.accept();
+                const connections = endpoint.listConnections();
+                expect(connections).toHaveLength(1);
+                endpoint.broadcast('TEST', { test: 'test' });
+            }
+            else {
+                res.reject();
+            }
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .expectMessage(expect.objectContaining({
+            event: 'TEST',
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+            payload: {
+                test: 'test',
+            },
+        }));
+    }));
+    it('should be able to accept connections on this handler', () => __awaiter(void 0, void 0, void 0, function* () {
+        const message = {
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
+            if (req.params.room === 'socket') {
+                res.accept();
+            }
+            else {
+                res.reject();
+            }
+        });
+        endpoint.createChannel('/test/:room', (req, res) => {
+            expect(req.event.params.room).toBeDefined();
+            res.accept({
+                assigns: {
+                    status: 'online',
+                },
+            });
+        });
+        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' }))
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: '/socket/socket',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {},
+        }))
+            .close()
+            .expectClosed();
+    }));
+    it('should send an error when the channel exists but other things happen', () => __awaiter(void 0, void 0, void 0, function* () {
+        const message = {
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        endpoint.createChannel('/test/:room', (req, res) => {
+            expect(req.event.params.room).toBeDefined();
+            res.reject('Something went wrong');
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.ERROR,
+            channelName: '/test/socket',
+            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            payload: {
+                message: 'Request to join channel /test/socket rejected: Something went wrong',
+                code: 403,
+            },
+        }))
+            .close()
+            .expectClosed();
+    }));
+    it('should be able to track the presence of its users', () => __awaiter(void 0, void 0, void 0, function* () {
+        const message = {
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        endpoint.createChannel('/test/:room', (req, res) => {
+            expect(req.event.params.room).toBeDefined();
+            res
+                .accept()
+                .trackPresence({
+                status: 'online',
+            });
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: '/test/socket',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {},
+        }))
+            .close();
+    }));
+    it('should throw an error if accept, reject / send is called more than once', () => __awaiter(void 0, void 0, void 0, function* () {
+        socket.createEndpoint('/api/:room', (_, res) => {
+            res.send('hello', {
+                test: 'test',
+            });
+            expect(() => res.accept()).toThrowError('Cannot execute response more than once');
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+            event: 'hello',
+            payload: {
+                test: 'test',
+            },
+        }));
+    }));
+    it('should be able to connect, join a channel and send a message', () => __awaiter(void 0, void 0, void 0, function* () {
+        const message = {
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            channelName: '/test/socket',
+            event: 'TEST',
+            payload: {},
+        };
+        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
+            res.accept();
+        });
+        const channel = endpoint.createChannel('/test/:room', (req, res) => {
+            expect(req.event.params.room).toBeDefined();
+            res.accept();
+        });
+        channel.onEvent('echo', (req, res) => {
+            res.send('echo', req.event.payload);
+        });
+        channel.onEvent('broadcast', (req) => {
+            channel.broadcast('broadcast', Object.assign(Object.assign({}, req.event.payload), { broadcast: true }));
+        });
+        yield (0, superwstest_1.default)(server)
+            .ws('/api/socket')
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
+            .sendJson(message)
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: '/test/socket',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {},
+        }))
+            .sendJson({
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER,
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: '/test/socket',
+            event: 'echo',
+            payload: {
+                test: 'test',
+            },
+        })
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: '/test/socket',
+            event: 'echo',
+            payload: {
+                test: 'test',
+            },
+        }))
+            .sendJson({
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: '/test/socket',
+            event: 'broadcast',
+            payload: {
+                test: 'test',
+            },
+        })
+            .expectMessage(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: '/test/socket',
+            event: 'broadcast',
+            payload: {
+                test: 'test',
+                broadcast: true,
+            },
+        }));
+    }));
+});

package/endpoint/response.js

@@ -13,13 +13,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _ConnectionResponse_instances, _ConnectionResponse_webSocket, _ConnectionResponse_engine, _ConnectionResponse_clientId, _ConnectionResponse_executed, _ConnectionResponse_sendMessage, _ConnectionResponse_performChecks;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConnectionResponse = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const abstractResponse_1 = require("../abstracts/abstractResponse");
-const enums_1 = require("../enums");
 const pondError_1 = require("../errors/pondError");
-const uuid_1 = require("../misc/uuid");
 class ConnectionResponse extends abstractResponse_1.PondResponse {
     constructor(webSocket, engine, clientId) {
-        super((0, uuid_1.uuid)());
+        super((0, pondsocket_common_1.uuid)());
         _ConnectionResponse_instances.add(this);
         _ConnectionResponse_webSocket.set(this, void 0);
         _ConnectionResponse_engine.set(this, void 0);
@@ -60,7 +59,7 @@ class ConnectionResponse extends abstractResponse_1.PondResponse {
             message: message || 'Unauthorized connection',
             code: errorCode || 401,
         };
-        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, enums_1.ServerActions.ERROR, enums_1.ErrorTypes.UNAUTHORIZED_CONNECTION, payload);
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, pondsocket_common_1.ServerActions.ERROR, pondsocket_common_1.ErrorTypes.UNAUTHORIZED_CONNECTION, payload);
         __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f").close();
     }
     /**
@@ -71,7 +70,7 @@ class ConnectionResponse extends abstractResponse_1.PondResponse {
      */
     send(event, payload, assigns) {
         this.accept(assigns);
-        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
     }
 }
 exports.ConnectionResponse = ConnectionResponse;
@@ -81,7 +80,7 @@ _ConnectionResponse_webSocket = new WeakMap(), _ConnectionResponse_engine = new
         action,
         payload,
         requestId: this.requestId,
-        channelName: enums_1.SystemSender.ENDPOINT,
+        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
     };
     __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f").send(JSON.stringify(message));
 }, _ConnectionResponse_performChecks = function _ConnectionResponse_performChecks() {

package/index.d.ts

@@ -1,3 +1,5 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
 import { PondSocket } from './types';
 
 export default PondSocket;