@eleven-am/pondsocket 0.1.141 → 0.1.143

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.js

@@ -10,9 +10,9 @@ 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 _Endpoint_instances, _Endpoint_middleware, _Endpoint_channels, _Endpoint_sockets, _Endpoint_sendMessage, _Endpoint_joinChannel, _Endpoint_execute, _Endpoint_handleMessage, _Endpoint_readMessage;
+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 = void 0;
+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");
@@ -22,15 +22,20 @@ const joinResponse_1 = require("../lobby/joinResponse");
 const lobby_1 = require("../lobby/lobby");
 const matcher_1 = require("../matcher/matcher");
 const schema_1 = require("../schema");
-class Endpoint {
-    constructor() {
-        _Endpoint_instances.add(this);
-        _Endpoint_middleware.set(this, void 0);
-        _Endpoint_channels.set(this, void 0);
-        _Endpoint_sockets.set(this, void 0);
-        __classPrivateFieldSet(this, _Endpoint_sockets, new Set(), "f");
-        __classPrivateFieldSet(this, _Endpoint_middleware, new middleware_1.Middleware(), "f");
-        __classPrivateFieldSet(this, _Endpoint_channels, new Set(), "f");
+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
@@ -47,8 +52,8 @@ class Endpoint {
      * });
      */
     createChannel(path, handler) {
-        const pondChannel = new lobby_1.LobbyEngine();
-        __classPrivateFieldGet(this, _Endpoint_middleware, "f").use((user, joinParams, next) => {
+        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);
@@ -60,20 +65,14 @@ class Endpoint {
             }
             next();
         });
-        __classPrivateFieldGet(this, _Endpoint_channels, "f").add(pondChannel);
+        __classPrivateFieldGet(this, _EndpointEngine_channels, "f").add(pondChannel);
         return new lobby_1.PondChannel(pondChannel);
     }
-    /**
-     * @desc List all clients connected to this endpoint
-     */
-    listConnections() {
-        return [...__classPrivateFieldGet(this, _Endpoint_sockets, "f")].map(({ clientId }) => clientId);
-    }
     /**
      * @desc Gets all clients connected to this endpoint
      */
     getClients() {
-        return [...__classPrivateFieldGet(this, _Endpoint_sockets, "f")];
+        return [...__classPrivateFieldGet(this, _EndpointEngine_sockets, "f").values()];
     }
     /**
      * @desc Broadcasts a message to all clients connected to this endpoint
@@ -81,7 +80,7 @@ class Endpoint {
      * @param payload - The payload to broadcast
      */
     broadcast(event, payload) {
-        __classPrivateFieldGet(this, _Endpoint_sockets, "f").forEach(({ socket }) => {
+        __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").forEach(({ socket }) => {
             const message = {
                 event,
                 payload,
@@ -89,7 +88,7 @@ class Endpoint {
                 action: pondsocket_common_1.ServerActions.BROADCAST,
                 channelName: pondsocket_common_1.SystemSender.ENDPOINT,
             };
-            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, socket, message);
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_sendMessage).call(this, socket, message);
         });
     }
     /**
@@ -110,98 +109,88 @@ class Endpoint {
      * @param cache - The socket cache
      */
     manageSocket(cache) {
-        __classPrivateFieldGet(this, _Endpoint_sockets, "f").add(cache);
+        __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").set(cache.clientId, cache);
         const socket = cache.socket;
         socket.addEventListener('message', (message) => {
-            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_readMessage).call(this, cache, message.data);
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_readMessage).call(this, cache, message.data);
         });
         socket.addEventListener('close', () => {
-            __classPrivateFieldGet(this, _Endpoint_channels, "f")
-                .forEach((manager) => manager.removeUser(cache.clientId));
+            cache.subscriptions.forEach((unsubscribe) => unsubscribe());
         });
         socket.addEventListener('error', () => {
-            __classPrivateFieldGet(this, _Endpoint_channels, "f")
-                .forEach((manager) => manager.removeUser(cache.clientId));
+            cache.subscriptions.forEach((unsubscribe) => unsubscribe());
         });
     }
     /**
-     * @desc Builds an error message
-     * @param error - The error to build
+     * @desc Retrieves a user from the endpoint
+     * @param clientId - The id of the user to retrieve
      * @private
      */
-    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,
-            };
+    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);
         }
-        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,
-            };
+        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 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 {
+            user.subscriptions.set(channel, channelEngine.addUser(userId, user.assigns, (event) => {
+                user.socket.send(JSON.stringify(event));
+            }));
         }
-        else if (error instanceof pondError_1.EndpointError) {
-            event.event = pondsocket_common_1.ErrorTypes.ENDPOINT_ERROR;
-            event.payload = {
-                message: error.message,
-                code: error.code,
-            };
+    }
+    /**
+     * @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 (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 if (user.pendingSubscriptions.has(channel)) {
+            user.pendingSubscriptions.delete(channel);
         }
         else {
-            event.payload = {
-                message: 'Unknown error',
-            };
+            throw new pondError_1.EndpointError(`GatewayEngine: User ${userId} is not subscribed to ${channel}`, 404);
         }
-        return event;
+    }
+    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.Endpoint = Endpoint;
-_Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpoint_sockets = new WeakMap(), _Endpoint_instances = new WeakSet(), _Endpoint_sendMessage = function _Endpoint_sendMessage(socket, message) {
+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));
-}, _Endpoint_joinChannel = function _Endpoint_joinChannel(channel, socket, joinParams, requestId) {
+}, _EndpointEngine_joinChannel = function _EndpointEngine_joinChannel(channel, socket, joinParams, requestId) {
     const cache = Object.assign(Object.assign({}, socket), { requestId, channelName: channel });
-    __classPrivateFieldGet(this, _Endpoint_middleware, "f").run(cache, joinParams, () => {
+    __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").run(cache, joinParams, () => {
         throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);
     });
-}, _Endpoint_execute = function _Endpoint_execute(channel, handler) {
-    for (const manager of __classPrivateFieldGet(this, _Endpoint_channels, "f")) {
+}, _EndpointEngine_execute = function _EndpointEngine_execute(channel, handler) {
+    for (const manager of __classPrivateFieldGet(this, _EndpointEngine_channels, "f")) {
         const isPresent = manager.listChannels()
             .includes(channel);
         if (isPresent) {
@@ -209,31 +198,124 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
         }
     }
     throw new Error(`GatewayEngine: Channel ${channel} does not exist`);
-}, _Endpoint_handleMessage = function _Endpoint_handleMessage(cache, message) {
+}, _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, _Endpoint_instances, "m", _Endpoint_joinChannel).call(this, message.channelName, cache, message.payload, message.requestId);
+            __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, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
-                channel.removeUser(cache.clientId, true);
-            });
+            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_leaveChannel).call(this, message.channelName, cache);
             break;
         case pondsocket_common_1.ClientActions.BROADCAST:
-            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
+            __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`);
     }
-}, _Endpoint_readMessage = function _Endpoint_readMessage(cache, message) {
+}, _EndpointEngine_readMessage = function _EndpointEngine_readMessage(cache, message) {
     try {
         const data = JSON.parse(message);
         const result = schema_1.clientMessageSchema.parse(data);
-        __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_handleMessage).call(this, cache, result);
+        __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleMessage).call(this, cache, result);
     }
     catch (e) {
-        __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, cache.socket, this.buildError(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();