@eleven-am/pondsocket 0.1.200 → 0.1.202

package/abstracts/distributor.js

@@ -0,0 +1,126 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RedisDistributedBackend_instances, _RedisDistributedBackend_publishClient, _RedisDistributedBackend_subscribeClient, _RedisDistributedBackend_keyPrefix, _RedisDistributedBackend_subject, _RedisDistributedBackend_isConnected, _RedisDistributedBackend_initialize, _RedisDistributedBackend_handleRedisMessage, _RedisDistributedBackend_isValidMessage, _RedisDistributedBackend_buildKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDistributedBackend = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const redis_1 = require("redis");
+const types_1 = require("../types");
+class RedisDistributedBackend {
+    constructor(options = {}) {
+        _RedisDistributedBackend_instances.add(this);
+        _RedisDistributedBackend_publishClient.set(this, void 0);
+        _RedisDistributedBackend_subscribeClient.set(this, void 0);
+        _RedisDistributedBackend_keyPrefix.set(this, void 0);
+        _RedisDistributedBackend_subject.set(this, void 0);
+        _RedisDistributedBackend_isConnected.set(this, false);
+        const { host = 'localhost', port = 6379, password, database = 0, url, keyPrefix = 'pondsocket', } = options;
+        __classPrivateFieldSet(this, _RedisDistributedBackend_keyPrefix, keyPrefix, "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_subject, new pondsocket_common_1.Subject(), "f");
+        // Create Redis clients
+        const clientConfig = url
+            ? { url }
+            : { socket: { host,
+                    port },
+                password,
+                database };
+        __classPrivateFieldSet(this, _RedisDistributedBackend_publishClient, (0, redis_1.createClient)(clientConfig), "f");
+        __classPrivateFieldSet(this, _RedisDistributedBackend_subscribeClient, __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").duplicate(), "f");
+        void __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_initialize).call(this);
+    }
+    /**
+     * Gets the subject for subscribing to distributed messages
+     */
+    get subject() {
+        return __classPrivateFieldGet(this, _RedisDistributedBackend_subject, "f");
+    }
+    /**
+     * Subscribe to messages for a specific endpoint and channel
+     */
+    subscribe(endpointName, channelName, handler) {
+        return this.subject.subscribe((message) => {
+            if (message.endpointName === endpointName && message.channelName === channelName) {
+                handler(message);
+            }
+        });
+    }
+    /**
+     * Broadcasts a message to all nodes for a specific endpoint and channel
+     */
+    broadcast(endpointName, channelName, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _RedisDistributedBackend_isConnected, "f")) {
+                throw new Error('Redis backend is not connected');
+            }
+            const key = __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_buildKey).call(this, endpointName, channelName);
+            const serializedMessage = JSON.stringify(message);
+            yield __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").publish(key, serializedMessage);
+        });
+    }
+    /**
+     * Cleanup and close all Redis connections
+     */
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.subject.close();
+            if (__classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").isOpen) {
+                yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").quit();
+            }
+            if (__classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").isOpen) {
+                yield __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").quit();
+            }
+            __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, false, "f");
+        });
+    }
+}
+exports.RedisDistributedBackend = RedisDistributedBackend;
+_RedisDistributedBackend_publishClient = new WeakMap(), _RedisDistributedBackend_subscribeClient = new WeakMap(), _RedisDistributedBackend_keyPrefix = new WeakMap(), _RedisDistributedBackend_subject = new WeakMap(), _RedisDistributedBackend_isConnected = new WeakMap(), _RedisDistributedBackend_instances = new WeakSet(), _RedisDistributedBackend_initialize = function _RedisDistributedBackend_initialize() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all([
+            __classPrivateFieldGet(this, _RedisDistributedBackend_publishClient, "f").connect(),
+            __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").connect(),
+        ]);
+        const pattern = `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:*`;
+        yield __classPrivateFieldGet(this, _RedisDistributedBackend_subscribeClient, "f").pSubscribe(pattern, (message) => {
+            __classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_handleRedisMessage).call(this, message);
+        });
+        __classPrivateFieldSet(this, _RedisDistributedBackend_isConnected, true, "f");
+    });
+}, _RedisDistributedBackend_handleRedisMessage = function _RedisDistributedBackend_handleRedisMessage(message) {
+    try {
+        const parsedMessage = JSON.parse(message);
+        if (__classPrivateFieldGet(this, _RedisDistributedBackend_instances, "m", _RedisDistributedBackend_isValidMessage).call(this, parsedMessage)) {
+            this.subject.publish(parsedMessage);
+        }
+    }
+    catch (_a) {
+        // Silently ignore invalid messages
+    }
+}, _RedisDistributedBackend_isValidMessage = function _RedisDistributedBackend_isValidMessage(message) {
+    return (typeof message === 'object' &&
+        typeof message.type === 'string' &&
+        Object.values(types_1.DistributedMessageType).includes(message.type) &&
+        typeof message.endpointName === 'string' &&
+        typeof message.channelName === 'string');
+}, _RedisDistributedBackend_buildKey = function _RedisDistributedBackend_buildKey(endpointName, channelName) {
+    return `${__classPrivateFieldGet(this, _RedisDistributedBackend_keyPrefix, "f")}:${endpointName}:${channelName}`;
+};

package/abstracts/middleware.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 __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
@@ -64,6 +73,26 @@ class Middleware {
         };
         next();
     }
+    runAsync(req, res, final) {
+        let index = 0;
+        const next = (err) => __awaiter(this, void 0, void 0, function* () {
+            if (err) {
+                return final(__classPrivateFieldGet(this, _Middleware_instances, "m", _Middleware_handleError).call(this, err));
+            }
+            if (index >= __classPrivateFieldGet(this, _Middleware_stack, "f").length) {
+                return final();
+            }
+            const middleware = __classPrivateFieldGet(this, _Middleware_stack, "f")[index];
+            index++;
+            try {
+                yield middleware(req, res, next);
+            }
+            catch (error) {
+                return final(__classPrivateFieldGet(this, _Middleware_instances, "m", _Middleware_handleError).call(this, error));
+            }
+        });
+        return next();
+    }
 }
 exports.Middleware = Middleware;
 _Middleware_stack = new WeakMap(), _Middleware_instances = new WeakSet(), _Middleware_handleError = function _Middleware_handleError(error) {

package/abstracts/types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedMessageType = void 0;
+var DistributedMessageType;
+(function (DistributedMessageType) {
+    DistributedMessageType["STATE_REQUEST"] = "STATE_REQUEST";
+    DistributedMessageType["STATE_RESPONSE"] = "STATE_RESPONSE";
+    DistributedMessageType["USER_JOINED"] = "USER_JOINED";
+    DistributedMessageType["USER_LEFT"] = "USER_LEFT";
+    DistributedMessageType["USER_MESSAGE"] = "USER_MESSAGE";
+    DistributedMessageType["PRESENCE_UPDATE"] = "PRESENCE_UPDATE";
+    DistributedMessageType["PRESENCE_REMOVED"] = "PRESENCE_REMOVED";
+    DistributedMessageType["ASSIGNS_UPDATE"] = "ASSIGNS_UPDATE";
+    DistributedMessageType["ASSIGNS_REMOVED"] = "ASSIGNS_REMOVED";
+    DistributedMessageType["EVICT_USER"] = "EVICT_USER";
+})(DistributedMessageType || (exports.DistributedMessageType = DistributedMessageType = {}));

package/contexts/baseContext.js

@@ -0,0 +1,86 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BaseContext_engine, _BaseContext_params, _BaseContext_event, _BaseContext_sender, _BaseContext_payload;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContext = void 0;
+const channel_1 = require("../wrappers/channel");
+class BaseContext {
+    constructor(engine, params, event, payload, sender) {
+        _BaseContext_engine.set(this, void 0);
+        _BaseContext_params.set(this, void 0);
+        _BaseContext_event.set(this, void 0);
+        _BaseContext_sender.set(this, void 0);
+        _BaseContext_payload.set(this, void 0);
+        __classPrivateFieldSet(this, _BaseContext_engine, engine, "f");
+        __classPrivateFieldSet(this, _BaseContext_params, params, "f");
+        __classPrivateFieldSet(this, _BaseContext_event, event, "f");
+        __classPrivateFieldSet(this, _BaseContext_payload, payload, "f");
+        __classPrivateFieldSet(this, _BaseContext_sender, sender, "f");
+    }
+    /**
+     * The event information
+     */
+    get event() {
+        return {
+            event: __classPrivateFieldGet(this, _BaseContext_event, "f"),
+            query: __classPrivateFieldGet(this, _BaseContext_params, "f").query,
+            params: __classPrivateFieldGet(this, _BaseContext_params, "f").params,
+            payload: __classPrivateFieldGet(this, _BaseContext_payload, "f"),
+        };
+    }
+    /**
+     * The channel name
+     */
+    get channelName() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f").name;
+    }
+    /**
+     * The channel instance
+     */
+    get channel() {
+        return new channel_1.Channel(__classPrivateFieldGet(this, _BaseContext_engine, "f"));
+    }
+    /**
+     * All current presences in the channel
+     */
+    get presences() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f").getPresence();
+    }
+    /**
+     * All current assigns in the channel
+     */
+    get assigns() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f").getAssigns();
+    }
+    /**
+     * The user who sent the request
+     */
+    get user() {
+        return this.channel.getUserData(__classPrivateFieldGet(this, _BaseContext_sender, "f"));
+    }
+    /**
+     * Gets the channel engine instance
+     * @protected
+     */
+    get engine() {
+        return __classPrivateFieldGet(this, _BaseContext_engine, "f");
+    }
+    /**
+     * Updates the event parameters.
+     */
+    updateParams(params) {
+        __classPrivateFieldSet(this, _BaseContext_params, params, "f");
+    }
+}
+exports.BaseContext = BaseContext;
+_BaseContext_engine = new WeakMap(), _BaseContext_params = new WeakMap(), _BaseContext_event = new WeakMap(), _BaseContext_sender = new WeakMap(), _BaseContext_payload = new WeakMap();

package/contexts/eventContext.js

@@ -10,80 +10,36 @@ 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 _EventContext_instances, _EventContext_event, _EventContext_engine, _EventContext_params, _EventContext_requestId, _EventContext_sendMessage;
+var _EventContext_instances, _EventContext_event, _EventContext_requestId, _EventContext_sendMessage;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventContext = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const channel_1 = require("../wrappers/channel");
+const baseContext_1 = require("./baseContext");
 /**
  * EventContext combines the functionality of EventRequest and EventResponse
  * to provide a unified interface for handling events in a channel.
  */
-class EventContext {
+class EventContext extends baseContext_1.BaseContext {
     constructor(event, params, engine) {
+        super(engine, params, event.event, event.payload, event.sender);
         _EventContext_instances.add(this);
         _EventContext_event.set(this, void 0);
-        _EventContext_engine.set(this, void 0);
-        _EventContext_params.set(this, void 0);
         _EventContext_requestId.set(this, void 0);
         __classPrivateFieldSet(this, _EventContext_event, event, "f");
-        __classPrivateFieldSet(this, _EventContext_params, params, "f");
-        __classPrivateFieldSet(this, _EventContext_engine, engine, "f");
         __classPrivateFieldSet(this, _EventContext_requestId, event.requestId, "f");
     }
-    /**
-     * The event information
-     */
-    get event() {
-        return {
-            event: __classPrivateFieldGet(this, _EventContext_event, "f").event,
-            query: __classPrivateFieldGet(this, _EventContext_params, "f").query,
-            params: __classPrivateFieldGet(this, _EventContext_params, "f").params,
-            payload: __classPrivateFieldGet(this, _EventContext_event, "f").payload,
-        };
-    }
-    /**
-     * The channel name
-     */
-    get channelName() {
-        return __classPrivateFieldGet(this, _EventContext_engine, "f").name;
-    }
-    /**
-     * The channel instance
-     */
-    get channel() {
-        return new channel_1.Channel(__classPrivateFieldGet(this, _EventContext_engine, "f"));
-    }
-    /**
-     * All current presences in the channel
-     */
-    get presences() {
-        return __classPrivateFieldGet(this, _EventContext_engine, "f").getPresence();
-    }
-    /**
-     * All current assigns in the channel
-     */
-    get assigns() {
-        return __classPrivateFieldGet(this, _EventContext_engine, "f").getAssigns();
-    }
-    /**
-     * The user who sent the request
-     */
-    get user() {
-        return __classPrivateFieldGet(this, _EventContext_engine, "f").getUserData(__classPrivateFieldGet(this, _EventContext_event, "f").sender);
-    }
     /**
      * Assigns data to the client
      */
     assign(assigns) {
-        __classPrivateFieldGet(this, _EventContext_engine, "f").updateAssigns(__classPrivateFieldGet(this, _EventContext_event, "f").sender, assigns);
+        this.channel.updateAssigns(__classPrivateFieldGet(this, _EventContext_event, "f").sender, assigns);
         return this;
     }
     /**
      * Sends a direct reply to the client
      */
     reply(event, payload) {
-        __classPrivateFieldGet(this, _EventContext_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventContext_event, "f").sender], pondsocket_common_1.ServerActions.SYSTEM, event, payload, __classPrivateFieldGet(this, _EventContext_requestId, "f"));
+        this.engine.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventContext_event, "f").sender], pondsocket_common_1.ServerActions.SYSTEM, event, payload, __classPrivateFieldGet(this, _EventContext_requestId, "f"));
         return this;
     }
     /**
@@ -112,32 +68,32 @@ class EventContext {
      * Tracks a user's presence
      */
     trackPresence(presence, userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
-        __classPrivateFieldGet(this, _EventContext_engine, "f").trackPresence(userId, presence);
+        this.channel.trackPresence(userId, presence);
         return this;
     }
     /**
      * Updates a user's presence
      */
     updatePresence(presence, userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
-        __classPrivateFieldGet(this, _EventContext_engine, "f").updatePresence(userId, presence);
+        this.channel.updatePresence(userId, presence);
         return this;
     }
     /**
      * Kicks a user from the channel
      */
     evictUser(reason, userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
-        __classPrivateFieldGet(this, _EventContext_engine, "f").kickUser(userId, reason);
+        this.channel.evictUser(userId, reason);
         return this;
     }
     /**
      * Removes a user's presence
      */
     removePresence(userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
-        __classPrivateFieldGet(this, _EventContext_engine, "f").removePresence(userId);
+        this.channel.removePresence(userId);
         return this;
     }
 }
 exports.EventContext = EventContext;
-_EventContext_event = new WeakMap(), _EventContext_engine = new WeakMap(), _EventContext_params = new WeakMap(), _EventContext_requestId = new WeakMap(), _EventContext_instances = new WeakSet(), _EventContext_sendMessage = function _EventContext_sendMessage(recipient, event, payload) {
-    __classPrivateFieldGet(this, _EventContext_engine, "f").sendMessage(__classPrivateFieldGet(this, _EventContext_event, "f").sender, recipient, pondsocket_common_1.ServerActions.BROADCAST, event, payload, __classPrivateFieldGet(this, _EventContext_requestId, "f"));
+_EventContext_event = new WeakMap(), _EventContext_requestId = new WeakMap(), _EventContext_instances = new WeakSet(), _EventContext_sendMessage = function _EventContext_sendMessage(recipient, event, payload) {
+    this.engine.sendMessage(__classPrivateFieldGet(this, _EventContext_event, "f").sender, recipient, pondsocket_common_1.ServerActions.BROADCAST, event, payload, __classPrivateFieldGet(this, _EventContext_requestId, "f"));
 };

package/contexts/joinContext.js

@@ -10,67 +10,31 @@ 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 _JoinContext_instances, _JoinContext_options, _JoinContext_engine, _JoinContext_user, _JoinContext_newAssigns, _JoinContext_executed, _JoinContext_accepted, _JoinContext_sendMessage, _JoinContext_directMessage, _JoinContext_performChecks;
+var _JoinContext_instances, _JoinContext_options, _JoinContext_user, _JoinContext_newAssigns, _JoinContext_executed, _JoinContext_accepted, _JoinContext_sendMessage, _JoinContext_directMessage, _JoinContext_performChecks;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinContext = void 0;
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const baseContext_1 = require("./baseContext");
 const httpError_1 = require("../errors/httpError");
-const channel_1 = require("../wrappers/channel");
 /**
  * JoinContext combines the functionality of JoinRequest and JoinResponse
  * to provide a unified interface for handling join events in a channel.
  */
-class JoinContext {
+class JoinContext extends baseContext_1.BaseContext {
     constructor(options, engine, user) {
+        super(engine, options.params, engine.name, options.joinParams, user.clientId);
         _JoinContext_instances.add(this);
         _JoinContext_options.set(this, void 0);
-        _JoinContext_engine.set(this, void 0);
         _JoinContext_user.set(this, void 0);
         _JoinContext_newAssigns.set(this, void 0);
         _JoinContext_executed.set(this, void 0);
         _JoinContext_accepted.set(this, void 0);
         __classPrivateFieldSet(this, _JoinContext_options, options, "f");
-        __classPrivateFieldSet(this, _JoinContext_engine, engine, "f");
         __classPrivateFieldSet(this, _JoinContext_user, user, "f");
         __classPrivateFieldSet(this, _JoinContext_executed, false, "f");
         __classPrivateFieldSet(this, _JoinContext_accepted, false, "f");
         __classPrivateFieldSet(this, _JoinContext_newAssigns, Object.assign({}, user.assigns), "f");
     }
-    /**
-     * The event information
-     */
-    get event() {
-        return {
-            event: __classPrivateFieldGet(this, _JoinContext_engine, "f").name,
-            query: __classPrivateFieldGet(this, _JoinContext_options, "f").params.query,
-            params: __classPrivateFieldGet(this, _JoinContext_options, "f").params.params,
-            payload: __classPrivateFieldGet(this, _JoinContext_options, "f").joinParams,
-        };
-    }
-    /**
-     * The channel name
-     */
-    get channelName() {
-        return __classPrivateFieldGet(this, _JoinContext_engine, "f").name;
-    }
-    /**
-     * The channel instance
-     */
-    get channel() {
-        return new channel_1.Channel(__classPrivateFieldGet(this, _JoinContext_engine, "f"));
-    }
-    /**
-     * All current presences in the channel
-     */
-    get presences() {
-        return __classPrivateFieldGet(this, _JoinContext_engine, "f").getPresence();
-    }
-    /**
-     * All current assigns in the channel
-     */
-    get assigns() {
-        return __classPrivateFieldGet(this, _JoinContext_engine, "f").getAssigns();
-    }
     /**
      * The user who sent the request
      */
@@ -98,8 +62,8 @@ class JoinContext {
      */
     accept() {
         __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_performChecks).call(this);
-        const onMessage = __classPrivateFieldGet(this, _JoinContext_engine, "f").parent.parent.sendMessage.bind(__classPrivateFieldGet(this, _JoinContext_engine, "f").parent.parent, __classPrivateFieldGet(this, _JoinContext_user, "f").socket);
-        const subscription = __classPrivateFieldGet(this, _JoinContext_engine, "f").addUser(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f"), onMessage);
+        const onMessage = this.engine.parent.parent.sendMessage.bind(this.engine.parent.parent, __classPrivateFieldGet(this, _JoinContext_user, "f").socket);
+        const subscription = this.engine.addUser(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f"), onMessage);
         __classPrivateFieldGet(this, _JoinContext_user, "f").subscriptions.add(subscription);
         __classPrivateFieldSet(this, _JoinContext_accepted, true, "f");
         return this;
@@ -115,7 +79,7 @@ class JoinContext {
                 message: message || 'Unauthorized connection',
                 code: errorCode || 401,
             },
-            channelName: __classPrivateFieldGet(this, _JoinContext_engine, "f").name,
+            channelName: this.engine.name,
             action: pondsocket_common_1.ServerActions.ERROR,
             requestId: __classPrivateFieldGet(this, _JoinContext_user, "f").requestId,
         };
@@ -127,7 +91,7 @@ class JoinContext {
      */
     assign(assigns) {
         if (__classPrivateFieldGet(this, _JoinContext_accepted, "f")) {
-            __classPrivateFieldGet(this, _JoinContext_engine, "f").updateAssigns(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, assigns);
+            this.engine.updateAssigns(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, assigns);
         }
         else {
             __classPrivateFieldSet(this, _JoinContext_newAssigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f")), assigns), "f");
@@ -140,7 +104,7 @@ class JoinContext {
     reply(event, payload) {
         const message = {
             action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: __classPrivateFieldGet(this, _JoinContext_engine, "f").name,
+            channelName: this.engine.name,
             requestId: __classPrivateFieldGet(this, _JoinContext_user, "f").requestId,
             payload,
             event,
@@ -174,18 +138,18 @@ class JoinContext {
      * Tracks the user's presence
      */
     trackPresence(presence) {
-        __classPrivateFieldGet(this, _JoinContext_engine, "f").trackPresence(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, presence);
+        this.engine.trackPresence(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, presence);
         return this;
     }
 }
 exports.JoinContext = JoinContext;
-_JoinContext_options = new WeakMap(), _JoinContext_engine = new WeakMap(), _JoinContext_user = new WeakMap(), _JoinContext_newAssigns = new WeakMap(), _JoinContext_executed = new WeakMap(), _JoinContext_accepted = new WeakMap(), _JoinContext_instances = new WeakSet(), _JoinContext_sendMessage = function _JoinContext_sendMessage(recipient, event, payload) {
-    __classPrivateFieldGet(this, _JoinContext_engine, "f").sendMessage(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, recipient, pondsocket_common_1.ServerActions.BROADCAST, event, payload, __classPrivateFieldGet(this, _JoinContext_user, "f").requestId);
+_JoinContext_options = new WeakMap(), _JoinContext_user = new WeakMap(), _JoinContext_newAssigns = new WeakMap(), _JoinContext_executed = new WeakMap(), _JoinContext_accepted = new WeakMap(), _JoinContext_instances = new WeakSet(), _JoinContext_sendMessage = function _JoinContext_sendMessage(recipient, event, payload) {
+    this.engine.sendMessage(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, recipient, pondsocket_common_1.ServerActions.BROADCAST, event, payload, __classPrivateFieldGet(this, _JoinContext_user, "f").requestId);
 }, _JoinContext_directMessage = function _JoinContext_directMessage(event) {
-    __classPrivateFieldGet(this, _JoinContext_engine, "f").parent.parent.sendMessage(__classPrivateFieldGet(this, _JoinContext_user, "f").socket, event);
+    this.engine.parent.parent.sendMessage(__classPrivateFieldGet(this, _JoinContext_user, "f").socket, event);
 }, _JoinContext_performChecks = function _JoinContext_performChecks() {
     if (__classPrivateFieldGet(this, _JoinContext_executed, "f")) {
-        const message = `Request to join channel ${__classPrivateFieldGet(this, _JoinContext_engine, "f").name} rejected: Request already executed`;
+        const message = `Request to join channel ${this.engine.name} rejected: Request already executed`;
         throw new httpError_1.HttpError(403, message);
     }
     __classPrivateFieldSet(this, _JoinContext_executed, true, "f");

package/contexts/outgoingContext.js

@@ -0,0 +1,59 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OutgoingContext_payload, _OutgoingContext_isBlocked;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutgoingContext = void 0;
+const baseContext_1 = require("./baseContext");
+class OutgoingContext extends baseContext_1.BaseContext {
+    constructor(event, params, engine, userid) {
+        super(engine, params, event.event, event.payload, userid);
+        _OutgoingContext_payload.set(this, void 0);
+        _OutgoingContext_isBlocked.set(this, void 0);
+        __classPrivateFieldSet(this, _OutgoingContext_payload, event.payload, "f");
+        __classPrivateFieldSet(this, _OutgoingContext_isBlocked, false, "f");
+    }
+    get payload() {
+        return __classPrivateFieldGet(this, _OutgoingContext_payload, "f");
+    }
+    /**
+     * Blocks the outgoing context, preventing further processing of the event.
+     */
+    block() {
+        __classPrivateFieldSet(this, _OutgoingContext_isBlocked, true, "f");
+        return this;
+    }
+    /**
+     * Checks if the outgoing context is blocked.
+     * @returns {boolean} - True if blocked, false otherwise.
+     */
+    isBlocked() {
+        return __classPrivateFieldGet(this, _OutgoingContext_isBlocked, "f");
+    }
+    /**
+     * Transforms the outgoing context with a new payload.
+     * @param payload - The new payload to set for the context.
+     */
+    transform(payload) {
+        __classPrivateFieldSet(this, _OutgoingContext_payload, payload, "f");
+        return this;
+    }
+    /**
+     * Updates the parameters of the outgoing context.
+     * @param params - The new parameters to set for the context.
+     */
+    updateParams(params) {
+        super.updateParams(params);
+    }
+}
+exports.OutgoingContext = OutgoingContext;
+_OutgoingContext_payload = new WeakMap(), _OutgoingContext_isBlocked = new WeakMap();