@eleven-am/pondsocket 0.1.141 → 0.1.143

package/endpoint/endpoint.test.js

@@ -12,19 +12,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEndpointEngine = void 0;
 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 */
+const createEndpointEngine = (socket) => ({
+    createChannel: jest.fn(),
+    listConnections: jest.fn(),
+    getClients: jest.fn(),
+    broadcast: jest.fn(),
+    closeConnection: jest.fn(),
+    manageSocket: jest.fn(),
+    getUser: () => socket,
+    subscribeTo: jest.fn(),
+    unsubscribeFrom: jest.fn(),
+});
+exports.createEndpointEngine = createEndpointEngine;
 describe('endpoint', () => {
     let socket;
     let server;
     beforeEach((done) => {
         socket = new pondSocket_1.PondSocket();
-        server = socket.listen(3000, 'localhost', done);
+        server = socket.listen(3000, 'localhost', () => {
+            done();
+        });
     });
     afterEach((done) => {
-        server.close(done);
+        server.close(() => {
+            done();
+        });
     });
     it('should be able to close a single socket', () => __awaiter(void 0, void 0, void 0, function* () {
         let count = 0;
@@ -37,7 +54,7 @@ describe('endpoint', () => {
                 }, 1000);
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         yield (0, superwstest_1.default)(server)
@@ -51,11 +68,11 @@ describe('endpoint', () => {
         const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
             if (req.params.room === 'socket') {
                 res.accept();
-                const connections = endpoint.listConnections();
+                const connections = endpoint.getClients();
                 expect(connections).toHaveLength(1);
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         yield (0, superwstest_1.default)(server)
@@ -67,7 +84,7 @@ describe('endpoint', () => {
         socket.createEndpoint('/api/:path', (req, res) => {
             count++;
             expect(req.params.path).toBe('socket');
-            res.reject();
+            res.decline();
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
@@ -88,12 +105,12 @@ describe('endpoint', () => {
         const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
             if (req.params.room === 'socket') {
                 res.accept();
-                const connections = endpoint.listConnections();
+                const connections = endpoint.getClients();
                 expect(connections).toHaveLength(1);
                 endpoint.broadcast('TEST', { test: 'test' });
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         yield (0, superwstest_1.default)(server)
@@ -120,12 +137,12 @@ describe('endpoint', () => {
                 res.accept();
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         endpoint.createChannel('/test/:room', (req, res) => {
             expect(req.event.params.room).toBeDefined();
-            res.accept({
+            res.accept().assign({
                 assigns: {
                     status: 'online',
                 },
@@ -162,7 +179,7 @@ describe('endpoint', () => {
         });
         endpoint.createChannel('/test/:room', (req, res) => {
             expect(req.event.params.room).toBeDefined();
-            res.reject('Something went wrong');
+            res.decline('Something went wrong');
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
@@ -212,7 +229,7 @@ describe('endpoint', () => {
     }));
     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', {
+            res.reply('hello', {
                 test: 'test',
             });
             expect(() => res.accept()).toThrowError('Cannot execute response more than once');
@@ -244,7 +261,7 @@ describe('endpoint', () => {
             res.accept();
         });
         channel.onEvent('echo', (req, res) => {
-            res.send('echo', req.event.payload);
+            res.reply('echo', req.event.payload);
         });
         channel.onEvent('broadcast', (req) => {
             channel.broadcast('broadcast', Object.assign(Object.assign({}, req.event.payload), { broadcast: true }));

package/endpoint/response.js

@@ -10,24 +10,26 @@ 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 _ConnectionResponse_instances, _ConnectionResponse_webSocket, _ConnectionResponse_engine, _ConnectionResponse_clientId, _ConnectionResponse_executed, _ConnectionResponse_sendMessage, _ConnectionResponse_performChecks;
+var _ConnectionResponse_instances, _ConnectionResponse_webSocket, _ConnectionResponse_engine, _ConnectionResponse_clientId, _ConnectionResponse_executed, _ConnectionResponse_assigns, _ConnectionResponse_requestId, _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 pondError_1 = require("../errors/pondError");
-class ConnectionResponse extends abstractResponse_1.PondResponse {
+class ConnectionResponse {
     constructor(webSocket, engine, clientId) {
-        super((0, pondsocket_common_1.uuid)());
         _ConnectionResponse_instances.add(this);
         _ConnectionResponse_webSocket.set(this, void 0);
         _ConnectionResponse_engine.set(this, void 0);
         _ConnectionResponse_clientId.set(this, void 0);
         _ConnectionResponse_executed.set(this, void 0);
+        _ConnectionResponse_assigns.set(this, void 0);
+        _ConnectionResponse_requestId.set(this, void 0);
         __classPrivateFieldSet(this, _ConnectionResponse_webSocket, webSocket, "f");
         __classPrivateFieldSet(this, _ConnectionResponse_engine, engine, "f");
         __classPrivateFieldSet(this, _ConnectionResponse_clientId, clientId, "f");
+        __classPrivateFieldSet(this, _ConnectionResponse_assigns, {}, "f");
         __classPrivateFieldSet(this, _ConnectionResponse_executed, false, "f");
+        __classPrivateFieldSet(this, _ConnectionResponse_requestId, (0, pondsocket_common_1.uuid)(), "f");
     }
     /**
      * @desc Whether the server has responded to the request
@@ -36,24 +38,40 @@ class ConnectionResponse extends abstractResponse_1.PondResponse {
         return __classPrivateFieldGet(this, _ConnectionResponse_executed, "f");
     }
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * @desc Assigns data to the user
+     * @param assigns - the data to assign
      */
-    accept(assigns) {
+    assign(assigns) {
+        if (!__classPrivateFieldGet(this, _ConnectionResponse_executed, "f")) {
+            __classPrivateFieldSet(this, _ConnectionResponse_assigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _ConnectionResponse_assigns, "f")), assigns), "f");
+        }
+        else {
+            const user = __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"));
+            user.assigns = Object.assign(Object.assign({}, user.assigns), assigns);
+        }
+        return this;
+    }
+    /**
+     * @desc Accepts the join request
+     */
+    accept() {
         __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_performChecks).call(this);
         const cache = {
             clientId: __classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"),
             socket: __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f"),
-            assigns: assigns || {},
+            assigns: __classPrivateFieldGet(this, _ConnectionResponse_assigns, "f"),
+            subscriptions: new Map(),
+            pendingSubscriptions: new Set(),
         };
         __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").manageSocket(cache);
+        return this;
     }
     /**
      * @desc Rejects the request with the given error message
      * @param message - the error message
      * @param errorCode - the error code
      */
-    reject(message, errorCode) {
+    decline(message, errorCode) {
         __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_performChecks).call(this);
         const payload = {
             message: message || 'Unauthorized connection',
@@ -66,20 +84,36 @@ class ConnectionResponse extends abstractResponse_1.PondResponse {
      * @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);
+    reply(event, payload) {
+        __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_performChecks).call(this);
         __classPrivateFieldGet(this, _ConnectionResponse_instances, "m", _ConnectionResponse_sendMessage).call(this, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+        return this;
+    }
+    /**
+     * @desc Subscribes the client to a channel
+     * @param channel - the channel to subscribe to
+     */
+    subscribeTo(channel) {
+        __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").subscribeTo(__classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"), channel);
+        return this;
+    }
+    /**
+     * @desc Unsubscribes the client from a channel
+     * @param channel - the channel to unsubscribe from
+     */
+    unsubscribeFrom(channel) {
+        __classPrivateFieldGet(this, _ConnectionResponse_engine, "f").unsubscribeFrom(__classPrivateFieldGet(this, _ConnectionResponse_clientId, "f"), channel);
+        return this;
     }
 }
 exports.ConnectionResponse = ConnectionResponse;
-_ConnectionResponse_webSocket = new WeakMap(), _ConnectionResponse_engine = new WeakMap(), _ConnectionResponse_clientId = new WeakMap(), _ConnectionResponse_executed = new WeakMap(), _ConnectionResponse_instances = new WeakSet(), _ConnectionResponse_sendMessage = function _ConnectionResponse_sendMessage(action, event, payload) {
+_ConnectionResponse_webSocket = new WeakMap(), _ConnectionResponse_engine = new WeakMap(), _ConnectionResponse_clientId = new WeakMap(), _ConnectionResponse_executed = new WeakMap(), _ConnectionResponse_assigns = new WeakMap(), _ConnectionResponse_requestId = new WeakMap(), _ConnectionResponse_instances = new WeakSet(), _ConnectionResponse_sendMessage = function _ConnectionResponse_sendMessage(action, event, payload) {
     const message = {
         event,
         action,
         payload,
-        requestId: this.requestId,
+        requestId: __classPrivateFieldGet(this, _ConnectionResponse_requestId, "f"),
         channelName: pondsocket_common_1.SystemSender.ENDPOINT,
     };
     __classPrivateFieldGet(this, _ConnectionResponse_webSocket, "f").send(JSON.stringify(message));

package/lobby/JoinRequest.test.js

@@ -1,18 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockSocket = void 0;
 const joinRequest_1 = require("./joinRequest");
 const eventResponse_test_1 = require("../channel/eventResponse.test");
-const createMockSocket = (params = {}) => {
-    const channelEngine = (0, eventResponse_test_1.createChannelEngine)();
+const createMockSocket = () => {
+    const { channelEngine } = (0, eventResponse_test_1.createChannelEngine)();
     const socket = {
         clientId: 'sender',
         assigns: { assign: 'assign' },
-        requestId: 'requestId',
         channelName: 'channel',
+        requestId: 'requestId',
+        subscriptions: new Map(),
+        pendingSubscriptions: new Set(),
         socket: {
             send: jest.fn(),
         },
     };
+    return {
+        channelEngine,
+        socket,
+    };
+};
+exports.createMockSocket = createMockSocket;
+const createJoinRequest = (params = {}) => {
+    const { channelEngine, socket } = (0, exports.createMockSocket)();
     const request = new joinRequest_1.JoinRequest(socket, params, channelEngine);
     return {
         channelEngine,
@@ -22,15 +33,15 @@ const createMockSocket = (params = {}) => {
 };
 describe('JoinRequest', () => {
     it('should create a new PondChannelResponse', () => {
-        const { request } = createMockSocket();
+        const { request } = createJoinRequest();
         expect(request).toBeDefined();
     });
     it('should return the join params', () => {
-        const { request } = createMockSocket({ params: 'params' });
+        const { request } = createJoinRequest({ params: 'params' });
         expect(request.joinParams).toEqual({ params: 'params' });
     });
     it('should return the user data', () => {
-        const { request } = createMockSocket();
+        const { request } = createJoinRequest();
         expect(request.user).toEqual({
             id: 'sender',
             assigns: { assign: 'assign' },

package/lobby/JoinResponse.test.js

@@ -1,19 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const JoinRequest_test_1 = require("./JoinRequest.test");
 const joinResponse_1 = require("./joinResponse");
-const eventResponse_test_1 = require("../channel/eventResponse.test");
 const createPondResponse = () => {
-    const channelEngine = (0, eventResponse_test_1.createChannelEngine)();
-    const socket = {
-        clientId: 'sender',
-        assigns: { assign: 'assign' },
-        channelName: 'channel',
-        requestId: 'requestId',
-        socket: {
-            send: jest.fn(),
-        },
-    };
+    const { channelEngine, socket } = (0, JoinRequest_test_1.createMockSocket)();
     const response = new joinResponse_1.JoinResponse(socket, channelEngine);
     return {
         channelEngine,
@@ -39,7 +30,7 @@ describe('JoinResponse', () => {
         const { response, channelEngine, socket } = createPondResponse();
         // spy on the channelEngine to see if the user was added
         jest.spyOn(channelEngine, 'addUser');
-        response.reject();
+        response.decline();
         // check if the response was sent
         expect(channelEngine.addUser).not.toHaveBeenCalled();
         expect(channelEngine.getUserData(socket.clientId)).toBeUndefined();
@@ -61,9 +52,12 @@ describe('JoinResponse', () => {
         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
+        response
+            .accept()
+            .reply('POND_MESSAGE', { message: 'message' })
+            .assign({ assign: 'assign' });
         expect(channelEngine.addUser).toHaveBeenCalled();
+        // check if the response was sent
         expect(channelEngine.getUserData(socket.clientId)).toStrictEqual({
             assigns: {
                 assign: 'assign',
@@ -98,27 +92,28 @@ describe('JoinResponse', () => {
         const { response, channelEngine } = createPondResponse();
         // spy on the channelEngine to see if any messages were published
         const broadcast = jest.spyOn(channelEngine, 'sendMessage');
+        const receiver = jest.fn();
         // add a second user to the channel
-        channelEngine.addUser('user2', { assign: 'assign' }, () => { });
+        channelEngine.addUser('user2', { assign: 'assign' }, receiver);
         // send a message to a single user
         // this is because the sender does not exist in the channel yet
-        expect(() => response.sendToUsers('hello_everyone', { message: 'hello' }, ['user2'])).toThrow();
+        expect(() => response.broadcastTo('hello_everyone', { message: 'hello' }, ['user2'])).toThrow();
         // clear the spy
         broadcast.mockClear();
         // add the sender to the channel by using the response.accept() method
-        response.accept().sendToUsers('hello_everyone', { message: 'hello' }, ['user2']);
+        response.accept().broadcastTo('hello_everyone', { message: 'hello' }, ['user2']);
         // check if the message was sent
-        expect(broadcast).toHaveBeenCalledWith('requestId', 'sender', ['user2'], pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('sender', ['user2'], pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' }, 'requestId');
         // clear the spy
         broadcast.mockClear();
         // send a message to all users
         response.broadcast('hello_everyone', { message: 'hello' });
-        expect(broadcast).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' }, 'requestId');
         // clear the spy
         broadcast.mockClear();
         // send a message to all users except the sender
-        response.broadcastFromUser('hello_everyone', { message: 'hello' });
-        expect(broadcast).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' });
+        response.broadcastFrom('hello_everyone', { message: 'hello' });
+        expect(broadcast).toHaveBeenCalledWith('sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'hello_everyone', { message: 'hello' }, 'requestId');
     });
     it('should be able to track the presence of users', () => {
         const { response, channelEngine } = createPondResponse();
@@ -139,7 +134,7 @@ describe('JoinResponse', () => {
         response.accept();
         expect(channelEngine.addUser).toHaveBeenCalledWith(socket.clientId, socket.assigns, expect.any(Function));
         expect(() => response.accept()).toThrow('Request to join channel test rejected: Request already executed');
-        expect(() => response.reject()).toThrow('Request to join channel test rejected: Request already executed');
-        expect(() => response.send('event', { payload: 'payload' })).toThrow('Request to join channel test rejected: Request already executed');
+        expect(() => response.decline()).toThrow('Request to join channel test rejected: Request already executed');
+        expect(() => response.reply('event', { payload: 'payload' })).not.toThrow();
     });
 });

package/lobby/joinResponse.js

@@ -10,22 +10,24 @@ 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 _JoinResponse_instances, _JoinResponse_user, _JoinResponse_engine, _JoinResponse_executed, _JoinResponse_performChecks;
+var _JoinResponse_instances, _JoinResponse_user, _JoinResponse_engine, _JoinResponse_newAssigns, _JoinResponse_executed, _JoinResponse_accepted, _JoinResponse_performChecks, _JoinResponse_sendMessage;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinResponse = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const abstractResponse_1 = require("../abstracts/abstractResponse");
 const pondError_1 = require("../errors/pondError");
-class JoinResponse extends abstractResponse_1.PondResponse {
+class JoinResponse {
     constructor(user, engine) {
-        super(user.requestId);
         _JoinResponse_instances.add(this);
         _JoinResponse_user.set(this, void 0);
         _JoinResponse_engine.set(this, void 0);
+        _JoinResponse_newAssigns.set(this, void 0);
         _JoinResponse_executed.set(this, void 0);
+        _JoinResponse_accepted.set(this, void 0);
         __classPrivateFieldSet(this, _JoinResponse_user, user, "f");
         __classPrivateFieldSet(this, _JoinResponse_engine, engine, "f");
         __classPrivateFieldSet(this, _JoinResponse_executed, false, "f");
+        __classPrivateFieldSet(this, _JoinResponse_accepted, false, "f");
+        __classPrivateFieldSet(this, _JoinResponse_newAssigns, Object.assign({}, user.assigns), "f");
     }
     /**
      * @desc Whether the server has responded to the request
@@ -34,23 +36,36 @@ class JoinResponse extends abstractResponse_1.PondResponse {
         return __classPrivateFieldGet(this, _JoinResponse_executed, "f");
     }
     /**
-     * @desc Accepts the request and optionally assigns data to the client
-     * @param assigns - the data to assign to the client
+     * @desc Assigns data to the client
+     * @param assigns - the data to assign
      */
-    accept(assigns) {
+    assign(assigns) {
+        if (__classPrivateFieldGet(this, _JoinResponse_accepted, "f")) {
+            __classPrivateFieldGet(this, _JoinResponse_engine, "f").updateAssigns(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, assigns);
+        }
+        else {
+            __classPrivateFieldSet(this, _JoinResponse_newAssigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _JoinResponse_newAssigns, "f")), assigns), "f");
+        }
+        return this;
+    }
+    /**
+     * @desc Accepts the join request to the channel
+     */
+    accept() {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
-        const newAssigns = Object.assign(Object.assign({}, assigns || {}), __classPrivateFieldGet(this, _JoinResponse_user, "f").assigns);
         const acknowledgement = {
             action: pondsocket_common_1.ServerActions.SYSTEM,
             channelName: __classPrivateFieldGet(this, _JoinResponse_engine, "f").name,
             event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            requestId: this.requestId,
+            requestId: __classPrivateFieldGet(this, _JoinResponse_user, "f").requestId,
             payload: {},
         };
         __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(acknowledgement));
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").addUser(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, newAssigns, (event) => {
+        const unsubscribe = __classPrivateFieldGet(this, _JoinResponse_engine, "f").addUser(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, __classPrivateFieldGet(this, _JoinResponse_newAssigns, "f"), (event) => {
             __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(event));
         });
+        __classPrivateFieldGet(this, _JoinResponse_user, "f").subscriptions.set(__classPrivateFieldGet(this, _JoinResponse_engine, "f").name, unsubscribe);
+        __classPrivateFieldSet(this, _JoinResponse_accepted, true, "f");
         return this;
     }
     /**
@@ -58,7 +73,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      * @param message - the error message
      * @param errorCode - the error code
      */
-    reject(message, errorCode) {
+    decline(message, errorCode) {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
         const errorMessage = {
             event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
@@ -68,7 +83,7 @@ class JoinResponse extends abstractResponse_1.PondResponse {
             },
             channelName: __classPrivateFieldGet(this, _JoinResponse_engine, "f").name,
             action: pondsocket_common_1.ServerActions.ERROR,
-            requestId: this.requestId,
+            requestId: __classPrivateFieldGet(this, _JoinResponse_user, "f").requestId,
         };
         __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(errorMessage));
         return this;
@@ -77,56 +92,80 @@ class JoinResponse extends abstractResponse_1.PondResponse {
      * @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);
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId], pondsocket_common_1.ServerActions.SYSTEM, event, payload);
+    reply(event, payload) {
+        const message = {
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: __classPrivateFieldGet(this, _JoinResponse_engine, "f").name,
+            requestId: __classPrivateFieldGet(this, _JoinResponse_user, "f").requestId,
+            payload,
+            event,
+        };
+        __classPrivateFieldGet(this, _JoinResponse_user, "f").socket.send(JSON.stringify(message));
         return this;
     }
     /**
-     * @desc Emits a message to all clients in the channel
-     * @param event - the event name
+     * @desc Sends a message to all clients in the channel
+     * @param event - the event to send
      * @param payload - the payload to send
      */
     broadcast(event, payload) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_USERS, event, payload);
         return this;
     }
     /**
-     * @desc Emits a message to all clients in the channel except the sender
-     * @param event - the event name
+     * @desc Sends a message to all clients in the channel except the client making the request
+     * @param event - the event to send
      * @param payload - the payload to send
      */
-    broadcastFromUser(event, payload) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    broadcastFrom(event, payload) {
+        __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, 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
+     * @desc Sends a message to a set of clients in the channel
+     * @param event - the event to send
+     * @param payload - the payload to send
      * @param userIds - the ids of the clients to send the message to
      */
-    sendToUsers(event, payload, userIds) {
-        __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, userIds, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
+    broadcastTo(event, payload, userIds) {
+        const ids = Array.isArray(userIds) ? userIds : [userIds];
+        __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_sendMessage).call(this, ids, event, payload);
         return this;
     }
     /**
-     * @desc tracks the presence of a client
-     * @param presence - the presence data to track
+     * @desc Tracks a user's presence in the channel
+     * @param presence - the initial presence data
      */
     trackPresence(presence) {
         __classPrivateFieldGet(this, _JoinResponse_engine, "f").presenceEngine.trackPresence(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, presence);
         return this;
     }
+    /**
+     * @desc Subscribes the client to a channel
+     * @param channel - the channel to subscribe to
+     */
+    subscribeTo(channel) {
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").subscribeTo(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, channel);
+        return this;
+    }
+    /**
+     * @desc Unsubscribes the client from a channel
+     * @param channel - the channel to unsubscribe from
+     */
+    unsubscribeFrom(channel) {
+        __classPrivateFieldGet(this, _JoinResponse_engine, "f").unsubscribeFrom(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, channel);
+        return this;
+    }
 }
 exports.JoinResponse = JoinResponse;
-_JoinResponse_user = new WeakMap(), _JoinResponse_engine = new WeakMap(), _JoinResponse_executed = new WeakMap(), _JoinResponse_instances = new WeakSet(), _JoinResponse_performChecks = function _JoinResponse_performChecks() {
+_JoinResponse_user = new WeakMap(), _JoinResponse_engine = new WeakMap(), _JoinResponse_newAssigns = new WeakMap(), _JoinResponse_executed = new WeakMap(), _JoinResponse_accepted = new WeakMap(), _JoinResponse_instances = new WeakSet(), _JoinResponse_performChecks = function _JoinResponse_performChecks() {
     if (__classPrivateFieldGet(this, _JoinResponse_executed, "f")) {
         const message = `Request to join channel ${__classPrivateFieldGet(this, _JoinResponse_engine, "f").name} rejected: Request already executed`;
         const code = 403;
         throw new pondError_1.ChannelError(message, code, __classPrivateFieldGet(this, _JoinResponse_engine, "f").name);
     }
     __classPrivateFieldSet(this, _JoinResponse_executed, true, "f");
+}, _JoinResponse_sendMessage = function _JoinResponse_sendMessage(recipient, event, payload) {
+    __classPrivateFieldGet(this, _JoinResponse_engine, "f").sendMessage(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, recipient, pondsocket_common_1.ServerActions.BROADCAST, event, payload, __classPrivateFieldGet(this, _JoinResponse_user, "f").requestId);
 };