@eleven-am/pondsocket 0.1.141 → 0.1.142

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 Accepts the join request
      */
-    accept(assigns) {
+    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 Assigns data to the user
+     * @param assigns - the data to assign
+     */
+    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 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,23 @@ 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 Accepts the join request to the channel
      */
-    accept(assigns) {
+    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 +60,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,65 +70,102 @@ 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;
     }
+    /**
+     * @desc Assigns data to the client
+     * @param assigns - the data to assign
+     */
+    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 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);
 };

package/lobby/lobby.js

@@ -10,20 +10,31 @@ 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 _LobbyEngine_channels, _LobbyEngine_middleware, _LobbyEngine_leaveCallback, _PondChannel_lobby;
+var _LobbyEngine_channels, _LobbyEngine_middleware, _LobbyEngine_leaveCallback, _LobbyEngine_parentEngine, _PondChannel_lobby;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondChannel = exports.LobbyEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const middleware_1 = require("../abstracts/middleware");
 const channel_1 = require("../channel/channel");
 class LobbyEngine {
-    constructor() {
+    constructor(endpointEngine) {
         _LobbyEngine_channels.set(this, void 0);
         _LobbyEngine_middleware.set(this, void 0);
         _LobbyEngine_leaveCallback.set(this, void 0);
+        _LobbyEngine_parentEngine.set(this, void 0);
+        __classPrivateFieldSet(this, _LobbyEngine_parentEngine, endpointEngine, "f");
         __classPrivateFieldSet(this, _LobbyEngine_channels, new Set(), "f");
         __classPrivateFieldSet(this, _LobbyEngine_middleware, new middleware_1.Middleware(), "f");
     }
+    get parent() {
+        return __classPrivateFieldGet(this, _LobbyEngine_parentEngine, "f");
+    }
+    get leaveCallback() {
+        return __classPrivateFieldGet(this, _LobbyEngine_leaveCallback, "f");
+    }
+    get middleware() {
+        return __classPrivateFieldGet(this, _LobbyEngine_middleware, "f");
+    }
     /**
      * @desc Handles an event request made by a user
      * @param event - The event to listen for
@@ -68,23 +79,14 @@ class LobbyEngine {
             if (!channel) {
                 throw new Error(`GatewayEngine: Channel ${channelName} does not exist`);
             }
-            channel.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
+            channel.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
         }
         else {
             __classPrivateFieldGet(this, _LobbyEngine_channels, "f").forEach((channel) => {
-                channel.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
+                channel.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
             });
         }
     }
-    /**
-     * @desc Removes a user from all channels
-     * @param clientId - The client id of the user to remove
-     */
-    removeUser(clientId) {
-        __classPrivateFieldGet(this, _LobbyEngine_channels, "f").forEach((channel) => {
-            channel.removeUser(clientId, true);
-        });
-    }
     /**
      * @desc Executes a function on a channel
      * @param channelName - The name of the channel to execute the function on
@@ -132,20 +134,14 @@ class LobbyEngine {
      * @private
      */
     createChannel(channelName) {
-        const destroyChannel = this.destroyChannel.bind(this, channelName);
-        const execute = __classPrivateFieldGet(this, _LobbyEngine_middleware, "f").run.bind(__classPrivateFieldGet(this, _LobbyEngine_middleware, "f"));
-        const parentEngine = {
-            execute,
-            destroyChannel,
-            leaveCallback: __classPrivateFieldGet(this, _LobbyEngine_leaveCallback, "f"),
-        };
-        const newChannel = new channel_1.ChannelEngine(channelName, parentEngine);
+        const newChannel = new channel_1.ChannelEngine(channelName, this);
+        __classPrivateFieldGet(this, _LobbyEngine_parentEngine, "f").subscribePendingUsers(newChannel);
         __classPrivateFieldGet(this, _LobbyEngine_channels, "f").add(newChannel);
         return newChannel;
     }
 }
 exports.LobbyEngine = LobbyEngine;
-_LobbyEngine_channels = new WeakMap(), _LobbyEngine_middleware = new WeakMap(), _LobbyEngine_leaveCallback = new WeakMap();
+_LobbyEngine_channels = new WeakMap(), _LobbyEngine_middleware = new WeakMap(), _LobbyEngine_leaveCallback = new WeakMap(), _LobbyEngine_parentEngine = new WeakMap();
 class PondChannel {
     constructor(lobby) {
         _PondChannel_lobby.set(this, void 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.141",
+  "version": "0.1.142",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "scripts": {
-    "test": "jest --coverage --verbose",
+    "test": "jest --coverage --verbose --forceExit --detectOpenHandles --runInBand --bail",
     "build": "rimraf dist && tsc && npm run remove",
     "lint": "eslint --ext .ts src",
     "lint:fix": "eslint --fix --ext .ts src",
@@ -34,22 +34,22 @@
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.10",
+    "@eleven-am/pondsocket-common": "^0.0.11",
     "ws": "^8.16.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.11",
-    "@types/node": "^20.11.5",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.20",
     "@types/websocket": "^1.0.10",
     "@types/ws": "^8.5.10",
-    "@typescript-eslint/eslint-plugin": "^6.19.0",
-    "eslint": "^8.56.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
+    "eslint": "^8.57.0",
     "eslint-plugin-file-progress": "^1.3.0",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
     "superwstest": "^2.0.3",
-    "ts-jest": "^29.1.1",
+    "ts-jest": "^29.1.2",
     "ts-node": "^10.9.2",
     "typescript": "^5.3.3"
   },

package/presence/presence.js

@@ -107,5 +107,5 @@ _PresenceEngine_presenceMap = new WeakMap(), _PresenceEngine_channel = new WeakM
     if (recipients.length === 0) {
         return;
     }
-    __classPrivateFieldGet(this, _PresenceEngine_channel, "f").sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, recipients, pondsocket_common_1.ServerActions.PRESENCE, event, payload);
+    __classPrivateFieldGet(this, _PresenceEngine_channel, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, recipients, pondsocket_common_1.ServerActions.PRESENCE, event, payload);
 };

package/presence/presenceEngine.test.js

@@ -9,7 +9,7 @@ describe('PresenceEngine', () => {
     let presenceKey;
     let channel;
     beforeEach(() => {
-        channel = (0, eventResponse_test_1.createChannelEngine)();
+        channel = (0, eventResponse_test_1.createChannelEngine)().channelEngine;
         channel.addUser('presenceKey', { assign: 'assign' }, () => {
             // do nothing
         });
@@ -33,7 +33,6 @@ describe('PresenceEngine', () => {
             // remove the first element as it contains the request id which is random
             params.shift();
             expect(params).toEqual([
-                pondsocket_common_1.SystemSender.CHANNEL,
                 ['presenceKey'],
                 pondsocket_common_1.ServerActions.PRESENCE,
                 pondsocket_common_1.PresenceEventTypes.JOIN,
@@ -65,7 +64,6 @@ describe('PresenceEngine', () => {
             // remove the first element as it contains the request id which is random
             params.shift();
             expect(params).toEqual([
-                pondsocket_common_1.SystemSender.CHANNEL,
                 ['presenceKey'],
                 pondsocket_common_1.ServerActions.PRESENCE,
                 pondsocket_common_1.PresenceEventTypes.UPDATE,
@@ -98,7 +96,6 @@ describe('PresenceEngine', () => {
             // remove the first element as it contains the request id which is random
             params.shift();
             expect(params).toEqual([
-                pondsocket_common_1.SystemSender.CHANNEL,
                 ['presenceKey2'],
                 pondsocket_common_1.ServerActions.PRESENCE,
                 pondsocket_common_1.PresenceEventTypes.LEAVE,

package/schema.js

@@ -9,5 +9,4 @@ exports.clientMessageSchema = zod_1.z.object({
     channelName: zod_1.z.string(),
     payload: zod_1.z.record(zod_1.z.any()),
     action: zod_1.z.nativeEnum(pondsocket_common_1.ClientActions),
-    addresses: zod_1.z.union([zod_1.z.nativeEnum(pondsocket_common_1.ChannelReceiver), zod_1.z.array(zod_1.z.string())]).optional(),
 });