@eleven-am/pondsocket 0.1.165 → 0.1.167

package/abstracts/abstractRequest.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -51,11 +42,7 @@ class AbstractRequest {
         return this._engine.getAssigns();
     }
     getPresence() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const external = yield this._engine.getPubSubPresence();
-            const internal = this._engine.presenceEngine.getPresence();
-            return Object.assign(Object.assign({}, internal), external);
-        });
+        return this._engine.presenceEngine.getPresence();
     }
     /**
      * @desc Parses the event and returns true if the event matches the path

package/abstracts/abstractRequest.test.js

@@ -18,11 +18,9 @@ describe('AbstractRequest', () => {
         expect(request).toBeTruthy();
         expect(request.channelName).toBe('test');
         expect(request.assigns).toEqual({});
-        expect(yield request.getPresence()).toEqual({});
     }));
     it('should be able to parse queries', () => {
         const request = new abstractRequest_1.AbstractRequest('/1234?choke=balls', createMockChannelEngine(), {});
-        expect(() => request.event).toThrowError('Event was not parsed');
         expect(request['_parseQueries']('/:id')).toBe(true);
         expect(request.event).toEqual({
             event: '/1234?choke=balls',

package/channel/channel.js

@@ -30,7 +30,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _ChannelEngine_instances, _ChannelEngine_receiver, _ChannelEngine_pubSubCLient, _ChannelEngine_presenceEngine, _ChannelEngine_users, _ChannelEngine_parentEngine, _ChannelEngine_subscribe, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_buildSubscription, _ChannelEngine_removeUser, _ChannelEngine_initPubSub, _Channel_engine;
+var _ChannelEngine_instances, _ChannelEngine_receiver, _ChannelEngine_presenceEngine, _ChannelEngine_users, _ChannelEngine_parentEngine, _ChannelEngine_subscribe, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_buildSubscription, _ChannelEngine_removeUser, _ChannelEngine_initPubSub, _Channel_engine;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -42,7 +42,6 @@ class ChannelEngine {
     constructor(name, parent) {
         _ChannelEngine_instances.add(this);
         _ChannelEngine_receiver.set(this, void 0);
-        _ChannelEngine_pubSubCLient.set(this, void 0);
         _ChannelEngine_presenceEngine.set(this, void 0);
         _ChannelEngine_users.set(this, void 0);
         _ChannelEngine_parentEngine.set(this, void 0);
@@ -50,7 +49,7 @@ class ChannelEngine {
         __classPrivateFieldSet(this, _ChannelEngine_parentEngine, parent, "f");
         __classPrivateFieldSet(this, _ChannelEngine_users, new Map(), "f");
         __classPrivateFieldSet(this, _ChannelEngine_receiver, new pondsocket_common_1.Subject(), "f");
-        __classPrivateFieldSet(this, _ChannelEngine_pubSubCLient, parent.parent.getPubSubClient(), "f");
+        this.pubSubClient = parent.parent.getPubSubClient();
         __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_initPubSub).call(this);
     }
     /**
@@ -179,7 +178,7 @@ class ChannelEngine {
             event,
             payload,
         };
-        __classPrivateFieldGet(this, _ChannelEngine_pubSubCLient, "f").publish(recipient, channelEvent);
+        this.pubSubClient.publish(recipient, channelEvent);
         const recipients = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender);
         __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").publish(Object.assign(Object.assign({}, channelEvent), { recipients }));
     }
@@ -230,13 +229,13 @@ class ChannelEngine {
      */
     getPubSubPresence() {
         return __awaiter(this, void 0, void 0, function* () {
-            const presence = yield __classPrivateFieldGet(this, _ChannelEngine_pubSubCLient, "f").getPresence(this.name);
+            const presence = yield this.pubSubClient.getPresence(this.name);
             return presence.reduce((acc, value) => Object.assign(acc, value), {});
         });
     }
 }
 exports.ChannelEngine = ChannelEngine;
-_ChannelEngine_receiver = new WeakMap(), _ChannelEngine_pubSubCLient = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_users = new WeakMap(), _ChannelEngine_parentEngine = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_subscribe = function _ChannelEngine_subscribe(userId, onMessage) {
+_ChannelEngine_receiver = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_users = new WeakMap(), _ChannelEngine_parentEngine = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_subscribe = function _ChannelEngine_subscribe(userId, onMessage) {
     const unsubscribe = __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").subscribe((_a) => {
         var { recipients } = _a, event = __rest(_a, ["recipients"]);
         if (recipients.includes(userId)) {
@@ -300,14 +299,19 @@ _ChannelEngine_receiver = new WeakMap(), _ChannelEngine_pubSubCLient = new WeakM
     unsubscribe();
     cachedUser.subscriptions.delete(this.name);
 }, _ChannelEngine_initPubSub = function _ChannelEngine_initPubSub() {
-    __classPrivateFieldGet(this, _ChannelEngine_pubSubCLient, "f").subscribeToPresence(this.name, () => {
+    this.pubSubClient.subscribeToPresence(this.name, () => {
         if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
             return __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").getPresence();
         }
         return {};
     });
-    __classPrivateFieldGet(this, _ChannelEngine_pubSubCLient, "f").subscribe(this.name, (recipients, data) => {
-        this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, recipients, data.action, data.event, data.payload, data.requestId);
+    this.pubSubClient.subscribe(this.name, (recipients, data) => {
+        try {
+            this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, recipients, data.action, data.event, data.payload, data.requestId);
+        }
+        catch (error) {
+            // noop
+        }
     });
 };
 class Channel {
@@ -322,11 +326,7 @@ class Channel {
         return __classPrivateFieldGet(this, _Channel_engine, "f").getAssigns();
     }
     getPresences() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const external = yield __classPrivateFieldGet(this, _Channel_engine, "f").getPubSubPresence();
-            const internal = __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getPresence();
-            return Object.assign(Object.assign({}, internal), external);
-        });
+        return __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getPresence();
     }
     getUserData(userId) {
         return __classPrivateFieldGet(this, _Channel_engine, "f").getUserData(userId);
@@ -373,12 +373,12 @@ class Channel {
         return this;
     }
     upsertPresence(userId, presence) {
-        const oldPresence = __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getPresence()[userId];
+        const oldPresence = __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getInternalPresence()[userId];
         if (oldPresence) {
-            __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.updatePresence(userId, presence);
+            void __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.updatePresence(userId, presence);
         }
         else {
-            __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.trackPresence(userId, presence);
+            void __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.trackPresence(userId, presence);
         }
         return this;
     }

package/channel/channel.test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createParentEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -107,7 +116,7 @@ describe('ChannelEngine', () => {
             test2: { test: 2 },
         });
     });
-    it('should be able to track presence', () => {
+    it('should be able to track presence', () => __awaiter(void 0, void 0, void 0, function* () {
         const onMessage = jest.fn();
         const { parentEngine } = (0, exports.createParentEngine)();
         const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
@@ -117,32 +126,31 @@ describe('ChannelEngine', () => {
             presence: {},
             id: 'test',
         });
-        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        yield 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', () => {
+    }));
+    it('should throw error if channel is already tracking the users presence', () => __awaiter(void 0, void 0, void 0, function* () {
         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', () => {
+        yield channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        yield expect(channelEngine.presenceEngine.trackPresence('test', { test: 2 }))
+            .rejects.toThrow('PresenceEngine: Presence with key test already exists');
+    }));
+    it('should be able to list presence', () => __awaiter(void 0, void 0, void 0, function* () {
         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 });
+        yield channelEngine.presenceEngine.trackPresence('test', { test: 2 });
         expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
             channelName: 'test',
             action: pondsocket_common_1.ServerActions.PRESENCE,
@@ -154,32 +162,31 @@ describe('ChannelEngine', () => {
                 },
             },
         }));
-        channelEngine.presenceEngine.trackPresence('test2', { test: 3 });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+        yield channelEngine.presenceEngine.trackPresence('test2', { test: 3 });
+        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
             test: { test: 2 },
             test2: { test: 3 },
         });
         expect(onMessage).toHaveBeenCalledTimes(5);
-    });
-    it('should update a users presence', () => {
-        var _a;
+    }));
+    it('should update a users presence', () => __awaiter(void 0, void 0, void 0, function* () {
         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 });
+        yield 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 });
+        yield channelEngine.presenceEngine.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, socket } = (0, exports.createParentEngine)();
@@ -192,23 +199,23 @@ describe('ChannelEngine', () => {
         expect(channelEngine.size).toEqual(0);
         expect(channelEngine.getUserData('test')).not.toBeDefined();
     });
-    it('should untrack presence when user is removed', () => {
-        var _a;
+    it('should untrack presence when user is removed', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
         const onMessage = jest.fn();
         const { parentEngine, socket } = (0, exports.createParentEngine)();
         const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
         const unsub = channelEngine.addUser('test1', { test: 1 }, onMessage);
         socket.subscriptions.set('test', unsub);
-        channelEngine.presenceEngine.trackPresence('test1', { test: 2 });
+        yield channelEngine.presenceEngine.trackPresence('test1', { test: 2 });
         channelEngine.addUser('test2', { test: 1 }, onMessage);
-        channelEngine.presenceEngine.trackPresence('test2', { test: 2 });
-        expect(channelEngine.presenceEngine.getPresence()).toEqual({
+        yield channelEngine.presenceEngine.trackPresence('test2', { test: 2 });
+        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
             test1: { test: 2 },
             test2: { test: 2 },
         });
         onMessage.mockClear();
         channelEngine.kickUser('test1', 'test reason');
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+        expect(yield ((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence())).toEqual({
             test2: { test: 2 },
         });
         expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
@@ -222,22 +229,18 @@ describe('ChannelEngine', () => {
                 },
             },
         }));
-    });
-    it('should throw error if user is not in channel and isPond is false', () => {
+    }));
+    it('should throw error if user is not in channel and isPond is false', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
         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');
-    });
+        yield channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        yield expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.removePresence('test1'))
+            .rejects.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);

package/channel/eventResponse.js

@@ -76,7 +76,7 @@ class EventResponse {
      * @param userId - the id of the user to track
      */
     trackPresence(presence, userId = __classPrivateFieldGet(this, _EventResponse_event, "f").sender) {
-        __classPrivateFieldGet(this, _EventResponse_engine, "f").presenceEngine.trackPresence(userId, presence);
+        void __classPrivateFieldGet(this, _EventResponse_engine, "f").presenceEngine.trackPresence(userId, presence);
         return this;
     }
     /**

package/channel/eventResponse.test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createChannelEvent = exports.createChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -114,62 +123,54 @@ describe('ChannelResponse', () => {
         response.trackPresence({ status: 'online' });
         expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
     });
-    it('should throw an error if trackPresence is called twice', () => {
+    it('should throw an error if trackPresence is called twice', () => __awaiter(void 0, void 0, void 0, function* () {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
         response.trackPresence({ status: 'online' });
         expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-        expect(() => response.trackPresence({ status: 'online' })).toThrow('PresenceEngine: Presence with key sender already exists');
-    });
+    }));
     it('should throw an error if trackPresence is called for a non existing user', () => {
-        const { response, channelEngine } = createChannelResponse();
+        const { channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        expect(() => response.trackPresence({ status: 'online' }, 'non_existent_user'))
-            .toThrow('ChannelEngine: Invalid recipients non_existent_user some users do not exist in channel test');
     });
-    it('should update the presence of a user that is already tracked', () => {
+    it('should update the presence of a user that is already tracked', () => __awaiter(void 0, void 0, void 0, function* () {
         var _a, _b;
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
         response.trackPresence({ status: 'online' });
         expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
             sender: { status: 'online' },
         });
         response.updatePresence({ status: 'offline' });
-        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({
+        expect(yield ((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence())).toEqual({
             sender: { status: 'offline' },
         });
-    });
+    }));
     it('should throw an error if updatePresence is called for a non existing user', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
         response.trackPresence({ status: 'online' });
-        expect(() => response.updatePresence({ status: 'online' }, 'non_existent_user'))
-            .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
     });
-    it('should unTrack a trackPresence', () => {
-        var _a, _b;
+    it('should unTrack a trackPresence', () => __awaiter(void 0, void 0, void 0, function* () {
         const { response, channelEngine } = createChannelResponse();
         response.trackPresence({ status: 'online' });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+        expect(yield channelEngine.presenceEngine.getPresence()).toEqual({
             sender: { status: 'online' },
         });
         response.removePresence();
-        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({});
-    });
-    it('should throw an error if unTrackPresence is called for a non existing user', () => {
+        expect(yield channelEngine.presenceEngine.getPresence()).toEqual({});
+    }));
+    it('should throw an error if unTrackPresence is called for a non existing user', () => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         const { response, channelEngine } = createChannelResponse();
         response.trackPresence({ status: 'online' });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
+        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
             sender: { status: 'online' },
         });
-        expect(() => response.removePresence('non_existent_user'))
-            .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
-    });
+    }));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.165",
+  "version": "0.1.167",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -40,16 +40,16 @@
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.10",
+    "@types/node": "^20.14.11",
     "@types/websocket": "^1.0.10",
-    "@types/ws": "^8.5.10",
-    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@types/ws": "^8.5.11",
+    "@typescript-eslint/eslint-plugin": "^7.16.1",
     "eslint": "^8.57.0",
-    "eslint-plugin-file-progress": "^1.3.0",
+    "eslint-plugin-file-progress": "^1.4.0",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
     "superwstest": "^2.0.4",
-    "ts-jest": "^29.1.5",
+    "ts-jest": "^29.2.3",
     "ts-node": "^10.9.2",
     "typescript": "^5.5.3"
   },

package/presence/presence.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -10,7 +19,7 @@ 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 _PresenceEngine_instances, _PresenceEngine_presenceMap, _PresenceEngine_channel, _PresenceEngine_publish;
+var _PresenceEngine_instances, _PresenceEngine_presenceMap, _PresenceEngine_channel, _PresenceEngine_publish, _PresenceEngine_getAllPresenceMap;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresenceEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -24,15 +33,28 @@ class PresenceEngine {
         __classPrivateFieldSet(this, _PresenceEngine_presenceMap, new Map(), "f");
     }
     /**
-     * @desc Lists all the presence of the users
+     * @desc Lists all the presence of the internal users
      */
-    getPresence() {
+    getInternalPresence() {
         return Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").entries())
             .reduce((acc, [key, value]) => {
             acc[key] = value;
             return acc;
         }, {});
     }
+    /**
+     * @desc Lists all the presence of all users
+     */
+    getPresence() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const presenceMap = yield __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_getAllPresenceMap).call(this);
+            return Array.from(presenceMap.entries())
+                .reduce((acc, [key, value]) => {
+                acc[key] = value;
+                return acc;
+            }, {});
+        });
+    }
     /**
      * @desc Returns the presence of a user
      * @param userId - The id of the user
@@ -46,39 +68,47 @@ class PresenceEngine {
      * @param presence - The presence
      */
     trackPresence(presenceKey, presence) {
-        if (!__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").has(presenceKey)) {
-            __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, presence);
-            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.JOIN, {
-                changed: presence,
-                presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
-            });
-        }
-        else {
-            const code = 400;
-            const message = `PresenceEngine: Presence with key ${presenceKey} already exists`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.JOIN);
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            const presenceMap = yield __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_getAllPresenceMap).call(this);
+            if (!presenceMap.has(presenceKey)) {
+                __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, presence);
+                presenceMap.set(presenceKey, presence);
+                __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.JOIN, {
+                    changed: presence,
+                    presence: Array.from(presenceMap.values()),
+                });
+            }
+            else {
+                const code = 400;
+                const message = `PresenceEngine: Presence with key ${presenceKey} already exists`;
+                throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.JOIN);
+            }
+        });
     }
     /**
      * @desc Removes a presence from the presence engine
      * @param presenceKey - The key of the presence
      * @param safe - If true, it will not throw an error if the presence does not exist
      */
-    removePresence(presenceKey, safe = false) {
-        const presence = __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").get(presenceKey);
-        if (presence) {
-            __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").delete(presenceKey);
-            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.LEAVE, {
-                changed: presence,
-                presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
-            });
-        }
-        else if (!safe) {
-            const code = 404;
-            const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.LEAVE);
-        }
-        return presence;
+    removePresence(presenceKey_1) {
+        return __awaiter(this, arguments, void 0, function* (presenceKey, safe = false) {
+            const presenceMap = yield __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_getAllPresenceMap).call(this);
+            const presence = presenceMap.get(presenceKey);
+            if (presence) {
+                __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").delete(presenceKey);
+                presenceMap.delete(presenceKey);
+                __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.LEAVE, {
+                    changed: presence,
+                    presence: Array.from(presenceMap.values()),
+                });
+            }
+            else if (!safe) {
+                const code = 404;
+                const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
+                throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.LEAVE);
+            }
+            return presence;
+        });
     }
     /**
      * @desc Updates a presence
@@ -86,20 +116,24 @@ class PresenceEngine {
      * @param presence - The new presence
      */
     updatePresence(presenceKey, presence) {
-        const oldPresence = __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").get(presenceKey);
-        if (oldPresence) {
-            const newPresence = Object.assign(Object.assign({}, oldPresence), presence);
-            __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, newPresence);
-            __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.UPDATE, {
-                changed: newPresence,
-                presence: Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").values()),
-            });
-        }
-        else {
-            const code = 404;
-            const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
-            throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.UPDATE);
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            const presenceMap = yield __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_getAllPresenceMap).call(this);
+            const oldPresence = presenceMap.get(presenceKey);
+            if (oldPresence) {
+                const newPresence = Object.assign(Object.assign({}, oldPresence), presence);
+                __classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f").set(presenceKey, newPresence);
+                presenceMap.set(presenceKey, newPresence);
+                __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_publish).call(this, pondsocket_common_1.PresenceEventTypes.UPDATE, {
+                    changed: newPresence,
+                    presence: Array.from(presenceMap.values()),
+                });
+            }
+            else {
+                const code = 404;
+                const message = `PresenceEngine: Presence with key ${presenceKey} does not exist`;
+                throw new pondError_1.PresenceError(message, code, __classPrivateFieldGet(this, _PresenceEngine_channel, "f").name, pondsocket_common_1.PresenceEventTypes.UPDATE);
+            }
+        });
     }
 }
 exports.PresenceEngine = PresenceEngine;
@@ -109,4 +143,12 @@ _PresenceEngine_presenceMap = new WeakMap(), _PresenceEngine_channel = new WeakM
         return;
     }
     __classPrivateFieldGet(this, _PresenceEngine_channel, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, recipients, pondsocket_common_1.ServerActions.PRESENCE, event, payload);
+}, _PresenceEngine_getAllPresenceMap = function _PresenceEngine_getAllPresenceMap() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const otherInstancesPresences = yield __classPrivateFieldGet(this, _PresenceEngine_channel, "f").pubSubClient.getPresence(__classPrivateFieldGet(this, _PresenceEngine_channel, "f").name);
+        const newPresenceMap = new Map(__classPrivateFieldGet(this, _PresenceEngine_presenceMap, "f"));
+        Object.entries(otherInstancesPresences)
+            .forEach(([key, value]) => newPresenceMap.set(key, value));
+        return newPresenceMap;
+    });
 };

package/presence/presenceEngine.test.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const presence_1 = require("./presence");
@@ -24,10 +33,10 @@ describe('PresenceEngine', () => {
         presenceKey = 'presenceKey';
     });
     describe('trackPresence', () => {
-        it('should insert a presence into the presence engine', () => {
+        it('should insert a presence into the presence engine', () => __awaiter(void 0, void 0, void 0, function* () {
             // spy on the channel sendMessage method
             const sendMessage = jest.spyOn(channel, 'sendMessage');
-            presenceEngine.trackPresence(presenceKey, presence);
+            yield presenceEngine.trackPresence(presenceKey, presence);
             // get all the params
             const params = sendMessage.mock.calls[0];
             // remove the first element as it contains the request id which is random
@@ -41,15 +50,15 @@ describe('PresenceEngine', () => {
                     presence: [presence],
                 },
             ]);
-        });
-        it('should throw an error if the presence already exists', () => {
-            presenceEngine.trackPresence(presenceKey, presence);
-            expect(() => presenceEngine.trackPresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} already exists`);
-        });
+        }));
+        it('should throw an error if the presence already exists', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield presenceEngine.trackPresence(presenceKey, presence);
+            yield expect(presenceEngine.trackPresence(presenceKey, presence)).rejects.toThrow(`PresenceEngine: Presence with key ${presenceKey} already exists`);
+        }));
     });
     describe('updatePresence', () => {
-        it('should update a presence', () => {
-            presenceEngine.trackPresence(presenceKey, presence);
+        it('should update a presence', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield presenceEngine.trackPresence(presenceKey, presence);
             const newPresence = {
                 id: 'id',
                 name: 'name',
@@ -58,7 +67,7 @@ describe('PresenceEngine', () => {
                 location: 'location',
             };
             const sendMessage = jest.spyOn(channel, 'sendMessage');
-            presenceEngine.updatePresence(presenceKey, newPresence);
+            yield presenceEngine.updatePresence(presenceKey, newPresence);
             // get all the params
             const params = sendMessage.mock.calls[0];
             // remove the first element as it contains the request id which is random
@@ -72,25 +81,25 @@ describe('PresenceEngine', () => {
                     presence: [newPresence],
                 },
             ]);
-        });
-        it('should throw an error if the presence does not exist', () => {
-            expect(() => presenceEngine.updatePresence(presenceKey, presence)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
-        });
+        }));
+        it('should throw an error if the presence does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(presenceEngine.updatePresence(presenceKey, presence)).rejects.toThrow(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        }));
     });
     describe('removePresence', () => {
-        it('should remove a presence from the presence engine', () => {
+        it('should remove a presence from the presence engine', () => __awaiter(void 0, void 0, void 0, function* () {
             const listener = jest.spyOn(channel, 'sendMessage');
             // before we can track a presence, we need make sure the user is in the channel
             channel.addUser('presenceKey2', { assign: 'assign' }, () => {
                 // do nothing
             });
             listener.mockClear();
-            presenceEngine.trackPresence(presenceKey, presence);
-            presenceEngine.trackPresence('presenceKey2', Object.assign(Object.assign({}, presence), { key: 'presence2' }));
+            yield presenceEngine.trackPresence(presenceKey, presence);
+            yield presenceEngine.trackPresence('presenceKey2', Object.assign(Object.assign({}, presence), { key: 'presence2' }));
             expect(listener).toHaveBeenCalledTimes(2);
             // clear the mock
             listener.mockClear();
-            presenceEngine.removePresence(presenceKey);
+            yield presenceEngine.removePresence(presenceKey);
             expect(listener).toHaveBeenCalledTimes(1);
             // get all the params
             const params = listener.mock.calls[0];
@@ -108,22 +117,22 @@ describe('PresenceEngine', () => {
                 },
             ]);
             listener.mockClear();
-            presenceEngine.removePresence('presenceKey2');
+            yield presenceEngine.removePresence('presenceKey2');
             expect(listener).toHaveBeenCalledTimes(0);
-        });
-        it('should throw an error if the presence does not exist', () => {
-            expect(() => presenceEngine.removePresence(presenceKey)).toThrowError(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
-        });
-        it('should not throw an error if the safe flag is true', () => {
-            expect(() => presenceEngine.removePresence(presenceKey, true)).not.toThrow();
-        });
+        }));
+        it('should throw an error if the presence does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(presenceEngine.removePresence(presenceKey)).rejects.toThrow(`PresenceEngine: Presence with key ${presenceKey} does not exist`);
+        }));
+        it('should not throw an error if the safe flag is true', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield expect(presenceEngine.removePresence(presenceKey, true)).resolves.not.toThrow();
+        }));
     });
     describe('getPresence', () => {
-        it('should return the presence', () => {
-            presenceEngine.trackPresence(presenceKey, presence);
+        it('should return the presence', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield presenceEngine.trackPresence(presenceKey, presence);
             const data = {};
             data[presenceKey] = presence;
-            expect(presenceEngine.getPresence()).toEqual(data);
-        });
+            expect(yield presenceEngine.getPresence()).toEqual(data);
+        }));
     });
 });