@eleven-am/pondsocket 0.1.197 → 0.1.198

package/engines/channelEngine.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -10,38 +19,68 @@ 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 _ChannelEngine_instances, _ChannelEngine_manager, _ChannelEngine_getUsersFromRecipients;
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var _ChannelEngine_instances, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_name, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const presenceEngine_1 = require("./presenceEngine");
 const httpError_1 = require("../errors/httpError");
-const channel_1 = require("../wrappers/channel");
 class ChannelEngine {
-    constructor(parent, name, manager) {
+    constructor(parent, name) {
         _ChannelEngine_instances.add(this);
         this.parent = parent;
-        this.name = name;
-        _ChannelEngine_manager.set(this, void 0);
-        __classPrivateFieldSet(this, _ChannelEngine_manager, manager, "f");
+        _ChannelEngine_presenceEngine.set(this, null);
+        _ChannelEngine_assignsCache.set(this, new Map());
+        _ChannelEngine_userSubscriptions.set(this, new Map());
+        _ChannelEngine_publisher.set(this, new pondsocket_common_1.Subject());
+        _ChannelEngine_name.set(this, void 0);
+        __classPrivateFieldSet(this, _ChannelEngine_name, name, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _ChannelEngine_name, "f");
     }
     get users() {
-        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").userIds;
+        return new Set(__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").keys());
     }
+    /**
+     * Adds a user to the channel
+     * @param userId - The user ID
+     * @param assigns - The user's assigns
+     * @param onMessage - Callback for messages
+     * @returns Unsubscribe function
+     */
     addUser(userId, assigns, onMessage) {
         if (this.users.has(userId)) {
             const message = `ChannelEngine: User with id ${userId} already exists in channel ${this.name}`;
-            const code = 400;
-            throw new httpError_1.HttpError(code, message);
+            throw new httpError_1.HttpError(400, message);
         }
-        __classPrivateFieldGet(this, _ChannelEngine_manager, "f").addUser(userId, assigns, onMessage);
+        // Store user assigns
+        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, assigns);
+        // Subscribe user to messages
+        __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_buildSubscriber).call(this, userId, onMessage);
+        // Send acknowledgment
         this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.SYSTEM, pondsocket_common_1.Events.ACKNOWLEDGE, {});
-        return this.removeUser.bind(this, userId);
+        // Return unsubscribe function
+        return () => this.removeUser(userId);
     }
+    /**
+     * Sends a message to recipients
+     */
     sendMessage(sender, recipient, action, event, payload, requestId = (0, pondsocket_common_1.uuid)()) {
         if (!this.users.has(sender) && sender !== pondsocket_common_1.SystemSender.CHANNEL) {
             const message = `ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`;
-            const code = 404;
-            throw new httpError_1.HttpError(code, message);
+            throw new httpError_1.HttpError(404, message);
         }
         const channelEvent = {
             channelName: this.name,
@@ -52,13 +91,15 @@ class ChannelEngine {
         };
         const recipients = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender);
         const internalEvent = Object.assign(Object.assign({}, channelEvent), { recipients });
-        __classPrivateFieldGet(this, _ChannelEngine_manager, "f").broadcast(internalEvent);
+        __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").publish(internalEvent);
     }
+    /**
+     * Broadcasts a message from a user
+     */
     broadcastMessage(userId, message) {
         if (!this.users.has(userId)) {
             const message = `ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`;
-            const code = 404;
-            throw new httpError_1.HttpError(code, message);
+            throw new httpError_1.HttpError(404, message);
         }
         const responseEvent = Object.assign(Object.assign({}, message), { sender: userId, action: pondsocket_common_1.ServerActions.BROADCAST });
         this.parent.middleware.run(responseEvent, this, (error) => {
@@ -68,21 +109,48 @@ class ChannelEngine {
             }, message.requestId);
         });
     }
+    /**
+     * Tracks a user's presence
+     */
     trackPresence(userId, presence) {
-        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").trackPresence(userId, presence);
+        const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+        presenceEngine.trackPresence(userId, presence);
     }
+    /**
+     * Updates a user's presence
+     */
     updatePresence(userId, presence) {
-        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").updatePresence(userId, presence);
+        const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+        presenceEngine.updatePresence(userId, presence);
     }
+    /**
+     * Removes a user's presence
+     */
     removePresence(userId) {
-        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").removePresence(userId);
+        if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(userId);
+        }
     }
+    /**
+     * Adds or updates a user's presence
+     */
     upsertPresence(userId, presence) {
-        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").upsertPresence(userId, presence);
+        const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+        presenceEngine.upsertPresence(userId, presence);
     }
+    /**
+     * Updates a user's assigns
+     */
     updateAssigns(userId, assigns) {
-        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").updateAssigns(userId, assigns);
+        if (!__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").has(userId)) {
+            throw new httpError_1.HttpError(404, `User with id ${userId} does not exist in channel ${this.name}`);
+        }
+        const currentAssigns = __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").get(userId) || {};
+        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, Object.assign(Object.assign({}, currentAssigns), assigns));
     }
+    /**
+     * Kicks a user from the channel
+     */
     kickUser(userId, reason) {
         this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.SYSTEM, 'kicked_out', {
             message: reason,
@@ -94,43 +162,131 @@ class ChannelEngine {
             reason,
         });
     }
+    /**
+     * Gets all assigns as an object
+     */
     getAssigns() {
         return Array
-            .from(__classPrivateFieldGet(this, _ChannelEngine_manager, "f").getAllAssigns().entries())
+            .from(__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").entries())
             .reduce((acc, [id, assigns]) => {
             acc[id] = assigns;
             return acc;
         }, {});
     }
+    /**
+     * Gets all presence data as an object
+     */
     getPresence() {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+            return {};
+        }
         return Array
-            .from(__classPrivateFieldGet(this, _ChannelEngine_manager, "f").getAllPresence().entries())
+            .from(__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").getAllPresence().entries())
             .reduce((acc, [id, presence]) => {
             acc[id] = presence;
             return acc;
         }, {});
     }
+    /**
+     * Destroys the channel
+     */
     destroy(reason) {
         this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.ERROR, 'destroyed', {
             message: reason !== null && reason !== void 0 ? reason : 'Channel has been destroyed',
         });
-        __classPrivateFieldGet(this, _ChannelEngine_manager, "f").close();
+        this.close();
     }
+    /**
+     * Removes a user from the channel
+     */
     removeUser(userId) {
-        const userData = __classPrivateFieldGet(this, _ChannelEngine_manager, "f").removeUser(userId);
-        if (this.parent.leaveCallback) {
-            this.parent.leaveCallback({
-                user: userData,
-                channel: new channel_1.Channel(this),
-            });
+        try {
+            const userData = this.getUserData(userId);
+            const unsubscribe = __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").get(userId);
+            __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(userId);
+            if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+                __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(userId);
+            }
+            if (unsubscribe) {
+                unsubscribe();
+                __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").delete(userId);
+            }
+            // Trigger leave callback if defined
+            if (this.parent.leaveCallback) {
+                this.parent.leaveCallback({
+                    user: userData,
+                    channel: this.parent.wrapChannel(this),
+                });
+            }
+            // If no users left, close the channel
+            if (this.users.size === 0) {
+                this.close();
+            }
+        }
+        catch (error) {
+            // Ignore cleanup errors
         }
     }
-    getUser(userId) {
-        return __classPrivateFieldGet(this, _ChannelEngine_manager, "f").getUserData(userId);
+    /**
+     * Gets user data by ID
+     */
+    getUserData(userId) {
+        var _a;
+        const assigns = __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").get(userId);
+        const presence = ((_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) === null || _a === void 0 ? void 0 : _a.getPresence(userId)) || null;
+        if (!assigns && !presence) {
+            const message = `User with id ${userId} does not exist in the channel ${this.name}`;
+            throw new httpError_1.HttpError(404, message);
+        }
+        return {
+            assigns: assigns || {},
+            presence: presence || {},
+            id: userId,
+        };
+    }
+    /**
+     * Closes the channel and cleans up resources
+     */
+    close() {
+        // Clear all user subscriptions
+        __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").forEach((unsubscribe) => unsubscribe());
+        __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").clear();
+        // Clear assigns
+        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").clear();
+        // Close presence engine if exists
+        if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").close();
+            __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, null, "f");
+        }
+        // Close publisher
+        __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").close();
     }
 }
 exports.ChannelEngine = ChannelEngine;
-_ChannelEngine_manager = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_getUsersFromRecipients = function _ChannelEngine_getUsersFromRecipients(recipients, sender) {
+_ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_name = new WeakMap(), _ChannelEngine_instances = new WeakSet(), _ChannelEngine_buildSubscriber = function _ChannelEngine_buildSubscriber(userId, onMessage) {
+    const subscription = __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").subscribe((_a) => __awaiter(this, void 0, void 0, function* () {
+        var { recipients } = _a, event = __rest(_a, ["recipients"]);
+        if (recipients.includes(userId)) {
+            if (event.action === pondsocket_common_1.ServerActions.SYSTEM) {
+                return onMessage(event);
+            }
+            const newEvent = yield this.parent.manageOutgoingEvents(event, userId, this);
+            if (newEvent) {
+                onMessage(newEvent);
+            }
+        }
+    }));
+    __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").set(userId, subscription);
+}, _ChannelEngine_getOrCreatePresenceEngine = function _ChannelEngine_getOrCreatePresenceEngine() {
+    if (!__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+        __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, new presenceEngine_1.PresenceEngine(this.name), "f");
+        // Subscribe to presence events and publish them through the channel publisher
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").subscribe((event) => {
+            __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").publish(event);
+        });
+    }
+    return __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f");
+}, _ChannelEngine_getUsersFromRecipients = function _ChannelEngine_getUsersFromRecipients(recipients, sender) {
     const allUsers = Array.from(this.users);
     let users;
     switch (recipients) {
@@ -140,21 +296,18 @@ _ChannelEngine_manager = new WeakMap(), _ChannelEngine_instances = new WeakSet()
         case pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER:
             if (sender === pondsocket_common_1.SystemSender.CHANNEL) {
                 const message = `ChannelEngine: Invalid sender ${sender} for recipients ${recipients}`;
-                const code = 400;
-                throw new httpError_1.HttpError(code, message);
+                throw new httpError_1.HttpError(400, message);
             }
             users = allUsers.filter((user) => user !== sender);
             break;
         default:
             if (!Array.isArray(recipients)) {
                 const message = `ChannelEngine: Invalid recipients ${recipients} must be an array of user ids or ${pondsocket_common_1.ChannelReceiver.ALL_USERS}`;
-                const code = 400;
-                throw new httpError_1.HttpError(code, message);
+                throw new httpError_1.HttpError(400, message);
             }
             if (recipients.some((user) => !allUsers.includes(user))) {
                 const message = `ChannelEngine: Invalid user ids in recipients ${recipients}`;
-                const code = 400;
-                throw new httpError_1.HttpError(code, message);
+                throw new httpError_1.HttpError(400, message);
             }
             users = recipients;
             break;

package/engines/endpointEngine.js

@@ -10,32 +10,32 @@ 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_clientFactory, _EndpointEngine_sockets, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_handleSocketClose, _EndpointEngine_handleMessage, _EndpointEngine_joinChannel, _EndpointEngine_leaveChannel, _EndpointEngine_retrieveChannel, _EndpointEngine_buildError, _EndpointEngine_broadcastMessage, _EndpointEngine_readMessage;
+var _EndpointEngine_instances, _EndpointEngine_sockets, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_handleSocketClose, _EndpointEngine_handleMessage, _EndpointEngine_joinChannel, _EndpointEngine_leaveChannel, _EndpointEngine_retrieveChannel, _EndpointEngine_buildError, _EndpointEngine_broadcastMessage, _EndpointEngine_readMessage;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndpointEngine = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const lobbyEngine_1 = require("./lobbyEngine");
 const middleware_1 = require("../abstracts/middleware");
 const httpError_1 = require("../errors/httpError");
-const managerFactory_1 = require("../managers/managerFactory");
 const matcher_1 = require("../matcher/matcher");
 const joinRequest_1 = require("../requests/joinRequest");
 const joinResponse_1 = require("../responses/joinResponse");
 const pondChannel_1 = require("../wrappers/pondChannel");
 class EndpointEngine {
-    constructor(clientFactory) {
+    constructor() {
         _EndpointEngine_instances.add(this);
-        _EndpointEngine_clientFactory.set(this, void 0);
         _EndpointEngine_sockets.set(this, void 0);
         _EndpointEngine_middleware.set(this, void 0);
         _EndpointEngine_lobbyEngines.set(this, void 0);
         __classPrivateFieldSet(this, _EndpointEngine_sockets, new Map(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_lobbyEngines, new Map(), "f");
         __classPrivateFieldSet(this, _EndpointEngine_middleware, new middleware_1.Middleware(), "f");
-        __classPrivateFieldSet(this, _EndpointEngine_clientFactory, clientFactory, "f");
     }
+    /**
+     * Creates a new channel on a specified path
+     */
     createChannel(path, handler) {
-        const pondChannel = new lobbyEngine_1.LobbyEngine(this);
+        const lobbyEngine = new lobbyEngine_1.LobbyEngine(this);
         __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
             const event = (0, matcher_1.parseAddress)(path, user.channelName);
             if (event) {
@@ -45,19 +45,25 @@ class EndpointEngine {
                     params: event,
                     joinParams,
                 };
-                const channel = pondChannel.getOrCreateChannel(user.channelName);
+                const channel = lobbyEngine.getOrCreateChannel(user.channelName);
                 const request = new joinRequest_1.JoinRequest(options, channel);
                 const response = new joinResponse_1.JoinResponse(user, channel);
                 return handler(request, response, next);
             }
             next();
         });
-        __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").set(path, pondChannel);
-        return new pondChannel_1.PondChannel(pondChannel);
+        __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").set(path, lobbyEngine);
+        return new pondChannel_1.PondChannel(lobbyEngine);
     }
+    /**
+     * Gets all connected clients
+     */
     getClients() {
         return [...__classPrivateFieldGet(this, _EndpointEngine_sockets, "f").values()];
     }
+    /**
+     * Gets a specific user by client ID
+     */
     getUser(clientId) {
         const user = __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").get(clientId);
         if (!user) {
@@ -65,6 +71,9 @@ class EndpointEngine {
         }
         return user;
     }
+    /**
+     * Manages a new WebSocket connection
+     */
     manageSocket(cache) {
         __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").set(cache.clientId, cache);
         cache.socket.on('message', (message) => __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_readMessage).call(this, cache, message));
@@ -79,12 +88,15 @@ class EndpointEngine {
         };
         this.sendMessage(cache.socket, event);
     }
-    createManager(channelName, onLeave) {
-        return managerFactory_1.ManagerFactory.create(channelName, __classPrivateFieldGet(this, _EndpointEngine_clientFactory, "f"), onLeave);
-    }
+    /**
+     * Sends a message to a WebSocket
+     */
     sendMessage(socket, message) {
         socket.send(JSON.stringify(message));
     }
+    /**
+     * Closes one or more client connections
+     */
     closeConnection(clientIds) {
         const clients = typeof clientIds === 'string' ? [clientIds] : clientIds;
         this.getClients()
@@ -96,7 +108,7 @@ class EndpointEngine {
     }
 }
 exports.EndpointEngine = EndpointEngine;
-_EndpointEngine_clientFactory = new WeakMap(), _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_handleSocketClose = function _EndpointEngine_handleSocketClose(cache) {
+_EndpointEngine_sockets = new WeakMap(), _EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_handleSocketClose = function _EndpointEngine_handleSocketClose(cache) {
     try {
         __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").delete(cache.clientId);
         cache.subscriptions.forEach((unsubscribe) => unsubscribe());
@@ -128,10 +140,10 @@ _EndpointEngine_clientFactory = new WeakMap(), _EndpointEngine_sockets = new Wea
     const engine = __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_retrieveChannel).call(this, channel);
     engine.removeUser(socket.clientId);
 }, _EndpointEngine_retrieveChannel = function _EndpointEngine_retrieveChannel(channel) {
-    for (const [path, manager] of __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f")) {
+    for (const [path, lobby] of __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f")) {
         const event = (0, matcher_1.parseAddress)(path, channel);
         if (event) {
-            return manager.getChannel(channel);
+            return lobby.getChannel(channel);
         }
     }
     throw new httpError_1.HttpError(404, `GatewayEngine: Channel ${channel} does not exist`);

package/engines/lobbyEngine.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -10,7 +19,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _LobbyEngine_instances, _LobbyEngine_channels, _LobbyEngine_getChannel, _LobbyEngine_createChannel;
+var _LobbyEngine_instances, _LobbyEngine_channels, _LobbyEngine_outGoingEvents, _LobbyEngine_getChannel, _LobbyEngine_createChannel;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LobbyEngine = void 0;
 const channelEngine_1 = require("./channelEngine");
@@ -19,17 +28,26 @@ const httpError_1 = require("../errors/httpError");
 const matcher_1 = require("../matcher/matcher");
 const eventRequest_1 = require("../requests/eventRequest");
 const eventResponse_1 = require("../responses/eventResponse");
+const channel_1 = require("../wrappers/channel");
 class LobbyEngine {
     constructor(parent) {
         _LobbyEngine_instances.add(this);
         this.parent = parent;
         _LobbyEngine_channels.set(this, void 0);
+        _LobbyEngine_outGoingEvents.set(this, void 0);
         this.middleware = new middleware_1.Middleware();
         __classPrivateFieldSet(this, _LobbyEngine_channels, new Map(), "f");
+        __classPrivateFieldSet(this, _LobbyEngine_outGoingEvents, [], "f");
     }
+    /**
+     * Sets the callback for when users leave channels
+     */
     onLeave(callback) {
         this.leaveCallback = callback;
     }
+    /**
+     * Attaches a handler for a specific event pattern
+     */
     onEvent(event, handler) {
         this.middleware.use((requestEvent, channel, next) => {
             const params = (0, matcher_1.parseAddress)(event, requestEvent.event);
@@ -41,6 +59,60 @@ class LobbyEngine {
             return next();
         });
     }
+    /**
+     * Attaches a handler for outgoing events
+     */
+    handleOutgoingEvent(event, handler) {
+        const handlerWrapper = (request, channel, userId) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const params = (0, matcher_1.parseAddress)(event, request.event);
+                if (!params) {
+                    return true;
+                }
+                const userData = channel.getUserData(userId);
+                const newEvent = {
+                    channel,
+                    userData,
+                    event: params,
+                    payload: request.payload,
+                };
+                const response = yield handler(newEvent);
+                if (response) {
+                    return response;
+                }
+                return false;
+            }
+            catch (error) {
+                return false;
+            }
+        });
+        __classPrivateFieldGet(this, _LobbyEngine_outGoingEvents, "f").push(handlerWrapper);
+    }
+    /**
+     * Internal method to handle outgoing events
+     * @param request - The request object
+     * @param userId - The user ID
+     * @param channel - The channel engine
+     */
+    manageOutgoingEvents(request, userId, channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _LobbyEngine_outGoingEvents, "f").length) {
+                return request;
+            }
+            const promises = __classPrivateFieldGet(this, _LobbyEngine_outGoingEvents, "f").map((handler) => handler(request, this.wrapChannel(channel), userId));
+            const results = yield Promise.all(promises);
+            if (results.some((result) => result === false)) {
+                return null;
+            }
+            request.payload = results
+                .filter((result) => typeof result !== 'boolean')
+                .reduce((acc, result) => Object.assign(acc, result), {});
+            return request;
+        });
+    }
+    /**
+     * Gets or creates a channel by name
+     */
     getOrCreateChannel(channelName) {
         const oldChannel = __classPrivateFieldGet(this, _LobbyEngine_instances, "m", _LobbyEngine_getChannel).call(this, channelName);
         if (oldChannel) {
@@ -48,6 +120,10 @@ class LobbyEngine {
         }
         return __classPrivateFieldGet(this, _LobbyEngine_instances, "m", _LobbyEngine_createChannel).call(this, channelName);
     }
+    /**
+     * Gets a channel by name
+     * @throws HttpError if channel not found
+     */
     getChannel(channelName) {
         const channel = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").get(channelName);
         if (!channel) {
@@ -55,14 +131,27 @@ class LobbyEngine {
         }
         return channel;
     }
+    /**
+     * Creates a Channel wrapper from a ChannelEngine
+     * Used by the channel engine for the leave callback
+     */
+    wrapChannel(engine) {
+        return new channel_1.Channel(engine);
+    }
 }
 exports.LobbyEngine = LobbyEngine;
-_LobbyEngine_channels = new WeakMap(), _LobbyEngine_instances = new WeakSet(), _LobbyEngine_getChannel = function _LobbyEngine_getChannel(channelName) {
+_LobbyEngine_channels = new WeakMap(), _LobbyEngine_outGoingEvents = new WeakMap(), _LobbyEngine_instances = new WeakSet(), _LobbyEngine_getChannel = function _LobbyEngine_getChannel(channelName) {
     return __classPrivateFieldGet(this, _LobbyEngine_channels, "f").get(channelName) || null;
 }, _LobbyEngine_createChannel = function _LobbyEngine_createChannel(channelName) {
-    const onManagerClose = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").delete.bind(__classPrivateFieldGet(this, _LobbyEngine_channels, "f"), channelName);
-    const manager = this.parent.createManager(channelName, onManagerClose);
-    const channel = new channelEngine_1.ChannelEngine(this, channelName, manager);
+    // Create the channel engine
+    const channel = new channelEngine_1.ChannelEngine(this, channelName);
+    // Add it to the channels map
     __classPrivateFieldGet(this, _LobbyEngine_channels, "f").set(channelName, channel);
+    // Set up a way to remove the channel when it's closed
+    // (We'll handle this in the ChannelEngine's close method)
+    const handleChannelClosed = () => {
+        __classPrivateFieldGet(this, _LobbyEngine_channels, "f").delete(channelName);
+    };
+    // Return the new channel engine
     return channel;
 };