@eleven-am/pondsocket 0.1.141 → 0.1.142

package/channel/eventResponse.test.js

@@ -6,8 +6,13 @@ const channel_1 = require("./channel");
 const channel_test_1 = require("./channel.test");
 const eventResponse_1 = require("./eventResponse");
 const createChannelEngine = () => {
-    const parentEngine = (0, channel_test_1.createParentEngine)();
-    return new channel_1.ChannelEngine('test', parentEngine);
+    const { parentEngine, socket } = (0, channel_test_1.createParentEngine)();
+    const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
+    return {
+        channelEngine,
+        parentEngine,
+        socket,
+    };
 };
 exports.createChannelEngine = createChannelEngine;
 const createChannelEvent = (name) => {
@@ -18,7 +23,6 @@ const createChannelEvent = (name) => {
         },
         sender: 'sender',
         action: pondsocket_common_1.ServerActions.BROADCAST,
-        recipients: ['recipient'],
         channelName: name,
         requestId: 'requestId',
     };
@@ -26,10 +30,11 @@ const createChannelEvent = (name) => {
 };
 exports.createChannelEvent = createChannelEvent;
 const createChannelResponse = () => {
-    const channelEngine = (0, exports.createChannelEngine)();
+    const { channelEngine, socket } = (0, exports.createChannelEngine)();
     const event = (0, exports.createChannelEvent)(channelEngine.name);
-    channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
-    channelEngine.addUser(event.recipients[0], { assign: 'assign' }, () => { });
+    const unsub = channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
+    socket.subscriptions.set(channelEngine.name, unsub);
+    channelEngine.addUser('tester', { assign: 'assign' }, () => { });
     const response = new eventResponse_1.EventResponse(event, channelEngine);
     return {
         channelEngine,
@@ -42,52 +47,36 @@ describe('ChannelResponse', () => {
         const { response } = createChannelResponse();
         expect(response).toBeDefined();
     });
-    it('should accept the request', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.accept();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-    it('should reject the request', () => {
-        const { response, channelEngine, event } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.reject();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_1.ServerActions.ERROR, pondsocket_common_1.ErrorTypes.UNAUTHORIZED_BROADCAST, {
-            message: 'Unauthorized request',
-            code: 403,
-        });
-    });
     it('should send a direct message', () => {
         const { response, channelEngine, event } = createChannelResponse();
         jest.spyOn(channelEngine, 'sendMessage');
-        response.send('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_1.ServerActions.SYSTEM, 'event', { payload: 'payload' });
+        response.reply('event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith(pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_1.ServerActions.SYSTEM, 'event', { payload: 'payload' }, 'requestId');
     });
     it('should broadcast a message', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine, 'sendMessage');
         response.broadcast('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
     });
     it('should broadcastFromUser a message', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcastFromUser('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+        response.broadcastFrom('event', { payload: 'payload' });
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
     });
     it('should sendToUsers a message', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine, 'sendMessage');
-        response.sendToUsers('event', { payload: 'payload' }, ['recipient']);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+        response.broadcastTo('event', { payload: 'payload' }, 'tester');
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['tester'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
+        channelEngine.sendMessage.mockClear();
+        response.broadcastTo('event', { payload: 'payload' }, ['tester', 'sender']);
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['tester', 'sender'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
     });
     it('should fail to send to non existing users', () => {
-        const { event, response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        event.recipients = ['non_existing_user'];
-        expect(() => response.accept()).toThrow('ChannelEngine: Invalid recipients non_existing_user some users do not exist in channel test');
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', event.sender, ['non_existing_user'], pondsocket_common_1.ServerActions.BROADCAST, event.event, event.payload);
-        expect(() => response.sendToUsers('event', { payload: 'payload' }, ['non_existing_user']))
+        const { response } = createChannelResponse();
+        expect(() => response.broadcastTo('event', { payload: 'payload' }, ['non_existing_user']))
             .toThrow('ChannelEngine: Invalid recipients non_existing_user some users do not exist in channel test');
     });
     it('should track a trackPresence', () => {
@@ -99,7 +88,7 @@ describe('ChannelResponse', () => {
     it('should update a users assign data', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine, 'updateAssigns');
-        response.accept({ assign: 'updated' });
+        response.assign({ assign: 'updated' });
         expect(channelEngine.updateAssigns).toHaveBeenCalledWith('sender', { assign: 'updated' });
     });
     it('should evict a user', () => {
@@ -109,7 +98,11 @@ describe('ChannelResponse', () => {
         expect(channelEngine.kickUser).toHaveBeenCalledWith('sender', 'recipient');
     });
     it('should destroy the channel', () => {
-        const { response, channelEngine } = createChannelResponse();
+        const { channelEngine, socket } = (0, exports.createChannelEngine)();
+        const event = (0, exports.createChannelEvent)(channelEngine.name);
+        const unsub = channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
+        socket.subscriptions.set(channelEngine.name, unsub);
+        const response = new eventResponse_1.EventResponse(event, channelEngine);
         jest.spyOn(channelEngine, 'destroy');
         response.closeChannel('recipient');
         expect(channelEngine.destroy).toHaveBeenCalledWith('recipient');
@@ -118,7 +111,6 @@ describe('ChannelResponse', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.accept();
         response.trackPresence({ status: 'online' });
         expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
     });
@@ -126,7 +118,6 @@ describe('ChannelResponse', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.accept();
         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');
@@ -135,7 +126,6 @@ describe('ChannelResponse', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.accept();
         expect(() => response.trackPresence({ status: 'online' }, 'non_existent_user'))
             .toThrow('ChannelEngine: Invalid recipients non_existent_user some users do not exist in channel test');
     });
@@ -144,7 +134,6 @@ describe('ChannelResponse', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.accept();
         response.trackPresence({ status: 'online' });
         expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
         expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
@@ -159,7 +148,6 @@ describe('ChannelResponse', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
         expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.accept();
         response.trackPresence({ status: 'online' });
         expect(() => response.updatePresence({ status: 'online' }, 'non_existent_user'))
             .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
@@ -171,7 +159,7 @@ describe('ChannelResponse', () => {
         expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
             sender: { status: 'online' },
         });
-        response.unTrackPresence();
+        response.removePresence();
         expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({});
     });
     it('should throw an error if unTrackPresence is called for a non existing user', () => {
@@ -181,17 +169,7 @@ describe('ChannelResponse', () => {
         expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
             sender: { status: 'online' },
         });
-        expect(() => response.unTrackPresence('non_existent_user'))
+        expect(() => response.removePresence('non_existent_user'))
             .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
     });
-    it('should throw an error if accept, reject / send is called more than once', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        expect(channelEngine.sendMessage).not.toHaveBeenCalled();
-        response.accept();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
-        expect(() => response.accept()).toThrow('Event response has already been executed');
-        expect(() => response.reject()).toThrow('Event response has already been executed');
-        expect(() => response.send('event', { payload: 'payload' })).toThrow('Event response has already been executed');
-    });
 });

package/endpoint/endpoint.test.js

@@ -12,19 +12,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+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(),
+    getClients: jest.fn(),
+    broadcast: jest.fn(),
+    closeConnection: jest.fn(),
+    manageSocket: jest.fn(),
+    getUser: () => socket,
+    subscribeTo: jest.fn(),
+    unsubscribeFrom: jest.fn(),
+});
+exports.createEndpointEngine = createEndpointEngine;
 describe('endpoint', () => {
     let socket;
     let server;
     beforeEach((done) => {
         socket = new pondSocket_1.PondSocket();
-        server = socket.listen(3000, 'localhost', done);
+        server = socket.listen(3000, 'localhost', () => {
+            done();
+        });
     });
     afterEach((done) => {
-        server.close(done);
+        server.close(() => {
+            done();
+        });
     });
     it('should be able to close a single socket', () => __awaiter(void 0, void 0, void 0, function* () {
         let count = 0;
@@ -37,7 +54,7 @@ describe('endpoint', () => {
                 }, 1000);
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         yield (0, superwstest_1.default)(server)
@@ -51,11 +68,11 @@ describe('endpoint', () => {
         const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
             if (req.params.room === 'socket') {
                 res.accept();
-                const connections = endpoint.listConnections();
+                const connections = endpoint.getClients();
                 expect(connections).toHaveLength(1);
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         yield (0, superwstest_1.default)(server)
@@ -67,7 +84,7 @@ describe('endpoint', () => {
         socket.createEndpoint('/api/:path', (req, res) => {
             count++;
             expect(req.params.path).toBe('socket');
-            res.reject();
+            res.decline();
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
@@ -88,12 +105,12 @@ describe('endpoint', () => {
         const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
             if (req.params.room === 'socket') {
                 res.accept();
-                const connections = endpoint.listConnections();
+                const connections = endpoint.getClients();
                 expect(connections).toHaveLength(1);
                 endpoint.broadcast('TEST', { test: 'test' });
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         yield (0, superwstest_1.default)(server)
@@ -120,12 +137,12 @@ describe('endpoint', () => {
                 res.accept();
             }
             else {
-                res.reject();
+                res.decline();
             }
         });
         endpoint.createChannel('/test/:room', (req, res) => {
             expect(req.event.params.room).toBeDefined();
-            res.accept({
+            res.accept().assign({
                 assigns: {
                     status: 'online',
                 },
@@ -162,7 +179,7 @@ describe('endpoint', () => {
         });
         endpoint.createChannel('/test/:room', (req, res) => {
             expect(req.event.params.room).toBeDefined();
-            res.reject('Something went wrong');
+            res.decline('Something went wrong');
         });
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
@@ -212,7 +229,7 @@ describe('endpoint', () => {
     }));
     it('should throw an error if accept, reject / send is called more than once', () => __awaiter(void 0, void 0, void 0, function* () {
         socket.createEndpoint('/api/:room', (_, res) => {
-            res.send('hello', {
+            res.reply('hello', {
                 test: 'test',
             });
             expect(() => res.accept()).toThrowError('Cannot execute response more than once');
@@ -244,7 +261,7 @@ describe('endpoint', () => {
             res.accept();
         });
         channel.onEvent('echo', (req, res) => {
-            res.send('echo', req.event.payload);
+            res.reply('echo', req.event.payload);
         });
         channel.onEvent('broadcast', (req) => {
             channel.broadcast('broadcast', Object.assign(Object.assign({}, req.event.payload), { broadcast: true }));

package/endpoint/endpointEngine.js

@@ -0,0 +1,321 @@
+"use strict";
+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 _EndpointEngine_instances, _EndpointEngine_middleware, _EndpointEngine_channels, _EndpointEngine_sockets, _EndpointEngine_parentEngine, _EndpointEngine_sendMessage, _EndpointEngine_joinChannel, _EndpointEngine_execute, _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");
+const zod_1 = require("zod");
+const middleware_1 = require("../abstracts/middleware");
+const pondError_1 = require("../errors/pondError");
+const joinRequest_1 = require("../lobby/joinRequest");
+const joinResponse_1 = require("../lobby/joinResponse");
+const lobby_1 = require("../lobby/lobby");
+const matcher_1 = require("../matcher/matcher");
+const schema_1 = require("../schema");
+class EndpointEngine {
+    constructor(parent) {
+        _EndpointEngine_instances.add(this);
+        _EndpointEngine_middleware.set(this, void 0);
+        _EndpointEngine_channels.set(this, void 0);
+        _EndpointEngine_sockets.set(this, void 0);
+        _EndpointEngine_parentEngine.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 Set(), "f");
+        __classPrivateFieldSet(this, _EndpointEngine_parentEngine, parent, "f");
+    }
+    get parent() {
+        return __classPrivateFieldGet(this, _EndpointEngine_parentEngine, "f");
+    }
+    /**
+     * @desc Adds a new PondChannel to this path on this endpoint
+     * @param path - The path to add the channel to
+     * @param handler - The handler to use to authenticate the client
+     *
+     * @example
+     * const channel = endpoint.createChannel('/chat', (request, response) => {
+     *     if (request.user.assigns.admin)
+     *         response.accept();
+     *
+     *     else
+     *         response.reject('You are not an admin', 403);
+     * });
+     */
+    createChannel(path, handler) {
+        const pondChannel = new lobby_1.LobbyEngine(this);
+        __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);
+                }
+            }
+            next();
+        });
+        __classPrivateFieldGet(this, _EndpointEngine_channels, "f").add(pondChannel);
+        return new lobby_1.PondChannel(pondChannel);
+    }
+    /**
+     * @desc Gets all clients connected to this endpoint
+     */
+    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,
+            };
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_sendMessage).call(this, socket, message);
+        });
+    }
+    /**
+     * @desc Closes specific clients connected to this endpoint
+     * @param clientIds - The id for the client / clients to close
+     */
+    closeConnection(clientIds) {
+        const clients = typeof clientIds === 'string' ? [clientIds] : clientIds;
+        this.getClients()
+            .forEach(({ clientId, socket }) => {
+            if (clients.includes(clientId)) {
+                socket.close();
+            }
+        });
+    }
+    /**
+     * @desc Manages a new socket connection
+     * @param cache - The socket cache
+     */
+    manageSocket(cache) {
+        __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").set(cache.clientId, cache);
+        const socket = cache.socket;
+        socket.addEventListener('message', (message) => {
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_readMessage).call(this, cache, message.data);
+        });
+        socket.addEventListener('close', () => {
+            cache.subscriptions.forEach((unsubscribe) => unsubscribe());
+        });
+        socket.addEventListener('error', () => {
+            cache.subscriptions.forEach((unsubscribe) => unsubscribe());
+        });
+    }
+    /**
+     * @desc Retrieves a user from the endpoint
+     * @param clientId - The id of the user to retrieve
+     * @private
+     */
+    getUser(clientId) {
+        const user = __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").get(clientId);
+        if (!user) {
+            throw new pondError_1.EndpointError(`GatewayEngine: User ${clientId} does not exist`, 404);
+        }
+        return user;
+    }
+    /**
+     * @desc Subscribes a user to a channel, Will join the channel if it exists or add to pending subscriptions
+     * @param userId - The id of the user to subscribe
+     * @param channel - The name of the channel to subscribe to
+     */
+    subscribeTo(userId, channel) {
+        const user = this.getUser(userId);
+        const channelEngine = __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_retrieveChannel).call(this, channel);
+        if (!channelEngine) {
+            user.pendingSubscriptions.add(channel);
+        }
+        else {
+            user.subscriptions.set(channel, channelEngine.addUser(userId, user.assigns, (event) => {
+                user.socket.send(JSON.stringify(event));
+            }));
+        }
+    }
+    /**
+     * @desc Unsubscribes a user from a channel
+     * @param userId - The id of the user to unsubscribe
+     * @param channel - The name of the channel to unsubscribe from
+     */
+    unsubscribeFrom(userId, channel) {
+        const user = this.getUser(userId);
+        const unsubscribe = user.subscriptions.get(channel);
+        if (unsubscribe) {
+            unsubscribe();
+            user.subscriptions.delete(channel);
+        }
+        else if (user.pendingSubscriptions.has(channel)) {
+            user.pendingSubscriptions.delete(channel);
+        }
+        else {
+            throw new pondError_1.EndpointError(`GatewayEngine: User ${userId} is not subscribed to ${channel}`, 404);
+        }
+    }
+    subscribePendingUsers(channel) {
+        const users = [...__classPrivateFieldGet(this, _EndpointEngine_sockets, "f").values()]
+            .filter(({ pendingSubscriptions }) => pendingSubscriptions.has(channel.name));
+        users.forEach(({ clientId, pendingSubscriptions, subscriptions, socket, assigns }) => {
+            const unsubscribe = channel.addUser(clientId, assigns, (event) => {
+                socket.send(JSON.stringify(event));
+            });
+            subscriptions.set(channel.name, unsubscribe);
+            pendingSubscriptions.delete(channel.name);
+        });
+    }
+}
+exports.EndpointEngine = EndpointEngine;
+_EndpointEngine_middleware = new WeakMap(), _EndpointEngine_channels = new WeakMap(), _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_parentEngine = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_sendMessage = function _EndpointEngine_sendMessage(socket, message) {
+    socket.send(JSON.stringify(message));
+}, _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 manager of __classPrivateFieldGet(this, _EndpointEngine_channels, "f")) {
+        const isPresent = manager.listChannels()
+            .includes(channel);
+        if (isPresent) {
+            return manager.execute(channel, handler);
+        }
+    }
+    throw new Error(`GatewayEngine: Channel ${channel} does not exist`);
+}, _EndpointEngine_retrieveChannel = function _EndpointEngine_retrieveChannel(channel) {
+    for (const manager of __classPrivateFieldGet(this, _EndpointEngine_channels, "f")) {
+        const isPresent = manager.listChannels()
+            .includes(channel);
+        if (isPresent) {
+            return manager.getChannel(channel);
+        }
+    }
+}, _EndpointEngine_handleMessage = function _EndpointEngine_handleMessage(cache, message) {
+    switch (message.action) {
+        case pondsocket_common_1.ClientActions.JOIN_CHANNEL:
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_joinChannel).call(this, message.channelName, cache, message.payload, message.requestId);
+            break;
+        case pondsocket_common_1.ClientActions.LEAVE_CHANNEL:
+            __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);
+            });
+            break;
+        default:
+            throw new Error(`GatewayEngine: Action ${message.action} does not exist`);
+    }
+}, _EndpointEngine_readMessage = function _EndpointEngine_readMessage(cache, message) {
+    try {
+        const data = JSON.parse(message);
+        const result = schema_1.clientMessageSchema.parse(data);
+        __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleMessage).call(this, cache, result);
+    }
+    catch (e) {
+        __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_sendMessage).call(this, cache.socket, __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_buildError).call(this, e));
+    }
+}, _EndpointEngine_buildError = function _EndpointEngine_buildError(error) {
+    const event = {
+        event: pondsocket_common_1.ErrorTypes.INVALID_MESSAGE,
+        action: pondsocket_common_1.ServerActions.ERROR,
+        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+        requestId: (0, pondsocket_common_1.uuid)(),
+        payload: {},
+    };
+    if (error instanceof SyntaxError) {
+        event.payload = {
+            message: 'Invalid JSON',
+        };
+    }
+    else if (error instanceof Error) {
+        event.event = pondsocket_common_1.ErrorTypes.INTERNAL_SERVER_ERROR;
+        event.payload = {
+            message: error.message,
+        };
+    }
+    else if (error instanceof pondError_1.PresenceError) {
+        event.event = pondsocket_common_1.ErrorTypes.PRESENCE_ERROR;
+        event.channelName = error.channel;
+        event.payload = {
+            message: error.message,
+            code: error.code,
+            action: error.event,
+        };
+    }
+    else if (error instanceof pondError_1.ChannelError) {
+        event.event = pondsocket_common_1.ErrorTypes.CHANNEL_ERROR;
+        event.channelName = error.channel;
+        event.payload = {
+            message: error.message,
+            code: error.code,
+        };
+    }
+    else if (error instanceof pondError_1.EndpointError) {
+        event.event = pondsocket_common_1.ErrorTypes.ENDPOINT_ERROR;
+        event.payload = {
+            message: error.message,
+            code: error.code,
+        };
+    }
+    else if (error instanceof zod_1.ZodError) {
+        const message = error.errors.map((error) => {
+            if ('expected' in error && 'received' in error) {
+                return `Expected ${error.path.join('.')} to be ${error.expected}, but received ${error.received}`;
+            }
+            return `${error.path.join('.')} ${error.message}`;
+        }).join(', ');
+        event.payload = {
+            message,
+            code: 400,
+        };
+    }
+    else {
+        event.payload = {
+            message: 'Unknown error',
+        };
+    }
+    return event;
+}, _EndpointEngine_leaveChannel = function _EndpointEngine_leaveChannel(channel, socket) {
+    const unsubscribe = socket.subscriptions.get(channel);
+    if (!unsubscribe) {
+        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);
+    }
+    unsubscribe();
+};
+class Endpoint {
+    constructor(engine) {
+        _Endpoint_engine.set(this, void 0);
+        __classPrivateFieldSet(this, _Endpoint_engine, engine, "f");
+    }
+    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);
+    }
+    getClients() {
+        return __classPrivateFieldGet(this, _Endpoint_engine, "f").getClients().map(({ socket }) => socket);
+    }
+}
+exports.Endpoint = Endpoint;
+_Endpoint_engine = new WeakMap();