@eleven-am/pondsocket 0.1.126 → 0.1.127

package/channel/channel.test.js

@@ -0,0 +1,415 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParentEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const channel_1 = require("./channel");
+const eventRequest_1 = require("./eventRequest");
+const eventResponse_1 = require("./eventResponse");
+const createParentEngine = () => {
+    const parentEngine = {
+        destroyChannel: jest.fn(),
+        execute: jest.fn(),
+    };
+    return parentEngine;
+};
+exports.createParentEngine = createParentEngine;
+describe('ChannelEngine', () => {
+    it('should add user to channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        expect(channelEngine.size).toEqual(0);
+        expect(channelEngine.getUserData('test')).not.toBeDefined();
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine.size).toEqual(1);
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: {},
+            id: 'test',
+        });
+    });
+    it('should throw error if user is already in channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(() => {
+            channelEngine.addUser('test', { test: 1 }, onMessage);
+        }).toThrow('ChannelEngine: User with id test already exists in channel testChannel');
+    });
+    it('should throw error if user is not in channel: updateAssigns', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
+        expect(() => {
+            channelEngine.updateAssigns('test', { test: 2 });
+        }).toThrow('ChannelEngine: User with id test does not exist in channel testChannel');
+    });
+    it('should throw error if user is not in channel: removeUser', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
+        expect(() => {
+            channelEngine.removeUser('test');
+        }).toThrow('ChannelEngine: User with id test does not exist in channel testChannel');
+    });
+    it('should update a users assigns', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: {},
+            id: 'test',
+        });
+        channelEngine.updateAssigns('test', { test: 2 });
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 2 },
+            presence: {},
+            id: 'test',
+        });
+    });
+    it('should be able to get users assigns in the channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        expect(channelEngine.getAssigns()).toEqual({});
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine.getAssigns()).toEqual({
+            test: { test: 1 },
+        });
+        channelEngine.addUser('test2', { test: 2 }, onMessage);
+        expect(channelEngine.getAssigns()).toEqual({
+            test: { test: 1 },
+            test2: { test: 2 },
+        });
+    });
+    it('should be able to track presence', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: {},
+            id: 'test',
+        });
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        expect(channelEngine.presenceEngine).toBeDefined();
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: { test: 2 },
+            id: 'test',
+        });
+    });
+    it('should throw error if channel is already tracking the users presence', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        expect(() => {
+            channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        }).toThrow('PresenceEngine: Presence with key test already exists');
+    });
+    it('should be able to list presence', () => {
+        var _a;
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 2 }, onMessage);
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
+            channelName: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.JOIN,
+            payload: {
+                presence: [{ test: 2 }],
+                changed: {
+                    test: 2,
+                },
+            },
+        }));
+        channelEngine.presenceEngine.trackPresence('test2', { test: 3 });
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+            test: { test: 2 },
+            test2: { test: 3 },
+        });
+        expect(onMessage).toHaveBeenCalledTimes(3);
+    });
+    it('should update a users presence', () => {
+        var _a;
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: { test: 2 },
+            id: 'test',
+        });
+        (_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.updatePresence('test', { test: 3 });
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: { test: 3 },
+            id: 'test',
+        });
+    });
+    it('should remove user from channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine.size).toEqual(1);
+        expect(channelEngine.getUserData('test')).toBeDefined();
+        channelEngine.removeUser('test');
+        expect(channelEngine.size).toEqual(0);
+        expect(channelEngine.getUserData('test')).not.toBeDefined();
+    });
+    it('should untrack presence when user is removed', () => {
+        var _a, _b;
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.presenceEngine.trackPresence('test2', { test: 2 });
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+            test: { test: 2 },
+            test2: { test: 2 },
+        });
+        onMessage.mockClear();
+        channelEngine.removeUser('test');
+        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({
+            test2: { test: 2 },
+        });
+        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
+            channelName: 'test',
+            event: pondsocket_common_1.PresenceEventTypes.LEAVE,
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            payload: {
+                presence: [{ test: 2 }],
+                changed: {
+                    test: 2,
+                },
+            },
+        }));
+    });
+    it('should throw error if user is not in channel and isPond is false', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
+        // add a user to the channel
+        channelEngine.addUser('test', { test: 1 }, jest.fn());
+        // track the added user's presence
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        // we do this because we want to initialize the presence engine
+        // the engine is not initialized by default when a channel is created
+        expect(() => {
+            var _a;
+            // now we try to untrack the presence of a user that is not in the channel
+            (_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.removePresence('test1');
+        }).toThrow('PresenceEngine: Presence with key test1 does not exist');
+    });
+    it('should not throw error if user is not in channel and isPond is true', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
+        // add a user to the channel
+        channelEngine.addUser('test', { test: 1 }, jest.fn());
+        // track the added user's presence
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        // we do this because we want to initialize the presence engine
+        // the engine is not initialized by default when a xhannel is created
+        expect(() => {
+            var _a;
+            // now we try to untrack the presence of a user that is not in the channel
+            (_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.removePresence('test');
+        }).not.toThrow();
+    });
+    it('should be able to kick a user from the channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.kickUser('test2', 'test reason');
+        expect(channelEngine.size).toEqual(1);
+        expect(channelEngine.getUserData('test2')).not.toBeDefined();
+        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: 'test',
+            event: 'kicked_out',
+            payload: {
+                code: 403,
+                message: 'test reason',
+            },
+        }));
+        expect(onMessage.mock.calls[1][0]).toStrictEqual(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: 'test',
+            event: 'kicked',
+            payload: {
+                reason: 'test reason',
+                userId: 'test2',
+            },
+        }));
+        expect(onMessage).toHaveBeenCalledTimes(2);
+    });
+    it('should call destroy on parent engine', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.destroy('test');
+        expect(parentEngine.destroyChannel).toHaveBeenCalled();
+    });
+    it('should broadcast a message to all users', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        parentEngine.execute = (_, res) => {
+            res.accept();
+        };
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 2 });
+        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 2,
+            },
+        }));
+        expect(onMessage).toHaveBeenCalledTimes(2);
+        onMessage.mockClear();
+        channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), 'test2', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        expect(onMessage).toHaveBeenCalledTimes(1);
+        onMessage.mockClear();
+        // when user is not in channel it throws an error
+        expect(() => {
+            channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), 'test3', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow('ChannelEngine: User with id test3 does not exist in channel test');
+    });
+    it('should broadcast a message to all users except sender', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        parentEngine.execute = (_, res) => {
+            res.accept();
+        };
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), 'test2', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 2 });
+        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 2,
+            },
+        }));
+        expect(onMessage).toHaveBeenCalledTimes(1);
+        // when user is not in channel it throws an error
+        expect(() => {
+            channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), 'test3', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow('ChannelEngine: User with id test3 does not exist in channel test');
+        // when sender is channel itself it throws an error
+        expect(() => {
+            channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow(`ChannelEngine: Cannot use ${pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER} with ${pondsocket_common_1.SystemSender.CHANNEL}`);
+    });
+    it('should broadcast a message to  specific users', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        parentEngine.execute = (_, res) => {
+            res.accept();
+        };
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.addUser('test3', { test: 1 }, onMessage);
+        channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), 'test2', ['test', 'test3'], pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 2 });
+        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 2,
+            },
+        }));
+        expect(onMessage.mock.calls[1][0]).toStrictEqual(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 2,
+            },
+        }));
+        expect(onMessage).toHaveBeenCalledTimes(2);
+        // when recipient is not in channel it throws an error
+        expect(() => {
+            channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), 'test3', ['test', 'test3', 'test4'], pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow('ChannelEngine: Invalid recipients test,test3,test4 some users do not exist in channel test');
+        // when sender is not in channel it throws an error
+        expect(() => {
+            channelEngine.sendMessage((0, pondsocket_common_1.uuid)(), 'test4', ['test', 'test3'], pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow('ChannelEngine: User with id test4 does not exist in channel test');
+    });
+    it('should broadcast messages while also triggering the onMessage callback', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+        parentEngine.execute = (req, res) => {
+            expect(req).toBeInstanceOf(eventRequest_1.EventRequest);
+            expect(res).toBeInstanceOf(eventResponse_1.EventResponse);
+            res.accept();
+        };
+        expect(() => channelEngine.broadcastMessage('test2', {
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: { test: 1 },
+            requestId: (0, pondsocket_common_1.uuid)(),
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+        })).toThrow('ChannelEngine: User with id test2 does not exist in channel test');
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.broadcastMessage('test2', {
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: { test: 1 },
+            requestId: (0, pondsocket_common_1.uuid)(),
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+        });
+        expect(onMessage).toHaveBeenCalledTimes(1);
+        let count = 0;
+        onMessage.mockClear();
+        parentEngine.execute = (req, res, next) => {
+            expect(req).toBeInstanceOf(eventRequest_1.EventRequest);
+            expect(res).toBeInstanceOf(eventResponse_1.EventResponse);
+            count++;
+            next();
+        };
+        channelEngine.broadcastMessage('test2', {
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: { test: 1 },
+            requestId: (0, pondsocket_common_1.uuid)(),
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+        });
+        // proves that the message was received by the parent engine
+        expect(count).toBe(1);
+        // however the onMessage callback was not called
+        // because the message was never handled by the parent engine
+        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ServerActions.ERROR,
+            channelName: 'test',
+            event: pondsocket_common_1.ErrorTypes.HANDLER_NOT_FOUND,
+            payload: {
+                code: 404,
+                message: 'A handler did not respond to the event',
+            },
+        }));
+    });
+});

package/channel/eventRequest.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const eventRequest_1 = require("./eventRequest");
+const eventResponse_test_1 = require("./eventResponse.test");
+describe('ChannelRequest', () => {
+    it('should create a new ChannelRequest', () => {
+        const channelEngine = (0, eventResponse_test_1.createChannelEngine)();
+        const event = (0, eventResponse_test_1.createChannelEvent)(channelEngine.name);
+        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
+        expect(channelRequest).toBeDefined();
+    });
+    it('should return the payload', () => {
+        const channelEngine = (0, eventResponse_test_1.createChannelEngine)();
+        const event = (0, eventResponse_test_1.createChannelEvent)(channelEngine.name);
+        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
+        channelRequest._parseQueries('event');
+        expect(channelRequest.event.payload).toEqual(event.payload);
+    });
+    it('should return the user', () => {
+        const channelEngine = (0, eventResponse_test_1.createChannelEngine)();
+        const event = (0, eventResponse_test_1.createChannelEvent)(channelEngine.name);
+        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
+        // because the user in the event does not exist in the channel, this should throw an error
+        expect(() => channelRequest.user).toThrow();
+        // add the user to the channel
+        channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
+        // now the user should be returned
+        expect(channelRequest.user).toEqual(channelEngine.getUserData(event.sender));
+    });
+});

package/channel/eventResponse.js

@@ -13,8 +13,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _EventResponse_instances, _EventResponse_event, _EventResponse_engine, _EventResponse_executed, _EventResponse_manageAssigns, _EventResponse_performChecks;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventResponse = 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");
 class EventResponse extends abstractResponse_1.PondResponse {
     constructor(event, engine) {
@@ -51,7 +51,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
     reject(message, errorCode, assigns) {
         __classPrivateFieldGet(this, _EventResponse_instances, "m", _EventResponse_manageAssigns).call(this, assigns);
         const text = message || 'Unauthorized request';
-        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, enums_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], enums_1.ServerActions.ERROR, enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST, {
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], pondsocket_common_1.ServerActions.ERROR, pondsocket_common_1.ErrorTypes.UNAUTHORIZED_BROADCAST, {
             message: text,
             code: errorCode || 403,
         });
@@ -65,7 +65,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
      */
     send(event, payload, assigns) {
         this.accept(assigns);
-        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, enums_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], enums_1.ServerActions.SYSTEM, event, payload);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], pondsocket_common_1.ServerActions.SYSTEM, event, payload);
     }
     /**
      * @desc Emits a direct message to the client without accepting the request
@@ -75,7 +75,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
      */
     sendOnly(event, payload, assigns) {
         __classPrivateFieldGet(this, _EventResponse_instances, "m", _EventResponse_manageAssigns).call(this, assigns);
-        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, enums_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], enums_1.ServerActions.SYSTEM, event, payload);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], pondsocket_common_1.ServerActions.SYSTEM, event, payload);
     }
     /**
      * @desc Sends a message to all clients in the channel
@@ -83,7 +83,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
      * @param payload - the payload to send
      */
     broadcast(event, payload) {
-        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _EventResponse_event, "f").sender, enums_1.ChannelReceiver.ALL_USERS, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _EventResponse_event, "f").sender, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
     /**
@@ -92,7 +92,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
      * @param payload - the payload to send
      */
     broadcastFromUser(event, payload) {
-        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _EventResponse_event, "f").sender, enums_1.ChannelReceiver.ALL_EXCEPT_SENDER, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _EventResponse_event, "f").sender, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
     /**
@@ -102,7 +102,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
      * @param userIds - the ids of the clients to send the message to
      */
     sendToUsers(event, payload, userIds) {
-        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _EventResponse_event, "f").sender, userIds, enums_1.ServerActions.BROADCAST, event, payload);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(this.requestId, __classPrivateFieldGet(this, _EventResponse_event, "f").sender, userIds, pondsocket_common_1.ServerActions.BROADCAST, event, payload);
         return this;
     }
     /**