@eleven-am/pondsocket 0.1.200 → 0.1.201

package/engines/channelEngine.js

@@ -30,22 +30,31 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _ChannelEngine_instances, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_name, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients;
+var _ChannelEngine_instances, _ChannelEngine_endpointId, _ChannelEngine_backend, _ChannelEngine_presenceEngine, _ChannelEngine_assignsCache, _ChannelEngine_userSubscriptions, _ChannelEngine_publisher, _ChannelEngine_distributedSubscription, _ChannelEngine_name, _ChannelEngine_buildSubscriber, _ChannelEngine_getOrCreatePresenceEngine, _ChannelEngine_getUsersFromRecipients, _ChannelEngine_setupDistributedSubscription, _ChannelEngine_handleDistributedMessage, _ChannelEngine_requestChannelState, _ChannelEngine_handleStateRequest, _ChannelEngine_handleStateResponse, _ChannelEngine_handleRemoteUserJoined, _ChannelEngine_handleRemoteUserLeft, _ChannelEngine_handleRemoteMessage, _ChannelEngine_handleRemotePresenceUpdate, _ChannelEngine_handleRemotePresenceRemoved, _ChannelEngine_handleRemoteAssignsUpdate, _ChannelEngine_handleRemoteAssignsRemoved, _ChannelEngine_handleRemoteEvictUser, _ChannelEngine_broadcastToNodes;
 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 types_1 = require("../abstracts/types");
 const httpError_1 = require("../errors/httpError");
 class ChannelEngine {
-    constructor(parent, name) {
+    constructor(parent, name, backend = null) {
         _ChannelEngine_instances.add(this);
         this.parent = parent;
+        _ChannelEngine_endpointId.set(this, void 0);
+        _ChannelEngine_backend.set(this, void 0);
         _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_distributedSubscription.set(this, null);
         _ChannelEngine_name.set(this, void 0);
         __classPrivateFieldSet(this, _ChannelEngine_name, name, "f");
+        __classPrivateFieldSet(this, _ChannelEngine_backend, backend, "f");
+        __classPrivateFieldSet(this, _ChannelEngine_endpointId, parent.parent.path, "f");
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_setupDistributedSubscription).call(this);
+        }
     }
     get name() {
         return __classPrivateFieldGet(this, _ChannelEngine_name, "f");
@@ -65,10 +74,22 @@ class ChannelEngine {
             const message = `ChannelEngine: User with id ${userId} already exists in channel ${this.name}`;
             throw new httpError_1.HttpError(400, message);
         }
-        // Store user assigns
+        const isFirstUser = this.users.size === 0;
         __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, assigns);
-        // Subscribe user to messages
         __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_buildSubscriber).call(this, userId, onMessage);
+        if (isFirstUser && __classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_requestChannelState).call(this);
+        }
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.USER_JOINED,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence: {},
+                assigns,
+            });
+        }
         // Send acknowledgment
         this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [userId], pondsocket_common_1.ServerActions.SYSTEM, pondsocket_common_1.Events.ACKNOWLEDGE, {});
         // Return unsubscribe function
@@ -91,15 +112,31 @@ class ChannelEngine {
         };
         const recipients = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getUsersFromRecipients).call(this, recipient, sender);
         const internalEvent = Object.assign(Object.assign({}, channelEvent), { recipients });
+        // Publish locally
         __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").publish(internalEvent);
+        // If distributed and this is a user message, broadcast to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f") && action === pondsocket_common_1.ServerActions.BROADCAST && sender !== pondsocket_common_1.SystemSender.CHANNEL) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.USER_MESSAGE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                fromUserId: sender,
+                event,
+                payload,
+                requestId,
+                recipients,
+            });
+        }
     }
     /**
      * Broadcasts a message from a user
+     * @param userId - The ID of the user sending the message
+     * @param message - The message to broadcast
      */
     broadcastMessage(userId, message) {
         if (!this.users.has(userId)) {
-            const message = `ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`;
-            throw new httpError_1.HttpError(404, message);
+            const messageText = `ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`;
+            throw new httpError_1.HttpError(404, messageText);
         }
         const responseEvent = Object.assign(Object.assign({}, message), { sender: userId, action: pondsocket_common_1.ServerActions.BROADCAST });
         this.parent.middleware.run(responseEvent, this, (error) => {
@@ -111,24 +148,58 @@ class ChannelEngine {
     }
     /**
      * Tracks a user's presence
+     * @param userId - The ID of the user
+     * @param presence - The presence data to track
      */
     trackPresence(userId, presence) {
         const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
         presenceEngine.trackPresence(userId, presence);
+        // Broadcast presence update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.PRESENCE_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence,
+            });
+        }
     }
     /**
      * Updates a user's presence
+     * @param userId - The ID of the user
+     * @param presence - The presence data to update
      */
     updatePresence(userId, presence) {
         const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
         presenceEngine.updatePresence(userId, presence);
+        // Broadcast presence update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.PRESENCE_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence,
+            });
+        }
     }
     /**
      * Removes a user's presence
+     * @param userId - The ID of the user to remove presence for
      */
     removePresence(userId) {
         if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
             __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(userId);
+            // Broadcast presence removal to other nodes
+            if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+                __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                    type: types_1.DistributedMessageType.PRESENCE_REMOVED,
+                    endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                    channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                    userId,
+                });
+            }
         }
     }
     /**
@@ -137,6 +208,16 @@ class ChannelEngine {
     upsertPresence(userId, presence) {
         const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
         presenceEngine.upsertPresence(userId, presence);
+        // Broadcast presence update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.PRESENCE_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                presence,
+            });
+        }
     }
     /**
      * Updates a user's assigns
@@ -146,7 +227,18 @@ class ChannelEngine {
             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));
+        const newAssigns = Object.assign(Object.assign({}, currentAssigns), assigns);
+        __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(userId, newAssigns);
+        // Broadcast assigns update to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.ASSIGNS_UPDATE,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                assigns: newAssigns,
+            });
+        }
     }
     /**
      * Kicks a user from the channel
@@ -156,6 +248,16 @@ class ChannelEngine {
             message: reason,
             code: 403,
         });
+        // Broadcast eviction to other nodes
+        if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                type: types_1.DistributedMessageType.EVICT_USER,
+                endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                userId,
+                reason,
+            });
+        }
         this.removeUser(userId);
         this.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.SYSTEM, 'kicked', {
             userId,
@@ -211,19 +313,26 @@ class ChannelEngine {
                 unsubscribe();
                 __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").delete(userId);
             }
-            // Trigger leave callback if defined
+            // Broadcast user left to other nodes
+            if (__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+                __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+                    type: types_1.DistributedMessageType.USER_LEFT,
+                    endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+                    channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+                    userId,
+                });
+            }
             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) {
+        catch (_a) {
             // Ignore cleanup errors
         }
     }
@@ -255,19 +364,23 @@ class ChannelEngine {
             __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").close();
             __classPrivateFieldSet(this, _ChannelEngine_presenceEngine, null, "f");
         }
+        if (__classPrivateFieldGet(this, _ChannelEngine_distributedSubscription, "f")) {
+            __classPrivateFieldGet(this, _ChannelEngine_distributedSubscription, "f").call(this);
+            __classPrivateFieldSet(this, _ChannelEngine_distributedSubscription, null, "f");
+        }
         __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").close();
         this.parent.deleteChannel(this.name);
     }
 }
 exports.ChannelEngine = ChannelEngine;
-_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) {
+_ChannelEngine_endpointId = new WeakMap(), _ChannelEngine_backend = new WeakMap(), _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new WeakMap(), _ChannelEngine_userSubscriptions = new WeakMap(), _ChannelEngine_publisher = new WeakMap(), _ChannelEngine_distributedSubscription = 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) {
+            if (event.action === pondsocket_common_1.ServerActions.PRESENCE) {
                 return onMessage(event);
             }
-            const newEvent = yield this.parent.manageOutgoingEvents(event, userId, this);
+            const newEvent = yield this.parent.processOutgoingEvents(event, this, userId);
             if (newEvent) {
                 onMessage(newEvent);
             }
@@ -277,7 +390,6 @@ _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new
 }, _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);
         });
@@ -310,4 +422,163 @@ _ChannelEngine_presenceEngine = new WeakMap(), _ChannelEngine_assignsCache = new
             break;
     }
     return users;
+}, _ChannelEngine_setupDistributedSubscription = function _ChannelEngine_setupDistributedSubscription() {
+    if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+        return;
+    }
+    __classPrivateFieldSet(this, _ChannelEngine_distributedSubscription, __classPrivateFieldGet(this, _ChannelEngine_backend, "f").subscribe(__classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"), __classPrivateFieldGet(this, _ChannelEngine_name, "f"), (message) => {
+        __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleDistributedMessage).call(this, message);
+    }), "f");
+}, _ChannelEngine_handleDistributedMessage = function _ChannelEngine_handleDistributedMessage(message) {
+    switch (message.type) {
+        case types_1.DistributedMessageType.STATE_REQUEST:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleStateRequest).call(this, message);
+            break;
+        case types_1.DistributedMessageType.STATE_RESPONSE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleStateResponse).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_JOINED:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserJoined).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_LEFT:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteUserLeft).call(this, message);
+            break;
+        case types_1.DistributedMessageType.USER_MESSAGE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteMessage).call(this, message);
+            break;
+        case types_1.DistributedMessageType.PRESENCE_UPDATE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemotePresenceUpdate).call(this, message);
+            break;
+        case types_1.DistributedMessageType.PRESENCE_REMOVED:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemotePresenceRemoved).call(this, message);
+            break;
+        case types_1.DistributedMessageType.ASSIGNS_UPDATE:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteAssignsUpdate).call(this, message);
+            break;
+        case types_1.DistributedMessageType.ASSIGNS_REMOVED:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteAssignsRemoved).call(this, message);
+            break;
+        case types_1.DistributedMessageType.EVICT_USER:
+            __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_handleRemoteEvictUser).call(this, message);
+            break;
+        default:
+            break;
+    }
+}, _ChannelEngine_requestChannelState = function _ChannelEngine_requestChannelState() {
+    if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+        type: types_1.DistributedMessageType.STATE_REQUEST,
+        endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        fromNode: 'current-node',
+    });
+}, _ChannelEngine_handleStateRequest = function _ChannelEngine_handleStateRequest(_message) {
+    if (this.users.size === 0) {
+        return;
+    }
+    const users = Array.from(__classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").entries()).map(([id, assigns]) => {
+        var _a;
+        return ({
+            id,
+            assigns,
+            presence: ((_a = __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) === null || _a === void 0 ? void 0 : _a.getPresence(id)) || {},
+        });
+    });
+    __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_broadcastToNodes).call(this, {
+        type: types_1.DistributedMessageType.STATE_RESPONSE,
+        endpointName: __classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"),
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        users,
+    });
+}, _ChannelEngine_handleStateResponse = function _ChannelEngine_handleStateResponse(message) {
+    if (!message.users) {
+        return;
+    }
+    message.users.forEach((user) => {
+        if (!this.users.has(user.id)) {
+            __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(user.id, user.assigns);
+            if (user.presence && Object.keys(user.presence).length > 0) {
+                const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+                presenceEngine.trackPresence(user.id, user.presence);
+            }
+        }
+    });
+}, _ChannelEngine_handleRemoteUserJoined = function _ChannelEngine_handleRemoteUserJoined(message) {
+    if (this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, message.assigns);
+    if (message.presence && Object.keys(message.presence).length > 0) {
+        const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+        presenceEngine.trackPresence(message.userId, message.presence);
+    }
+}, _ChannelEngine_handleRemoteUserLeft = function _ChannelEngine_handleRemoteUserLeft(message) {
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(message.userId);
+    if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(message.userId);
+    }
+}, _ChannelEngine_handleRemoteMessage = function _ChannelEngine_handleRemoteMessage(message) {
+    const localRecipients = message.recipients.filter((userId) => this.users.has(userId));
+    if (localRecipients.length === 0) {
+        return;
+    }
+    const internalEvent = {
+        channelName: __classPrivateFieldGet(this, _ChannelEngine_name, "f"),
+        requestId: message.requestId,
+        action: pondsocket_common_1.ServerActions.BROADCAST,
+        event: message.event,
+        payload: message.payload,
+        recipients: localRecipients,
+    };
+    __classPrivateFieldGet(this, _ChannelEngine_publisher, "f").publish(internalEvent);
+}, _ChannelEngine_handleRemotePresenceUpdate = function _ChannelEngine_handleRemotePresenceUpdate(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    const presenceEngine = __classPrivateFieldGet(this, _ChannelEngine_instances, "m", _ChannelEngine_getOrCreatePresenceEngine).call(this);
+    presenceEngine.upsertPresence(message.userId, message.presence);
+}, _ChannelEngine_handleRemotePresenceRemoved = function _ChannelEngine_handleRemotePresenceRemoved(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(message.userId);
+    }
+}, _ChannelEngine_handleRemoteAssignsUpdate = function _ChannelEngine_handleRemoteAssignsUpdate(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, message.assigns);
+}, _ChannelEngine_handleRemoteAssignsRemoved = function _ChannelEngine_handleRemoteAssignsRemoved(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").set(message.userId, {});
+}, _ChannelEngine_handleRemoteEvictUser = function _ChannelEngine_handleRemoteEvictUser(message) {
+    if (!this.users.has(message.userId)) {
+        return;
+    }
+    __classPrivateFieldGet(this, _ChannelEngine_assignsCache, "f").delete(message.userId);
+    if (__classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f")) {
+        __classPrivateFieldGet(this, _ChannelEngine_presenceEngine, "f").removePresence(message.userId);
+    }
+    const unsubscribe = __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").get(message.userId);
+    if (unsubscribe) {
+        unsubscribe();
+        __classPrivateFieldGet(this, _ChannelEngine_userSubscriptions, "f").delete(message.userId);
+    }
+}, _ChannelEngine_broadcastToNodes = function _ChannelEngine_broadcastToNodes(message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!__classPrivateFieldGet(this, _ChannelEngine_backend, "f")) {
+            return;
+        }
+        try {
+            yield __classPrivateFieldGet(this, _ChannelEngine_backend, "f").broadcast(__classPrivateFieldGet(this, _ChannelEngine_endpointId, "f"), __classPrivateFieldGet(this, _ChannelEngine_name, "f"), message);
+        }
+        catch (_a) {
+            // Silently ignore broadcast errors to prevent cascading failures
+        }
+    });
 };

package/engines/endpointEngine.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EndpointEngine_instances, _EndpointEngine_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_backend, _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");
@@ -21,20 +21,23 @@ const httpError_1 = require("../errors/httpError");
 const matcher_1 = require("../matcher/matcher");
 const pondChannel_1 = require("../wrappers/pondChannel");
 class EndpointEngine {
-    constructor() {
+    constructor(path, backend) {
         _EndpointEngine_instances.add(this);
+        this.path = path;
         _EndpointEngine_sockets.set(this, void 0);
+        _EndpointEngine_backend.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_backend, backend || null, "f");
     }
     /**
      * Creates a new channel on a specified path
      */
     createChannel(path, handler) {
-        const lobbyEngine = new lobbyEngine_1.LobbyEngine(this);
+        const lobbyEngine = new lobbyEngine_1.LobbyEngine(this, __classPrivateFieldGet(this, _EndpointEngine_backend, "f"));
         __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
             const event = (0, matcher_1.parseAddress)(path, user.channelName);
             if (event) {
@@ -106,7 +109,7 @@ class EndpointEngine {
     }
 }
 exports.EndpointEngine = EndpointEngine;
-_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_backend = 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());

package/engines/lobbyEngine.js

@@ -19,24 +19,26 @@ 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_outGoingEvents, _LobbyEngine_getChannel, _LobbyEngine_createChannel;
+var _LobbyEngine_instances, _LobbyEngine_backend, _LobbyEngine_channels, _LobbyEngine_getChannel, _LobbyEngine_createChannel;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LobbyEngine = void 0;
 const channelEngine_1 = require("./channelEngine");
 const middleware_1 = require("../abstracts/middleware");
 const eventContext_1 = require("../contexts/eventContext");
+const outgoingContext_1 = require("../contexts/outgoingContext");
 const httpError_1 = require("../errors/httpError");
 const matcher_1 = require("../matcher/matcher");
 const channel_1 = require("../wrappers/channel");
 class LobbyEngine {
-    constructor(parent) {
+    constructor(parent, backend) {
         _LobbyEngine_instances.add(this);
         this.parent = parent;
+        _LobbyEngine_backend.set(this, void 0);
         _LobbyEngine_channels.set(this, void 0);
-        _LobbyEngine_outGoingEvents.set(this, void 0);
         this.middleware = new middleware_1.Middleware();
+        this.outgoing = new middleware_1.Middleware();
         __classPrivateFieldSet(this, _LobbyEngine_channels, new Map(), "f");
-        __classPrivateFieldSet(this, _LobbyEngine_outGoingEvents, [], "f");
+        __classPrivateFieldSet(this, _LobbyEngine_backend, backend, "f");
     }
     /**
      * Sets the callback for when users leave channels
@@ -61,51 +63,38 @@ class LobbyEngine {
      * 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;
+        this.outgoing.use((context, chEvent, next) => __awaiter(this, void 0, void 0, function* () {
+            const params = (0, matcher_1.parseAddress)(event, chEvent.event);
+            if (!params || context.isBlocked()) {
+                return next();
             }
-            catch (error) {
-                return false;
+            context.updateParams(params);
+            const payload = yield handler(context, next);
+            if (payload === undefined || payload === null) {
+                return;
             }
-        });
-        __classPrivateFieldGet(this, _LobbyEngine_outGoingEvents, "f").push(handlerWrapper);
+            context.transform(Object.assign(Object.assign({}, chEvent), { payload }));
+            return next();
+        }));
     }
     /**
-     * Internal method to handle outgoing events
-     * @param request - The request object
-     * @param userId - The user ID
-     * @param channel - The channel engine
+     * Processes an outgoing event, applying middleware and returning a new event
+     * @param event - The channel event to process
+     * @param engine - The channel engine handling the event
+     * @param userId - The ID of the user sending the event
+     * @returns A new ChannelEvent or undefined if blocked
      */
-    manageOutgoingEvents(request, userId, channel) {
+    processOutgoingEvents(event, engine, userId) {
         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;
+            const params = (0, matcher_1.parseAddress)('*', event.event);
+            const context = new outgoingContext_1.OutgoingContext(event, params, engine, userId);
+            yield this.outgoing.runAsync(context, event, () => {
+                // no-op
+            });
+            if (context.isBlocked()) {
+                return;
             }
-            request.payload = results
-                .filter((result) => typeof result !== 'boolean')
-                .reduce((acc, result) => Object.assign(acc, result), {});
-            return request;
+            return Object.assign(Object.assign({}, event), { payload: context.payload, event: context.event.event });
         });
     }
     /**
@@ -120,7 +109,7 @@ class LobbyEngine {
     }
     /**
      * Gets a channel by name
-     * @throws HttpError if channel not found
+     * @throws HttpError if a channel not found
      */
     getChannel(channelName) {
         const channel = __classPrivateFieldGet(this, _LobbyEngine_channels, "f").get(channelName);
@@ -147,18 +136,10 @@ class LobbyEngine {
     }
 }
 exports.LobbyEngine = LobbyEngine;
-_LobbyEngine_channels = new WeakMap(), _LobbyEngine_outGoingEvents = new WeakMap(), _LobbyEngine_instances = new WeakSet(), _LobbyEngine_getChannel = function _LobbyEngine_getChannel(channelName) {
+_LobbyEngine_backend = new WeakMap(), _LobbyEngine_channels = 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) {
-    // Create the channel engine
-    const channel = new channelEngine_1.ChannelEngine(this, channelName);
-    // Add it to the channels map
+    const channel = new channelEngine_1.ChannelEngine(this, channelName, __classPrivateFieldGet(this, _LobbyEngine_backend, "f"));
     __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;
 };

package/engines/presenceEngine.js

@@ -124,7 +124,6 @@ _PresenceEngine_presenceCache = new WeakMap(), _PresenceEngine_publisher = new W
     }
     const total = Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").values());
     const userIds = Array.from(__classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").keys());
-    // Create the presence event
     const internalEvent = {
         event: action,
         requestId: (0, pondsocket_common_1.uuid)(),