@eleven-am/pondsocket 0.1.199 → 0.1.200

package/contexts/connectionContext.js

@@ -0,0 +1,169 @@
+"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 _ConnectionContext_instances, _ConnectionContext_executed, _ConnectionContext_assigns, _ConnectionContext_clientId, _ConnectionContext_engine, _ConnectionContext_params, _ConnectionContext_webSocketServer, _ConnectionContext_connectionData, _ConnectionContext_performChecks;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionContext = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const httpError_1 = require("../errors/httpError");
+/**
+ * ConnectionContext combines IncomingConnection data with ConnectionResponse functionality.
+ */
+class ConnectionContext {
+    constructor(connectionData, { engine, params, webSocketServer }) {
+        _ConnectionContext_instances.add(this);
+        _ConnectionContext_executed.set(this, void 0);
+        _ConnectionContext_assigns.set(this, void 0);
+        _ConnectionContext_clientId.set(this, void 0);
+        _ConnectionContext_engine.set(this, void 0);
+        _ConnectionContext_params.set(this, void 0);
+        _ConnectionContext_webSocketServer.set(this, void 0);
+        _ConnectionContext_connectionData.set(this, void 0);
+        __classPrivateFieldSet(this, _ConnectionContext_webSocketServer, webSocketServer, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_clientId, connectionData.id, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_executed, false, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_engine, engine, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_params, params, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_assigns, {}, "f");
+        __classPrivateFieldSet(this, _ConnectionContext_connectionData, connectionData, "f");
+    }
+    /**
+     * Whether the connection has been handled
+     */
+    get hasResponded() {
+        return __classPrivateFieldGet(this, _ConnectionContext_executed, "f");
+    }
+    /**
+     * Connection details including headers, cookies, address, id, etc.
+     */
+    get connection() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f");
+    }
+    /**
+     * The request parameters
+     */
+    get requestId() {
+        return __classPrivateFieldGet(this, _ConnectionContext_params, "f").requestId;
+    }
+    /**
+     * The client ID
+     */
+    get clientId() {
+        return __classPrivateFieldGet(this, _ConnectionContext_clientId, "f");
+    }
+    /**
+     * The request headers
+     */
+    get headers() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").headers;
+    }
+    /**
+     * The request cookies
+     */
+    get cookies() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").cookies;
+    }
+    /**
+     * The client address
+     */
+    get address() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").address;
+    }
+    /**
+     * The event parameters
+     */
+    get event() {
+        return {
+            query: __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").query,
+            params: __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").params,
+        };
+    }
+    /**
+     * The query parameters
+     */
+    get query() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").query;
+    }
+    /**
+     * The path parameters
+     */
+    get params() {
+        return __classPrivateFieldGet(this, _ConnectionContext_connectionData, "f").params;
+    }
+    /**
+     * Assigns data to the client
+     */
+    assign(assigns) {
+        if (!__classPrivateFieldGet(this, _ConnectionContext_executed, "f")) {
+            __classPrivateFieldSet(this, _ConnectionContext_assigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _ConnectionContext_assigns, "f")), assigns), "f");
+        }
+        else {
+            const user = __classPrivateFieldGet(this, _ConnectionContext_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionContext_clientId, "f"));
+            user.assigns = Object.assign(Object.assign({}, user.assigns), assigns);
+        }
+        return this;
+    }
+    /**
+     * Accepts the connection request
+     */
+    accept() {
+        __classPrivateFieldGet(this, _ConnectionContext_instances, "m", _ConnectionContext_performChecks).call(this);
+        __classPrivateFieldGet(this, _ConnectionContext_webSocketServer, "f").handleUpgrade(__classPrivateFieldGet(this, _ConnectionContext_params, "f").request, __classPrivateFieldGet(this, _ConnectionContext_params, "f").socket, __classPrivateFieldGet(this, _ConnectionContext_params, "f").head, (ws) => {
+            const cache = {
+                clientId: __classPrivateFieldGet(this, _ConnectionContext_clientId, "f"),
+                subscriptions: new Set(),
+                assigns: __classPrivateFieldGet(this, _ConnectionContext_assigns, "f"),
+                socket: ws,
+            };
+            __classPrivateFieldGet(this, _ConnectionContext_webSocketServer, "f").emit('connection', ws);
+            __classPrivateFieldGet(this, _ConnectionContext_engine, "f").manageSocket(cache);
+        });
+        return this;
+    }
+    /**
+     * Declines the connection request
+     */
+    decline(message, errorCode) {
+        __classPrivateFieldGet(this, _ConnectionContext_instances, "m", _ConnectionContext_performChecks).call(this);
+        const code = errorCode || 400;
+        const { socket } = __classPrivateFieldGet(this, _ConnectionContext_params, "f");
+        const newMessage = message || 'Unauthorized connection';
+        socket.write(`HTTP/1.1 ${code} ${newMessage}\r\n\r\n`);
+        socket.destroy();
+        return this;
+    }
+    /**
+     * Sends a direct reply to the client
+     */
+    reply(event, payload) {
+        if (!__classPrivateFieldGet(this, _ConnectionContext_executed, "f")) {
+            throw new httpError_1.HttpError(400, 'Connection has not been accepted');
+        }
+        const { socket } = __classPrivateFieldGet(this, _ConnectionContext_engine, "f").getUser(__classPrivateFieldGet(this, _ConnectionContext_clientId, "f"));
+        const message = {
+            event,
+            payload,
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            requestId: __classPrivateFieldGet(this, _ConnectionContext_params, "f").requestId,
+            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+        };
+        __classPrivateFieldGet(this, _ConnectionContext_engine, "f").sendMessage(socket, message);
+        return this;
+    }
+}
+exports.ConnectionContext = ConnectionContext;
+_ConnectionContext_executed = new WeakMap(), _ConnectionContext_assigns = new WeakMap(), _ConnectionContext_clientId = new WeakMap(), _ConnectionContext_engine = new WeakMap(), _ConnectionContext_params = new WeakMap(), _ConnectionContext_webSocketServer = new WeakMap(), _ConnectionContext_connectionData = new WeakMap(), _ConnectionContext_instances = new WeakSet(), _ConnectionContext_performChecks = function _ConnectionContext_performChecks() {
+    if (__classPrivateFieldGet(this, _ConnectionContext_executed, "f")) {
+        throw new httpError_1.HttpError(400, 'Response has already been executed');
+    }
+    __classPrivateFieldSet(this, _ConnectionContext_executed, true, "f");
+};

package/contexts/eventContext.js

@@ -0,0 +1,143 @@
+"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 _EventContext_instances, _EventContext_event, _EventContext_engine, _EventContext_params, _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");
+/**
+ * EventContext combines the functionality of EventRequest and EventResponse
+ * to provide a unified interface for handling events in a channel.
+ */
+class EventContext {
+    constructor(event, params, engine) {
+        _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);
+        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"));
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users in the channel
+     */
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _EventContext_instances, "m", _EventContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_USERS, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users except the sender
+     */
+    broadcastFrom(event, payload) {
+        __classPrivateFieldGet(this, _EventContext_instances, "m", _EventContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to specific users
+     */
+    broadcastTo(event, payload, userIds) {
+        const ids = Array.isArray(userIds) ? userIds : [userIds];
+        __classPrivateFieldGet(this, _EventContext_instances, "m", _EventContext_sendMessage).call(this, ids, event, payload);
+        return this;
+    }
+    /**
+     * Tracks a user's presence
+     */
+    trackPresence(presence, userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
+        __classPrivateFieldGet(this, _EventContext_engine, "f").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);
+        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);
+        return this;
+    }
+    /**
+     * Removes a user's presence
+     */
+    removePresence(userId = __classPrivateFieldGet(this, _EventContext_event, "f").sender) {
+        __classPrivateFieldGet(this, _EventContext_engine, "f").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"));
+};

package/contexts/joinContext.js

@@ -0,0 +1,192 @@
+"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 _JoinContext_instances, _JoinContext_options, _JoinContext_engine, _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 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 {
+    constructor(options, engine, user) {
+        _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
+     */
+    get user() {
+        return {
+            id: __classPrivateFieldGet(this, _JoinContext_options, "f").clientId,
+            assigns: __classPrivateFieldGet(this, _JoinContext_options, "f").assigns,
+            presence: {},
+        };
+    }
+    /**
+     * The join parameters
+     */
+    get joinParams() {
+        return __classPrivateFieldGet(this, _JoinContext_options, "f").joinParams;
+    }
+    /**
+     * Whether the request has been handled
+     */
+    get hasResponded() {
+        return __classPrivateFieldGet(this, _JoinContext_executed, "f");
+    }
+    /**
+     * Accepts the join request
+     */
+    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);
+        __classPrivateFieldGet(this, _JoinContext_user, "f").subscriptions.add(subscription);
+        __classPrivateFieldSet(this, _JoinContext_accepted, true, "f");
+        return this;
+    }
+    /**
+     * Declines the join request
+     */
+    decline(message, errorCode) {
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_performChecks).call(this);
+        const errorMessage = {
+            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
+            payload: {
+                message: message || 'Unauthorized connection',
+                code: errorCode || 401,
+            },
+            channelName: __classPrivateFieldGet(this, _JoinContext_engine, "f").name,
+            action: pondsocket_common_1.ServerActions.ERROR,
+            requestId: __classPrivateFieldGet(this, _JoinContext_user, "f").requestId,
+        };
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_directMessage).call(this, errorMessage);
+        return this;
+    }
+    /**
+     * Assigns data to the user
+     */
+    assign(assigns) {
+        if (__classPrivateFieldGet(this, _JoinContext_accepted, "f")) {
+            __classPrivateFieldGet(this, _JoinContext_engine, "f").updateAssigns(__classPrivateFieldGet(this, _JoinContext_user, "f").clientId, assigns);
+        }
+        else {
+            __classPrivateFieldSet(this, _JoinContext_newAssigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _JoinContext_newAssigns, "f")), assigns), "f");
+        }
+        return this;
+    }
+    /**
+     * Sends a direct reply to the user
+     */
+    reply(event, payload) {
+        const message = {
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: __classPrivateFieldGet(this, _JoinContext_engine, "f").name,
+            requestId: __classPrivateFieldGet(this, _JoinContext_user, "f").requestId,
+            payload,
+            event,
+        };
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_directMessage).call(this, message);
+        return this;
+    }
+    /**
+     * Broadcasts a message to specific users
+     */
+    broadcastTo(event, payload, userIds) {
+        const ids = Array.isArray(userIds) ? userIds : [userIds];
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_sendMessage).call(this, ids, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users in the channel
+     */
+    broadcast(event, payload) {
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_USERS, event, payload);
+        return this;
+    }
+    /**
+     * Broadcasts a message to all users except the sender
+     */
+    broadcastFrom(event, payload) {
+        __classPrivateFieldGet(this, _JoinContext_instances, "m", _JoinContext_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, event, payload);
+        return this;
+    }
+    /**
+     * Tracks the user's presence
+     */
+    trackPresence(presence) {
+        __classPrivateFieldGet(this, _JoinContext_engine, "f").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_directMessage = function _JoinContext_directMessage(event) {
+    __classPrivateFieldGet(this, _JoinContext_engine, "f").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`;
+        throw new httpError_1.HttpError(403, message);
+    }
+    __classPrivateFieldSet(this, _JoinContext_executed, true, "f");
+};

package/engines/channelEngine.js

@@ -248,19 +248,14 @@ class ChannelEngine {
      * 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();
-        // Remove the channel from the parent
         this.parent.deleteChannel(this.name);
     }
 }

package/engines/endpointEngine.js

@@ -16,10 +16,9 @@ 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 joinContext_1 = require("../contexts/joinContext");
 const httpError_1 = require("../errors/httpError");
 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() {
@@ -46,9 +45,8 @@ class EndpointEngine {
                     joinParams,
                 };
                 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);
+                const context = new joinContext_1.JoinContext(options, channel, user);
+                return handler(context, next);
             }
             next();
         });

package/engines/lobbyEngine.js

@@ -24,10 +24,9 @@ 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 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) {
@@ -51,12 +50,11 @@ class LobbyEngine {
     onEvent(event, handler) {
         this.middleware.use((requestEvent, channel, next) => {
             const params = (0, matcher_1.parseAddress)(event, requestEvent.event);
-            if (params) {
-                const eventRequest = new eventRequest_1.EventRequest(requestEvent, params, channel);
-                const response = new eventResponse_1.EventResponse(requestEvent, channel);
-                return handler(eventRequest, response, next);
+            if (!params) {
+                return next();
             }
-            return next();
+            const context = new eventContext_1.EventContext(requestEvent, params, channel);
+            return handler(context, next);
         });
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.199",
+  "version": "0.1.200",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",

package/server/server.js

@@ -17,12 +17,12 @@ const http_1 = require("http");
 const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
 const ws_1 = require("ws");
 const middleware_1 = require("../abstracts/middleware");
+const connectionContext_1 = require("../contexts/connectionContext");
 const endpointEngine_1 = require("../engines/endpointEngine");
 const matcher_1 = require("../matcher/matcher");
-const connectionResponse_1 = require("../responses/connectionResponse");
 const endpoint_1 = require("../wrappers/endpoint");
 class PondSocket {
-    constructor({ server, socketServer, exclusiveServer = true } = {}) {
+    constructor({ server, socketServer, exclusiveServer = true, } = {}) {
         _PondSocket_instances.add(this);
         _PondSocket_exclusiveServer.set(this, void 0);
         _PondSocket_server.set(this, void 0);
@@ -53,17 +53,17 @@ class PondSocket {
         const endpoint = new endpointEngine_1.EndpointEngine();
         __classPrivateFieldGet(this, _PondSocket_middleware, "f").use((req, params, next) => {
             const event = (0, matcher_1.parseAddress)(path, req.address);
-            if (event) {
-                const request = Object.assign(Object.assign({}, event), { cookies: __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_getCookies).call(this, req.headers), headers: req.headers, address: req.address, id: req.id });
-                const newParams = {
-                    params,
-                    engine: endpoint,
-                    webSocketServer: __classPrivateFieldGet(this, _PondSocket_socketServer, "f"),
-                };
-                const response = new connectionResponse_1.ConnectionResponse(request.id, newParams);
-                return handler(request, response, next);
+            if (!event) {
+                return next();
             }
-            return next();
+            const request = Object.assign(Object.assign({}, event), { cookies: __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_getCookies).call(this, req.headers), headers: req.headers, address: req.address, id: req.id });
+            const newParams = {
+                params,
+                engine: endpoint,
+                webSocketServer: __classPrivateFieldGet(this, _PondSocket_socketServer, "f"),
+            };
+            const context = new connectionContext_1.ConnectionContext(request, newParams);
+            return handler(context, next);
         });
         return new endpoint_1.Endpoint(endpoint);
     }
@@ -128,8 +128,10 @@ _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_server = new WeakMap(),
     if (!cookieHeader) {
         return {};
     }
-    return cookieHeader.split(';').reduce((cookies, cookie) => {
-        const [name, value] = cookie.trim().split('=');
+    return cookieHeader.split(';')
+        .reduce((cookies, cookie) => {
+        const [name, value] = cookie.trim()
+            .split('=');
         cookies[name] = decodeURIComponent(value);
         return cookies;
     }, {});