@eleven-am/pondsocket 0.1.160 → 0.1.162

package/abstracts/abstractRequest.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");
@@ -41,8 +50,12 @@ class AbstractRequest {
     get assigns() {
         return this._engine.getAssigns();
     }
-    get presence() {
-        return this._engine.presenceEngine.getPresence();
+    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);
+        });
     }
     /**
      * @desc Parses the event and returns true if the event matches the path

package/abstracts/abstractRequest.test.js

@@ -1,16 +1,25 @@
 "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 abstractRequest_1 = require("./abstractRequest");
 const eventResponse_test_1 = require("../channel/eventResponse.test");
 const createMockChannelEngine = () => (0, eventResponse_test_1.createChannelEngine)().channelEngine;
 describe('AbstractRequest', () => {
-    it('should be able to be instantiated', () => {
+    it('should be able to be instantiated', () => __awaiter(void 0, void 0, void 0, function* () {
         const request = new abstractRequest_1.AbstractRequest('/test', createMockChannelEngine(), {});
         expect(request).toBeTruthy();
         expect(request.channelName).toBe('test');
         expect(request.assigns).toEqual({});
-        expect(request.presence).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');

package/channel/channel.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");
@@ -21,7 +30,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, _Channel_engine;
+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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Channel = exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
@@ -33,13 +42,16 @@ 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);
         this.name = name;
-        __classPrivateFieldSet(this, _ChannelEngine_receiver, new pondsocket_common_1.Subject(), "f");
-        __classPrivateFieldSet(this, _ChannelEngine_users, new Map(), "f");
         __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");
+        __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_initPubSub).call(this);
     }
     /**
      * @desc Gets the presence engine for the channel
@@ -160,15 +172,16 @@ class ChannelEngine {
         if (!__classPrivateFieldGet(this, _ChannelEngine_users, "f").has(sender) && sender !== pondsocket_common_1.SystemSender.CHANNEL) {
             throw new pondError_1.ChannelError(`ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`, 404, this.name);
         }
-        const eventMessage = {
-            recipients: __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender),
+        const channelEvent = {
             channelName: this.name,
             requestId,
             action,
-            payload,
             event,
+            payload,
         };
-        __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").publish(eventMessage);
+        __classPrivateFieldGet(this, _ChannelEngine_pubSubCLient, "f").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 }));
     }
     /**
      * @desc Handles a message from a user
@@ -212,9 +225,18 @@ 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 __classPrivateFieldGet(this, _ChannelEngine_pubSubCLient, "f").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) {
+_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) {
     const unsubscribe = __classPrivateFieldGet(this, _ChannelEngine_receiver, "f").subscribe((_a) => {
         var { recipients } = _a, event = __rest(_a, ["recipients"]);
         if (recipients.includes(userId)) {
@@ -277,6 +299,16 @@ _ChannelEngine_receiver = new WeakMap(), _ChannelEngine_presenceEngine = new Wea
     }
     unsubscribe();
     cachedUser.subscriptions.delete(this.name);
+}, _ChannelEngine_initPubSub = function _ChannelEngine_initPubSub() {
+    __classPrivateFieldGet(this, _ChannelEngine_pubSubCLient, "f").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);
+    });
 };
 class Channel {
     constructor(engine) {
@@ -290,7 +322,11 @@ class Channel {
         return __classPrivateFieldGet(this, _Channel_engine, "f").getAssigns();
     }
     getPresences() {
-        return __classPrivateFieldGet(this, _Channel_engine, "f").presenceEngine.getPresence();
+        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);
+        });
     }
     getUserData(userId) {
         return __classPrivateFieldGet(this, _Channel_engine, "f").getUserData(userId);

package/channel/channel.test.js

@@ -77,7 +77,7 @@ describe('ChannelEngine', () => {
     });
     it('should update a users assigns', () => {
         const onMessage = jest.fn();
-        const { parentEngine, socket } = (0, exports.createParentEngine)();
+        const { parentEngine } = (0, exports.createParentEngine)();
         const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
         channelEngine.addUser('test', { test: 1 }, onMessage);
         expect(channelEngine.getUserData('test')).toEqual({
@@ -293,9 +293,6 @@ describe('ChannelEngine', () => {
     it('should broadcast a message to all users', () => {
         const onMessage = jest.fn();
         const { parentEngine } = (0, exports.createParentEngine)();
-        parentEngine.middleware.run = (_, res) => {
-            // res.accept();
-        };
         const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
         channelEngine.addUser('test', { test: 1 }, onMessage);
         channelEngine.addUser('test2', { test: 1 }, onMessage);
@@ -322,9 +319,6 @@ describe('ChannelEngine', () => {
     it('should broadcast a message to all users except sender', () => {
         const onMessage = jest.fn();
         const { parentEngine } = (0, exports.createParentEngine)();
-        parentEngine.middleware.run = (_, res) => {
-            // res.accept();
-        };
         const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
         channelEngine.addUser('test', { test: 1 }, onMessage);
         channelEngine.addUser('test2', { test: 1 }, onMessage);
@@ -351,9 +345,6 @@ describe('ChannelEngine', () => {
     it('should broadcast a message to  specific users', () => {
         const onMessage = jest.fn();
         const { parentEngine } = (0, exports.createParentEngine)();
-        parentEngine.middleware.run = (_, res) => {
-            // res.accept();
-        };
         const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
         channelEngine.addUser('test', { test: 1 }, onMessage);
         channelEngine.addUser('test2', { test: 1 }, onMessage);

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_channels, _EndpointEngine_sockets, _EndpointEngine_parentEngine, _EndpointEngine_joinChannel, _EndpointEngine_execute, _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_client, _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,16 +22,20 @@ const joinResponse_1 = require("../lobby/joinResponse");
 const lobby_1 = require("../lobby/lobby");
 const matcher_1 = require("../matcher/matcher");
 class EndpointEngine {
-    constructor(parent) {
+    constructor(parent, client) {
         _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_channels, new Map(), "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");
@@ -47,7 +51,7 @@ class EndpointEngine {
      *         response.accept();
      *
      *     else
-     *         response.reject('You are not an admin', 403);
+     *         response.decline('You are not an admin', 403);
      * });
      */
     createChannel(path, handler) {
@@ -55,16 +59,16 @@ class EndpointEngine {
         __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
             const event = (0, matcher_1.parseAddress)(path, user.channelName);
             if (event) {
-                const newChannel = pondChannel.getChannel(user.channelName) || pondChannel.createChannel(user.channelName);
-                const request = new joinRequest_1.JoinRequest(user, joinParams, newChannel);
-                const response = new joinResponse_1.JoinResponse(user, newChannel);
-                if (request._parseQueries(path)) {
-                    return handler(request, response);
-                }
+                const channel = pondChannel.getChannel(user.channelName) || pondChannel.createChannel(user.channelName);
+                const request = new joinRequest_1.JoinRequest(user, joinParams, channel);
+                const response = new joinResponse_1.JoinResponse(user, channel);
+                request._parseQueries(path);
+                __classPrivateFieldGet(this, _EndpointEngine_channels, "f").set(user.channelName, channel);
+                return handler(request, response);
             }
             next();
         });
-        __classPrivateFieldGet(this, _EndpointEngine_channels, "f").set(path, pondChannel);
+        __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").set(path, pondChannel);
         return new lobby_1.PondChannel(pondChannel);
     }
     /**
@@ -73,23 +77,6 @@ class EndpointEngine {
     getClients() {
         return [...__classPrivateFieldGet(this, _EndpointEngine_sockets, "f").values()];
     }
-    /**
-     * @desc Broadcasts a message to all clients connected to this endpoint
-     * @param event - The event to broadcast
-     * @param payload - The payload to broadcast
-     */
-    broadcast(event, payload) {
-        __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").forEach(({ socket }) => {
-            const message = {
-                event,
-                payload,
-                requestId: (0, pondsocket_common_1.uuid)(),
-                action: pondsocket_common_1.ServerActions.BROADCAST,
-                channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-            };
-            this.sendMessage(socket, message);
-        });
-    }
     /**
      * @desc Closes specific clients connected to this endpoint
      * @param clientIds - The id for the client / clients to close
@@ -177,23 +164,28 @@ 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_channels = new WeakMap(), _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_parentEngine = 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_client = 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);
     });
-}, _EndpointEngine_execute = function _EndpointEngine_execute(channel, handler) {
-    for (const [path, manager] of __classPrivateFieldGet(this, _EndpointEngine_channels, "f")) {
-        const event = (0, matcher_1.parseAddress)(path, channel);
-        if (event) {
-            return manager.execute(channel, handler);
-        }
+}, _EndpointEngine_broadcastMessage = function _EndpointEngine_broadcastMessage(cache, message) {
+    const engine = __classPrivateFieldGet(this, _EndpointEngine_channels, "f").get(message.channelName);
+    if (!engine) {
+        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${message.channelName} does not exist`, 404);
     }
+    engine.broadcastMessage(cache.clientId, message);
 }, _EndpointEngine_retrieveChannel = function _EndpointEngine_retrieveChannel(channel) {
     let channelEngine;
-    for (const [path, manager] of __classPrivateFieldGet(this, _EndpointEngine_channels, "f")) {
+    for (const [path, manager] of __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f")) {
         const event = (0, matcher_1.parseAddress)(path, channel);
         if (event) {
             channelEngine = manager.getChannel(channel) || manager.createChannel(channel);
@@ -213,9 +205,7 @@ _EndpointEngine_middleware = new WeakMap(), _EndpointEngine_channels = new WeakM
             __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_leaveChannel).call(this, message.channelName, cache);
             break;
         case pondsocket_common_1.ClientActions.BROADCAST:
-            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_execute).call(this, message.channelName, (channel) => {
-                channel.broadcastMessage(cache.clientId, message);
-            });
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_broadcastMessage).call(this, cache, message);
             break;
         default:
             throw new Error(`GatewayEngine: Action ${message.action} does not exist`);
@@ -306,9 +296,6 @@ class Endpoint {
     createChannel(path, handler) {
         return __classPrivateFieldGet(this, _Endpoint_engine, "f").createChannel(path, handler);
     }
-    broadcast(event, payload) {
-        __classPrivateFieldGet(this, _Endpoint_engine, "f").broadcast(event, payload);
-    }
     closeConnection(clientIds) {
         __classPrivateFieldGet(this, _Endpoint_engine, "f").closeConnection(clientIds);
     }

package/endpoint/endpoint.test.js

@@ -28,6 +28,12 @@ const createEndpointEngine = (socket) => ({
     subscribeTo: jest.fn(),
     unsubscribeFrom: jest.fn(),
     sendMessage: (socket, msg) => socket.send(JSON.stringify(msg)),
+    getPubSubClient: () => ({
+        publish: jest.fn(),
+        subscribeToPresence: jest.fn(),
+        subscribe: jest.fn(),
+        getPresence: () => new Promise((resolve) => setTimeout(() => resolve([]), 100)),
+    }),
 });
 exports.createEndpointEngine = createEndpointEngine;
 describe('endpoint', () => {
@@ -102,30 +108,6 @@ describe('endpoint', () => {
             .expectClosed();
         expect(count).toBe(1);
     }));
-    it('should be able to send a message to all connection', () => __awaiter(void 0, void 0, void 0, function* () {
-        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
-            if (req.params.room === 'socket') {
-                res.accept();
-                const connections = endpoint.getClients();
-                expect(connections).toHaveLength(1);
-                endpoint.broadcast('TEST', { test: 'test' });
-            }
-            else {
-                res.decline();
-            }
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .expectMessage(expect.objectContaining({
-            event: 'TEST',
-            action: pondsocket_common_1.ServerActions.BROADCAST,
-            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-            payload: {
-                test: 'test',
-            },
-        }));
-    }));
     it('should be able to accept connections on this handler', () => __awaiter(void 0, void 0, void 0, function* () {
         const message = {
             action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
@@ -266,7 +248,9 @@ describe('endpoint', () => {
             res.reply('echo', req.event.payload);
         });
         channel.onEvent('broadcast', (req) => {
-            channel.broadcast('broadcast', Object.assign(Object.assign({}, req.event.payload), { broadcast: true }));
+            const internal = channel.getChannel('/test/socket');
+            expect(internal).toBeDefined();
+            internal.broadcast('broadcast', Object.assign(Object.assign({}, req.event.payload), { broadcast: true }));
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')

package/lobby/lobby.js

@@ -13,7 +13,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _LobbyEngine_channels, _LobbyEngine_middleware, _LobbyEngine_leaveCallback, _LobbyEngine_parentEngine, _PondChannel_lobby;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondChannel = exports.LobbyEngine = void 0;
-const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const middleware_1 = require("../abstracts/middleware");
 const channel_1 = require("../channel/channel");
 class LobbyEngine {
@@ -70,45 +69,6 @@ class LobbyEngine {
     onLeave(callback) {
         __classPrivateFieldSet(this, _LobbyEngine_leaveCallback, callback, "f");
     }
-    /**
-     * @desc Broadcasts a message to all users in a channel
-     * @param event - The event to broadcast
-     * @param payload - The payload to send
-     * @param channelName - The channel to broadcast to (if not specified, broadcast to all channels)
-     * @example
-     * pond.broadcast('echo', {
-     *    message: 'Hello World',
-     *    timestamp: Date.now(),
-     *    channel: 'my_channel',
-     *});
-     */
-    broadcast(event, payload, channelName) {
-        if (channelName) {
-            const channel = this.getChannel(channelName);
-            if (!channel) {
-                throw new Error(`GatewayEngine: Channel ${channelName} does not exist`);
-            }
-            channel.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
-        }
-        else {
-            __classPrivateFieldGet(this, _LobbyEngine_channels, "f").forEach((channel) => {
-                channel.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, event, payload);
-            });
-        }
-    }
-    /**
-     * @desc Executes a function on a channel
-     * @param channelName - The name of the channel to execute the function on
-     * @param handler - The function to execute
-     * @private
-     */
-    execute(channelName, handler) {
-        const newChannel = this.getChannel(channelName);
-        if (newChannel) {
-            return handler(newChannel);
-        }
-        throw new Error(`GatewayEngine: Channel ${channelName} does not exist`);
-    }
     /**
      * @desc Gets a channel by name
      * @param channelName - The name of the channel to get
@@ -150,9 +110,6 @@ class PondChannel {
     onEvent(event, handler) {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").onEvent(event, handler);
     }
-    broadcast(event, payload, channelName) {
-        __classPrivateFieldGet(this, _PondChannel_lobby, "f").broadcast(event, payload, channelName);
-    }
     onLeave(callback) {
         __classPrivateFieldGet(this, _PondChannel_lobby, "f").onLeave(callback);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.160",
+  "version": "0.1.162",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -34,12 +34,13 @@
     "url": "git+https://github.com/Eleven-am/pondSocket.git"
   },
   "dependencies": {
-    "@eleven-am/pondsocket-common": "^0.0.18",
-    "ws": "^8.17.1"
+    "@eleven-am/pondsocket-common": "^0.0.23",
+    "ioredis": "^5.4.1",
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "@types/node": "^20.14.9",
+    "@types/node": "^20.14.10",
     "@types/websocket": "^1.0.10",
     "@types/ws": "^8.5.10",
     "@typescript-eslint/eslint-plugin": "^7.1.0",
@@ -47,10 +48,10 @@
     "eslint-plugin-file-progress": "^1.3.0",
     "eslint-plugin-import": "^2.29.1",
     "jest": "^29.7.0",
-    "superwstest": "^2.0.3",
+    "superwstest": "^2.0.4",
     "ts-jest": "^29.1.5",
     "ts-node": "^10.9.2",
-    "typescript": "^5.5.2"
+    "typescript": "^5.5.3"
   },
   "jest": {
     "moduleFileExtensions": [

package/pubSub/pubSubEngine.js

@@ -0,0 +1,150 @@
+"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_pubSub, "f")) === null || _a === void 0 ? void 0 : _a.publish('app:messages', JSON.stringify(message));
+};

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_socketServer, _PondSocket_middleware, _PondSocket_manageHeartbeat, _PondSocket_init;
+var _PondSocket_instances, _PondSocket_server, _PondSocket_pubSubEngine, _PondSocket_socketServer, _PondSocket_middleware, _PondSocket_manageHeartbeat, _PondSocket_init;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 const http_1 = require("http");
@@ -20,15 +20,26 @@ 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) {
+    constructor({ server, socketServer, db, redisUrl } = {}) {
         _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);
     }
     /**
@@ -62,7 +73,8 @@ class PondSocket {
      * })
      */
     createEndpoint(path, handler) {
-        const endpoint = new endpoint_1.EndpointEngine(this);
+        const client = __classPrivateFieldGet(this, _PondSocket_pubSubEngine, "f").buildClient(path);
+        const endpoint = new endpoint_1.EndpointEngine(this, client);
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, socket, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
             if (event) {
@@ -76,7 +88,7 @@ class PondSocket {
     }
 }
 exports.PondSocket = PondSocket;
-_PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
+_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() {
     __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('connection', (socket) => {
         socket.on('pong', () => {
             socket.isAlive = true;
@@ -95,10 +107,12 @@ _PondSocket_server = new WeakMap(), _PondSocket_socketServer = 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

@@ -24,8 +24,15 @@ export type LeaveCallback<EventTypes extends PondEventMap = PondEventMap, Presen
 
 export type RequestHandler<Request, Response> = (request: Request, response: Response) => void | Promise<void>;
 
+export interface PondSocketOptions {
+    server?: HTTPServer;
+    socketServer?: WebSocketServer;
+    redisUrl?: string;
+    db?: number;
+}
+
 export declare class PondSocket {
-    constructor(server?: HTTPServer, socketServer?: WebSocketServer);
+    constructor(options?: PondSocketOptions);
 
     /**
      * @desc Specifies the port to listen on
@@ -158,7 +165,7 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
     /**
      * @desc Gets the current presence data for the channel.
      */
-    getPresences(): Record<string, PresenceType>;
+    getPresences(): Promise<Record<string, PresenceType>>;
 
     /**
      * @desc Gets the assign date for a specific user.
@@ -252,7 +259,7 @@ export declare class AbstractRequest<Path extends string, PresenceType extends P
 
     assigns: Record<string, AssignType>;
 
-    presence: Record<string, PresenceType>;
+    getPresence(): Promise<Record<string, PresenceType>>;
 }
 
 export declare class JoinRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> extends AbstractRequest<Path, PresenceType, AssignType> {