@eleven-am/pondsocket 0.1.167 → 0.1.169

package/abstracts/abstractRequest.test.js

@@ -18,9 +18,11 @@ 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

@@ -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");
@@ -30,7 +21,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _ChannelEngine_instances, _ChannelEngine_receiver, _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, _Channel_engine;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -49,8 +40,6 @@ 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");
-        this.pubSubClient = parent.parent.getPubSubClient();
-        __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_initPubSub).call(this);
     }
     /**
      * @desc Gets the presence engine for the channel
@@ -178,7 +167,6 @@ class ChannelEngine {
             event,
             payload,
         };
-        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 }));
     }
@@ -224,15 +212,6 @@ class ChannelEngine {
     unsubscribeFrom(userId, channel) {
         __classPrivateFieldGet(this, _ChannelEngine_parentEngine, "f").parent.unsubscribeFrom(userId, channel);
     }
-    /**
-     * @desc Gets the presence from the pubSub client
-     */
-    getPubSubPresence() {
-        return __awaiter(this, void 0, void 0, function* () {
-            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_presenceEngine = new WeakMap(), _ChannelEngine_users = new WeakMap(), _ChannelEngine_parentEngine = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_subscribe = function _ChannelEngine_subscribe(userId, onMessage) {
@@ -298,21 +277,6 @@ _ChannelEngine_receiver = new WeakMap(), _ChannelEngine_presenceEngine = new Wea
     }
     unsubscribe();
     cachedUser.subscriptions.delete(this.name);
-}, _ChannelEngine_initPubSub = function _ChannelEngine_initPubSub() {
-    this.pubSubClient.subscribeToPresence(this.name, () => {
-        if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
-            return __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").getPresence();
-        }
-        return {};
-    });
-    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 {
     constructor(engine) {
@@ -373,12 +337,12 @@ class Channel {
         return this;
     }
     upsertPresence(userId, presence) {
-        const oldPresence = __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getInternalPresence()[userId];
+        const oldPresence = __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getPresence()[userId];
         if (oldPresence) {
-            void __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.updatePresence(userId, presence);
+            __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.updatePresence(userId, presence);
         }
         else {
-            void __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.trackPresence(userId, presence);
+            __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.trackPresence(userId, presence);
         }
         return this;
     }

package/channel/channel.test.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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createParentEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -116,7 +107,7 @@ describe('ChannelEngine', () => {
             test2: { test: 2 },
         });
     });
-    it('should be able to track presence', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should be able to track presence', () => {
         const onMessage = jest.fn();
         const { parentEngine } = (0, exports.createParentEngine)();
         const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
@@ -126,31 +117,32 @@ describe('ChannelEngine', () => {
             presence: {},
             id: 'test',
         });
-        yield channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        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', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    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);
-        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* () {
+        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);
-        yield channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
         expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
             channelName: 'test',
             action: pondsocket_common_1.ServerActions.PRESENCE,
@@ -162,31 +154,32 @@ describe('ChannelEngine', () => {
                 },
             },
         }));
-        yield channelEngine.presenceEngine.trackPresence('test2', { test: 3 });
-        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
+        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(5);
-    }));
-    it('should update a users presence', () => __awaiter(void 0, void 0, void 0, function* () {
+    });
+    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);
-        yield channelEngine.presenceEngine.trackPresence('test', { test: 2 });
+        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
         expect(channelEngine.getUserData('test')).toEqual({
             assigns: { test: 1 },
             presence: { test: 2 },
             id: 'test',
         });
-        yield channelEngine.presenceEngine.updatePresence('test', { test: 3 });
+        (_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, socket } = (0, exports.createParentEngine)();
@@ -199,23 +192,23 @@ describe('ChannelEngine', () => {
         expect(channelEngine.size).toEqual(0);
         expect(channelEngine.getUserData('test')).not.toBeDefined();
     });
-    it('should untrack presence when user is removed', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _a, _b;
+    it('should untrack presence when user is removed', () => {
+        var _a;
         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);
-        yield channelEngine.presenceEngine.trackPresence('test1', { test: 2 });
+        channelEngine.presenceEngine.trackPresence('test1', { test: 2 });
         channelEngine.addUser('test2', { test: 1 }, onMessage);
-        yield channelEngine.presenceEngine.trackPresence('test2', { test: 2 });
-        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
+        channelEngine.presenceEngine.trackPresence('test2', { test: 2 });
+        expect(channelEngine.presenceEngine.getPresence()).toEqual({
             test1: { test: 2 },
             test2: { test: 2 },
         });
         onMessage.mockClear();
         channelEngine.kickUser('test1', 'test reason');
-        expect(yield ((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence())).toEqual({
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
             test2: { test: 2 },
         });
         expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
@@ -229,18 +222,22 @@ describe('ChannelEngine', () => {
                 },
             },
         }));
-    }));
-    it('should throw error if user is not in channel and isPond is false', () => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
+    });
+    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
-        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');
-    }));
+        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);

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) {
-        void __classPrivateFieldGet(this, _EventResponse_engine, "f").presenceEngine.trackPresence(userId, presence);
+        __classPrivateFieldGet(this, _EventResponse_engine, "f").presenceEngine.trackPresence(userId, presence);
         return this;
     }
     /**

package/channel/eventResponse.test.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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createChannelEvent = exports.createChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -123,54 +114,62 @@ describe('ChannelResponse', () => {
         response.trackPresence({ status: 'online' });
         expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
     });
-    it('should throw an error if trackPresence is called twice', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should throw an error if trackPresence is called twice', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
         response.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 { channelEngine } = createChannelResponse();
+        const { response, 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', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should update the presence of a user that is already tracked', () => {
         var _a, _b;
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
         response.trackPresence({ status: 'online' });
         expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
             sender: { status: 'online' },
         });
         response.updatePresence({ status: 'offline' });
-        expect(yield ((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence())).toEqual({
+        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({
             sender: { status: 'offline' },
         });
-    }));
+    });
     it('should throw an error if updatePresence is called for a non existing user', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
         response.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', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should unTrack a trackPresence', () => {
+        var _a, _b;
         const { response, channelEngine } = createChannelResponse();
         response.trackPresence({ status: 'online' });
-        expect(yield channelEngine.presenceEngine.getPresence()).toEqual({
+        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
             sender: { status: 'online' },
         });
         response.removePresence();
-        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* () {
+        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({});
+    });
+    it('should throw an error if unTrackPresence is called for a non existing user', () => {
         var _a;
         const { response, channelEngine } = createChannelResponse();
         response.trackPresence({ status: 'online' });
-        expect(yield ((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence())).toEqual({
+        expect((_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/endpoint/endpoint.js

@@ -10,7 +10,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 _EndpointEngine_instances, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_channels, _EndpointEngine_sockets, _EndpointEngine_parentEngine, _EndpointEngine_client, _EndpointEngine_joinChannel, _EndpointEngine_broadcastMessage, _EndpointEngine_retrieveChannel, _EndpointEngine_handleMessage, _EndpointEngine_readMessage, _EndpointEngine_buildError, _EndpointEngine_leaveChannel, _Endpoint_engine;
+var _EndpointEngine_instances, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_channels, _EndpointEngine_sockets, _EndpointEngine_parentEngine, _EndpointEngine_joinChannel, _EndpointEngine_broadcastMessage, _EndpointEngine_retrieveChannel, _EndpointEngine_handleMessage, _EndpointEngine_readMessage, _EndpointEngine_buildError, _EndpointEngine_leaveChannel, _Endpoint_engine;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Endpoint = exports.EndpointEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -22,20 +22,18 @@ const joinResponse_1 = require("../lobby/joinResponse");
 const lobby_1 = require("../lobby/lobby");
 const matcher_1 = require("../matcher/matcher");
 class EndpointEngine {
-    constructor(parent, client) {
+    constructor(parent) {
         _EndpointEngine_instances.add(this);
         _EndpointEngine_middleware.set(this, void 0);
         _EndpointEngine_lobbyEngines.set(this, void 0);
         _EndpointEngine_channels.set(this, void 0);
         _EndpointEngine_sockets.set(this, void 0);
         _EndpointEngine_parentEngine.set(this, void 0);
-        _EndpointEngine_client.set(this, void 0);
         __classPrivateFieldSet(this, _EndpointEngine_sockets, new Map(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_middleware, new middleware_1.Middleware(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_lobbyEngines, new Map(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_parentEngine, parent, "f");
         __classPrivateFieldSet(this, _EndpointEngine_channels, new Map(), "f");
-        __classPrivateFieldSet(this, _EndpointEngine_client, client, "f");
     }
     get parent() {
         return __classPrivateFieldGet(this, _EndpointEngine_parentEngine, "f");
@@ -164,15 +162,9 @@ class EndpointEngine {
     sendMessage(socket, message) {
         socket.send(JSON.stringify(message));
     }
-    /**
-     * @desc Gets the PubSubClient for this endpoint
-     */
-    getPubSubClient() {
-        return __classPrivateFieldGet(this, _EndpointEngine_client, "f");
-    }
 }
 exports.EndpointEngine = EndpointEngine;
-_EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_channels = new WeakMap(), _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_parentEngine = new WeakMap(), _EndpointEngine_client = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_joinChannel = function _EndpointEngine_joinChannel(channel, socket, joinParams, requestId) {
+_EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_channels = new WeakMap(), _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_parentEngine = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_joinChannel = function _EndpointEngine_joinChannel(channel, socket, joinParams, requestId) {
     const cache = Object.assign(Object.assign({}, socket), { requestId, channelName: channel });
     __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").run(cache, joinParams, () => {
         throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);

package/endpoint/endpoint.test.js

@@ -16,7 +16,6 @@ exports.createEndpointEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const superwstest_1 = __importDefault(require("superwstest"));
 const pondSocket_1 = require("../server/pondSocket");
-/* eslint-disable line-comment-position, no-inline-comments */
 const createEndpointEngine = (socket) => ({
     createChannel: jest.fn(),
     listConnections: jest.fn(),
@@ -95,7 +94,7 @@ describe('endpoint', () => {
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101)) // the connection is still upgraded, so we can send error messages
+            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .expectMessage(expect.objectContaining({
             action: pondsocket_common_1.ServerActions.ERROR,
             event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_CONNECTION,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.167",
+  "version": "0.1.169",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -35,7 +35,6 @@
   },
   "dependencies": {
     "@eleven-am/pondsocket-common": "^0.0.23",
-    "ioredis": "^5.4.1",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/presence/presence.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");
@@ -19,7 +10,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, _PresenceEngine_getAllPresenceMap;
+var _PresenceEngine_instances, _PresenceEngine_presenceMap, _PresenceEngine_channel, _PresenceEngine_publish;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PresenceEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -33,28 +24,15 @@ class PresenceEngine {
         __classPrivateFieldSet(this, _PresenceEngine_presenceMap, new Map(), "f");
     }
     /**
-     * @desc Lists all the presence of the internal users
+     * @desc Lists all the presence of the users
      */
-    getInternalPresence() {
+    getPresence() {
         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
@@ -68,47 +46,39 @@ class PresenceEngine {
      * @param presence - The presence
      */
     trackPresence(presenceKey, presence) {
-        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);
-            }
-        });
+        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);
+        }
     }
     /**
      * @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_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;
-        });
+    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;
     }
     /**
      * @desc Updates a presence
@@ -116,24 +86,20 @@ class PresenceEngine {
      * @param presence - The new presence
      */
     updatePresence(presenceKey, presence) {
-        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);
-            }
-        });
+        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);
+        }
     }
 }
 exports.PresenceEngine = PresenceEngine;
@@ -143,12 +109,4 @@ _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,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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const presence_1 = require("./presence");
@@ -33,10 +24,10 @@ describe('PresenceEngine', () => {
         presenceKey = 'presenceKey';
     });
     describe('trackPresence', () => {
-        it('should insert a presence into the presence engine', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should insert a presence into the presence engine', () => {
             // spy on the channel sendMessage method
             const sendMessage = jest.spyOn(channel, 'sendMessage');
-            yield presenceEngine.trackPresence(presenceKey, presence);
+            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
@@ -50,15 +41,15 @@ describe('PresenceEngine', () => {
                     presence: [presence],
                 },
             ]);
-        }));
-        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`);
-        }));
+        });
+        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`);
+        });
     });
     describe('updatePresence', () => {
-        it('should update a presence', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield presenceEngine.trackPresence(presenceKey, presence);
+        it('should update a presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
             const newPresence = {
                 id: 'id',
                 name: 'name',
@@ -67,7 +58,7 @@ describe('PresenceEngine', () => {
                 location: 'location',
             };
             const sendMessage = jest.spyOn(channel, 'sendMessage');
-            yield presenceEngine.updatePresence(presenceKey, newPresence);
+            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
@@ -81,25 +72,25 @@ describe('PresenceEngine', () => {
                     presence: [newPresence],
                 },
             ]);
-        }));
-        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`);
-        }));
+        });
+        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`);
+        });
     });
     describe('removePresence', () => {
-        it('should remove a presence from the presence engine', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('should remove a presence from the presence engine', () => {
             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();
-            yield presenceEngine.trackPresence(presenceKey, presence);
-            yield presenceEngine.trackPresence('presenceKey2', Object.assign(Object.assign({}, presence), { key: 'presence2' }));
+            presenceEngine.trackPresence(presenceKey, presence);
+            presenceEngine.trackPresence('presenceKey2', Object.assign(Object.assign({}, presence), { key: 'presence2' }));
             expect(listener).toHaveBeenCalledTimes(2);
             // clear the mock
             listener.mockClear();
-            yield presenceEngine.removePresence(presenceKey);
+            presenceEngine.removePresence(presenceKey);
             expect(listener).toHaveBeenCalledTimes(1);
             // get all the params
             const params = listener.mock.calls[0];
@@ -117,22 +108,22 @@ describe('PresenceEngine', () => {
                 },
             ]);
             listener.mockClear();
-            yield presenceEngine.removePresence('presenceKey2');
+            presenceEngine.removePresence('presenceKey2');
             expect(listener).toHaveBeenCalledTimes(0);
-        }));
-        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();
-        }));
+        });
+        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();
+        });
     });
     describe('getPresence', () => {
-        it('should return the presence', () => __awaiter(void 0, void 0, void 0, function* () {
-            yield presenceEngine.trackPresence(presenceKey, presence);
+        it('should return the presence', () => {
+            presenceEngine.trackPresence(presenceKey, presence);
             const data = {};
             data[presenceKey] = presence;
-            expect(yield presenceEngine.getPresence()).toEqual(data);
-        }));
+            expect(presenceEngine.getPresence()).toEqual(data);
+        });
     });
 });

package/server/pondSocket.js

@@ -10,7 +10,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 _PondSocket_instances, _PondSocket_server, _PondSocket_pubSubEngine, _PondSocket_socketServer, _PondSocket_middleware, _PondSocket_manageHeartbeat, _PondSocket_init;
+var _PondSocket_instances, _PondSocket_server, _PondSocket_socketServer, _PondSocket_middleware, _PondSocket_manageHeartbeat, _PondSocket_init;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 const http_1 = require("http");
@@ -20,26 +20,15 @@ const middleware_1 = require("../abstracts/middleware");
 const endpoint_1 = require("../endpoint/endpoint");
 const response_1 = require("../endpoint/response");
 const matcher_1 = require("../matcher/matcher");
-const pubSubEngine_1 = require("../pubSub/pubSubEngine");
 class PondSocket {
-    constructor({ server, socketServer, db, redisUrl } = {}) {
+    constructor({ server, socketServer } = {}) {
         _PondSocket_instances.add(this);
         _PondSocket_server.set(this, void 0);
-        _PondSocket_pubSubEngine.set(this, void 0);
         _PondSocket_socketServer.set(this, void 0);
         _PondSocket_middleware.set(this, void 0);
         __classPrivateFieldSet(this, _PondSocket_server, server !== null && server !== void 0 ? server : new http_1.Server(), "f");
         __classPrivateFieldSet(this, _PondSocket_socketServer, socketServer !== null && socketServer !== void 0 ? socketServer : new ws_1.WebSocketServer({ noServer: true }), "f");
         __classPrivateFieldSet(this, _PondSocket_middleware, new middleware_1.Middleware(), "f");
-        if (redisUrl && db !== undefined) {
-            __classPrivateFieldSet(this, _PondSocket_pubSubEngine, new pubSubEngine_1.PubSubEngine({
-                redisUrl,
-                db,
-            }), "f");
-        }
-        else {
-            __classPrivateFieldSet(this, _PondSocket_pubSubEngine, new pubSubEngine_1.PubSubEngine(), "f");
-        }
         __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_init).call(this);
     }
     /**
@@ -73,8 +62,7 @@ class PondSocket {
      * })
      */
     createEndpoint(path, handler) {
-        const client = __classPrivateFieldGet(this, _PondSocket_pubSubEngine, "f").buildClient(path);
-        const endpoint = new endpoint_1.EndpointEngine(this, client);
+        const endpoint = new endpoint_1.EndpointEngine(this);
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, socket, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
             if (event) {
@@ -88,7 +76,7 @@ class PondSocket {
     }
 }
 exports.PondSocket = PondSocket;
-_PondSocket_server = new WeakMap(), _PondSocket_pubSubEngine = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
+_PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
     __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('connection', (socket) => {
         socket.on('pong', () => {
             socket.isAlive = true;
@@ -107,12 +95,10 @@ _PondSocket_server = new WeakMap(), _PondSocket_pubSubEngine = new WeakMap(), _P
     const timeout = __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_manageHeartbeat).call(this);
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('error', (error) => {
         clearInterval(timeout);
-        __classPrivateFieldGet(this, _PondSocket_pubSubEngine, "f").close();
         throw new Error(error.message);
     });
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('close', () => {
         clearInterval(timeout);
-        __classPrivateFieldGet(this, _PondSocket_pubSubEngine, "f").close();
     });
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', (req, socket, head) => {
         const clientId = req.headers['sec-websocket-key'];

package/types.d.ts

@@ -27,8 +27,6 @@ export type RequestHandler<Request, Response> = (request: Request, response: Res
 export interface PondSocketOptions {
     server?: HTTPServer;
     socketServer?: WebSocketServer;
-    redisUrl?: string;
-    db?: number;
 }
 
 export declare class PondSocket {
@@ -196,7 +194,7 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
     /**
      * @desc Gets the current presence data for the channel.
      */
-    getPresences(): Promise<Record<string, PresenceType>>;
+    getPresences(): Record<string, PresenceType>;
 
     /**
      * @desc Gets the assign date for a specific user.
@@ -290,7 +288,7 @@ export declare class AbstractRequest<Path extends string, PresenceType extends P
 
     assigns: Record<string, AssignType>;
 
-    getPresence(): Promise<Record<string, PresenceType>>;
+    getPresence(): Record<string, PresenceType>;
 }
 
 export declare class JoinRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {

package/pubSub/pubSubEngine.js

@@ -1,150 +0,0 @@
-"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");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _PubSubEngine_instances, _PubSubEngine_subscriber, _PubSubEngine_redis, _PubSubEngine_pubSub, _PubSubEngine_id, _PubSubEngine_expirationTime, _PubSubEngine_heartbeatInterval, _PubSubEngine_interval, _PubSubEngine_getPresence, _PubSubEngine_registerInstance, _PubSubEngine_getActiveInstances, _PubSubEngine_subscribeToChannel, _PubSubEngine_getPresenceFromInstance, _PubSubEngine_subscribeToPresence, _PubSubEngine_subscribe, _PubSubEngine_publish;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PubSubEngine = void 0;
-const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const ioredis_1 = __importDefault(require("ioredis"));
-class PubSubEngine {
-    constructor(options = null) {
-        _PubSubEngine_instances.add(this);
-        _PubSubEngine_subscriber.set(this, void 0);
-        _PubSubEngine_redis.set(this, void 0);
-        _PubSubEngine_pubSub.set(this, void 0);
-        _PubSubEngine_id.set(this, (0, pondsocket_common_1.uuid)());
-        _PubSubEngine_expirationTime.set(this, 60);
-        _PubSubEngine_heartbeatInterval.set(this, 5000);
-        _PubSubEngine_interval.set(this, void 0);
-        __classPrivateFieldSet(this, _PubSubEngine_subscriber, new pondsocket_common_1.Subject(), "f");
-        __classPrivateFieldSet(this, _PubSubEngine_redis, options ? new ioredis_1.default(options.redisUrl, { db: options.db }) : null, "f");
-        __classPrivateFieldSet(this, _PubSubEngine_pubSub, options ? new ioredis_1.default(options.redisUrl, { db: options.db }) : null, "f");
-        __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_subscribeToChannel).call(this);
-        __classPrivateFieldSet(this, _PubSubEngine_interval, setInterval(() => __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_registerInstance).call(this), __classPrivateFieldGet(this, _PubSubEngine_heartbeatInterval, "f")), "f");
-    }
-    /**
-     * @desc Builds a client for the given endpoint
-     * @param endpoint - the endpoint to build the client for
-     */
-    buildClient(endpoint) {
-        const subscribeToPresence = __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_subscribeToPresence).bind(this, endpoint);
-        const getPresence = __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_getPresence).bind(this, endpoint);
-        const subscribe = __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_subscribe).bind(this, endpoint);
-        const publish = __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_publish).bind(this, endpoint);
-        const client = {
-            getPresence,
-            publish,
-            subscribeToPresence,
-            subscribe,
-        };
-        return client;
-    }
-    /**
-     * @desc Closes the connection
-     */
-    close() {
-        var _a, _b;
-        clearInterval(__classPrivateFieldGet(this, _PubSubEngine_interval, "f"));
-        (_a = __classPrivateFieldGet(this, _PubSubEngine_redis, "f")) === null || _a === void 0 ? void 0 : _a.quit();
-        (_b = __classPrivateFieldGet(this, _PubSubEngine_pubSub, "f")) === null || _b === void 0 ? void 0 : _b.quit();
-    }
-}
-exports.PubSubEngine = PubSubEngine;
-_PubSubEngine_subscriber = new WeakMap(), _PubSubEngine_redis = new WeakMap(), _PubSubEngine_pubSub = new WeakMap(), _PubSubEngine_id = new WeakMap(), _PubSubEngine_expirationTime = new WeakMap(), _PubSubEngine_heartbeatInterval = new WeakMap(), _PubSubEngine_interval = new WeakMap(), _PubSubEngine_instances = new WeakSet(), _PubSubEngine_getPresence = function _PubSubEngine_getPresence(endpoint, channel) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const instances = yield __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_getActiveInstances).call(this);
-        return Promise.all(instances.map((instance) => __classPrivateFieldGet(this, _PubSubEngine_instances, "m", _PubSubEngine_getPresenceFromInstance).call(this, endpoint, channel, instance)));
-    });
-}, _PubSubEngine_registerInstance = function _PubSubEngine_registerInstance() {
-    if (!__classPrivateFieldGet(this, _PubSubEngine_redis, "f")) {
-        return;
-    }
-    __classPrivateFieldGet(this, _PubSubEngine_redis, "f").setex(`app:instance:${__classPrivateFieldGet(this, _PubSubEngine_id, "f")}`, __classPrivateFieldGet(this, _PubSubEngine_expirationTime, "f"), 'active');
-}, _PubSubEngine_getActiveInstances = function _PubSubEngine_getActiveInstances() {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!__classPrivateFieldGet(this, _PubSubEngine_redis, "f")) {
-            return [];
-        }
-        const keys = yield __classPrivateFieldGet(this, _PubSubEngine_redis, "f").keys('app:instance:*');
-        return keys.map((key) => key.replace('app:instance:', ''))
-            .filter((key) => key !== __classPrivateFieldGet(this, _PubSubEngine_id, "f"));
-    });
-}, _PubSubEngine_subscribeToChannel = function _PubSubEngine_subscribeToChannel() {
-    if (!__classPrivateFieldGet(this, _PubSubEngine_pubSub, "f")) {
-        return;
-    }
-    __classPrivateFieldGet(this, _PubSubEngine_pubSub, "f").subscribe('app:messages', (err) => {
-        if (err) {
-            console.error('Failed to subscribe: ', err);
-        }
-    });
-    __classPrivateFieldGet(this, _PubSubEngine_pubSub, "f").on('message', (channel, message) => {
-        const data = pondsocket_common_1.pubSubEventSchema.parse(JSON.parse(message));
-        if (data.pubSubId === __classPrivateFieldGet(this, _PubSubEngine_id, "f")) {
-            return;
-        }
-        __classPrivateFieldGet(this, _PubSubEngine_subscriber, "f").publish(data);
-    });
-}, _PubSubEngine_getPresenceFromInstance = function _PubSubEngine_getPresenceFromInstance(endpoint, channel, instance) {
-    return new Promise((resolve) => {
-        const unsubscribe = __classPrivateFieldGet(this, _PubSubEngine_subscriber, "f").subscribe((data) => {
-            if (data.endpoint === endpoint && data.channel === channel && data.event === pondsocket_common_1.PubSubEvents.PRESENCE && data.pubSubId === instance) {
-                resolve(data.presence);
-                unsubscribe();
-            }
-        });
-    });
-}, _PubSubEngine_subscribeToPresence = function _PubSubEngine_subscribeToPresence(endpoint, channel, handler) {
-    return __classPrivateFieldGet(this, _PubSubEngine_subscriber, "f").subscribe((data) => {
-        var _a;
-        if (data.endpoint === endpoint && data.channel === channel && data.event === pondsocket_common_1.PubSubEvents.GET_PRESENCE) {
-            const presence = handler();
-            const message = {
-                event: pondsocket_common_1.PubSubEvents.PRESENCE,
-                pubSubId: __classPrivateFieldGet(this, _PubSubEngine_id, "f"),
-                endpoint,
-                channel,
-                presence,
-            };
-            (_a = __classPrivateFieldGet(this, _PubSubEngine_pubSub, "f")) === null || _a === void 0 ? void 0 : _a.publish('app:messages', JSON.stringify(message));
-        }
-    });
-}, _PubSubEngine_subscribe = function _PubSubEngine_subscribe(endpoint, channel, handler) {
-    return __classPrivateFieldGet(this, _PubSubEngine_subscriber, "f").subscribe((data) => {
-        if (data.endpoint === endpoint && data.channel === channel && data.event === pondsocket_common_1.PubSubEvents.MESSAGE) {
-            handler(data.recipient, data.message);
-        }
-    });
-}, _PubSubEngine_publish = function _PubSubEngine_publish(endpoint, recipients, data) {
-    var _a;
-    const message = {
-        event: pondsocket_common_1.PubSubEvents.MESSAGE,
-        pubSubId: __classPrivateFieldGet(this, _PubSubEngine_id, "f"),
-        endpoint,
-        channel: data.channelName,
-        message: data,
-        recipient: recipients,
-    };
-    (_a = __classPrivateFieldGet(this, _PubSubEngine_redis, "f")) === null || _a === void 0 ? void 0 : _a.publish('app:messages', JSON.stringify(message));
-};