@eleven-am/pondsocket 0.1.197 → 0.1.198

package/engines/presenceEngine.js

@@ -0,0 +1,140 @@
+"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 _PresenceEngine_instances, _PresenceEngine_presenceCache, _PresenceEngine_publisher, _PresenceEngine_channelId, _PresenceEngine_processPresenceAction;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresenceEngine = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+/**
+ * Manages user presence for a channel
+ */
+class PresenceEngine {
+    /**
+     * Creates a new Presence manager
+     * @param channelId - The ID of the channel this presence belongs to
+     */
+    constructor(channelId) {
+        _PresenceEngine_instances.add(this);
+        _PresenceEngine_presenceCache.set(this, new Map());
+        _PresenceEngine_publisher.set(this, new pondsocket_common_1.Subject());
+        _PresenceEngine_channelId.set(this, void 0);
+        __classPrivateFieldSet(this, _PresenceEngine_channelId, channelId, "f");
+    }
+    /**
+     * Gets the number of users with presence data
+     */
+    get presenceCount() {
+        return __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").size;
+    }
+    /**
+     * Track a new user's presence
+     * @param userId - The ID of the user
+     * @param data - The presence data
+     * @returns The generated presence event
+     */
+    trackPresence(userId, data) {
+        return __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_processPresenceAction).call(this, pondsocket_common_1.PresenceEventTypes.JOIN, userId, data);
+    }
+    /**
+     * Update an existing user's presence
+     * @param userId - The ID of the user
+     * @param data - The updated presence data
+     * @returns The generated presence event
+     */
+    updatePresence(userId, data) {
+        return __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_processPresenceAction).call(this, pondsocket_common_1.PresenceEventTypes.UPDATE, userId, data);
+    }
+    /**
+     * Remove a user's presence
+     * @param userId - The ID of the user
+     * @returns The generated presence event
+     */
+    removePresence(userId) {
+        return __classPrivateFieldGet(this, _PresenceEngine_instances, "m", _PresenceEngine_processPresenceAction).call(this, pondsocket_common_1.PresenceEventTypes.LEAVE, userId, null);
+    }
+    /**
+     * Add or update a user's presence
+     * @param userId - The ID of the user
+     * @param data - The presence data
+     * @returns The generated presence event
+     */
+    upsertPresence(userId, data) {
+        if (__classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").has(userId)) {
+            return this.updatePresence(userId, data);
+        }
+        return this.trackPresence(userId, data);
+    }
+    /**
+     * Get a specific user's presence
+     * @param userId - The ID of the user
+     * @returns The user's presence data or null if not found
+     */
+    getPresence(userId) {
+        return __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").get(userId) || null;
+    }
+    /**
+     * Get presence data for all users
+     * @returns A copy of all presence data
+     */
+    getAllPresence() {
+        return new Map(__classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f"));
+    }
+    /**
+     * Subscribe to presence events
+     * @param callback - The callback to invoke when presence changes
+     * @returns A function to unsubscribe
+     */
+    subscribe(callback) {
+        return __classPrivateFieldGet(this, _PresenceEngine_publisher, "f").subscribe(callback);
+    }
+    /**
+     * Clear all presence data and close the publisher
+     */
+    close() {
+        __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").clear();
+        __classPrivateFieldGet(this, _PresenceEngine_publisher, "f").close();
+    }
+}
+exports.PresenceEngine = PresenceEngine;
+_PresenceEngine_presenceCache = new WeakMap(), _PresenceEngine_publisher = new WeakMap(), _PresenceEngine_channelId = new WeakMap(), _PresenceEngine_instances = new WeakSet(), _PresenceEngine_processPresenceAction = function _PresenceEngine_processPresenceAction(action, userId, data) {
+    if (action === pondsocket_common_1.PresenceEventTypes.JOIN && __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").has(userId)) {
+        throw new Error(`User with id ${userId} already exists in the presence cache`);
+    }
+    else if ((action === pondsocket_common_1.PresenceEventTypes.UPDATE || action === pondsocket_common_1.PresenceEventTypes.LEAVE) && !__classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").has(userId)) {
+        throw new Error(`User with id ${userId} does not exist in the presence cache`);
+    }
+    if (action !== pondsocket_common_1.PresenceEventTypes.LEAVE && !data) {
+        throw new Error(`Data is required for ${action} action`);
+    }
+    const current = __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").get(userId);
+    if (data) {
+        __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").set(userId, data);
+    }
+    else {
+        __classPrivateFieldGet(this, _PresenceEngine_presenceCache, "f").delete(userId);
+    }
+    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)(),
+        recipients: userIds,
+        channelName: __classPrivateFieldGet(this, _PresenceEngine_channelId, "f"),
+        action: pondsocket_common_1.ServerActions.PRESENCE,
+        payload: {
+            changed: current || data || {},
+            presence: total,
+        },
+    };
+    __classPrivateFieldGet(this, _PresenceEngine_publisher, "f").publish(internalEvent);
+};

package/index.js

@@ -1,7 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisError = void 0;
 const server_1 = require("./server/server");
-var redisError_1 = require("./errors/redisError");
-Object.defineProperty(exports, "RedisError", { enumerable: true, get: function () { return redisError_1.RedisError; } });
 exports.default = server_1.PondSocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.197",
+  "version": "0.1.198",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -46,8 +46,8 @@
     "@types/jest": "^29.5.14",
     "@types/node": "^22.15.3",
     "@types/ws": "^8.18.1",
-    "@typescript-eslint/eslint-plugin": "^8.31.0",
-    "@typescript-eslint/parser": "^8.31.0",
+    "@typescript-eslint/eslint-plugin": "^8.31.1",
+    "@typescript-eslint/parser": "^8.31.1",
     "eslint": "^9.25.1",
     "eslint-config-prettier": "^10.1.2",
     "eslint-import-resolver-node": "^0.3.9",

package/requests/eventRequest.js

@@ -23,6 +23,9 @@ class EventRequest {
         __classPrivateFieldSet(this, _EventRequest_params, params, "f");
         __classPrivateFieldSet(this, _EventRequest_engine, engine, "f");
     }
+    /**
+     * The event information
+     */
     get event() {
         return {
             event: __classPrivateFieldGet(this, _EventRequest_event, "f").event,
@@ -31,20 +34,35 @@ class EventRequest {
             payload: __classPrivateFieldGet(this, _EventRequest_event, "f").payload,
         };
     }
+    /**
+     * The channel name
+     */
     get channelName() {
         return __classPrivateFieldGet(this, _EventRequest_engine, "f").name;
     }
+    /**
+     * The channel instance
+     */
     get channel() {
         return new channel_1.Channel(__classPrivateFieldGet(this, _EventRequest_engine, "f"));
     }
+    /**
+     * All current presences in the channel
+     */
     get presences() {
         return __classPrivateFieldGet(this, _EventRequest_engine, "f").getPresence();
     }
+    /**
+     * All current assigns in the channel
+     */
     get assigns() {
         return __classPrivateFieldGet(this, _EventRequest_engine, "f").getAssigns();
     }
+    /**
+     * The user who sent the request
+     */
     get user() {
-        return __classPrivateFieldGet(this, _EventRequest_engine, "f").getUser(__classPrivateFieldGet(this, _EventRequest_event, "f").sender);
+        return __classPrivateFieldGet(this, _EventRequest_engine, "f").getUserData(__classPrivateFieldGet(this, _EventRequest_event, "f").sender);
     }
 }
 exports.EventRequest = EventRequest;

package/responses/eventResponse.js

@@ -24,42 +24,72 @@ class EventResponse {
         __classPrivateFieldSet(this, _EventResponse_engine, engine, "f");
         __classPrivateFieldSet(this, _EventResponse_requestId, event.requestId, "f");
     }
+    /**
+     * Whether the response has been handled
+     */
     get hasResponded() {
         return false;
     }
+    /**
+     * Assigns data to the client
+     */
     assign(assigns) {
         __classPrivateFieldGet(this, _EventResponse_engine, "f").updateAssigns(__classPrivateFieldGet(this, _EventResponse_event, "f").sender, assigns);
         return this;
     }
+    /**
+     * Sends a direct reply to the client
+     */
     reply(event, payload) {
         __classPrivateFieldGet(this, _EventResponse_engine, "f").sendMessage(pondsocket_common_1.SystemSender.CHANNEL, [__classPrivateFieldGet(this, _EventResponse_event, "f").sender], pondsocket_common_1.ServerActions.SYSTEM, event, payload, __classPrivateFieldGet(this, _EventResponse_requestId, "f"));
         return this;
     }
+    /**
+     * Broadcasts a message to all users in the channel
+     */
     broadcast(event, payload) {
         __classPrivateFieldGet(this, _EventResponse_instances, "m", _EventResponse_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, _EventResponse_instances, "m", _EventResponse_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, _EventResponse_instances, "m", _EventResponse_sendMessage).call(this, ids, event, payload);
         return this;
     }
+    /**
+     * Tracks a user's presence
+     */
     trackPresence(presence, userId = __classPrivateFieldGet(this, _EventResponse_event, "f").sender) {
         __classPrivateFieldGet(this, _EventResponse_engine, "f").trackPresence(userId, presence);
         return this;
     }
+    /**
+     * Updates a user's presence
+     */
     updatePresence(presence, userId = __classPrivateFieldGet(this, _EventResponse_event, "f").sender) {
         __classPrivateFieldGet(this, _EventResponse_engine, "f").updatePresence(userId, presence);
         return this;
     }
+    /**
+     * Kicks a user from the channel
+     */
     evictUser(reason, userId = __classPrivateFieldGet(this, _EventResponse_event, "f").sender) {
         __classPrivateFieldGet(this, _EventResponse_engine, "f").kickUser(userId, reason);
         return this;
     }
+    /**
+     * Removes a user's presence
+     */
     removePresence(userId = __classPrivateFieldGet(this, _EventResponse_event, "f").sender) {
         __classPrivateFieldGet(this, _EventResponse_engine, "f").removePresence(userId);
         return this;

package/responses/joinResponse.js

@@ -29,9 +29,15 @@ class JoinResponse {
         __classPrivateFieldSet(this, _JoinResponse_accepted, false, "f");
         __classPrivateFieldSet(this, _JoinResponse_newAssigns, Object.assign({}, user.assigns), "f");
     }
+    /**
+     * Whether the request has been handled
+     */
     get hasResponded() {
         return __classPrivateFieldGet(this, _JoinResponse_executed, "f");
     }
+    /**
+     * Accepts the join request
+     */
     accept() {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
         const onMessage = __classPrivateFieldGet(this, _JoinResponse_engine, "f").parent.parent.sendMessage.bind(__classPrivateFieldGet(this, _JoinResponse_engine, "f").parent.parent, __classPrivateFieldGet(this, _JoinResponse_user, "f").socket);
@@ -40,6 +46,9 @@ class JoinResponse {
         __classPrivateFieldSet(this, _JoinResponse_accepted, true, "f");
         return this;
     }
+    /**
+     * Declines the join request
+     */
     decline(message, errorCode) {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_performChecks).call(this);
         const errorMessage = {
@@ -55,15 +64,21 @@ class JoinResponse {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_directMessage).call(this, errorMessage);
         return this;
     }
+    /**
+     * Assigns data to the user
+     */
     assign(assigns) {
         if (__classPrivateFieldGet(this, _JoinResponse_accepted, "f")) {
-            void __classPrivateFieldGet(this, _JoinResponse_engine, "f").updateAssigns(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, assigns);
+            __classPrivateFieldGet(this, _JoinResponse_engine, "f").updateAssigns(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, assigns);
         }
         else {
             __classPrivateFieldSet(this, _JoinResponse_newAssigns, Object.assign(Object.assign({}, __classPrivateFieldGet(this, _JoinResponse_newAssigns, "f")), assigns), "f");
         }
         return this;
     }
+    /**
+     * Sends a direct reply to the user
+     */
     reply(event, payload) {
         const message = {
             action: pondsocket_common_1.ServerActions.SYSTEM,
@@ -75,19 +90,31 @@ class JoinResponse {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_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, _JoinResponse_instances, "m", _JoinResponse_sendMessage).call(this, ids, event, payload);
         return this;
     }
+    /**
+     * Broadcasts a message to all users in the channel
+     */
     broadcast(event, payload) {
         __classPrivateFieldGet(this, _JoinResponse_instances, "m", _JoinResponse_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, _JoinResponse_instances, "m", _JoinResponse_sendMessage).call(this, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, event, payload);
         return this;
     }
+    /**
+     * Tracks the user's presence
+     */
     trackPresence(presence) {
         __classPrivateFieldGet(this, _JoinResponse_engine, "f").trackPresence(__classPrivateFieldGet(this, _JoinResponse_user, "f").clientId, presence);
         return this;
@@ -101,8 +128,7 @@ _JoinResponse_user = new WeakMap(), _JoinResponse_engine = new WeakMap(), _JoinR
 }, _JoinResponse_performChecks = function _JoinResponse_performChecks() {
     if (__classPrivateFieldGet(this, _JoinResponse_executed, "f")) {
         const message = `Request to join channel ${__classPrivateFieldGet(this, _JoinResponse_engine, "f").name} rejected: Request already executed`;
-        const code = 403;
-        throw new httpError_1.HttpError(code, message);
+        throw new httpError_1.HttpError(403, message);
     }
     __classPrivateFieldSet(this, _JoinResponse_executed, true, "f");
 };

package/server/server.js

@@ -1,13 +1,4 @@
 "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");
@@ -19,48 +10,47 @@ 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 _PondSocket_instances, _PondSocket_exclusiveServer, _PondSocket_server, _PondSocket_socketServer, _PondSocket_redisClient, _PondSocket_middleware, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
+var _PondSocket_instances, _PondSocket_exclusiveServer, _PondSocket_server, _PondSocket_socketServer, _PondSocket_middleware, _PondSocket_manageHeartbeat, _PondSocket_init, _PondSocket_getCookies;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
 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 redisClient_1 = require("../abstracts/redisClient");
 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, redisOptions, exclusiveServer = true } = {}) {
+    constructor({ server, socketServer, exclusiveServer = true } = {}) {
         _PondSocket_instances.add(this);
         _PondSocket_exclusiveServer.set(this, void 0);
         _PondSocket_server.set(this, void 0);
         _PondSocket_socketServer.set(this, void 0);
-        _PondSocket_redisClient.set(this, void 0);
         _PondSocket_middleware.set(this, void 0);
         __classPrivateFieldSet(this, _PondSocket_middleware, new middleware_1.Middleware(), "f");
         __classPrivateFieldSet(this, _PondSocket_exclusiveServer, exclusiveServer, "f");
         __classPrivateFieldSet(this, _PondSocket_server, server !== null && server !== void 0 ? server : new http_1.Server(), "f");
-        __classPrivateFieldSet(this, _PondSocket_redisClient, redisOptions ? new redisClient_1.RedisClient(redisOptions) : null, "f");
         __classPrivateFieldSet(this, _PondSocket_socketServer, socketServer !== null && socketServer !== void 0 ? socketServer : new ws_1.WebSocketServer({ noServer: true }), "f");
         __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_init).call(this);
     }
+    /**
+     * Start listening for connections
+     */
     listen(...args) {
-        if (__classPrivateFieldGet(this, _PondSocket_redisClient, "f")) {
-            __classPrivateFieldGet(this, _PondSocket_redisClient, "f").initialize()
-                .then(() => __classPrivateFieldGet(this, _PondSocket_server, "f").listen(...args));
-        }
-        else {
-            return __classPrivateFieldGet(this, _PondSocket_server, "f").listen(...args);
-        }
+        return __classPrivateFieldGet(this, _PondSocket_server, "f").listen(...args);
     }
+    /**
+     * Close the server
+     */
     close(callback) {
         return __classPrivateFieldGet(this, _PondSocket_server, "f").close(callback);
     }
+    /**
+     * Create a new endpoint
+     */
     createEndpoint(path, handler) {
-        var _a, _b;
-        const endpoint = new endpointEngine_1.EndpointEngine((_b = (_a = __classPrivateFieldGet(this, _PondSocket_redisClient, "f")) === null || _a === void 0 ? void 0 : _a.buildClient(String(path))) !== null && _b !== void 0 ? _b : null);
+        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) {
@@ -77,6 +67,9 @@ class PondSocket {
         });
         return new endpoint_1.Endpoint(endpoint);
     }
+    /**
+     * Handle WebSocket upgrade requests
+     */
     handleUpgrade(req, socket, head) {
         const clientId = req.headers['sec-websocket-key'];
         const request = {
@@ -105,7 +98,7 @@ class PondSocket {
     }
 }
 exports.PondSocket = PondSocket;
-_PondSocket_exclusiveServer = new WeakMap(), _PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_redisClient = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
+_PondSocket_exclusiveServer = new WeakMap(), _PondSocket_server = new WeakMap(), _PondSocket_socketServer = new WeakMap(), _PondSocket_middleware = new WeakMap(), _PondSocket_instances = new WeakSet(), _PondSocket_manageHeartbeat = function _PondSocket_manageHeartbeat() {
     __classPrivateFieldGet(this, _PondSocket_socketServer, "f").on('connection', (socket) => {
         socket.on('pong', () => {
             socket.isAlive = true;
@@ -122,17 +115,13 @@ _PondSocket_exclusiveServer = new WeakMap(), _PondSocket_server = new WeakMap(),
     }, 30000);
 }, _PondSocket_init = function _PondSocket_init() {
     const timeout = __classPrivateFieldGet(this, _PondSocket_instances, "m", _PondSocket_manageHeartbeat).call(this);
-    __classPrivateFieldGet(this, _PondSocket_server, "f").on('error', (error) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+    __classPrivateFieldGet(this, _PondSocket_server, "f").on('error', (error) => {
         clearInterval(timeout);
-        yield ((_a = __classPrivateFieldGet(this, _PondSocket_redisClient, "f")) === null || _a === void 0 ? void 0 : _a.shutdown());
         throw new Error(error.message);
-    }));
-    __classPrivateFieldGet(this, _PondSocket_server, "f").on('close', () => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+    });
+    __classPrivateFieldGet(this, _PondSocket_server, "f").on('close', () => {
         clearInterval(timeout);
-        yield ((_a = __classPrivateFieldGet(this, _PondSocket_redisClient, "f")) === null || _a === void 0 ? void 0 : _a.shutdown());
-    }));
+    });
     __classPrivateFieldGet(this, _PondSocket_server, "f").on('upgrade', this.handleUpgrade.bind(this));
 }, _PondSocket_getCookies = function _PondSocket_getCookies(headers) {
     const cookieHeader = headers.cookie;

package/types.d.ts

@@ -12,33 +12,32 @@ import {
     UserPresences,
     UserAssigns,
     JoinParams,
+    EventParams,
 } from '@eleven-am/pondsocket-common';
 import { WebSocket, WebSocketServer } from 'ws';
 
 export * from '@eleven-am/pondsocket-common';
 
-export interface RedisOptions {
-    host: string;
-    port: number;
-    db?: number;
-    username?: string;
-    password?: string;
-    instanceTtl?: number;
-}
-
 export interface LeaveEvent<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     user: UserData<PresenceType, AssignType>;
     channel: Channel<EventTypes, PresenceType, AssignType>;
 }
 
+export interface OutgoingEvent<Event extends string, EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
+    payload: PondMessage;
+    event: EventParams<Event>;
+    channel: Channel<EventTypes, PresenceType, AssignType>;
+}
+
 export type LeaveCallback<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> = (event: LeaveEvent<EventTypes, PresenceType, AssignType>) => void;
 
+export type OutgoingHandler<Event extends string, EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> = (event: OutgoingEvent<Event, EventTypes, PresenceType, AssignType>) => PondMessage | Promise<PondMessage> | void | Promise<void>;
+
 export type RequestHandler<Request, Response> = (request: Request, response: Response) => void | Promise<void>;
 
 export interface PondSocketOptions {
     server?: Server;
     exclusiveServer?: boolean;
-    redisOptions?: RedisOptions;
     socketServer?: WebSocketServer;
 }
 
@@ -130,6 +129,19 @@ export declare class PondChannel<EventType extends PondEventMap = PondEventMap,
      */
     onLeave(callback: LeaveCallback<EventType, PresenceType, AssignType>): void;
 
+    /**
+     * @desc Handles an outgoing event, this is useful for modifying the event before it is sent to the client
+     * @param {PondPath<string>} event - The event to handle
+     * @param {OutgoingHandler} handler - The handler to execute when the event is sent
+     * @example
+     * pond.onOutgoing('echo', (event) => {
+     *     return {
+     *         message: 'Hello, world!'
+     *     };
+     * });
+     */
+    onOutgoing<Event extends string> (event: PondPath<Event>, handler: OutgoingHandler<Event, EventType, PresenceType, AssignType>): void;
+
     /**
      * @desc Gets a channel by name
      * @param {string} channelName - The name of the channel to get
@@ -185,7 +197,7 @@ export declare class PondChannel<EventType extends PondEventMap = PondEventMap,
     broadcastTo <Key extends keyof EventType> (channelName: string, event: Key, payload: EventType[Key], userIds: string | string[]): void;
 }
 
-export declare class Channel<EventType extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
+export declare class Channel<EventTypes extends PondEventMap = PondEventMap, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
     /**
      * The name of the channel.
      */
@@ -212,7 +224,7 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
      * @param {string} event - The event to send.
      * @param {PondMessage} payload - The message to send.
      */
-    broadcast<Key extends keyof EventType>(event: Key, payload: EventType[Key]): Channel<EventType, PresenceType, AssignType>;
+    broadcast<Key extends keyof EventTypes>(event: Key, payload: EventTypes[Key]): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc Broadcasts a message to every client in the channel except the sender,
@@ -220,7 +232,7 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
      * @param {string} event - The event to send.
      * @param {PondMessage} payload - The message to send.
      */
-    broadcastFrom<Key extends keyof EventType>(userId: string, event: Key, payload: EventType[Key]): Channel<EventType, PresenceType, AssignType>;
+    broadcastFrom<Key extends keyof EventTypes>(userId: string, event: Key, payload: EventTypes[Key]): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc Sends a message to a specific client in the channel.
@@ -228,48 +240,48 @@ export declare class Channel<EventType extends PondEventMap = PondEventMap, Pres
      * @param {string} event - The event to send.
      * @param {PondMessage} payload - The message to send.
      */
-    broadcastTo<Key extends keyof EventType>(clientIds: string | string[], event: Key, payload: EventType[Key]): Channel<EventType, PresenceType, AssignType>;
+    broadcastTo<Key extends keyof EventTypes>(clientIds: string | string[], event: Key, payload: EventTypes[Key]): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc Bans a user from the channel.
      * @param {string} userId - The id of the user to ban.
      * @param {string} reason - The reason for the ban.
      */
-    evictUser(userId: string, reason?: string): Channel<EventType, PresenceType, AssignType>;
+    evictUser(userId: string, reason?: string): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc tracks a user's presence in the channel
      * @param {string} userId - the id of the user to track
      * @param {PondPresence} presence - the presence data to track
      */
-    trackPresence(userId: string, presence: PresenceType): Channel<EventType, PresenceType, AssignType>;
+    trackPresence(userId: string, presence: PresenceType): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc removes a user's presence from the channel
      * @param {string} userId - the id of the user to remove
      */
-    removePresence(userId: string): Channel<EventType, PresenceType, AssignType>;
+    removePresence(userId: string): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc updates a user's presence in the channel
      * @param {string} userId - the id of the user to update
      * @param {PondPresence} presence - the presence data to update
      */
-    updatePresence(userId: string, presence: Partial<PresenceType>): Channel<EventType, PresenceType, AssignType>;
+    updatePresence(userId: string, presence: Partial<PresenceType>): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc Updates a user's assigns in the channel
      * @param userId - the id of the user to update
      * @param assigns - the assigns data to update
      */
-    updateAssigns(userId: string, assigns: Partial<AssignType>): Channel<EventType, PresenceType, AssignType>;
+    updateAssigns(userId: string, assigns: Partial<AssignType>): Channel<EventTypes, PresenceType, AssignType>;
 
     /**
      * @desc Tracks or updates a user's presence in the channel
      * @param userId - the id of the user to upsert
      * @param presence - the presence data to upsert
      */
-    upsertPresence (userId: string, presence: PresenceType): Channel<EventType, PresenceType, AssignType>;
+    upsertPresence(userId: string, presence: PresenceType): Channel<EventTypes, PresenceType, AssignType>;
 }
 
 export declare class JoinRequest<Path extends string, PresenceType extends PondPresence = PondPresence, AssignType extends PondAssigns = PondAssigns> {
@@ -474,7 +486,3 @@ export declare class EventResponse<EventType extends PondEventMap = PondEventMap
      */
     evictUser(reason: string, userId?: string): EventResponse;
 }
-
-export declare class RedisError extends Error {
-    constructor(message: string);
-}